/**
 * 
 * SmartEarthSDK 基于Cesium的三维web开发
 * author: 张丹钊、金磊、薛鹏、张恒
 * 
 */
(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
    typeof define === 'function' && define.amd ? define(['exports'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SmartEarth = {}));
})(this, (function (exports) { 'use strict';

    function Cdcl(lat1, lng1, lat2, lng2) {
        var cdcl = 0.0;
        var EARTH_RADIUS = 6378137.0;    //单位M
        var PI = Math.PI;

        function getRad(d) {
            return d * PI / 180.0;
        }
        var f = getRad((lat1 + lat2) / 2);
        var g = getRad((lat1 - lat2) / 2);
        var l = getRad((lng1 - lng2) / 2);

        var sg = Math.sin(g);
        var sl = Math.sin(l);
        var sf = Math.sin(f);

        var s, c, w, r, d, h1, h2;
        var a = EARTH_RADIUS;
        var fl = 1 / 298.257;

        sg = sg * sg;
        sl = sl * sl;
        sf = sf * sf;

        s = sg * (1 - sl) + (1 - sf) * sl;
        c = (1 - sg) * (1 - sl) + sf * sl;

        w = Math.atan(Math.sqrt(s / c));
        r = Math.sqrt(s * c) / w;
        d = 2 * w * a;
        h1 = (3 * r - 1) / 2 / c;
        h2 = (3 * r + 1) / 2 / s;
        cdcl = d * (1 + fl * (h1 * sf * (1 - sg) - h2 * (1 - sf) * sg));
        return cdcl;

    }

    /**
    *
    * 这个方法用于测量空间距离。
    *
    * @alias measureTerrainPerimeter 
    * @constructor
    *
    */
    function measureTerrainPerimeter(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    /**
    * 这个方法用于测量水平距离
    *@param {Array} [pIGeometry] 一个经纬度数组例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
    * @returns {Promise.<Number>} 返回一个长度。
    * 
    */
    measureTerrainPerimeter.prototype.measureTerrainPerimeter = function (pIGeometry) {
        var point1 = pIGeometry[pIGeometry.length - 2];
        var point2 = pIGeometry[pIGeometry.length - 1];
        Math.abs(point1.x - point2.x);
        Math.abs(point1.y - point2.y);
        var distance = Cdcl(point1.y, point1.x, point2.y, point2.x);
        return distance;
    };

    /**
    *
    * 这个方法用于测量高度。
    *
    * @alias measureTerrainHeight 
    * @constructor
    *
    */
    function measureTerrainHeight(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    /**
    * 这个方法用于测量高度
    *@param {Array} [pIGeometry] 一个经纬度数组例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
    * @returns {Promise.<Number>} 返回高度。
    * 
    */
    measureTerrainHeight.prototype.measureTerrainHeight = function (pIGeometry) {
        var point1 = pIGeometry[pIGeometry.length - 2];
        var point2 = pIGeometry[pIGeometry.length - 1];
        Math.abs(point1.x - point2.x);
        Math.abs(point1.y - point2.y);
        if (point1.hit >= point2.hit) ;
        var distance = Math.abs(point1.z - point2.z);
        return distance;
    };

    function Bearing(from, to) {
        /*方向*/
        var radiansPerDegree = Math.PI / 180.0;
        var degreesPerRadian = 180.0 / Math.PI;
        var lat1 = from.y * radiansPerDegree;
        var lon1 = from.x * radiansPerDegree;
        var lat2 = to.y * radiansPerDegree;
        var lon2 = to.x * radiansPerDegree;
        var angle = -Math.atan2(Math.sin(lon1 - lon2) * Math.cos(lat2), Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon1 - lon2));
        if (angle < 0) {
            angle += Math.PI * 2.0;
        }
        angle = angle * degreesPerRadian;
        return angle;
    }

    function Angle(p1, p2, p3) {
        var bearing21 = Bearing(p2, p1);
        var bearing23 = Bearing(p2, p3);
        var angle = bearing21 - bearing23;
        if (angle < 0) {
            angle += 360;
        }
        return angle;
    }

    //计算多边形面积
    function Mjcl(points) {
        if (!points || points.length < 3) return 0;
        var earthRadiusMeters = 6371000.0;
        var radiansPerDegree = Math.PI / 180.0;
        var totalAngle = 0;
        for (var i = 0; i < points.length; i++) {
            var j = (i + 1) % points.length;
            var k = (i + 2) % points.length;
            totalAngle += Angle(points[i], points[j], points[k]);
        }
        var planarTotalAngle = (points.length - 2) * 180.0;
        var sphericalExcess = totalAngle - planarTotalAngle;
        if (sphericalExcess > 420.0) {
            totalAngle = points.length * 360.0 - totalAngle;
            sphericalExcess = totalAngle - planarTotalAngle;
        } else if (sphericalExcess > 300.0 && sphericalExcess < 420.0) {
            sphericalExcess = Math.abs(360.0 - sphericalExcess);
        }
        return sphericalExcess * radiansPerDegree * earthRadiusMeters * earthRadiusMeters;
    }

    /**
    *
    *测量水平面积。
    *
    * @alias measureTerrainArea 
    * @constructor
    *
    */
    function measureTerrainArea(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    /**
    * 这个方法用于测量水平面积
    *@param {Array} [pIGeometry] 一个经纬度数组例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
    * @returns {Promise.<Number>} 返回面积。
    * 
    */
    measureTerrainArea.prototype.measureTerrainArea = function (pIGeometry) {

        var distance = Mjcl(pIGeometry).toFixed(1);
        return distance;
    };

    /**
    *
    * 这个方法用于测量空间距离。
    *
    * @alias measureTerrainkPerimeter 
    * @constructor
    *
    */
    function measureTerrainkPerimeter(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }
    /**
    * 这个方法用于测量空间距离
    *@param {Array} [pIGeometry] 一个经纬度数组例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
    * @returns {Promise.<Number>} 返回一个长度。
    * 
    */
    measureTerrainkPerimeter.prototype.measureTerrainkPerimeter = function (pIGeometry) {
        var point1 = pIGeometry[pIGeometry.length - 2];
        var point2 = pIGeometry[pIGeometry.length - 1];
        Math.abs(point1.x - point2.x);
        Math.abs(point1.y - point2.y);
        var height = Math.abs(point1.z - point2.z);
        var distance = Cdcl(point1.y, point1.z, point2.y, point2.z);
        var kjdistance = Math.sqrt(height * height + distance * distance);
        return kjdistance;
    };

    let configData = {
        testModel: 'Workers/Model/xiaoche.gltf',
        modelAxis: 'Workers/Model/axis.gltf',
        flyModel: 'Workers/Model/fly.glb',
        divpoint: 'Workers/image/divpoint.png',
        divpoint1: 'Workers/image/divpoint1.png',
        richtextpoint: 'Workers/image/richtextpoint1.png',
        mark: 'Workers/image/mark.png',
        TrailLine: 'Workers/image/TrailLine.png',
        road: 'Workers/image/road.jpg',
        colors3: 'Workers/image/colors3.png',
        loading: 'Workers/image/loading.gif',
        smog: 'Workers/image/smog.png',
        penquan: 'Workers/image/penquan.png',
        fire: 'Workers/image/fire.png',
        bottomplane: 'Workers/image/bottomplane.jpg',
        wall: 'Workers/image/ggy.jpg',
        rotate: 'Workers/image/rotate.png',
        move: 'Workers/image/move.png',
        draw: 'Workers/image/cursor/draw.cur',
        water: 'Workers/image/waterNormals.jpg',
        movingRiver: 'Workers/image/movingRiver.png',
    };
    var configData$1 = Object.freeze(configData);

    /**
     * 流动线纹理
     * 
     * @alias PolylineTrailLinkMaterial
     * @constructor
     * 
     * @param {String} [color] 颜色
     * @param {String|Object} [Line] 线样式或贴图
     * @param {Number} [duration=3000] 持续时间 毫秒
     * 
    */
    function PolylineTrailLinkMaterial(color, Line, duration) {
        Material();

        this._definitionChanged = new Cesium.Event();
        this._color = undefined;
        this._colorSubscription = undefined;
        this.color = Cesium.Color.fromCssColorString(color || "#ffffff");
        this._Line = Line || Cesium.Material.PolylineTrailLinkImage;
        this.duration = duration || 3000;
        this.alpha = 0.3;
        this._time = (new Date()).getTime();

        if (typeof this._Line === 'object') {
            if (this._Line.LightSpot) {
                this._Line.color = Cesium.Color.fromCssColorString(this._Line.color);
            } else {
                this._Line.color1 = Cesium.Color.fromCssColorString(this._Line.color1);
                this._Line.color2 = Cesium.Color.fromCssColorString(this._Line.color2);
            }
        }
    }

    Object.defineProperties(PolylineTrailLinkMaterial.prototype, {
        isConstant: {
            get: function () {
                return false;
            }
        },
        definitionChanged: {
            get: function () {
                return this._definitionChanged;
            }
        },
        color: Cesium.createPropertyDescriptor('color')
    });
    PolylineTrailLinkMaterial.prototype.getType = function (time) {
        return 'PolylineTrailLink';
    };
    PolylineTrailLinkMaterial.prototype.setScale = function (scale) {
        this.scale = scale;
    };
    PolylineTrailLinkMaterial.prototype.getValue = function (time, result) {
        if (!Cesium.defined(result)) {
            result = {};
        }
        result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.Color.WHITE, result.color);
        if (typeof this._Line === 'object') {
            if (this._Line.LightSpot) {
                result.lightSpot = true;
                result.lightSpotColor = this._Line.color;
            } else {
                result.color1 = this._Line.color1;
                result.color2 = this._Line.color2;
                result.twoColor = true;
            }
        } else {
            result.image = this._Line;
        }
        if (this.scale !== undefined) {
            result.time = this.scale;
        } else {
            result.time = (((new Date()).getTime() - this._time) % this.duration) / this.duration;
        }
        result.alpha = this.alpha;
        return result;
    };
    PolylineTrailLinkMaterial.prototype.equals = function (other) {
        return this === other ||
            (other instanceof PolylineTrailLinkMaterial &&
                Cesium.Property.equals(this._color, other._color))
    };

    function Material() {
        if (!Cesium.PolylineTrailLinkMaterialProperty) {
            Cesium.PolylineTrailLinkMaterialProperty = PolylineTrailLinkMaterial;
            Cesium.Material.PolylineTrailLinkType = 'PolylineTrailLink';
            Cesium.Material.PolylineTrailLinkImage = window.SmartEarthRootUrl + configData$1.colors1;
            Cesium.Material.PolylineTrailLinkSource = "czm_material czm_getMaterial(czm_materialInput materialInput)\n\
                                                      {\n\
                                                           czm_material material = czm_getDefaultMaterial(materialInput);\n\
                                                           vec2 st = materialInput.st;\n\
                                                           if(twoColor){\n\
                                                            if(st.s<time){\n\
                                                                material.alpha = color1.a;\n\
                                                                material.diffuse = color1.rgb;\n\
                                                            }else{\n\
                                                                material.alpha = color2.a;\n\
                                                                material.diffuse = color2.rgb;\n\
                                                            }\n\
                                                           }else if(lightSpot){\n\
                                                            if(st.s<time){\n\
                                                                material.alpha = pow(st.s / time, 20.0);\n\
                                                                if(material.alpha<alpha){\n\
                                                                    material.alpha = alpha;\n\
                                                                    material.diffuse = color.rgb;\n\
                                                                }else{\n\
                                                                    material.diffuse = lightSpotColor.rgb;\n\
                                                                }\n\
                                                            }else{\n\
                                                                material.alpha = alpha;\n\
                                                                material.diffuse = color.rgb;\n\
                                                            }\n\
                                                           }else{\n\
                                                            vec4 colorImage = texture2D(image, vec2(fract(st.s - time), st.t));\n\
                                                            material.alpha = colorImage.a * color.a;\n\
                                                            material.diffuse = (colorImage.rgb+color.rgb)/2.0;\n\
                                                           }\n\
                                                           return material;\n\
                                                       }";
            Cesium.Material._materialCache.addMaterial(Cesium.Material.PolylineTrailLinkType, {
                fabric: {
                    type: Cesium.Material.PolylineTrailLinkType,
                    uniforms: {
                        color: new Cesium.Color(1.0, 0.0, 0.0, 0.5),
                        color1: new Cesium.Color(0.0, 1.0, 0.0, 0.5),
                        color2: new Cesium.Color(1.0, 0.0, 0.0, 0.5),
                        image: Cesium.Material.PolylineTrailLinkImage,
                        twoColor: false,
                        lightSpot: false,
                        lightSpotColor: new Cesium.Color(1.0, 1.0, 1.0, 0.5),
                        alpha: 0.3,
                        time: 0
                    },
                    source: Cesium.Material.PolylineTrailLinkSource
                },
                translucent: function (material) {
                    return true;
                }
            });
        }
        return Cesium.Material;
    }

    /**
     * 如果未定义，则返回第一个参数，否则返回第二个参数。
     * 用于设置参数的默认值。
     *
     * @function
     *
     * @param {*} a
     * @param {*} b
     * @returns {*} 如果未定义，则返回第一个参数，否则返回第二个参数。
     *
     * @example
     * param = SmartEarth.defaultValue(param, 'default');
     */
    function defaultValue(a, b) {
      if (a !== undefined && a !== null) {
        return a;
      }
      return b;
    }

    /**
     * 加载js文件
     *
     * @alias Skip
     * @constructor
     *
     * @param {Boolean} [type=true] 是否异步。
     */
    function Skip(type = true) {
        this.async = type;
    }

    /**
     * 获取XMLHttpRequest对象(提供客户端同http服务器通讯的协议)
     *
     */
    Skip.prototype.getXmlHttpRequest = function () {
        if (window.XMLHttpRequest) // 除了IE外的其它浏览器
            return new XMLHttpRequest();
        else if (window.ActiveXObject) // IE
            return new ActiveXObject("MsXml2.XmlHttp");
    };
    Skip.prototype.includeJsText = function (rootObject, jsText) {
        if (rootObject != null) {
            var oScript = document.createElement("script");
            oScript.type = "text/javascript";
            oScript.text = jsText;
            rootObject.appendChild(oScript);
        }
    };
    Skip.prototype.includeJsSrc = function (rootObject, fileUrl) {
        if (rootObject != null) {
            var oScript = document.createElement("script");
            oScript.type = "text/javascript";
            oScript.src = fileUrl;
            rootObject.appendChild(oScript);
        }
    };
    /**
     * 加载js
     *
     * @param {DOM} rootObject html节点
     * @param {String} url js路径
     */
    Skip.prototype.addJs = function (rootObject, url) {
        var oXmlHttp = this.getXmlHttpRequest();
        var Skipthis = this;
        oXmlHttp.onreadystatechange = function () {
            if (oXmlHttp.readyState === 4) {  //当执行完成以后(返回了响应)所要执行的
                if (oXmlHttp.status === 200 || oXmlHttp.status === 304) { //200有读取对应的url文件,404表示不存在这个文件
                    Skipthis.includeJsSrc(rootObject, url);
                } else {
                    console.log('XML request error: ' + oXmlHttp.statusText + ' (' + oXmlHttp.status + ')');
                }
            }
        };
        oXmlHttp.open('GET', url, Skipthis.async); //url为js文件时,ie会自动生成 '<script src="*.js" type="text/javascript"> </scr ipt>',ff不会
        oXmlHttp.send(null);
        if (oXmlHttp.status === 404) {
            console.log(url + ' is not found');
        } else {
            Skipthis.includeJsText(rootObject, oXmlHttp.responseText);
        }
    };

    /**
     * Echarts扩展
     *
     * @alias CombineEcharts
     * @constructor
     *
     * @param {Viewer} viewer 地图视图。
     * 
     * @example
     * echartsTool = SmartEarth.CombineEcharts(Viewer);
     */
    function CombineEcharts(viewer) {
        this._mapContainer = viewer;
        if (!window.echarts) {
            let SkipTool = new Skip(false);
            SkipTool.addJs(document.body, window.SmartEarthRootUrl + 'Workers/echarts.min.js');
        }
        this.Init(viewer);
    }

    /**
     * 设置Echarts对应的参数
     * 
     * @param {Object} [option] Echarts对应的参数。
     * @param {Boolean} [isClear=false] 是否清除原先图层。
     *
     */
    CombineEcharts.prototype.setOption = function (option, isClear) {
        if (this._echartsContainer && isClear) {
            this.clear();
        }
        !this._overlay && (this._overlay = this._createChartOverlay());

        this._overlay.setOption(option);

        return this;
    };

    CombineEcharts.prototype._createChartOverlay = function () {
        var t = this._mapContainer.scene;
        t.canvas.setAttribute('tabIndex', 0);
        var e = document.createElement('div');
        e.style.position = 'absolute';
        e.style.top = '0px';
        e.style.left = '0px';
        e.style.width = t.canvas.width + 'px';
        e.style.height = t.canvas.height + 'px';
        e.style.pointerEvents = 'none';
        e.setAttribute('id', 'smartearth-cesium-echarts');
        e.setAttribute('class', 'echartMap');
        this._mapContainer.container.appendChild(e);

        this._echartsContainer = e;

        return echarts.init(e)
    };

    /**
     * 清除图层
     *
     */
    CombineEcharts.prototype.clear = function () {
        this._echartsContainer && (this._mapContainer.container.removeChild(this._echartsContainer), (this._echartsContainer = null)), this._overlay && (this._overlay.dispose(), (this._overlay = null));
    };

    /**
     * 清除图层
     *
     */
    CombineEcharts.prototype.deleteObject = CombineEcharts.prototype.clear;

    /**
     * 更新图层
     * 
     * @param {Object} [option] Echarts对应的参数。
     *
     */
    CombineEcharts.prototype.updateOverlay = function (option) {
        this._overlay && this._overlay.setOption(option);
    };

    CombineEcharts.prototype.getMap = function () {
        return this._mapContainer
    };

    CombineEcharts.prototype.getOverlay = function () {
        return this._overlay
    };

    /**
     * 显示图层
     *
     */
    CombineEcharts.prototype.show = function () {
        document.getElementById(this._id).style.visibility = 'visible';
    };

    /**
     * 隐藏图层
     * 
     */
    CombineEcharts.prototype.hide = function () {
        document.getElementById(this._id).style.visibility = 'hidden';
    };

    /**
     * 隐藏图层
     * 
     */
    CombineEcharts.prototype.Init = function (viewer) {
        //坐标转换及事件监听
        (function (e) {
            var t = {};
            function n(r) {
                if (t[r]) return t[r].exports;
                var i = t[r] = {
                    i: r,
                    l: !1,
                    exports: {}
                };
                return e[r].call(i.exports, i, i.exports, n),
                    i.l = !0,
                    i.exports
            }
            n.m = e,
                n.c = t,
                n.d = function (e, t, r) {
                    n.o(e, t) || Object.defineProperty(e, t, {
                        enumerable: !0,
                        get: r
                    });
                },
                n.r = function (e) {
                    "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(e, Symbol.toStringTag, {
                        value: "Module"
                    }),
                        Object.defineProperty(e, "__esModule", {
                            value: !0
                        });
                },
                n.t = function (e, t) {
                    if (1 & t && (e = n(e)), 8 & t) return e;
                    if (4 & t && "object" == typeof e && e && e.__esModule) return e;
                    var r = Object.create(null);
                    if (n.r(r), Object.defineProperty(r, "default", {
                        enumerable: !0,
                        value: e
                    }), 2 & t && "string" != typeof e) for (var i in e) n.d(r, i,
                        function (t) {
                            return e[t]
                        }.bind(null, i));
                    return r
                },
                n.n = function (e) {
                    var t = e && e.__esModule ?
                        function () {
                            return e.
                                default
                        } :
                        function () {
                            return e
                        };
                    return n.d(t, "a", t),
                        t
                },
                n.o = function (e, t) {
                    return Object.prototype.hasOwnProperty.call(e, t)
                },
                n.p = "",
                n(n.s = 0);
        })([function (e, t, n) { e.exports = n(1); }, function (e, t, n) {
            echarts ? n(2).load() : console.error("missing echarts lib");
        }, function (e, t, n) {
            function r(e, t) {
                for (var n = 0; n < t.length; n++) {
                    var r = t[n];
                    r.enumerable = r.enumerable || !1,
                        r.configurable = !0,
                        "value" in r && (r.writable = !0),
                        Object.defineProperty(e, r.key, r);
                }
            }
            n.r(t);
            var i = function () {
                function e(t, n) {
                    !
                        function (e, t) {
                            if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function")
                        }(this, e),
                        this._viewer = t,
                        this.dimensions = ["lng", "lat"],
                        this._mapOffset = [0, 0],
                        this._api = n;
                }
                var t, n, i;
                return t = e,
                    i = [{
                        key: "create",
                        value: function (t, n) {
                            var r;
                            t.eachComponent("GLMap",
                                function (t) {
                                    (r = new e(viewer, n)).setMapOffset(t.__mapOffset || [0, 0]),
                                        t.coordinateSystem = r;
                                }),
                                t.eachSeries(function (e) {
                                    "GLMap" === e.get("coordinateSystem") && (e.coordinateSystem = r);
                                });
                        }
                    },
                    {
                        key: "dimensions",
                        get: function () {
                            return ["lng", "lat"]
                        }
                    }],
                    (n = [{
                        key: "setMapOffset",
                        value: function (e) {
                            return this._mapOffset = e,
                                this
                        }
                    },
                    {
                        key: "getViewer",
                        value: function () {
                            return this._viewer
                        }
                    },
                    {
                        key: "dataToPoint",
                        value: function (e) {
                            if (this._viewer && this._viewer.scene) {
                                var t = this._viewer.scene,
                                    n = [0, 0],
                                    r = Cesium.Cartesian3.fromDegrees(e[0], e[1]);
                                if (!r) return n;
                                if (t.mode === Cesium.SceneMode.SCENE3D && Cesium.Cartesian3.angleBetween(t.camera.position, r) > Cesium.Math.toRadians(80)) return !1;
                                var i = t.cartesianToCanvasCoordinates(r);
                                return i ? [i.x - this._mapOffset[0], i.y - this._mapOffset[1]] : []
                            } else {
                                return []
                            }
                        }
                    },
                    {
                        key: "pointToData",
                        value: function (e) {
                            var t = this._mapOffset,
                                n = viewer.scene.globe.ellipsoid,
                                r = new Cesium.cartesian3(e[1] + t, e[2] + t[2], 0),
                                i = n.cartesianToCartographic(r);
                            return [i.lng, i.lat]
                        }
                    },
                    {
                        key: "getViewRect",
                        value: function () {
                            var e = this._api;
                            return new echarts.graphic.BoundingRect(0, 0, e.getWidth(), e.getHeight())
                        }
                    },
                    {
                        key: "getRoamTransform",
                        value: function () {
                            return echarts.matrix.create()
                        }
                    }]) && r(t.prototype, n),
                    i && r(t, i),
                    e
            }();
            echarts.extendComponentModel({
                type: "GLMap",
                getViewer: function () {
                    return viewer
                },
                defaultOption: {
                    roam: !1
                }
            });
            echarts.extendComponentView({
                type: "GLMap",
                init: function (e, t) {
                    this.api = t;
                    this.dispose();
                    viewer.scene.postRender.addEventListener(this.moveHandler, this);
                },
                moveHandler: function (e, t) {
                    this.api.dispatchAction({
                        type: "GLMapRoam"
                    });
                },
                render: function (e, t, n) { },
                dispose: function (e) {
                    viewer.scene.postRender.removeEventListener(this.moveHandler, this);
                }
            });
            function a() {
                echarts.registerCoordinateSystem("GLMap", i),
                    echarts.registerAction({
                        type: "GLMapRoam",
                        event: "GLMapRoam",
                        update: "updateLayout"
                    },
                        function (e, t) { });
            }
            n.d(t, "load",
                function () {
                    return a
                });
        }]);
    };

    /**
     * CIMServer查询工具
     *
     * @alias CIMServerTool
     * @constructor
     *
     * @param {String} url CIMServer服务地址。
     */
    function CIMServerTool(url) {
        this.serverUrl = url;
    }

    /**
     * 查询场景列表。
     * 
     * @param {Function} [callback] 回调函数。
     *
     */
    CIMServerTool.prototype.getSceneList = function (callback) {
        $.ajax({
            url: this.serverUrl + "/scene/sceneList",
            type: "get",
            success: function (data) {
                (callback && typeof callback === 'function') && data && callback(JSON.parse(data));
            }
        });
    };

    /**
     * 查询详细信息。
     * 
     * @param {Object} [option] 请求参数。
     * @param {String} [option.database] 对应的信息库名
     * @param {String} [option.type='building'] 查询类型
     * @param {String} [option.id] id
     * @param {Boolean} [option.returnGeometry=true] 是否返回Geometry
     * @param {Boolean} [option.returnChildren=true] 是否返回子集
     * @param {Function} [callback] 回调函数。
     *
     */
    CIMServerTool.prototype.query = function (option, callback) {
        var database = option.database;
        var params = {
            type: defaultValue(option.type, 'building'),
            id: option.id,
            returnGeometry: defaultValue(option.returnGeometry, true),
            returnChildren: defaultValue(option.returnChildren, true),
        };

        $.ajax({
            url: this.serverUrl + "/" + database + "/query?version=v2.1",
            type: 'post',
            async: true,
            data: params,
            success: function (data) {
                (callback && typeof callback === 'function') && data && callback(JSON.parse(data));
            }, error: function (XMLHttpRequest, textStatus, errorThrown) {
                alert("error:" + XMLHttpRequest.status);
            }
        });
    };

    /**
    * 自动录屏*录制桌面
    *
    * @alias Recorder
    * @constructor
    *
    * @param {String} [path='test.mp4'] 保存文件名。
    * @param {Number} [videoBPS=5120000] 视频bps。
    */
    function Recorder(path, videoBPS) {
        this.mediaOutputPath = path || 'test.mp4';
        this.videoBPS = videoBPS || 5120000;
    }

    /**
    * 开始录制
    *
    */
    Recorder.prototype.startRecord = function () {

        navigator.mediaDevices.getDisplayMedia({ video: true, audio: true }).then(Mediastream => {

            this.createRecorder(Mediastream);



        }).catch(err => {

            this.getUserMediaError(err);

        });

    };

    /**
    * 获取媒体源失败
    */
    Recorder.prototype.getUserMediaError = function (err) {

        console.log('mediaError', err);

    };

    /**
    * 开始视频录制
    *
    */
    Recorder.prototype.createRecorder = function (stream) {

        console.log('start record');

        var options = {
            videoBitsPerSecond: this.videoBPS
        };

        this.recorder = new MediaRecorder(stream, options);

        this.recorder.start();

        var chunks = [];

        this.recorder.onstop = event => {

            let blob = new Blob(chunks, {

                type: 'video/mp4'

            });

            this.saveMedia(blob);

        };

        this.recorder.ondataavailable = event => {

            chunks.push(event.data);

        };

    };

    /**
    * 数据转换并保存成MP4
    *
    */
    Recorder.prototype.saveMedia = function (blob) {

        let url = window.URL.createObjectURL(blob);

        var a = document.createElement('a');

        a.innerHTML = "test";

        a.download = this.mediaOutputPath;

        a.href = url;

        a.click();

    };

    /**
    * 停止录制视频
    *
    */
    Recorder.prototype.stopRecord = function () {

        this.recorder.stop();

    };

    const CoordTransform_BD_FACTOR = (3.14159265358979324 * 3000.0) / 180.0;
    const CoordTransform_PI = 3.1415926535897932384626;
    const CoordTransform_RADIUS = 6378245.0;
    const CoordTransform_EE = 0.00669342162296594323;

    /**
     * 坐标转换
     */
    const CoordTransform = {
      /**
       * BD-09 To GCJ-02
       * @param lng
       * @param lat
       * @returns {number[]}
       */
      BD09ToGCJ02(lng, lat) {
        let x = +lng - 0.0065;
        let y = +lat - 0.006;
        let z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * CoordTransform_BD_FACTOR);
        let theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * CoordTransform_BD_FACTOR);
        let gg_lng = z * Math.cos(theta);
        let gg_lat = z * Math.sin(theta);
        return [gg_lng, gg_lat]
      },

      /**
       * GCJ-02 To BD-09
       * @param lng
       * @param lat
       * @returns {number[]}
       * @constructor
       */
      GCJ02ToBD09(lng, lat) {
        lat = +lat;
        lng = +lng;
        let z =
          Math.sqrt(lng * lng + lat * lat) + 0.00002 * Math.sin(lat * CoordTransform_BD_FACTOR);
        let theta = Math.atan2(lat, lng) + 0.000003 * Math.cos(lng * CoordTransform_BD_FACTOR);
        let bd_lng = z * Math.cos(theta) + 0.0065;
        let bd_lat = z * Math.sin(theta) + 0.006;
        return [bd_lng, bd_lat]
      },

      /**
       * WGS-84 To GCJ-02
       * @param lng
       * @param lat
       * @returns {number[]}
       */
      WGS84ToGCJ02(lng, lat) {
        lat = +lat;
        lng = +lng;
        if (this.out_of_china(lng, lat)) {
          return [lng, lat]
        } else {
          let d = this.delta(lng, lat);
          return [lng + d[0], lat + d[1]]
        }
      },

      /**
       * GCJ-02 To WGS-84
       * @param lng
       * @param lat
       * @returns {number[]}
       * @constructor
       */
      GCJ02ToWGS84(lng, lat) {
        lat = +lat;
        lng = +lng;
        if (this.out_of_china(lng, lat)) {
          return [lng, lat]
        } else {
          let d = this.delta(lng, lat);
          let mgLng = lng + d[0];
          let mgLat = lat + d[1];
          return [lng * 2 - mgLng, lat * 2 - mgLat]
        }
      },

      /**
       *
       * @param lng
       * @param lat
       * @returns {number[]}
       */
      delta(lng, lat) {
        let dLng = this.transformLng(lng - 105, lat - 35);
        let dLat = this.transformLat(lng - 105, lat - 35);
        const radLat = (lat / 180) * CoordTransform_PI;
        let magic = Math.sin(radLat);
        magic = 1 - CoordTransform_EE * magic * magic;
        const sqrtMagic = Math.sqrt(magic);
        dLng = (dLng * 180) / ((CoordTransform_RADIUS / sqrtMagic) * Math.cos(radLat) * CoordTransform_PI);
        dLat = (dLat * 180) / (((CoordTransform_RADIUS * (1 - CoordTransform_EE)) / (magic * sqrtMagic)) * CoordTransform_PI);
        return [dLng, dLat]
      },

      /**
       *
       * @param lng
       * @param lat
       * @returns {number}
       */
      transformLng(lng, lat) {
        lat = +lat;
        lng = +lng;
        let ret =
          300.0 +
          lng +
          2.0 * lat +
          0.1 * lng * lng +
          0.1 * lng * lat +
          0.1 * Math.sqrt(Math.abs(lng));
        ret +=
          ((20.0 * Math.sin(6.0 * lng * CoordTransform_PI) + 20.0 * Math.sin(2.0 * lng * CoordTransform_PI)) *
            2.0) /
          3.0;
        ret +=
          ((20.0 * Math.sin(lng * CoordTransform_PI) + 40.0 * Math.sin((lng / 3.0) * CoordTransform_PI)) * 2.0) /
          3.0;
        ret +=
          ((150.0 * Math.sin((lng / 12.0) * CoordTransform_PI) +
            300.0 * Math.sin((lng / 30.0) * CoordTransform_PI)) *
            2.0) /
          3.0;
        return ret
      },

      /**
       *
       * @param lng
       * @param lat
       * @returns {number}
       */
      transformLat(lng, lat) {
        lat = +lat;
        lng = +lng;
        let ret =
          -100.0 +
          2.0 * lng +
          3.0 * lat +
          0.2 * lat * lat +
          0.1 * lng * lat +
          0.2 * Math.sqrt(Math.abs(lng));
        ret +=
          ((20.0 * Math.sin(6.0 * lng * CoordTransform_PI) + 20.0 * Math.sin(2.0 * lng * CoordTransform_PI)) *
            2.0) /
          3.0;
        ret +=
          ((20.0 * Math.sin(lat * CoordTransform_PI) + 40.0 * Math.sin((lat / 3.0) * CoordTransform_PI)) * 2.0) /
          3.0;
        ret +=
          ((160.0 * Math.sin((lat / 12.0) * CoordTransform_PI) +
            320 * Math.sin((lat * CoordTransform_PI) / 30.0)) *
            2.0) /
          3.0;
        return ret
      },

      /**
       *
       * @param lng
       * @param lat
       * @returns {boolean}
       */
      out_of_china(lng, lat) {
        lat = +lat;
        lng = +lng;
        return !(lng > 73.66 && lng < 135.05 && lat > 3.86 && lat < 53.55)
      }
    };

    /**
    * 工具类
    *createUrlTemplateImageryProvider
    * @alias Core
    * @constructor
    *
    */
    function Core() {

    }

    /**
     * 如果未定义，则返回第一个参数，否则返回第二个参数。
     * 用于设置参数的默认值。
     *
     * @param {*} a
     * @param {*} b
     * @returns {*} 如果未定义，则返回第一个参数，否则返回第二个参数。
     *
     * @example
     * param = sgworld.Core.defaultValue(param, 'default');
     */
    Core.prototype.defaultValue = function (a, b) {
        return defaultValue(a, b);
    };

    /**
     * 修改鼠标样式。
     *
     * @param {DOM} container html DOM节点
     * @param {Number} [cursorstyle=0] 鼠标类型（0为默认，1为使用cur图标）
     * @param {String} url cur图标路径。
     *
     * @example
     * sgworld.Core.mouse(Viewer.container, 1, 'draw.cur');
     */
    Core.prototype.mouse = function (container, cursorstyle, url) {
        if (cursorstyle == 1) {
            container.style.cursor = "url(" + url + "),auto";
        } else {
            container.style.cursor = "default";
        }
    };
    /**
     * 创建鼠标Tooltip提示框。
     *
     * @param {*} [styleOrText] 提示框样式或文本内容
     * @param {String} [styleOrText.origin='center'] 对齐方式(center/top/bottom)
     * @param {String} [styleOrText.color='black'] 提示框颜色(black/white/yellow)
     * @param {String} [styleOrText.id=undefined] 提示框唯一id(可选)
     * @param {Object} position 显示位置
     * @param {Boolean} show 是否显示(如果为true，styleOrText必须为显示的文本内容)
     * @returns {Tooltip} Tooltip提示框。
     *
     * @example
     * sgworld.Core.CreateTooltip('这里是提示信息', {x:500, y:500}, true);
     * 或
     * tooltip = sgworld.Core.CreateTooltip();
     * tooltip.showAt({x:500, y:500}, '这里是提示信息');
     * 
     * tooltip.show(false); //隐藏提示框
     * tooltip.show(true); //显示提示框
     */
    Core.prototype.CreateTooltip = function (styleOrText = {}, position, show) {
        var style, _x, _y, _color, id;
        if (typeof styleOrText === 'object') {
            style = styleOrText;
        }
        if (style && style.origin) {
            style.origin === 'center' && (_x = 15, _y = -12);
            style.origin === 'top' && (_x = 15, _y = -44);
            style.origin === 'bottom' && (_x = 15, _y = 20);
        } else {
            _x = 15, _y = 20;
        }
        if (style && style.color) {
            style.color === 'white' && (_color = 'background: rgba(255, 255, 255, 0.8);color: black;');
            style.color === 'black' && (_color = 'background: rgba(0, 0, 0, 0.5);color: white;');
            style.color === 'yellow' && (_color = 'color: black;background-color: #ffcc33;border: 1px solid white;');
        } else {
            _color = 'background: rgba(0, 0, 0, 0.5);color: white;';
        }
        if (style && style.id) {
            id = "toolTip" + style.id;
        } else {
            id = "toolTip";
        }

        var tooltip = document.getElementById(id);

        if (!tooltip) {
            var elementbottom = document.createElement("div");
            $(".cesium-viewer").append(elementbottom);
            var html = '<div id="' + id + '" style="display: none;pointer-events: none;position: absolute;z-index: 1000;opacity: 0.8;border-radius: 4px;padding: 4px 8px;white-space: nowrap;font-family:黑体;color:white;font-weight: bolder;font-size: 14px;' + _color + '"></div>';
            $('.cesium-viewer').append(html);
            tooltip = document.getElementById(id);
        }
        if (show) {
            tooltip.innerHTML = styleOrText;
            tooltip.style.left = position.x + _x + "px";
            tooltip.style.top = position.y + _y + "px";
            tooltip.style.display = "block";
        } else {
            tooltip.style.display = "none";
        }
        return {
            tooltip: tooltip,
            style: style,
            showAt: function (position, text) {
                this.tooltip.innerHTML = text;
                if (this.style && this.style.origin) {
                    this.style.origin === 'center' && (_x = 15, _y = -this.tooltip.offsetHeight / 2);
                    this.style.origin === 'top' && (_x = 15, _y = -this.tooltip.offsetHeight - 20);
                    this.style.origin === 'bottom' && (_x = 15, _y = 20);
                } else {
                    _x = 15, _y = -this.tooltip.offsetHeight / 2;
                }
                this.tooltip.style.left = position.x + _x + "px";
                this.tooltip.style.top = position.y + _y + "px";
                this.tooltip.style.display = "block";
            },
            show: function (show) {
                if (show) {
                    this.tooltip.style.display = "block";
                } else {
                    this.tooltip.style.display = "none";
                }
            }
        };
    };

    /**
     * 获取点位到相机的距离
     * @param {Viewer} Viewer 地图视图
     * @param {Cartesian3} position 点位坐标
     * @returns {Number}
     */
    Core.prototype.getPointToCameraDistance = function (Viewer, position) {
        let distance;
        if (Viewer.scene.mode === 2) {
            let Cartographic = Viewer.camera.positionCartographic.clone();
            distance = Cesium.Cartesian3.distance(position,
                Cesium.Cartesian3.fromRadians(
                    Cartographic.longitude,
                    Cartographic.latitude,
                    Cartographic.height
                )
            );
        } else {
            distance = Cesium.Cartesian3.distance(position, Viewer.camera.position);
        }
        return distance;
    };

    /**
     * 创建结果提示框
     *
     * @param {Viewer} [Viewer] 地图视图
     * @param {Object} [style] 样式
     * @param {String} [style.id=undefined] 提示框唯一id(可选)
     * @param {String} [style.color='yellow'] 提示框颜色(black/white/yellow/blue)
     * @param {Number} [style.addX=0] 提示框X方向偏移量
     * @param {Number} [style.addY=0] 提示框Y方向偏移量
     * @param {Number} [style.near=undefined] 提示框最小可视距离
     * @param {Number} [style.far=undefined] 提示框最大可视距离
     * 
     * @returns {ResultTooltip} ResultTooltip提示框。
     *
     * @example
     * tooltip = sgworld.Core.CreateResultTooltip(Viewer);
     * tooltip.showAt(Cesium.Cartesian3.fromDegrees(110, 30, 10), '这里是提示信息');
     * 
     * tooltip.show(false); //隐藏提示框
     * tooltip.show(true); //显示提示框
     */
    Core.prototype.CreateResultTooltip = function (Viewer, style = {}) {
        var _x, _y, _color;
        let toolId = style.id ? 'resultToolTip' + style.id : 'resultToolTip';
        var tooltip = document.getElementById(toolId);

        if (style.color) {
            style.color === 'white' && (_color = 'background: rgba(255, 255, 255, 0.8);color: black;');
            style.color === 'black' && (_color = 'background: rgba(0, 0, 0, 0.5);color: white;');
            style.color === 'blue' && (_color = 'background: rgba(48, 119, 221);color: white;');
            style.color === 'yellow' && (_color = 'color: black;background-color: #ffcc33;border: 1px solid white;');
        } else {
            _color = 'color: black;background-color: #ffcc33;border: 1px solid white;';
        }
        if (!tooltip) {
            var html = '<div id="' + toolId + '" class="resultToolTip" style="display: none;pointer-events: none;position: absolute;z-index: 1000;opacity: 0.8;border-radius: 4px;padding: 4px 8px;white-space: nowrap;font-family:黑体;color:white;font-weight: bolder;font-size: 14px;' + _color + '"></div>';
            $(Viewer.container).append(html);
            tooltip = document.getElementById(toolId);
        }
        var addX = style.addX || 0;
        var addY = style.addY || 0;
        var position;
        var _this = this;
        function updateHtmlPosition() {
            if (position) {
                if (style.far !== undefined || style.near !== undefined) {
                    let distance = _this.getPointToCameraDistance(Viewer, position);
                    if (distance > style.far) {
                        tooltip.style.display = "none";
                        return;
                    } else if (distance < style.near) {
                        tooltip.style.display = "none";
                        return;
                    } else {
                        tooltip.style.display = "block";
                    }
                }
                var CanvasCoordinates = Viewer.scene.cartesianToCanvasCoordinates(position);
                if (!CanvasCoordinates) return;
                _x = -tooltip.offsetWidth / 2 + addX;
                _y = -tooltip.offsetHeight + addY;
                tooltip.style.left = CanvasCoordinates.x + _x + "px";
                tooltip.style.top = CanvasCoordinates.y + _y + "px";
            }
        }
        //监听视角改变
        Viewer.clock.onTick.addEventListener(updateHtmlPosition);
        return {
            tooltip: tooltip,
            position: position,
            showAt: function (_position, text) {
                this.tooltip.innerHTML = text;
                this.tooltip.style.display = "block";
                this.position = _position;
                position = _position;
                if (position) {
                    var CanvasCoordinates = Viewer.scene.cartesianToCanvasCoordinates(position);
                    if (!CanvasCoordinates) return;
                    _x = -this.tooltip.offsetWidth / 2 + addX;
                    _y = -this.tooltip.offsetHeight + addY;
                    this.tooltip.style.left = CanvasCoordinates.x + _x + "px";
                    this.tooltip.style.top = CanvasCoordinates.y + _y + "px";
                }
            },
            show: function (show) {
                if (show) {
                    this.tooltip.style.display = "block";
                    position = this.position;
                } else {
                    this.tooltip.style.display = "none";
                    position = undefined;
                }
            },
            destroy() {
                Viewer.clock.onTick.removeEventListener(updateHtmlPosition);
                tooltip.remove();
            }
        };
    };

    /**
     * Echarts扩展
     *
     * @param {Viewer} [Viewer] 地图视图
     * @param {Object} [option] Echarts对应的参数。
     * @param {Boolean} [isClear=false] 是否清除原先图层。
     * 
     * @returns {CombineEcharts} Echarts扩展工具
     *
     * @example
     * echartsTool = sgworld.Core.CombineEcharts(Viewer, option, true);
     */
    Core.prototype.CombineEcharts = function (Viewer, option, isClear) {
        if (!this._CombineEcharts) {
            this._CombineEcharts = new CombineEcharts(Viewer);
        }
        return this._CombineEcharts.setOption(option, isClear);
    };

    /**
     * 获取随机的热力图数据
     *
     * @param {Object} [bounds] 数据范围。
     * @param {Number} [bounds.east] 东。
     * @param {Number} [bounds.south] 南。
     * @param {Number} [bounds.west] 西。
     * @param {Number} [bounds.north] 北。
     * @param {Object} [data] 热力值。
     * @param {Number} [data.max] 最大值。
     * @param {Number} [data.min] 最小值。
     * @param {Number} [data.value] 固定值，如设置value，则所有点的热力值都为该值。
     * @param {Number} [num=600] 随机点数。
     * 
     * @returns {Object} 热力图数据
     *
     * @example
     * data = sgworld.Core.getHeatmapData({
     *  west: 70.0, 
     *  south: 10.0,
     *  east: 140.0,
     *  north: 50.0
     * }, {
     *  max:100, 
     *  min:0
     * });
     */
    Core.prototype.getHeatmapData = function (bounds, data, num = 600) {
        let heatmapData = [];
        for (let i = 0; i < num; i++) {
            let x = Math.random() * (bounds.east - bounds.west) + bounds.west;
            let y = Math.random() * (bounds.north - bounds.south) + bounds.south;
            let value = data.value || Math.random() * (data.max - data.min) + data.min;
            heatmapData.push({ x: x, y: y, value: value });
        }
        return heatmapData;
    };

    /**
     * 射线求交
     * 
     * @param {Viewer} Viewer 地图视图
     * @param {Cesium.Cartesian3} start 起点
     * @param {Cesium.Cartesian3} end 终点
     * @param {Array} objectsToExclude 排除的对象
     */
    Core.prototype.pickFromRay = function (Viewer, start, end, objectsToExclude = []) {
        // 计算射线的方向，目标点left 视点right
        let direction = Cesium.Cartesian3.normalize(Cesium.Cartesian3.subtract(end, start, new Cesium.Cartesian3()), new Cesium.Cartesian3());
        // 建立射线
        let ray = new Cesium.Ray(start, direction);
        let result = Viewer.scene.pickFromRay(ray, objectsToExclude); // 计算交互点，返回第一个
        return result;
    };

    /**
     * 获取json数据
     *
     * @param {String} url json地址。
     * @param {Function} callback 回调函数。
     * 
     * @example
     * sgworld.Core.getJSON('./abc.json', data => {
     *  console.log(data)
     * });
     */
    Core.prototype.getJSON = function (url, callback) {
        const xhr = new XMLHttpRequest();
        xhr.responseType = 'json';
        xhr.open('get', url, true);
        xhr.onload = function () {
            if (xhr.status >= 200 && xhr.status < 300) {
                callback(xhr.response);
            } else {
                throw new Error(xhr.statusText);
            }
        };
        xhr.send();
    };
    /**
     * WKT转三维笛卡尔坐标
     *
     * @param {String} [WKT] WKT坐标串
     * 
     * @returns {Cartesian3[]} 三维笛卡尔坐标数组
     *
     * @example
     * positions = sgworld.Core.getPositionFromWKT(WKT);
     */
    Core.prototype.getPositionFromWKT = function (WKT) {
        let geometry = WKT + "!";
        let geo;
        let position = [];
        if (geometry.indexOf("MULTIPOLYGON") > -1) {
            //去除首尾“MULTIPOLYGON(...)!  ——>  ((),(),()) , ((),(),()) , ((),(),())”
            geo = geometry.replace("MULTIPOLYGON(", "");
            geo = geo.replace(")!", "");
            //拆分多面
            geo = geo.split(")),((");

            geo.forEach((item, index) => {
                let _geo;
                if (geo.length === 1) {
                    //如果只有1个，说明没有被分割
                    // 去掉首尾括号 ((),(),()) ——> (),(),()
                    _geo = item.substring(1, item.length - 1);
                } else if (index === 0) {
                    // 第一个，去第一个(,   补结尾加上)    ((),(),(  ——> (),(),()
                    _geo = item.substring(1, item.length) + ")";
                } else if (index === geo.length - 1) {
                    // 最后一个, 补第一个(, 去 最后一个)    ),(),())  ——> (),(),()
                    _geo = "(" + item.substring(0, item.length - 1);
                } else {
                    // 中间，补第一个(,   补最后一个)    ),(),(  ——> (),(),()
                    _geo = "(" + item + ")";
                }
                //_geo为(),(),()   环的集合

                //拆分多环
                _geo = _geo.split("),(");

                _geo.forEach((ring, _index) => {
                    let ringGeo;
                    if (_geo.length === 1) {
                        //如果只有1个，说明没有被分割
                        // 去掉首尾括号 ()
                        ringGeo = ring.substring(1, ring.length - 1);
                    } else if (_index === 0) {
                        // 第一个，去第一个(
                        ringGeo = ring.substring(1, ring.length);
                    } else if (_index === _geo.length - 1) {
                        // 最后一个, 去最后一个)
                        ringGeo = ring.substring(0, ring.length - 1);
                    }
                    //ringGeo为点串 118.729063485 29.7893243870001,118.726590019 29.78666994

                    //拆分点
                    ringGeo = ringGeo.split(",");
                    let _position = [];
                    ringGeo.forEach((point) => {
                        let degrees = point.split(" ");
                        _position.push(
                            Cesium.Cartesian3.fromDegrees(degrees[0], degrees[1])
                        );
                    });
                    position.push(_position);
                });
            });
        } else if (geometry.indexOf("POLYGON") > -1) {
            //去除首尾“POLYGON(...)!  ——>  (),(),()”
            geo = geometry.replace("POLYGON(", "");
            geo = geo.replace(")!", "");

            //拆分多环
            geo = geo.split("),(");

            geo.forEach((ring, _index) => {
                let ringGeo;
                if (geo.length === 1) {
                    //如果只有1个，说明没有被分割
                    // 去掉首尾括号 ()
                    ringGeo = ring.substring(1, ring.length - 1);
                } else if (_index === 0) {
                    // 第一个，去第一个(
                    ringGeo = ring.substring(1, ring.length);
                } else if (_index === geo.length - 1) {
                    // 最后一个, 去最后一个)
                    ringGeo = ring.substring(0, ring.length - 1);
                }
                //ringGeo为点串 118.729063485 29.7893243870001,118.726590019 29.78666994

                //拆分点
                ringGeo = ringGeo.split(",");
                let _position = [];
                ringGeo.forEach((point) => {
                    let degrees = point.split(" ");
                    _position.push(
                        Cesium.Cartesian3.fromDegrees(degrees[0], degrees[1])
                    );
                });
                position.push(_position);
            });
        }

        return position;
    };
    /**
     * 矢量切片样式
     *
     * @param {Object} [option] 样式
     * 
     * @returns {Object} 矢量切片样式
     *
     */
    Core.prototype.VectorSlice = function (option) {
        var port = 'EPSG:4490';
        if (option.port) {
            port = option.port;
        }
        var defaultGeoOptions = {
            url: option.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: option.layer,
                STYLE: '',
                TILEMATRIX: port + ':{z}',
                TILEMATRIXSET: port,
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: option.upperLevelLimit,
            lowerLevelLimit: option.lowerLevelLimit,
            rectangle: Cesium.Rectangle.fromDegrees(option.minx, option.miny, option.maxx, option.maxy)
        };
        return defaultGeoOptions;
    };

    /**
     * 三点计算角度 <ABC | <B
     * @param {Object} centerP 中点B
     * @param {Object} startP 起点A
     * @param {Object} endP 终点C
     * @param {String} [type="180"] 类型["180" | "360" | "+-"]
     * @param {Boolean} [isCanvasCoordinates=false] 是否是屏幕坐标
     * 
     */
    Core.prototype.arge = function (centerP, startP, endP, type = '180', isCanvasCoordinates = false) {
        let lengthAB = Math.sqrt(Math.pow(centerP.x - startP.x, 2) +
            Math.pow(centerP.y - startP.y, 2)),
            lengthAC = Math.sqrt(Math.pow(centerP.x - endP.x, 2) +
                Math.pow(centerP.y - endP.y, 2)),
            lengthBC = Math.sqrt(Math.pow(startP.x - endP.x, 2) +
                Math.pow(startP.y - endP.y, 2));
        let cosA = (Math.pow(lengthAB, 2) + Math.pow(lengthAC, 2) - Math.pow(lengthBC, 2)) /
            (2 * lengthAB * lengthAC);
        let angle = Math.round(Math.acos(cosA) * 180 / Math.PI);
        if (type === '360' || type === '+-') {
            let scale = isCanvasCoordinates ? -1 : 1;
            // 屏幕坐标Y轴向下，对于正常的XY坐标来说，y值相反
            let isClockwise = this.isClockwise([[startP.x, scale * startP.y], [centerP.x, scale * centerP.y], [endP.x, scale * endP.y], [startP.x, scale * startP.y]]);
            if (!isClockwise) {
                if (type === '+-') {
                    angle = -angle;
                } else {
                    angle = 360 - angle;
                }
            }
        }
        return angle
    };

    /**
     * 是否顺时针
     * @param {Array} points 点串
     * @returns {Boolean}
     * 
     * @example
     * isClockwise = sgworld.Core.isClockwise([[0,0],[1,1],[1,0],[0,0]]);
     * //=true
     */
    Core.prototype.isClockwise = function (points) {
        let clockwiseRing = Cesium.turf.lineString(points);
        return Cesium.turf.booleanClockwise(clockwiseRing)
    };

    /**
     * 保存
     * @param {Array} points 点串
     * @returns {Boolean}
     * 
     * @example
     * sgworld.Core.saveAs(blob, 'test.json');
     */
    Core.prototype.saveAs = function (blob, fileName) {
        if (!window.saveAs) {
            let SkipTool = new Skip(false);
            SkipTool.addJs(document.body, window.SmartEarthRootUrl + 'Workers/FileSaver.js');
        }
        saveAs(blob, fileName);
    };

    /**
     * 修改三维笛卡尔坐标高度
     *
     * @param {Cartesian3} [position] 三维笛卡尔坐标
     * @param {Number} [height] 修改后高度
     * 
     * @returns {Cartesian3} 三维笛卡尔坐标
     *
     */
    Core.prototype.setheight = function (position, height) {
        var Cartographic = Cesium.Cartographic.fromCartesian(position);
        return Cesium.Cartesian3.fromRadians(Cartographic.longitude, Cartographic.latitude, height);
    };

    /**
     * 修改多个三维笛卡尔坐标高度
     *
     * @param {Cartesian3[]} [positions] 三维笛卡尔坐标串
     * @param {Number} [height] 修改后高度
     * 
     * @returns {Cartesian3[]} 三维笛卡尔坐标
     *
     */
    Core.prototype.setpolylineheight = function (position, height) {
        var path = [];
        position.forEach(function (item) {
            var Cartographic = Cesium.Cartographic.fromCartesian(item);
            path.push(Cesium.Cartesian3.fromRadians(Cartographic.longitude, Cartographic.latitude, height));
        });
        return path;
    };

    //GeoJson数据对比
    Core.prototype.StyleContrastGeoJson = function (obj1, Cesium) {
        var point = {
            color: Cesium.Color.WHITE,
            pixelSize: 1,
            outlineColor: Cesium.Color.BLACK,
            outlineWidth: 0,
            show: true,
            distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, 999999999)
        };
        var label = {
            id: 'my label',
            text: "",
            font: "30px sans-serif",
            fillColor: Cesium.Color.WHITE,
            outlineColor: Cesium.Color.WHITE,
            outlineWidth: "10",
            scale: 1.0,
            distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, 999999999)
        };
        var billboard = {
            show: true,
            scale: 1.0,
            width: undefined,
            height: undefined,
            pixelOffset: undefined,
            color: Cesium.Color.WHITE,
            image: "",
            distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, 999999999)
        };
        var polyline = {
            positions: [],
            arcType: Cesium.ArcType.GEODESIC,
            clampToGround: true,
            width: 1.0,
            show: true,
            material: Cesium.Color.RED,
            height: 30,
        };
        var polygon = {
            height: 0,
            heightReference: Cesium.HeightReference.NONE,
            show: true,
            fill: true,
            material: Cesium.Color.WHITE,
            outline: false,
            outlineColor: Cesium.Color.BLACK,
            outlineWidth: 1.0,
            stRotation: 0.0,
            granularity: Cesium.Math.RADIANS_PER_DEGREE,
            perPositionHeight: false,
            closeTop: true,
            closeBottom: true,
            shadows: Cesium.ShadowMode.ENABLED,
            clampToGround: true,
        };
        if (this.isnull(obj1.near)) {
            obj1.near = 0;
        }
        if (this.isnull(obj1.far)) {
            obj1.far = 999999999;
        }
        var min = parseFloat(obj1.near);
        var max = parseFloat(obj1.far);
        delete obj1.near;
        delete obj1.far;
        // obj1.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(min, max);
        if (obj1.point != undefined) {
            obj1.point = this.extend(point, obj1.point, true);
            obj1.point.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(min, max);
        }
        if (obj1.label != undefined) {
            obj1.label = this.extend(label, obj1.label, true);
            obj1.label.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(min, max);
        }
        if (obj1.billboard != undefined) {
            obj1.billboard = this.extend(billboard, obj1.billboard, true);
            obj1.billboard.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(min, max);
        }
        if (obj1.polyline != undefined) {
            obj1.polyline = this.extend(polyline, obj1.polyline, true);
            obj1.polyline.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(min, max);
        }
        if (obj1.polygon != undefined) {
            obj1.polygon = this.extend(polygon, obj1.polygon, true);
            obj1.polygon.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(min, max);
        }
        return obj1;
    };
    //点坐标解析
    Core.prototype.getCatesian3FromPX = function (px, viewer, Cesium, entitys) {
        var pick = viewer.scene.pick(px);
        var cartesian;
        var drillPick = viewer.scene.drillPick(px);
        var truePick = null;
        if (entitys) {
            for (var i = 0; i < drillPick.length; i++) {
                if (drillPick[i].id._id != (entitys && entitys[0] && entitys[0].id) && drillPick[i].id._id != (entitys && entitys[1] && entitys[1].id)) {
                    truePick = drillPick[i].id;
                    break;
                }
            }
        } else {
            truePick = pick;
        }
        if (viewer.scene.pickPositionSupported && Cesium.defined(truePick)) {
            cartesian = viewer.scene.pickPosition(px);
        } else {
            var ray = viewer.camera.getPickRay(px);
            if (!ray) return;
            cartesian = viewer.scene.globe.pick(ray, viewer.scene);
        }
        return cartesian;
    };
    //矢量数据样式对比
    Core.prototype.StyleContrast = function (EntityTyple, obj1, Cesium) {
        var lable = {
            text: "",
            font: ' 30px sans-serif',
            style: Cesium.LabelStyle.FILL_AND_OUTLINE,
            fillColor: Cesium.Color.WHITE, //	optional A Property specifying the fill Color.
            outlineColor: Cesium.Color.BLACK, //	optional A Property specifying the outline Color.
            outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
            show: true, //	optional A boolean Property specifying the visibility of the label.
            showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new Cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
            backgroundPadding: new Cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: Cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
            verticalOrigin: Cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
            eyeOffset: Cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: Cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: Cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
            scaleByDistance: undefined,
            distanceDisplayCondition: undefined
        };
        var billboard = {
            show: true,
            position: Cesium.Cartesian3.ZERO,
            pixelOffset: Cesium.Cartesian2.ZERO,
            eyeOffset: Cesium.Cartesian3.ZERO,
            heightReference: Cesium.HeightReference.NONE,
            horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
            verticalOrigin: Cesium.VerticalOrigin.CENTER,
            scale: 1.0,
            image: '',
            imageSubRegion: undefined,
            color: Cesium.Color.WHITE,
            rotation: 0.0,
            alignedAxis: Cesium.Cartesian3.ZERO,
            width: undefined,
            height: undefined,
            scaleByDistance: undefined,
            translucencyByDistance: undefined,
            pixelOffsetScaleByDistance: undefined,
            sizeInMeters: false,
            distanceDisplayCondition: undefined
        };
        var point = {
            show: true,
            pixelSize: 1,
            heightReference: Cesium.HeightReference.NONE,
            color: Cesium.WHITE,
            outlineColor: Cesium.Color.BLACK,
            outlineWidth: 1.0,
            scaleByDistance: undefined,
            translucencyByDistance: undefined,
            distanceDisplayCondition: undefined
        };
        var polyline = {
            positions: [],
            width: 5,
            material: Cesium.Color.ALICEBLUE,
            arcType: Cesium.ArcType.GEODESIC
        };
        var polygon = {
            polygonHierarchy: new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromDegreesArray([-72.0, 40.0, -70.0, 35.0, -75.0, 30.0, -70.0, 30.0, -68.0, 40.0])),
            height: 0,
            extrudedHeight: 0,
            material: "rgba(245, 20, 20, 0.91)"
        };
        if (this.isnull(obj1.near)) {
            obj1.near = 0;
        }
        if (this.isnull(obj1.far)) {
            obj1.far = 999999999;
        }
        var min = parseFloat(obj1.near);
        var max = parseFloat(obj1.far);
        delete obj1.near;
        delete obj1.far;
        obj1.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(min, max);
        if (EntityTyple == "lable") {
            obj1 = this.extend(lable, obj1, true);
        } else if (EntityTyple == "billboard") {
            obj1 = this.extend(billboard, obj1, true);
        } else if (EntityTyple == "point") {
            obj1 = this.extend(point, obj1, true);
        } else if (EntityTyple == "polyline") {
            obj1 = this.extend(polyline, obj1, true);
        } else if (EntityTyple == "polygon") {
            obj1 = this.extend(polygon, obj1, true);
        }
        return obj1;
    };
    //创建矢量PolylineObject
    Core.prototype.createPolyline = function (entity, Type, id, Cesium) {
        var geometryInstance = null;
        if (Type == -1) {
            var geometry = new Cesium.PolylineGeometry(entity);
            geometryInstance = new Cesium.GeometryInstance({
                id: id,
                geometry: geometry
            });
        } else {
            var geometry = new Cesium.GroundPolylineGeometry(entity);
            geometryInstance = new Cesium.GeometryInstance({
                geometry: geometry,
                id: id
            });
        }
        return geometryInstance;
    };
    //创建矢量PolygonObject
    Core.prototype.createPolygon = function (entity, Type, id, Cesium) {
        var geometryInstance = null;
        var color = entity.material;
        var extrudedPolygon = new Cesium.PolygonGeometry(entity);
        delete entity.material;
        //var geometry = Cesium.PolygonGeometry.createGeometry(extrudedPolygon);
        geometryInstance = new Cesium.GeometryInstance({
            id: id,
            geometry: extrudedPolygon,
            attributes: {
                color: new Cesium.ColorGeometryInstanceAttribute.fromColor(color),
            }
        });
        return geometryInstance;
    };
    //坐标转化添加
    Core.prototype.coordinate = function (newArr, arr) {
        for (var i = 0; i < arr.length; i++) {
            if (Array.isArray(arr[i])) {
                this.coordinate(newArr, arr[i]);
            } else {
                newArr.push(arr[i]);
            }
        }
        return newArr;
    };
    //从矢量数据中解析数据
    Core.prototype.Analysis = function (obj1, feature) {
        if (/^\[/.test(obj1) && /\]$/.test(obj1)) {
            var material = obj1.replace(/\[/, '').replace(/\]/, '');
            if (feature.properties[material] != undefined) {
                obj1 = feature.properties[material];
            }
        }
        return obj1;
    };
    //数据数组去重
    Core.prototype.unique = function (arr) {
        var newArr = [];
        for (var i = 0; i < arr.length; i++) {
            if (newArr.indexOf(arr[i]) === -1) {
                newArr.push(arr[i]);
            }
        }
        return newArr
    };
    //数据对比获取属性
    Core.prototype.extend = function (o, n, override) {
        for (var key in n) {
            if (n.hasOwnProperty(key) && (!o.hasOwnProperty(key) || override)) {
                o[key] = n[key];
            }
        }
        //this.extendgl(o);
        return o;
    };

    /**
     * 获取影像偏移的切片方案
     * @param {String} [srs="GCJ02"] 坐标系
     */
    Core.prototype.getOffsetTilingScheme = function (srs = "GCJ02", tilingScheme) {
        let TilingScheme = tilingScheme || new Cesium.WebMercatorTilingScheme();
        let isWebMercator = true;
        if (TilingScheme instanceof Cesium.GeographicTilingScheme) {
            isWebMercator = false;
        }
        let projection;
        if (isWebMercator) {
            projection = new Cesium.WebMercatorProjection();
        } else {
            projection = new Cesium.GeographicProjection();
        }
        if (srs === 'GCJ02') {
            TilingScheme._projection.project = function (cartographic, result) {
                result = CoordTransform.WGS84ToGCJ02(
                    Cesium.Math.toDegrees(cartographic.longitude),
                    Cesium.Math.toDegrees(cartographic.latitude)
                );
                result = projection.project(
                    new Cesium.Cartographic(
                        Cesium.Math.toRadians(result[0]),
                        Cesium.Math.toRadians(result[1])
                    )
                );
                return new Cesium.Cartesian2(result.x, result.y);
            };
            TilingScheme._projection.unproject = function (cartesian, result) {
                let cartographic = projection.unproject(cartesian);
                result = CoordTransform.GCJ02ToWGS84(
                    Cesium.Math.toDegrees(cartographic.longitude),
                    Cesium.Math.toDegrees(cartographic.latitude)
                );
                return new Cesium.Cartographic(
                    Cesium.Math.toRadians(result[0]),
                    Cesium.Math.toRadians(result[1])
                );
            };
        }
        return TilingScheme;
    };
    Core.prototype.getPointFromWindowPoint = function (point, _viewer) {
        if (_viewer.scene.terrainProvider.constructor.name == "EllipsoidTerrainProvider") {
            return _viewer.camera.pickEllipsoid(point, _viewer.scene.globe.ellipsoid);
        } else {
            var ray = _viewer.scene.camera.getPickRay(point);
            return _viewer.scene.globe.pick(ray, _viewer.scene);
        }
    };
    Core.prototype.isnull = function (param) {
        if (param == null || param == undefined || param === '')
            return true;
        else
            return false;
    };
    Core.prototype.getuid = function () {
        // var idStr = Date.now().toString(36);
        // idStr += Math.random().toString(36).substr(3);
        // return idStr;

        // return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        //     var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
        //     return v.toString(16);
        // });

        return this.uuid(8, 16);
    };
    //过滤数据
    Core.prototype.extendgl = function (entity, optionItem, optionItems) {
        if (optionItem != undefined && optionItem != null) {
            if (typeof (optionItem) == 'string') {
                if (optionItem.charAt(0) == "[" && optionItem.charAt(optionItem.length - 1) == "]") {
                    optionItem = optionItem.substr(0, optionItem.length - 1);
                    optionItem = optionItem.substr(1);
                    if (entity.properties[optionItem]._value != undefined) {
                        optionItem = entity.properties[optionItem]._value;
                    } else if (entity.properties[optionItem] != undefined) {
                        optionItem = entity.properties[optionItem];
                    }
                }
            }
            return optionItem;
        } else {
            return optionItems;
        }
    };
    /**
     * 获取uuid
     */
    Core.prototype.uuid = function (len, radix) {
        var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
        var uuid = [], i;
        var uuid = [],
            i;
        radix = radix || chars.length;

        if (len) {
            // Compact form
            for (i = 0; i < len; i++) uuid[i] = chars[0 | Math.random() * radix];
        } else {
            // rfc4122, version 4 form
            var r;

            // rfc4122 requires these characters
            uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
            uuid[14] = '4';

            // Fill in random data.  At i==19 set the high bits of clock sequence as
            // per rfc4122, sec. 4.1.5
            for (i = 0; i < 36; i++) {
                if (!uuid[i]) {
                    r = 0 | Math.random() * 16;
                    uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
                }
            }
        }

        return uuid.join('');
    };
    //着色器
    Core.prototype.Shaders = function (Shadersp) {
        var Shaders = "";
        if (Shadersp == "VSHADER_SOURCE ") {
            Shaders = "attribute vec4 a_Position;"
                + "\nattribute vec2 a_TexCoord;"
                + "\nuniform mat4 u_MvpMatrix;"
                + "\nvarying vec2 v_TexCoord;"
                + "\n"
                + "void main()"
                + "{\ngl_Position = u_MvpMatrix * a_Position;\nv_TexCoord = a_TexCoord;\n}\n";
        } else if (Shadersp == "TRIANGLE_FSHADER_SOURCE") {
            Shaders = "#ifdef GL_ES" +
                "\nprecision mediump float;"
                + "\n#endif"
                + "\nvarying vec4 v_Color;"
                + "\nvoid main()"
                + " {\ngl_FragColor = v_Color;\n'}\n";
        } else if (Shadersp == "TRIANGLE_VSHADER_SOURCE") {
            Shaders = "attribute vec4 a_Position;"
                + "\nattribute vec4 a_Normal;"
                + "\nuniform mat4 u_MvpMatrix;"
                + "\nuniform mat4 u_NormalMatrix;"
                + "\nvarying vec4 v_Color;"
                + "\n"
                + "void main() {"
                + "\nvec3 lightDirection = vec3(0.0, 0.0, 1.0);\nvec4 color = vec4(1.0, 1.0, 0.0, 1.0);\ngl_Position = u_MvpMatrix * a_Position;\nvec3 normal = normalize(vec3(u_NormalMatrix * a_Normal));\nfloat nDotL = max(dot(normal, lightDirection), 0.0);\nv_Color = vec4(color.rgb * nDotL, color.a);\n}\n";
        } else if (Shadersp == "vertexShaderSource") {
            Shaders = "attribute vec3 position3DHigh;"
                + "\r\n" + "attribute vec3 position3DLow;"
                + "\r\n" + "attribute vec3 normal;"
                + "\r\nattribute vec2 st;"
                + "\r\nattribute vec4 color;"
                + "\r\nattribute float batchId;"
                + "\r\nvarying vec3 v_positionEC;"
                + "\r\nvarying vec3 v_normalEC;"
                + "\r\nvarying vec2 v_st;"
                + "\r\nvarying vec4 v_color;"
                + "\r\n"
                + "void main()"
                + "\r\n{"
                + "\r\nvec4 p = czm_computePosition();"
                + "\r\nv_positionEC = (czm_modelViewRelativeToEye * p).xyz;"
                + "\r\nv_normalEC = czm_normal * normal;"
                + "\r\nv_st = st;"
                + "\r\nv_color = color;"
                + "\r\ngl_Position = czm_modelViewProjectionRelativeToEye * p;"
                + "\r\n}\r\n";
        } else if (Shadersp == "fragmentShaderSource") {
            Shaders = "varying vec3 v_positionEC;"
                + "\r\nvarying vec3 v_normalEC;"
                + "\r\nvarying vec2 v_st;"
                + "\r\nvarying vec4 v_color;"
                + "\r\n"

                + "\r\nvec4 czm_phong(vec3 toEye, czm_material material)"
                + "\r\n{"

                + "\r\nfloat diffuse = czm_private_getLambertDiffuseOfMaterial(vec3(0.0, 0.0, 1.0), material);"
                + "\r\nif (czm_sceneMode == czm_sceneMode3D) {"
                + "\r\n    diffuse += czm_private_getLambertDiffuseOfMaterial(vec3(0.0, 1.0, 0.0), material);"
                + "\r\n}"

                + "\r\nfloat specular = czm_private_getSpecularOfMaterial(czm_sunDirectionEC, toEye, material) + czm_private_getSpecularOfMaterial(czm_moonDirectionEC, toEye, material);"

                + "\r\nvec3 materialDiffuse = material.diffuse * 0.5;"

                + "\r\nvec3 ambient = materialDiffuse;"
                + "\r\nvec3 color = ambient + material.emission;"
                + "\r\ncolor += materialDiffuse * diffuse;"
                + "\r\ncolor += material.specular * specular;"

                + "\r\nreturn vec4(color, material.alpha);"
                + "\r\n}"
                + "void main()"
                + "\r\n{\r\nvec3 positionToEyeEC = -v_positionEC;"
                + "\r\nvec3 normalEC = normalize(v_normalEC);"
                + "\r\n#ifdef FACE_FORWARD"
                + "\r\nnormalEC = faceforward(normalEC, vec3(0.0, 0.0, 1.0), -normalEC);"
                + "\r\n#endif"
                + "\r\nvec4 color = czm_gammaCorrect(v_color);"
                + "\r\nczm_materialInput materialInput;"
                + "\r\nmaterialInput.normalEC = normalEC;"
                + "\r\nmaterialInput.positionToEyeEC = positionToEyeEC;\r\nmaterialInput.st = v_st;"
                + "\r\nczm_material material = czm_getDefaultMaterial(materialInput);"
                + "\r\nmaterial.diffuse = color.rgb;\r\nmaterial.alpha = color.a;"
                + "\r\n#ifdef FLAT\r\ngl_FragColor = vec4(material.diffuse + material.emission, material.alpha);"
                + "\r\n#else\r\ngl_FragColor = czm_phong(normalize(positionToEyeEC), material);\r\n#endif\r\n}\r\n";
        }
        return Shaders;
    };
    //判断是否是颜色
    Core.prototype.isHtmlColor = function (htmlcolor) {
        var reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6}|[0-9a-fA-f]{8})$/;
        return reg.test(htmlcolor);
    };
    Core.prototype.isUrl = function (url) {
        if (this.isnull(url)) {
            return false;
        }
        var reg = /^(?:([A-Za-z]+):)?(\/{0,3})([0-9.\-A-Za-z]+)(?::(\d+))?(?:\/([^?#]*))?(?:\?([^#]*))?(?:#(.*))?$/;
        return reg.test(url);
    };
    Core.prototype.dateTimespan = function () {
        var date = new Date();
        return date.toTimeString();
    };
    //获取两点间距离起点某一距离的一个点
    Core.prototype.getPointFromTwoPointCenter = function (positions, distance, height) {

        let allDistance = this.getSpaceDistancem(positions, Cesium);
        let startPoint = positions[0];
        let endPoint = positions[1];

        let scartographic = Cesium.Cartographic.fromCartesian(startPoint);
        let slongitude = Cesium.Math.toDegrees(scartographic.longitude);
        let slatitude = Cesium.Math.toDegrees(scartographic.latitude);
        let sheight = scartographic.height;

        let ecartographic = Cesium.Cartographic.fromCartesian(endPoint);
        let elongitude = Cesium.Math.toDegrees(ecartographic.longitude);
        let elatitude = Cesium.Math.toDegrees(ecartographic.latitude);
        let eheight = ecartographic.height;

        let pointSum = parseFloat(allDistance / distance); //取样点个数
        let addX = Cesium.Math.lerp(slongitude, elongitude, 1.0 / pointSum) - slongitude;
        let addY = Cesium.Math.lerp(slatitude, elatitude, 1.0 / pointSum) - slatitude;
        let addZ = Cesium.Math.lerp(sheight, eheight, 1.0 / pointSum) - sheight;
        return Cesium.Cartesian3.fromDegrees(slongitude + addX, slatitude + addY, height || sheight + addZ);
    };
    //空间距离测量(千米)
    Core.prototype.getSpaceDistance = function (positions, Cesium) {
        var distance = 0;
        var dis = "";
        for (var i = 0; i < positions.length - 1; i++) {
            var point1cartographic = Cesium.Cartographic.fromCartesian(positions[i]);
            var point2cartographic = Cesium.Cartographic.fromCartesian(positions[i + 1]);
            /**根据经纬度计算出距离**/
            var geodesic = new Cesium.EllipsoidGeodesic();
            geodesic.setEndPoints(point1cartographic, point2cartographic);
            var s = geodesic.surfaceDistance;
            //console.log(Math.sqrt(Math.pow(distance, 2) + Math.pow(endheight, 2)));
            //返回两点之间的距离
            s = (Math.sqrt(Math.pow(s, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2)));
            distance = distance + s;
        }
        if (distance >= 1000) {
            dis = (distance / 1000).toFixed(2) + "千米";
        } else {
            dis = (distance.toFixed(2)) + "米";
        }
        //return distance.toFixed(2);
        return dis;
    };
    //空间距离测量用米
    Core.prototype.getSpaceDistancem = function (positions, Cesium) {
        var distance = 0;
        for (var i = 0; i < positions.length - 1; i++) {
            var point1cartographic = Cesium.Cartographic.fromCartesian(positions[i]);
            var point2cartographic = Cesium.Cartographic.fromCartesian(positions[i + 1]);
            /**根据经纬度计算出距离**/
            var geodesic = new Cesium.EllipsoidGeodesic();
            geodesic.setEndPoints(point1cartographic, point2cartographic);
            var s = geodesic.surfaceDistance;
            //console.log(Math.sqrt(Math.pow(distance, 2) + Math.pow(endheight, 2)));
            //返回两点之间的距离
            s = (Math.sqrt(Math.pow(s, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2)));
            distance = distance + s;
        }
        return distance.toFixed(2);
    };
    //水平距离测量
    Core.prototype.getHorizontalDistance = function (positions, Cesium) {
        var distance = 0;
        for (var i = 0; i < positions.length - 1; i++) {

            var point1cartographic = Cesium.Cartographic.fromCartesian(positions[i]);
            var point2cartographic = Cesium.Cartographic.fromCartesian(positions[i + 1]);
            /**根据经纬度计算出距离**/
            var geodesic = new Cesium.EllipsoidGeodesic();
            geodesic.setEndPoints(point1cartographic, point2cartographic);
            var s = geodesic.surfaceDistance;
            //console.log(Math.sqrt(Math.pow(distance, 2) + Math.pow(endheight, 2)));
            //返回两点之间的距离
            //s = Math.sqrt(Math.pow(s, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2));
            distance = distance + s;
        }
        if (distance >= 1000) {
            distance = (distance / 1000).toFixed(2) + "千米";
        } else {
            distance = (distance.toFixed(2)) + "米";
        }
        return distance;
    };
    //扫掠体截面样式-多边形
    Core.prototype.starPositions = function (arms, rOuter, rInner) {
        var angle = Math.PI / arms;
        var pos = [];
        for (var i = 0; i < 2 * arms; i++) {
            var r = (i % 2) === 0 ? rOuter : rInner;
            var p = new Cesium.Cartesian2(Math.cos(i * angle) * r, Math.sin(i * angle) * r);
            pos.push(p);
        }
        return pos;
    };
    //扫掠体截面样式-圆形
    Core.prototype.computeCircle = function (radius) {
        var positions = [];
        for (var i = 0; i < 360; i++) {
            var radians = Cesium.Math.toRadians(i);
            positions.push(new Cesium.Cartesian2(radius * Math.cos(radians), radius * Math.sin(radians)));
        }
        return positions;
    };
    //计算多边形面积
    Core.prototype.getArea = function (points, positions, Cesium, isnum) {
        var res = 0;
        //拆分三角曲面
        for (var i = 0; i < points.length - 2; i++) {
            var j = (i + 1) % points.length;
            var k = (i + 2) % points.length;
            var totalAngle = this.Angle(points[i], points[j], points[k]);

            var dis_temp1 = this.getdistance(positions[i], positions[j], Cesium);
            var dis_temp2 = this.getdistance(positions[j], positions[k], Cesium);
            res += dis_temp1 * dis_temp2 * Math.abs(Math.sin(totalAngle));
            // console.log(res);
        }
        if (isnum) {
            return res;
        }
        if (res < 1000000) {
            res = res.toFixed(2) + '平方米';
        } else {
            res = (res / 1000000.0).toFixed(2) + '平方千米';
        }
        return res;
    };
    //计算
    Core.prototype.getdistance = function (point1, point2, Cesium) {
        var point1cartographic = Cesium.Cartographic.fromCartesian(point1);
        var point2cartographic = Cesium.Cartographic.fromCartesian(point2);
        /**根据经纬度计算出距离**/
        var geodesic = new Cesium.EllipsoidGeodesic();
        geodesic.setEndPoints(point1cartographic, point2cartographic);
        var s = geodesic.surfaceDistance;
        //console.log(Math.sqrt(Math.pow(distance, 2) + Math.pow(endheight, 2)));
        //返回两点之间的距离
        s = Math.sqrt(Math.pow(s, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2));
        return s;
    };
    //角度计算
    Core.prototype.Angle = function (p1, p2, p3) {
        var bearing21 = this.Bearing(p2, p1);
        var bearing23 = this.Bearing(p2, p3);
        var angle = bearing21 - bearing23;
        if (angle < 0) {
            angle += 360;
        }
        return angle;
    };
    //方向计算
    Core.prototype.Bearing = function (from, to) {
        var radiansPerDegree = Math.PI / 180.0;//角度转化为弧度(rad) 
        var degreesPerRadian = 180.0 / Math.PI;//弧度转化为角度
        var radiansPerDegree = Math.PI / 180.0; //角度转化为弧度(rad) 
        var degreesPerRadian = 180.0 / Math.PI; //弧度转化为角度
        var lat1 = from.lat * radiansPerDegree;
        var lon1 = from.lon * radiansPerDegree;
        var lat2 = to.lat * radiansPerDegree;
        var lon2 = to.lon * radiansPerDegree;
        var angle = -Math.atan2(Math.sin(lon1 - lon2) * Math.cos(lat2), Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon1 - lon2));
        if (angle < 0) {
            angle += Math.PI * 2.0;
        }
        angle = angle * degreesPerRadian;//角度
        angle = angle * degreesPerRadian; //角度
        return angle;
    };
    //获取高度
    Core.prototype.getHeight = function (_positions, Cesium) {
        try {
            if (_positions.length > 1) {
                var cartographic = Cesium.Cartographic.fromCartesian(_positions[0]);
                var cartographic1 = Cesium.Cartographic.fromCartesian(_positions[1]);
                var height_temp = (cartographic1.height - cartographic.height) / 1000;
                //var height_temp = _positions[1].z - _positions[0].z;
                return height_temp.toFixed(2);
            } else {
                return 0;
            }
        } catch (ex) {
            console.log(ex);
        }

    };
    //剖面分析
    Core.prototype.getPmfx = function (_positions, pointSum1, cyjj, Cesium, viewer, methond) {
        //起止点相关信息
        var pmx = {
            gcs: [],
            min: 99999,
            max: 0,
            juli: 0.0,
            cys: pointSum1
        };
        var julifr = this.getSpaceDistancem(_positions, Cesium);
        pmx.juli = julifr;
        if (cyjj == 0) ; else {
            pointSum1 = parseInt(julifr / cyjj);
        }
        pmx.cys = pointSum1;
        var startPoint = _positions[0];
        var endPoint = _positions[_positions.length - 1];
        var scartographic = Cesium.Cartographic.fromCartesian(startPoint);
        var slongitude = Cesium.Math.toDegrees(scartographic.longitude);
        var slatitude = Cesium.Math.toDegrees(scartographic.latitude);
        scartographic.height;

        var ecartographic = Cesium.Cartographic.fromCartesian(endPoint);
        var elongitude = Cesium.Math.toDegrees(ecartographic.longitude);
        var elatitude = Cesium.Math.toDegrees(ecartographic.latitude);
        ecartographic.height;


        var pointSum = pointSum1; //取样点个数
        var addXTT = Cesium.Math.lerp(slongitude, elongitude, 1.0 / pointSum) - slongitude;
        var addYTT = Cesium.Math.lerp(slatitude, elatitude, 1.0 / pointSum) - slatitude;

        var positions = [];
        var heightArr = [];
        var Cartesian;

        positions.push(scartographic);
        for (var i = 0; i < pointSum; i++) {

            var longitude = slongitude + (i + 1) * addXTT;
            var latitude = slatitude + (i + 1) * addYTT;
            Cartesian = Cesium.Cartesian3.fromDegrees(longitude, latitude);
            positions.push(Cesium.Cartographic.fromCartesian(Cartesian));
        }
        var _this = this;
        this.getHeightsFromLonLat(positions, Cesium, viewer, function (data) {
            if (data) {
                heightArr = data;
                var changeDepthTest = false;
                if (viewer.scene.globe.depthTestAgainstTerrain !== true) {
                    viewer.scene.globe.depthTestAgainstTerrain = true;
                    changeDepthTest = true;
                }
                for (i = 0; i < heightArr.length; i++) {
                    var modelHeight = _this.get3DTileOrPrimitivesHeights(positions[i], viewer);
                    if (modelHeight !== undefined) {
                        heightArr[i] = modelHeight;
                    }
                    var he = heightArr[i].toFixed(2);
                    if (parseFloat(he) < parseFloat(pmx.min)) {
                        pmx.min = parseFloat(he);
                    }
                    if (parseFloat(he) > parseFloat(pmx.max)) {
                        pmx.max = parseFloat(he);
                    }
                    pmx.gcs.push(he);
                }
                if (changeDepthTest) {
                    viewer.scene.globe.depthTestAgainstTerrain = false;
                }
                if (methond != "" && methond != null) {
                    if (typeof methond == 'function')
                        methond(pmx);
                }
            }
        });
    };

    //剖面分析
    Core.prototype.getPmfxPro = function (_positions, pointSum1, cyjj, Cesium, viewer, methond) {
        let _this = this;
        //起止点相关信息
        let pmx = {
            gcs: [],
            min: 99999,
            max: 0,
            juli: 0.0,
            cys: 0
        };
        let positions = [];
        let pointNum = [];
        //获取总间隔点数和距离
        for (let i = 0; i < _positions.length - 1; i++) {
            let julifr = _this.getSpaceDistancem([_positions[i], _positions[i + 1]], Cesium);
            julifr = parseFloat(julifr);
            pmx.juli += julifr;
            if (cyjj == 0) ; else {
                pointSum1 = parseInt(julifr / cyjj);
            }
            pointNum.push(pointSum1);
            pmx.cys += pointSum1;
        }
        let startAnalyse = () => {
            pointNum.forEach((num, i) => {
                let startPoint = _positions[i];
                let endPoint = _positions[i + 1];
                //起点
                let scartographic = Cesium.Cartographic.fromCartesian(startPoint);
                let slongitude = Cesium.Math.toDegrees(scartographic.longitude);
                let slatitude = Cesium.Math.toDegrees(scartographic.latitude);

                //终点
                let ecartographic = Cesium.Cartographic.fromCartesian(endPoint);
                let elongitude = Cesium.Math.toDegrees(ecartographic.longitude);
                let elatitude = Cesium.Math.toDegrees(ecartographic.latitude);

                let pointSum = num; //取样点个数
                let addXTT = Cesium.Math.lerp(slongitude, elongitude, 1.0 / pointSum) - slongitude;
                let addYTT = Cesium.Math.lerp(slatitude, elatitude, 1.0 / pointSum) - slatitude;

                let Cartesian;

                i === 0 && positions.push(scartographic);
                for (let j = 0; j < pointSum; j++) {
                    let longitude = slongitude + (j + 1) * addXTT;
                    let latitude = slatitude + (j + 1) * addYTT;
                    Cartesian = Cesium.Cartesian3.fromDegrees(longitude, latitude);
                    positions.push(Cesium.Cartographic.fromCartesian(Cartesian));
                }
            });

            positions.push(Cesium.Cartographic.fromCartesian(_positions[_positions.length - 1]));

            let heightArr = [];
            pmx.allPoint = positions;
            this.getHeightsFromLonLat(positions, Cesium, viewer, function (data) {
                if (data) {
                    heightArr = data;
                    let changeDepthTest = viewer.scene.globe.depthTestAgainstTerrain;
                    viewer.scene.globe.depthTestAgainstTerrain = true;
                    for (let i = 0; i < heightArr.length; i++) {
                        let modelHeight = _this.get3DTileOrPrimitivesHeights(positions[i], viewer);
                        if (modelHeight !== undefined) {
                            heightArr[i] = modelHeight;
                        }
                        let he = heightArr[i].toFixed(2);
                        if (parseFloat(he) < parseFloat(pmx.min)) {
                            pmx.min = parseFloat(he);
                        }
                        if (parseFloat(he) > parseFloat(pmx.max)) {
                            pmx.max = parseFloat(he);
                        }
                        pmx.gcs.push(he);
                    }
                    viewer.scene.globe.depthTestAgainstTerrain = changeDepthTest;
                    methond && typeof methond == 'function' && methond(pmx);
                }
            });
        };
        if (pmx.cys > 1000) {
            layuiLayer && layuiLayer.msg('当前采样点数过多，是否继续分析？', {
                time: 0,
                btn: ['继续', '取消'],
                btnAlign: 'c',
                yes: (index) => {
                    layuiLayer.close(index);
                    setTimeout(() => {
                        startAnalyse();
                    }, 10);
                },
                btn2: () => {
                    methond && typeof methond == 'function' && methond(pmx);
                }
            });
        } else {
            setTimeout(() => {
                startAnalyse();
            }, 10);
        }
    };

    //根据位置(Cartographic)获取3DTiles和Primitives高度
    Core.prototype.get3DTileOrPrimitivesHeights = function (position, Viewer) {
        return Viewer.scene.sampleHeight(position);
    };

    //根据经纬度获取高度
    Core.prototype.getHeightsFromLonLat = function (positions, Cesium, Viewer, callback) {
        var camera = Viewer.camera;
        var heights = [];
        if (Viewer.scene && Viewer.scene.terrainProvider && Viewer.scene.terrainProvider._layers) {
            //根据经纬度计算出地形高度。
            var promise = Cesium.sampleTerrainMostDetailed(Viewer.terrainProvider, positions);
            camera.positionCartographic.height;
            Cesium.when(promise, function (updatedPositions) {
                updatedPositions.forEach(function (item) {
                    heights.push(item.height);
                });
                if (typeof callback === "function") {
                    callback(heights);
                }
            });
        } else {
            positions.forEach(function (p) {
                heights.push(Viewer.scene.globe.getHeight(p));
            });
            if (typeof callback === "function") {
                callback(heights);
            }
        }
    };

    Core.prototype.getColorRamp = function (selectedShading, colorArr, min, max) {
        var elevationRamp = [0.0, 0.05, 0.2, 0.35, 0.5, 0.65, 0.8, 0.95, 1.0];
        var slopeRamp = [];
        var aspectRamp = [0.0, 0.0, 0.2, 0.4, 0.6, 0.8, 0.9, 1.0, 1.0];
        var ramp = document.createElement('canvas');
        ramp.width = 100;
        ramp.height = 1;
        var ctx = ramp.getContext('2d');
        var values;
        if (selectedShading === 'elevation') {
            values = elevationRamp;
        } else if (selectedShading === 'slope') {
            values = slopeRamp;
        } else if (selectedShading === 'aspect') {
            values = aspectRamp;
        }
        if (!colorArr) {
            colorArr = ['#0b0b88', '#2747E0', '#D33B7D', '#D33038', '#FF9742', '#ffd700', '#bbff00'];
        }
        var grd = ctx.createLinearGradient(0, 0, 100, 0);
        if (selectedShading === 'slope') {
            if (min === undefined) {
                min = 0;
            }
            if (max === undefined) {
                min = 90;
            }

            if (min == 0) {
                slopeRamp.push(0.0);
            } else {
                slopeRamp.push(min / 90);
                grd.addColorStop(0.0, '#000000');
            }

            var ave = (max - min) / 6;
            if (max == 90) {
                for (var i = 1; i <= 5; i++) {
                    slopeRamp.push((min + i * ave) / 90);
                }
                slopeRamp.push(1.0);
                slopeRamp.forEach(function (item, index) {
                    grd.addColorStop(item, colorArr[index]);
                });
            } else {
                for (var i = 1; i <= 5; i++) {
                    slopeRamp.push((min + i * ave) / 90);
                }
                slopeRamp.push(max / 90);
                slopeRamp.forEach(function (item, index) {
                    grd.addColorStop(item, colorArr[index]);
                });
                grd.addColorStop(1.0, '#000000');
            }
        } else {
            grd.addColorStop(values[0], '#000000');
            grd.addColorStop(values[1], colorArr[0]);
            grd.addColorStop(values[2], colorArr[1]);
            grd.addColorStop(values[3], colorArr[2]);
            grd.addColorStop(values[4], colorArr[3]);
            grd.addColorStop(values[5], colorArr[4]);
            grd.addColorStop(values[6], colorArr[5]);
            grd.addColorStop(values[7], colorArr[6]);
            grd.addColorStop(values[8], '#000000');
        }
        ctx.fillStyle = grd;
        ctx.fillRect(0, 0, 100, 1);
        return ramp;
    };
    //贴地面积测量

    Core.prototype.Gauss_to_XY = function (L, B, middleL2, Cesium) {
        var aEarth = 6378137;
        var bEarth = 6356752.3142;
        var e2 = Math.sqrt(aEarth * aEarth - bEarth * bEarth) / bEarth;
        var t = 0, yita = 0;
        var t = 0,
            yita = 0;
        var nn = 0;
        var n = 0;
        var middleL = this.to_Radian(middleL2);
        B = this.to_Radian(B);
        L = this.to_Radian(L);
        var dL = L - middleL;
        var cosB = Math.cos(B);
        n = this.to_N(B);
        nn = n * Math.cos(B);
        t = Math.tan(B);
        yita = e2 * cosB;
        var pow_t2 = Math.pow(t, 2);
        var pow_t4 = Math.pow(t, 4);
        var pow_yita2 = Math.pow(yita, 2);
        var pow_yita4 = Math.pow(yita, 4);
        var pow_cosB3 = Math.pow(cosB, 3);
        var pow_cosB5 = Math.pow(cosB, 5);
        var tY = this.to_Sm(B) + Math.pow(dL, 2) / 2 * nn * cosB * t + Math.pow(dL, 4) / 24 * t * nn * pow_cosB3 * (5.0 - pow_t2 + 9.0 * pow_yita2 + 4 * pow_yita4) + Math.pow(dL, 6) / 720 * t * nn * pow_cosB5 * (61.0 - 58.0 * t * t + pow_t4 + 270 * pow_yita2 - 330 * t * t * pow_yita2);
        var tX = dL * n * cosB + Math.pow(dL, 3) / 6.0 * n * pow_cosB3 * (1 - t * t + yita * yita) + Math.pow(dL, 5) / 120.0 * n * pow_cosB5 * (5 - 18 * t * t + pow_t4 + 14.0 * pow_yita2 - 58.0 * pow_yita2 * pow_t2);
        return new Cesium.Cartesian2(tX, tY)
    };
    Core.prototype.to_Radian = function (degree) {
        return degree * Math.PI / 180.0
    };
    Core.prototype.to_N = function (B) {
        var aEarth = 6378137;
        var bEarth = 6356752.3142;
        var e1 = Math.sqrt(aEarth * aEarth - bEarth * bEarth) / aEarth;
        var ans = (aEarth / Math.sqrt(1.00 - e1 * e1 * Math.sin(B) * Math.sin(B)));
        return ans
    };
    Core.prototype.to_Sm = function (B) {
        var aEarth = 6378137;
        var bEarth = 6356752.3142;
        var e1 = Math.sqrt(aEarth * aEarth - bEarth * bEarth) / aEarth;
        var AA, BB, CC, DD, EE;
        AA = 1 + (e1 * e1) * 3 / 4 + Math.pow(e1, 4.0) * 45 / 64 + Math.pow(e1, 6) * 175 / 256 + Math.pow(e1, 8) * 11025 / 16384;
        BB = Math.pow(e1, 2) * 3 / 4 + Math.pow(e1, 4) * 15 / 16 + Math.pow(e1, 6) * 525 / 512 + Math.pow(e1, 8) * 2205 / 2048;
        CC = Math.pow(e1, 4) * 15 / 64 + Math.pow(e1, 6) * 105 / 256 + Math.pow(e1, 8) * 2205 / 4096;
        DD = Math.pow(e1, 6) * 35 / 512 + Math.pow(e1, 8) * 315 / 2048;
        EE = Math.pow(e1, 8) * 315 / 16384;
        return aEarth * (1 - e1 * e1) * (AA * B - BB / 2 * Math.sin(2 * B) + CC / 4 * Math.sin(4 * B) - DD / 6 * Math.sin(6 * B) + EE / 8 * Math.sin(8 * B))
    };

    /**
     * 计算空间两点之间的俯仰角
     * @param {Object} p1 起始点
     * @param {Object} p2 结束点
     */
    Core.prototype.ElevationAngle = function (p1, p2, Cesium) {
        //空间距离测量
        function getSpaceDistance(positions, Cesium) {
            var distance = 0;
            for (var i = 0; i < positions.length - 1; i++) {
                var point1cartographic = Cesium.Cartographic.fromCartesian(positions[i]);
                var point2cartographic = Cesium.Cartographic.fromCartesian(positions[i + 1]);
                /**根据经纬度计算出距离**/
                var geodesic = new Cesium.EllipsoidGeodesic();
                geodesic.setEndPoints(point1cartographic, point2cartographic);
                var s = geodesic.surfaceDistance;
                //console.log(Math.sqrt(Math.pow(distance, 2) + Math.pow(endheight, 2)));
                //返回两点之间的距离
                s = (Math.sqrt(Math.pow(s, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2)));
                distance = distance + s;
            }
            return distance;
        }

        //水平距离测量
        function getHorizontalDistance(positions, Cesium) {
            var distance = 0;
            for (var i = 0; i < positions.length - 1; i++) {

                var point1cartographic = Cesium.Cartographic.fromCartesian(positions[i]);
                var point2cartographic = Cesium.Cartographic.fromCartesian(positions[i + 1]);
                /**根据经纬度计算出距离**/
                var geodesic = new Cesium.EllipsoidGeodesic();
                geodesic.setEndPoints(point1cartographic, point2cartographic);
                var s = geodesic.surfaceDistance;
                //console.log(Math.sqrt(Math.pow(distance, 2) + Math.pow(endheight, 2)));
                //返回两点之间的距离
                //s = Math.sqrt(Math.pow(s, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2));
                distance = distance + s;
            }
            return distance;
        }

        //获取高度
        function getHeight(_positions, Cesium) {
            try {
                if (_positions.length > 1) {
                    var cartographic = Cesium.Cartographic.fromCartesian(_positions[0]);
                    var cartographic1 = Cesium.Cartographic.fromCartesian(_positions[1]);
                    var height_temp = (cartographic1.height - cartographic.height);
                    //var height_temp = _positions[1].z - _positions[0].z;
                    return height_temp;
                } else {
                    return 0;
                }
            } catch (ex) {
                console.log(ex);
            }

        }

        var cartographic = Cesium.Cartographic.fromCartesian(p1);
        var cartographic1 = Cesium.Cartographic.fromCartesian(p2);
        cartographic.height - (cartographic.height - cartographic1.height);
        var p3 = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(cartographic1.longitude), Cesium.Math.toDegrees(cartographic1.latitude), cartographic.height);

        var c = parseFloat(getSpaceDistance([p1, p2], Cesium));
        parseFloat(getHorizontalDistance([p1, p3], Cesium));
        var b = parseFloat(getHeight([p3, p2], Cesium));
        var sinb = b / c;
        var angle = Math.asin(sinb) * 180 / 3.14;
        return angle;
    };
    /**
     * 两点方位角
     * @param {number} lon1 起点经度
     * @param {number} lat1 起点纬度
     * @param {number} lon2 终点经度
     * @param {number} lat2 终点纬度
     */
    Core.prototype.TwoPointAzimuth = function (lon1, lat1, lon2, lat2) {
        var result = 0.0;
        var getRad = function (d) {
            return d * Math.PI / 180.0;
        };

        var ilat1 = Math.round(0.50 + lat1 * 360000.0);
        var ilat2 = Math.round(0.50 + lat2 * 360000.0);
        var ilon1 = Math.round(0.50 + lon1 * 360000.0);
        var ilon2 = Math.round(0.50 + lon2 * 360000.0);

        lat1 = getRad(lat1);
        lon1 = getRad(lon1);
        lat2 = getRad(lat2);
        lon2 = getRad(lon2);

        if ((ilat1 === ilat2) && (ilon1 === ilon2)) {
            return result;
        } else if (ilon1 === ilon2) {
            if (ilat1 > ilat2)
                result = 180.0;
        } else {
            var c = Math.acos(Math.sin(lat2) * Math.sin(lat1) + Math.cos(lat2) * Math.cos(lat1) * Math.cos((lon2 - lon1)));
            var A = Math.asin(Math.cos(lat2) * Math.sin((lon2 - lon1)) / Math.sin(c));
            result = A * 180 / Math.PI;
            if ((ilat2 > ilat1) && (ilon2 > ilon1)) ; else if ((ilat2 < ilat1) && (ilon2 < ilon1)) {
                result = 180.0 - result;
            } else if ((ilat2 < ilat1) && (ilon2 > ilon1)) {
                result = 180.0 - result;
            } else if ((ilat2 > ilat1) && (ilon2 < ilon1)) {
                result += 360.0;
            }
        }
        return result;
    };
    /**
     * 三点测量方位角
     * @param {Object} p1 起始点
     * @param {Object} p2 第二点
     * @param {Object} p3 第三点
     */
    Core.prototype.ThreePointAzimuth = function (p1, p2, p3, Cesium) {
        var radiansPerDegree = Math.PI / 180.0;
        var degreesPerRadian = 180.0 / Math.PI;

        var cartographic1 = Cesium.Cartographic.fromCartesian(p1);
        var cartographic2 = Cesium.Cartographic.fromCartesian(p2);
        var cartographic3 = Cesium.Cartographic.fromCartesian(p3);
        p2 = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(cartographic2.longitude), Cesium.Math.toDegrees(cartographic2.latitude), cartographic1.height);
        p3 = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(cartographic3.longitude), Cesium.Math.toDegrees(cartographic3.latitude), cartographic1.height);
        cartographic2 = Cesium.Cartographic.fromCartesian(p2);
        cartographic3 = Cesium.Cartographic.fromCartesian(p3);

        /*角度*/
        function Angle(p1, p2, p3) {
            var bearing21 = Bearing(p2, p1);
            var bearing23 = Bearing(p2, p3);
            var angle = bearing21 - bearing23;
            if (angle < 0) {
                angle += 360;
            }
            return angle;
        }

        /*方向*/
        function Bearing(from, to) {
            var lat1 = from.latitude * radiansPerDegree;
            var lon1 = from.longitude * radiansPerDegree;
            var lat2 = to.latitude * radiansPerDegree;
            var lon2 = to.longitude * radiansPerDegree;
            var angle = -Math.atan2(Math.sin(lon1 - lon2) * Math.cos(lat2), Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon1 - lon2));
            if (angle < 0) {
                angle += Math.PI * 2.0;
            }
            angle = angle * degreesPerRadian;
            return angle;
        }

        var angle = Angle(cartographic1, cartographic2, cartographic3);
        return angle;
    };
    /**
     * 开启/还原深度检测
     * @param {String} type 状态（open/close）
     * @param {Object} viewer 视图
     */
    Core.prototype.setDepthTest = function (type, viewer) {
        if (type === 'open' && this.defaultDepthTest === undefined) {
            this.defaultDepthTest = !!viewer.scene.globe.depthTestAgainstTerrain;
            viewer.scene.globe.depthTestAgainstTerrain = true;
        } else if (type === 'close' && this.defaultDepthTest !== undefined) {
            viewer.scene.globe.depthTestAgainstTerrain = !!this.defaultDepthTest;
            this.defaultDepthTest = undefined;
        }
    };
    /**
     * 动态变化材质
     * @param {String} type 状态（open/close）
     * @param {Object} viewer 视图
     */
    //var images = "../../img/arrow.png";
    //var curCanvas = "a";
    //var i = 0;
    Core.prototype.setImageMaterialProperty = function (image, Cesium, type, id) {
        this.id = id;
        var that = this;
        var canvas = document.createElement('canvas');
        canvas.id = this.id + "-a";
        canvas.width = 700;
        canvas.height = 100;

        var canvas1 = document.createElement('canvas');
        canvas1.id = this.id + "-b";
        canvas1.width = 700;
        canvas1.height = 100;
        document.body.appendChild(canvas);
        document.body.appendChild(canvas1);
        if (image) {
            that.images = image;
        }
        var ima = new Cesium.CallbackProperty(function (time, result) {
            var canvas = document.getElementById(that.id + "-" + that.curCanvas);
            var cwidth = 700;
            var cheight = 100;
            var ctx = canvas.getContext("2d");
            var img = new Image();
            img.src = that.images;
            ctx.clearRect(0, 0, cwidth, cheight);
            img.onload = function () {
                if (that.i <= cwidth) {
                    ctx.drawImage(img, that.i, 0);
                    ctx.drawImage(img, that.i + 100, 0);
                } else
                    that.i = 0;
                that.i += 5;
            };
            that.curCanvas = that.curCanvas === 'a' ? 'b' : 'a';
            return canvas;
        }, false);
        if (type == 1) {
            ima = new Cesium.CallbackProperty(function (time, result) {
                var canvas = document.getElementById(that.id + "-" + that.curCanvas);
                var ctx = canvas.getContext("2d");
                var grd = ctx.createLinearGradient(0, 100, 0, 0);
                grd.addColorStop(0, "red");
                if (that.i > 1) {
                    that.i = 1;
                }
                grd.addColorStop(that.i, "rgb(255,0,0,0.6)");
                grd.addColorStop(1, "rgb(255,0,0,0.1)");
                ctx.clearRect(0, 0, 700, 100);
                ctx.fillStyle = grd;
                ctx.fillRect(0, 0, 700, 100);
                if (that.i < 1) {
                    that.i += 0.01;
                } else {
                    that.i = 0;
                }
                that.curCanvas = that.curCanvas === 'a' ? 'b' : 'a';
                return canvas;
            }, false);
        }
        return new Cesium.ImageMaterialProperty({
            image: ima,
            transparent: true
        })
    };
    /**
     * 动态变化材质回调函数(水平移动图像)
     * @param {String} type 状态（open/close）
     * @param {Object} viewer 视图
     */
    Core.prototype.setDrawCanvasImage = function (time, result) {
        var canvas = document.getElementById("canvas-" + curCanvas);
        var cwidth = 700;
        var cheight = 100;
        var ctx = canvas.getContext("2d");
        var img = new Image();
        img.src = images;
        ctx.clearRect(0, 0, cwidth, cheight);
        img.onload = function () {
            if (i <= cwidth) {
                ctx.drawImage(img, i, 0);
                ctx.drawImage(img, i + 100, 0);
            } else
                i = 0;
            i += 5;
        };
        curCanvas = curCanvas === 'a' ? 'b' : 'a';
        return canvas;
    };
    /**
     * 动态变化材质回调函数(上下移动颜色渐变)
     * @param {String} type 状态（open/close）
     * @param {Object} viewer 视图
     */
    Core.prototype.setDrawCanvasColorUpdown = function (time, result) {
        var canvas = document.getElementById("canvas-" + curCanvas);
        var ctx = canvas.getContext("2d");
        var grd = ctx.createLinearGradient(0, 100, 0, 0);
        grd.addColorStop(0, "red");
        if (i > 1) {
            i = 1;
        }
        grd.addColorStop(i, "rgb(255,0,0,0.6)");
        grd.addColorStop(1, "rgb(255,0,0,0.1)");
        ctx.clearRect(0, 0, 700, 100);
        ctx.fillStyle = grd;
        ctx.fillRect(0, 0, 700, 100);
        if (i < 1) {
            i += 0.01;
        } else {
            i = 0;
        }
        curCanvas = curCanvas === 'a' ? 'b' : 'a';
        return canvas;
    };
    /**
      * 获取鼠标当前世界坐标
      * @param {object} [movement] 鼠标屏幕位置
      * @param {Array/Object} [objectsToExclude] 排除的实体对象
      * @param {number} [type] 类型（0为模型优先，1为地形优先）,默认模型优先
      * @param {boolean} [isAdsorption] true|false 是否吸附，默认否
      * @param {number} [distance] 吸附半径，默认30
      **/
    Core.prototype.getMousePosition = function (movement, Cesium, viewer, objectsToExclude, type, isAdsorption, distance) {
        var mousePosition = movement.endPosition || movement.position;
        type === undefined && (type = 0);
        this._cesium = Cesium;
        this._viewer = viewer;
        isAdsorption = this._cesium.defaultValue(isAdsorption, false);
        this.defaultDepthTest === undefined && (this.defaultDepthTest = !!this._viewer.scene.globe.depthTestAgainstTerrain);
        var ray, cartesian, _cartesian, feature;
        //this.isObjectsToExcludeShow(objectsToExclude, false);
        var width = isAdsorption ? (distance ? distance : 30) : 1;
        if (type !== 0) {
            //地形优先
            //开启深度检测
            this._viewer.scene.globe.depthTestAgainstTerrain = true;
            ray = this._viewer.camera.getPickRay(mousePosition);
            ray && (cartesian = this._viewer.scene.globe.pick(ray, this._viewer.scene));
            //isAdsorption && (mousePosition = this.getAdsorptionPosition(mousePosition, objectsToExclude));

            feature = this._viewer.scene.drillPick(mousePosition, (objectsToExclude && objectsToExclude.length && objectsToExclude.length + 1) || 1, width, width);
            feature = this.getNotExcludedObj(feature, objectsToExclude);
            if (feature && !isAdsorption) {
                this._viewer.scene.pick(mousePosition);
                _cartesian = this._viewer.scene.pickPosition(mousePosition);
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            } else {
                cartesian && isAdsorption && (_cartesian = this._getAdsorptionPosition(mousePosition, feature, distance));//吸附
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            }
        } else {
            //模型优先
            //isAdsorption && (mousePosition = this.getAdsorptionPosition(mousePosition, objectsToExclude));//吸附
            feature = this._viewer.scene.drillPick(mousePosition, (objectsToExclude && objectsToExclude.length && objectsToExclude.length + 1) || 1, width, width);
            feature = this.getNotExcludedObj(feature, objectsToExclude);
            if (feature && !isAdsorption) {
                this._viewer.scene.pick(mousePosition);
                cartesian = this._viewer.scene.pickPosition(mousePosition);
            } else if (feature && isAdsorption) {
                this._viewer.scene.pick(mousePosition);
                cartesian = this._viewer.scene.pickPosition(mousePosition);
                _cartesian = this._getAdsorptionPosition(mousePosition, feature, distance); //吸附
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            } else {
                //开启深度检测
                this._viewer.scene.globe.depthTestAgainstTerrain = true;
                ray = this._viewer.camera.getPickRay(mousePosition);
                ray && (cartesian = this._viewer.scene.globe.pick(ray, this._viewer.scene));
            }
        }
        if (!cartesian) {
            console.log('未拾取到坐标！');
            return;
        }
        this._viewer.scene.globe.depthTestAgainstTerrain = !!this.defaultDepthTest;
        this.defaultDepthTest = undefined;
        //this.isObjectsToExcludeShow(objectsToExclude, true);

        return cartesian;
    };
    /**
    * 
    * 世界坐标转经纬度
    * 
    */
    Core.prototype.toDegrees = function (cartesian) {
        let cartographic = Cesium.Cartographic.fromCartesian(cartesian);
        return {
            lon: Cesium.Math.toDegrees(cartographic.longitude),
            lat: Cesium.Math.toDegrees(cartographic.latitude),
            height: cartographic.height
        };
    };
    //线段插值
    Core.prototype.LineInterpolation = function (Viewer, option) {
        let positions, num;
        let getHeight = false;
        if (option.positions) {
            positions = option.positions;
        } else {
            positions = option;
        }
        num = option.num || 100;   //采样点数
        option.getHeight && (getHeight = true); //获取高度

        let data = {
            positions: [],
            cartographic: [],
            lon_lat: [],
            height: []
        };
        for (let i = 0; i < positions.length - 1; i++) {
            let degrees1 = this.toDegrees(positions[i]);
            let degrees2 = this.toDegrees(positions[i + 1]);
            getPoint(degrees1.lon, degrees1.lat, degrees2.lon, degrees2.lat);
        }

        function getPoint(lon1, lat1, lon2, lat2) {
            // //获取面上的高程和经纬度
            let addX = Cesium.Math.lerp(lon1, lon2, 1.0 / num) - lon1;
            let addY = Cesium.Math.lerp(lat1, lat2, 1.0 / num) - lat1;

            data.lon_lat.push(lon1, lat1);
            let height;
            if (getHeight) {
                height = getHeightFromLonLat(lon1, lat1);
                data.height.push(height);
                data.positions.push(Cesium.Cartesian3.fromDegrees(lon1, lat1, height));

                for (let i = 0; i < num; i++) {
                    let longitude = lon1 + (i + 1) * addX;
                    let latitude = lat1 + (i + 1) * addY;
                    data.lon_lat.push(longitude, latitude);

                    height = getHeightFromLonLat(longitude, latitude);
                    data.height.push(height);
                    data.positions.push(Cesium.Cartesian3.fromDegrees(longitude, latitude, height));
                }

                data.lon_lat.push(lon2, lat2);
                height = getHeightFromLonLat(lon2, lat2);
                data.height.push(height);
                data.positions.push(Cesium.Cartesian3.fromDegrees(lon2, lat2, height));
            } else {
                data.positions.push(Cesium.Cartesian3.fromDegrees(lon1, lat1));

                for (let i = 0; i < num; i++) {
                    let longitude = lon1 + (i + 1) * addX;
                    let latitude = lat1 + (i + 1) * addY;

                    data.lon_lat.push(longitude, latitude);
                    data.positions.push(Cesium.Cartesian3.fromDegrees(longitude, latitude));
                }
                data.lon_lat.push(lon2, lat2);
                data.positions.push(Cesium.Cartesian3.fromDegrees(lon2, lat2));
            }
        }

        //根据经纬度获取高度
        function getHeightFromLonLat(lon, lat) {
            let Cartographic = Cesium.Cartographic.fromDegrees(lon, lat);
            let height = Viewer.scene.globe.getHeight(Cartographic);
            // let height2 = Viewer.scene.sampleHeight(Cartographic, option.objectsToExclude);
            // if (height2 !== undefined && height2 > height) {
            //     height = height2;
            // }
            return height;
        }

        return data;
    };
    /**
     * 创建CIMServer查询工具
     * @param {String} url 服务地址
     */
    Core.prototype.CIMServerTool = function (url) {
        return new CIMServerTool(url);
    };

    /**
     * 录屏
     * @param {String} url 服务地址
     */
    Core.prototype.Recorder = function (path, videoBPS) {
        if (this._Recorder) {
            this._Recorder.mediaOutputPath = this.defaultValue(path, 'test.mp4');
            videoBPS && (this._Recorder.videoBPS = videoBPS);
        } else {
            this._Recorder = new Recorder(path, videoBPS);
        }
        return this._Recorder;
    };


    /**
     * 添加链路纹理
     */
    Core.prototype.getLinkMaterial = function (color, lightSpotColor, time) {
        if (!Cesium.PolylineLinkMaterialProperty) {

            /*
               链路纹理线
               color 线颜色
               pointColor 精灵点颜色
               duration 持续时间 毫秒
            */
            function PolylineLinkMaterialProperty(color, lightSpotColor, duration) {
                this._definitionChanged = new Cesium.Event();
                this._color = undefined;
                this._colorSubscription = undefined;
                this.color = color;
                this.lightSpotColor = lightSpotColor;
                this.duration = duration;
                this.old = undefined;
                this._time = (new Date()).getTime();
            }

            Object.defineProperties(PolylineLinkMaterialProperty.prototype, {
                isConstant: {
                    get: function () {
                        return false;
                    }
                },
                definitionChanged: {
                    get: function () {
                        return this._definitionChanged;
                    }
                },
                color: Cesium.createPropertyDescriptor('color')
            });
            PolylineLinkMaterialProperty.prototype.getType = function (time) {
                return 'PolylineLink';
            };
            PolylineLinkMaterialProperty.prototype.getValue = function (time, result) {
                if (!Cesium.defined(result)) {
                    result = {};
                }
                result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.Color.WHITE, result.color);
                result.lightSpotColor = this.lightSpotColor;
                result.time = (((new Date()).getTime() - this._time) % this.duration) / this.duration;


                this.old === undefined && (this.old = result.time);
                if (this.old > 0.5 && result.time < 0.5) {
                    result.plus = !result.plus;
                    result.inverse = !result.inverse;
                }
                this.old = result.time;
                if (result.plus) {
                    result.time = result.time * 1.1;
                } else {
                    result.time = result.time * 1.2 - 0.1;
                }

                return result;
            };
            PolylineLinkMaterialProperty.prototype.equals = function (other) {
                return this === other ||
                    (other instanceof PolylineLinkMaterialProperty &&
                        Cesium.Property.equals(this._color, other._color))
            };
            Cesium.PolylineLinkMaterialProperty = PolylineLinkMaterialProperty;
            Cesium.Material.PolylineLinkType = 'PolylineLink';
            Cesium.Material.PolylineLinkSource = "czm_material czm_getMaterial(czm_materialInput materialInput)\n\
                                                      {\n\
                                                           czm_material material = czm_getDefaultMaterial(materialInput);\n\
                                                           vec2 st = materialInput.st;\n\
                                                           if(plus && st.s < time && time - st.s <= 0.1){\n\
                                                                material.alpha = 1.0 - (time - st.s) / 0.1;\n\
                                                                if(material.alpha < 0.3){\n\
                                                                    material.alpha = 0.3;\n\
                                                                    material.diffuse = color.rgb;\n\
                                                                }else{\n\
                                                                    material.diffuse = lightSpotColor.rgb;\n\
                                                                }\n\
                                                            }else if(inverse && st.s < (1.0 - time) && (1.0 - time) - st.s <= 0.1){\n\
                                                                material.alpha = ((1.0-time) - st.s) / 0.1;\n\
                                                                if(material.alpha < 0.3){\n\
                                                                    material.alpha = 0.3;\n\
                                                                    material.diffuse = color.rgb;\n\
                                                                }else{\n\
                                                                    material.diffuse = lightSpotColor.rgb;\n\
                                                                }\n\
                                                            }else{\n\
                                                                material.alpha = 0.3;\n\
                                                                material.diffuse = color.rgb;\n\
                                                            }\n\
                                                           return material;\n\
                                                       }";
            Cesium.Material._materialCache.addMaterial(Cesium.Material.PolylineLinkType, {
                fabric: {
                    type: Cesium.Material.PolylineLinkType,
                    uniforms: {
                        color: new Cesium.Color(1.0, 0.0, 0.0, 0.5),
                        lightSpotColor: new Cesium.Color(1.0, 1.0, 1.0, 0.5),
                        time: 0,
                        plus: true,
                        inverse: false
                    },
                    source: Cesium.Material.PolylineLinkSource
                },
                translucent: function (material) {
                    return true;
                }
            });
        }
        return new Cesium.PolylineLinkMaterialProperty(Cesium.Color.fromCssColorString(this.defaultValue(color, "#0000ff")), Cesium.Color.fromCssColorString(this.defaultValue(lightSpotColor, "#ffffff")), this.defaultValue(time, 3000));
    };

    /**
     * 添加链路纹理
     */
    Core.prototype.getTrailLinkMaterial = function (color, LinkImage, time) {
        return new PolylineTrailLinkMaterial(color, LinkImage, time);
    };

    /**
     * 添加卫星雷达扫描纹理
     */
    Core.prototype.getConeRadarMaterial = function (color) {
        if (!Cesium.ConeRadarMaterialProperty) {

            /*
               雷达正射
               color 颜色
               duration 持续时间 毫秒
            */
            function ConeRadarMaterialProperty(color, duration) {
                this._definitionChanged = new Cesium.Event();
                this._color = undefined;
                this._colorSubscription = undefined;
                this.color = color;
                this.duration = duration;
                this._time = (new Date()).getTime();
            }

            Object.defineProperties(ConeRadarMaterialProperty.prototype, {
                isConstant: {
                    get: function () {
                        return false;
                    }
                },
                definitionChanged: {
                    get: function () {
                        return this._definitionChanged;
                    }
                },
                color: Cesium.createPropertyDescriptor('color')
            });
            ConeRadarMaterialProperty.prototype.getType = function (time) {
                return 'ConeRadar';
            };
            ConeRadarMaterialProperty.prototype.getValue = function (time, result) {
                if (!Cesium.defined(result)) {
                    result = {};
                }
                result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.Color.WHITE, result.color);

                result.time = (((new Date()).getTime() - this._time) % this.duration) / this.duration;

                return result;
            };
            ConeRadarMaterialProperty.prototype.equals = function (other) {
                return this === other ||
                    (other instanceof ConeRadarMaterialProperty &&
                        Cesium.Property.equals(this._color, other._color))
            };
            Cesium.ConeRadarMaterialProperty = ConeRadarMaterialProperty;
            Cesium.Material.ConeRadarType = 'ConeRadar';
            Cesium.Material.ConeRadarSource = "\n\
                                                float ripple(float dist, float rippleIntensity, float rippleScale) {\n\
                                                    return rippleScale * ((sin(dist * rippleIntensity - czm_frameNumber/10.0)-0.9) / (dist * rippleIntensity));\n\
                                                }\n\
                                                czm_material czm_getMaterial(czm_materialInput materialInput)\n\
                                                {\n\
                                                    czm_material material = czm_getDefaultMaterial(materialInput);\n\
                                                    material.diffuse = color.rgb;\n\
                                                    vec2 st = materialInput.st;\n\
                                                    float dis = distance(st, vec2(0.5, 0.5));\n\
                                                    material.alpha = 0.0;\n\
                                                    float intensity = step(0.001,ripple(dis, 80.0, 15.0));\n\
                                                    if(intensity == 1.0)\n\
                                                    {\n\
                                                        material.alpha = 1.0;\n\
                                                    }\n\
                                                    return material;\n\
                                                }";
            Cesium.Material._materialCache.addMaterial(Cesium.Material.ConeRadarType, {
                fabric: {
                    type: Cesium.Material.ConeRadarType,
                    uniforms: {
                        color: new Cesium.Color(1.0, 0.0, 0.0, 0.5),
                        time: 0
                    },
                    source: Cesium.Material.ConeRadarSource
                },
                translucent: function (material) {
                    return true;
                }
            });
        }
        return new Cesium.ConeRadarMaterialProperty(Cesium.Color.fromCssColorString(this.defaultValue(color, "#0000ff")), 3000);
    };

    /**
     * 添加扩散圆扫描纹理（三环）
     */
    Core.prototype.getMultiCircleScanMaterial = function (color, time) {
        if (!Cesium.CircleScanMultiMaterialProperty) {
            function CircleScanMultiMaterialProperty(color, duration) {
                this._definitionChanged = new Cesium.Event();
                this._color = undefined;
                this._colorSubscription = undefined;
                this.color = color;
                this.u_radius1 = 0;
                this.u_radius2 = 0;
                this.u_radius3 = 0;
                this.duration = duration;

                this._time = (new Date()).getTime();
            }
            Object.defineProperties(CircleScanMultiMaterialProperty.prototype, {
                isConstant: {
                    get: function () {
                        return false
                    }
                },
                definitionChanged: {
                    get: function () {
                        return this._definitionChanged
                    }
                },
                color: Cesium.createPropertyDescriptor('color')
            });
            CircleScanMultiMaterialProperty.prototype.getType = function (time) {
                return 'CircleScanMulti';
            };
            CircleScanMultiMaterialProperty.prototype.getValue = function (time, result) {
                if (!Cesium.defined(result)) {
                    result = {};
                }
                result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.Color.WHITE, result.color);
                result.time = (((new Date()).getTime() - this._time) % this.duration) / this.duration;
                if (result.time < 1 / 3 && this.u_radius2 === 0 && this.u_radius1 === 0) {
                    this.u_radius3 = result.time;
                } else if (result.time >= 1 / 3 && result.time < 2 / 3 && this.u_radius1 === 0) {
                    this.u_radius3 = result.time;
                    this.u_radius2 = this.u_radius3 - 1 / 3;
                } else if (result.time >= 2 / 3) {
                    this.u_radius3 = result.time;
                    this.u_radius2 = this.u_radius3 - 1 / 3;
                    this.u_radius1 = this.u_radius3 - 2 / 3;
                } else if (result.time < 1 / 3 && this.u_radius2 !== 0 && this.u_radius1 !== 0) {
                    this.u_radius1 = result.time;
                    this.u_radius2 = result.time + 1 / 3;
                    this.u_radius3 = result.time + 2 / 3;
                } else if (result.time >= 1 / 3 && result.time < 2 / 3 && this.u_radius1 !== 0) {
                    this.u_radius1 = result.time - 1 / 3;
                    this.u_radius2 = result.time;
                    this.u_radius3 = result.time + 1 / 3;
                }
                result.u_radius1 = this.u_radius1;
                result.u_radius2 = this.u_radius2;
                result.u_radius3 = this.u_radius3;
                return result;
            };
            CircleScanMultiMaterialProperty.prototype.equals = function (other) {
                return this === other ||
                    (other instanceof CircleScanMultiMaterialProperty &&
                        Cesium.Property.equals(this._color, other._color))
            };
            Cesium.CircleScanMultiMaterialProperty = CircleScanMultiMaterialProperty;

            Cesium.Material.CircleScanMultiType = "CircleScanMulti";
            // 自定义着色器
            Cesium.Material.CircleScanMultiSource =
                "czm_material czm_getMaterial(czm_materialInput materialInput)\n\
                {\n\
                    czm_material material = czm_getDefaultMaterial(materialInput);\n\
                    material.diffuse = color.rgb;\n\
                    vec2 st = materialInput.st;\n\
                    float dis = distance(st, vec2(0.5, 0.5));\n\
                    dis = dis * 2.0;\n\
                    if(dis < u_radius1)\n\n\
                    {\n\
                        float f = dis / u_radius1;\n\
                        material.alpha  = pow(f, 9.0);\n\
                    }else if(dis < u_radius2){\n\
                        float f = dis / u_radius2;\n\
                        material.alpha  = pow(f, 9.0);\n\
                    }else if(dis < u_radius3){\n\
                        float f = dis / u_radius3;\n\
                        material.alpha  = pow(f, 9.0);\n\
                    }else{\n\
                        material.alpha = 0.0;\n\
                    }\n\
                    return material;\n\
                }";


            Cesium.Material._materialCache.addMaterial(Cesium.Material.CircleScanMultiType, {
                fabric: {
                    type: Cesium.Material.CircleScanMultiType,
                    uniforms: {
                        color: new Cesium.Color(1.0, 0.0, 0.0, 1),
                        time: 0,
                        u_radius1: 0,
                        u_radius2: 0,
                        u_radius3: 0
                    },
                    source: Cesium.Material.CircleScanMultiSource

                },
                translucent: function (material) {
                    return true;
                }
            });
        }
        return new Cesium.CircleScanMultiMaterialProperty(Cesium.Color.fromCssColorString(this.defaultValue(color, "#ff0000")), this.defaultValue(time, 3000));
    };

    /**
     * 添加扇形扫描纹理
     */
    Core.prototype.getSectorScanMaterial = function (color, angle) {
        if (!Cesium.EllipsoidFadeMaterialProperty) {
            function EllipsoidFadeMaterialProperty(color, angle, duration) {
                this._definitionChanged = new Cesium.Event();
                this._color = undefined;
                this._colorSubscription = undefined;
                this.color = color;
                this.duration = duration;
                this._angle = angle;

                this._time = (new Date()).getTime();
            }
            Object.defineProperties(EllipsoidFadeMaterialProperty.prototype, {
                isConstant: {
                    get: function () {
                        return false
                    }
                },
                definitionChanged: {
                    get: function () {
                        return this._definitionChanged
                    }
                },
                color: Cesium.createPropertyDescriptor('color'),
                angle: Cesium.createPropertyDescriptor('angle'),
            });
            EllipsoidFadeMaterialProperty.prototype.getType = function (time) {
                return 'EllipsoidFade';
            };
            EllipsoidFadeMaterialProperty.prototype.getValue = function (time, result) {
                if (!Cesium.defined(result)) {
                    result = {};
                }
                result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.ColorWHITE, result
                    .color);
                result.angle = this._angle;

                return result;
            };
            EllipsoidFadeMaterialProperty.prototype.equals = function (other) {
                return this === other ||
                    (other instanceof EllipsoidFadeMaterialProperty && Property.equals(this._color, other._color))
            };
            Cesium.EllipsoidFadeMaterialProperty = EllipsoidFadeMaterialProperty;

            Cesium.Material.EllipsoidFadeType = "EllipsoidFade";
            // 自定义着色器
            Cesium.Material.EllipsoidFadeSource =
                "float getAngle(in vec2 dv)\n" +
                "{\n" +
                "    if(dv.y == 0.0 && dv.x > 0.0)\n" +
                "    {\n" +
                "        return 90.0;\n" +
                "    }\n" +
                "    if(dv.y == 0.0 && dv.x < 0.0)\n" +
                "    {\n" +
                "        return 270.0;\n" +
                "    }\n" +
                "    float rAngle = atan(dv.x/dv.y) * 180.0 / 3.1415926;\n" +
                "    if(dv.x > 0.0)\n" +
                "    {\n" +
                "        if(dv.y < 0.0)\n" +
                "        {\n" +
                "            rAngle = 180.0 + rAngle;\n" +
                "        }\n" +
                "    }\n" +
                "    if(dv.x <= 0.0)\n" +
                "    {\n" +
                "        if(dv.y < 0.0)\n" +
                "        {\n" +
                "            rAngle = 180.0 + rAngle;\n" +
                "        }\n" +
                "        if(dv.y > 0.0)\n" +
                "        {\n" +
                "            rAngle = 360.0 + rAngle;\n" +
                "        }\n" +
                "    }\n" +
                "    return rAngle;\n" +
                "}\n" +

                "float ripple(float dist, float rippleIntensity, float rippleScale) {\n" +
                "    return rippleScale * ((sin(dist * rippleIntensity - czm_frameNumber/10.0)-0.9) / (dist * rippleIntensity));\n" +
                "}\n" +
                "czm_material czm_getMaterial(czm_materialInput materialInput)\n" +
                "{\n" +
                "  czm_material material = czm_getDefaultMaterial(materialInput);\n" +
                "  material.diffuse = 1.5 * color.rgb;\n" +
                "  vec2 st = materialInput.st;\n" +
                "  float dis = distance(st, vec2(0.5, 0.5));\n" +
                "  float nowAngle = getAngle(st.xy-vec2(0.5, 0.5));\n" +
                "  if(nowAngle < angle)\n" +
                "  {\n" +
                "       material.alpha = 1.0 - dis/0.5;\n" +
                "       float intensity =step(0.001,ripple(dis, 100.0, 15.0));\n" +
                "       if(intensity == 1.0)\n" +
                "       {\n" +
                "           material.alpha = material.alpha/2.0;\n" +
                "       }\n" +
                "  }\n" +
                "  else{\n" +
                "       material.alpha = 0.0;\n" +
                "       discard;\n" +
                "  }\n" +
                "  return material;\n" +
                "}";


            Cesium.Material._materialCache.addMaterial(Cesium.Material.EllipsoidFadeType, {
                fabric: {
                    type: Cesium.Material.EllipsoidFadeType,
                    uniforms: {
                        color: new Cesium.Color(1.0, 0.0, 0.0, 1),
                        angle: 90
                    },
                    source: Cesium.Material.EllipsoidFadeSource

                },
                translucent: function (material) {
                    return true;
                }
            });
        }
        return new Cesium.EllipsoidFadeMaterialProperty(Cesium.Color.fromCssColorString(this.defaultValue(color, "#ff0000")), this.defaultValue(angle, 45))
    };

    /**
     * 添加扩散圆扫描纹理
     */
    Core.prototype.getCircleScanMaterial = function (color, time) {
        if (!Cesium.CircleScanMaterialProperty) {
            function CircleScanMaterialProperty(color, duration) {
                this._definitionChanged = new Cesium.Event();
                this._color = undefined;
                this._colorSubscription = undefined;
                this.color = color;
                this.duration = duration;

                this._time = (new Date()).getTime();
            }
            Object.defineProperties(CircleScanMaterialProperty.prototype, {
                isConstant: {
                    get: function () {
                        return false
                    }
                },
                definitionChanged: {
                    get: function () {
                        return this._definitionChanged
                    }
                },
                color: Cesium.createPropertyDescriptor('color')
            });
            CircleScanMaterialProperty.prototype.getType = function (time) {
                return 'CircleScan';
            };
            CircleScanMaterialProperty.prototype.getValue = function (time, result) {
                if (!Cesium.defined(result)) {
                    result = {};
                }
                result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.Color.WHITE, result.color);
                result.time = (((new Date()).getTime() - this._time) % this.duration) / this.duration;
                return result;
            };
            CircleScanMaterialProperty.prototype.equals = function (other) {
                return this === other ||
                    (other instanceof CircleScanMaterialProperty &&
                        Cesium.Property.equals(this._color, other._color))
            };
            Cesium.CircleScanMaterialProperty = CircleScanMaterialProperty;

            Cesium.Material.CircleScanType = "CircleScan";
            // 自定义着色器
            Cesium.Material.CircleScanSource =
                "czm_material czm_getMaterial(czm_materialInput materialInput)\n\
                {\n\
                    czm_material material = czm_getDefaultMaterial(materialInput);\n\
                    material.diffuse = color.rgb;\n\
                    vec2 st = materialInput.st;\n\
                    float dis = distance(st, vec2(0.5, 0.5));\n\
                    if(dis<time){\n\
                        float f = dis / time;\n\
                        material.alpha = pow(f, 4.0);\n\
                    }else{\n\
                        material.alpha = 0.0;\n\
                    }\n\
                    return material;\n\
                }";


            Cesium.Material._materialCache.addMaterial(Cesium.Material.CircleScanType, {
                fabric: {
                    type: Cesium.Material.CircleScanType,
                    uniforms: {
                        color: new Cesium.Color(1.0, 0.0, 0.0, 1),
                        time: 0
                    },
                    source: Cesium.Material.CircleScanSource

                },
                translucent: function (material) {
                    return true;
                }
            });
        }
        return new Cesium.CircleScanMaterialProperty(Cesium.Color.fromCssColorString(this.defaultValue(color, "#ff0000")), this.defaultValue(time, 3000));
    };

    /**
     * 添加雷达扫描纹理
     */
    Core.prototype.getRadarScanMaterial = function (color, time) {
        if (!Cesium.RadarScanMaterialProperty) {
            function RadarScanMaterialProperty(color, duration) {
                this._definitionChanged = new Cesium.Event();
                this._color = undefined;
                this._colorSubscription = undefined;
                this.color = color;
                this.duration = duration;

                this._time = (new Date()).getTime();
            }
            Object.defineProperties(RadarScanMaterialProperty.prototype, {
                isConstant: {
                    get: function () {
                        return false
                    }
                },
                definitionChanged: {
                    get: function () {
                        return this._definitionChanged
                    }
                },
                color: Cesium.createPropertyDescriptor('color')
            });
            RadarScanMaterialProperty.prototype.getType = function (time) {
                return 'RadarScan';
            };
            RadarScanMaterialProperty.prototype.getValue = function (time, result) {
                if (!Cesium.defined(result)) {
                    result = {};
                }
                result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.Color.WHITE, result.color);
                result.time = (((new Date()).getTime() - this._time) % this.duration) / this.duration;
                result.angle1 = 360 * result.time;
                result.angle2 = 360 * result.time + 60;
                if (result.angle2 > 360) {
                    result.angle2 = result.angle2 - 360;
                }
                return result;
            };
            RadarScanMaterialProperty.prototype.equals = function (other) {
                return this === other ||
                    (other instanceof RadarScanMaterialProperty &&
                        Cesium.Property.equals(this._color, other._color))
            };
            Cesium.RadarScanMaterialProperty = RadarScanMaterialProperty;

            Cesium.Material.RadarScanType = "RadarScan";
            // 自定义着色器
            Cesium.Material.RadarScanSource =
                "float getAngle(in vec2 dv)\n\
                {\n\
                    if(dv.y == 0.0 && dv.x > 0.0)\n\
                    {\n\
                        return 90.0;\n\
                    }\n\
                    if(dv.y == 0.0 && dv.x < 0.0)\n\
                    {\n\
                        return 270.0;\n\
                    }\n\
                    float rAngle = atan(dv.x/dv.y) * 180.0 / 3.1415926;\n\
                    if(dv.x > 0.0)\n\
                    {\n\
                        if(dv.y < 0.0)\n\
                        {\n\
                            rAngle = 180.0 + rAngle;\n\
                        }\n\
                    }\n\
                    if(dv.x <= 0.0)\n\
                    {\n\
                        if(dv.y < 0.0)\n\
                        {\n\
                            rAngle = 180.0 + rAngle;\n\
                        }\n\
                        if(dv.y > 0.0)\n\
                        {\n\
                            rAngle = 360.0 + rAngle;\n\
                        }\n\
                    }\n\
                    return rAngle;\n\
                }\n\
                float ripple(float dist, float rippleIntensity, float rippleScale) {\n\
                    return rippleScale * ((sin(dist * rippleIntensity - czm_frameNumber/10.0)-0.9) / (dist * rippleIntensity));\n\
                }\n\
                czm_material czm_getMaterial(czm_materialInput materialInput)\n\
                {\n\
                    czm_material material = czm_getDefaultMaterial(materialInput);\n\
                    material.diffuse = color.rgb;\n\
                    vec2 st = materialInput.st;\n\
                    float dis = distance(st, vec2(0.5, 0.5));\n\
                    float f = 0.0;\n\
                    float nowAngle = getAngle(st.xy-vec2(0.5, 0.5));\n\
                    if(nowAngle < angle2 && nowAngle > angle1)\n\
                    {\n\
                        f = (nowAngle - angle1) / 60.0;\n\
                        material.alpha = f;\n\
                    }else if(nowAngle < 360.0 && nowAngle > angle1 && angle2 < 60.0){\n\
                        f = (nowAngle - angle1) / 60.0;\n\
                        material.alpha = f;\n\
                    }else if(nowAngle < angle2 && nowAngle > 0.0 && angle2 < 60.0){\n\
                        f = (nowAngle + 360.0 - angle1) / 60.0;\n\
                        material.alpha = f;\n\
                    }else{\n\
                        material.alpha = 0.0;\n\
                        discard;\n\
                    }\n\
                    return material;\n\
                }";


            Cesium.Material._materialCache.addMaterial(Cesium.Material.RadarScanType, {
                fabric: {
                    type: Cesium.Material.RadarScanType,
                    uniforms: {
                        color: new Cesium.Color(1.0, 0.0, 0.0, 1),
                        time: 0,
                        angle2: 0,
                        angle1: 0
                    },
                    source: Cesium.Material.RadarScanSource

                },
                translucent: function (material) {
                    return true;
                }
            });
        }
        return new Cesium.RadarScanMaterialProperty(Cesium.Color.fromCssColorString(this.defaultValue(color, "#ff0000")), this.defaultValue(time, 3000));
    };

    /**
     * 创建颜色阶梯过渡工具
     * @param {String} url 服务地址
     */
    Core.prototype.gradientColor = function (startColor, endColor, step) {
        return new gradientColor(startColor, endColor, step);
    };
    /**
     * ajax
     * @param {*} param 
     */
    Core.prototype.xhr = function (param) {
        // $method, $url, param, success, error
        var Request = new XMLHttpRequest();
        var async = true;
        if (param.async == undefined)
            async = true;
        else if (param.async == null)
            async = true;
        else
            async = param.async;
        Request.open(param.type, param.url, async);
        // Request.setRequestHeader("CONTENT-TYPE", "application/x-www-from-urlencoded");
        Request.send(param.data || {});
        Request.onreadystatechange = function () {
            if (this.readyState === 4 && this.status === 200) {
                //obj.innerHTML = Request.responseText;
                if (param.success && typeof param.success == 'function')
                    param.success(param.isXml ? this.responseXML : JSON.parse(this.responseText));
            } else {
                if (param.error && typeof param.error == 'function')
                    param.error(Request);
            }
            if (param.complete && typeof param.complete == 'function')
                param.complete();
        };
    };
    var _typeof$7 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
        return typeof obj;
    } : function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    /**
    * 序列化参数对象
    *
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    */
    Core.prototype._serialize = function (params) {
        var queryArray = [];
        var encode = window.encodeURIComponent;

        for (var key in params) {
            var value = params[key];

            if ((typeof value === 'undefined' ? 'undefined' : _typeof$7(value)) === 'object') {
                queryArray.push(encode(key) + '=' + encode(JSON.stringify(value)));
            } else {
                queryArray.push(encode(key) + '=' + encode(params[key]));
            }
        }

        return queryArray.join('&');
    };

    /**
    * xml转json
    */
    Core.prototype.xml2json = function (xml, extended) {
        if (!xml) return {}; // quick fail
        if (typeof xml === 'string') {
            xml = loadXML(xml);
        }
        var that = this;

        //### PARSER LIBRARY
        // Core function
        function parseXML(node, simple) {
            if (!node) return null;
            var txt = "",
                obj = null,
                att = null;
            node.nodeType;
                jsVar(node.localName || node.nodeName);
            node.text || node.nodeValue || ""; //if(window.console) console.log(['x2j',nn,nt,nv.length+' bytes']);
              /*DBG*/ if (node.childNodes) {
                if (node.childNodes.length > 0) {
                    /*DBG*/ //if(window.console) console.log(['x2j',nn,'CHILDREN',node.childNodes]);
                    node.childNodes.forEach((cn, n) => {
                        var cnt = cn.nodeType,
                            cnn = jsVar(cn.localName || cn.nodeName);
                        var cnv = cn.text || cn.nodeValue || ""; //if(window.console) console.log(['x2j',nn,'node>a',cnn,cnt,cnv]);
                    /*DBG*/ if (cnt == 8) {
                            /*DBG*/ //if(window.console) console.log(['x2j',nn,'node>b',cnn,'COMMENT (ignore)']);
                            return; // ignore comment node
                        } else if (cnt == 3 || cnt == 4 || !cnn) {
                            // ignore white-space in between tags
                            if (cnv.match(/^\s+$/)) {
                                /*DBG*/ //if(window.console) console.log(['x2j',nn,'node>c',cnn,'WHITE-SPACE (ignore)']);
                                return;
                            } //if(window.console) console.log(['x2j',nn,'node>d',cnn,'TEXT']);
                      /*DBG*/ txt += cnv.replace(/^\s+/, "").replace(/\s+$/, "");
                            // make sure we ditch trailing spaces from markup
                        } else {
                            /*DBG*/ //if(window.console) console.log(['x2j',nn,'node>e',cnn,'OBJECT']);
                            obj = obj || {};
                            if (obj[cnn]) {
                                /*DBG*/ //if(window.console) console.log(['x2j',nn,'node>f',cnn,'ARRAY']);

                                // http://forum.jquery.com/topic/jquery-jquery-xml2json-problems-when-siblings-of-the-same-tagname-only-have-a-textnode-as-a-child
                                if (!obj[cnn].length) obj[cnn] = myArr(obj[cnn]);
                                obj[cnn] = myArr(obj[cnn]);

                                obj[cnn][obj[cnn].length] = parseXML(cn, true /* simple */);
                                obj[cnn].length = obj[cnn].length;
                            } else {
                                /*DBG*/ //if(window.console) console.log(['x2j',nn,'node>g',cnn,'dig deeper...']);
                                obj[cnn] = parseXML(cn);
                            }
                        }
                    });
                } //node.childNodes.length>0
            } //node.childNodes
            if (node.attributes) {
                if (node.attributes.length > 0) {
                    /*DBG*/ //if(window.console) console.log(['x2j',nn,'ATTRIBUTES',node.attributes])
                    att = {};
                    obj = obj || {};
                    for (let a = 0, at; a < node.attributes.length; a++) {
                        at = node.attributes[a];
                        var atn = jsVar("@" + at.name),
                            atv = at.value;
                        att[atn] = atv;
                        if (obj[atn]) {
                            /*DBG*/ //if(window.console) console.log(['x2j',nn,'attr>',atn,'ARRAY']);

                            // http://forum.jquery.com/topic/jquery-jquery-xml2json-problems-when-siblings-of-the-same-tagname-only-have-a-textnode-as-a-child
                            //if(!obj[atn].length) obj[atn] = myArr(obj[atn]);//[ obj[ atn ] ];
                            obj[cnn] = myArr(obj[cnn]);

                            obj[atn][obj[atn].length] = atv;
                            obj[atn].length = obj[atn].length;
                        } else {
                            /*DBG*/ //if(window.console) console.log(['x2j',nn,'attr>',atn,'TEXT']);
                            obj[atn] = atv;
                        }
                    }
                    //obj['attributes'] = att;
                } //node.attributes.length>0
            } //node.attributes
            if (obj) {
                obj = that.extend(
                    txt != "" ? new String(txt) : {},
                  /* {text:txt},*/ obj || {} /*, att || {}*/
                );
                //txt = (obj.text) ? (typeof(obj.text)=='object' ? obj.text : [obj.text || '']).concat([txt]) : txt;
                txt = obj.text ? [obj.text || ""].concat([txt]) : txt;
                if (txt) obj.text = txt;
                txt = "";
            }
            var out = obj || txt;
            //console.log([extended, simple, out]);
            if (extended) {
                if (txt) out = {}; //new String(out);
                txt = out.text || txt || "";
                if (txt) out.text = txt;
                if (!simple) out = myArr(out);
            }
            return out;
        } // parseXML
        // Core Function End
        // Utility functions
        var jsVar = function (s) {
            return String(s || "").replace(/-/g, "Core");
        };
        // OLD isNum function: (for reference only)
        //var isNum = function(s){ return (typeof s == "number") || String((s && typeof s == "string") ? s : '').test(/^((-)?([0-9]*)((\.{0,1})([0-9]+))?$)/); };

        var myArr = function (o) {
            // http://forum.jquery.com/topic/jquery-jquery-xml2json-problems-when-siblings-of-the-same-tagname-only-have-a-textnode-as-a-child
            //if(!o.length) o = [ o ]; o.length=o.length;
            if (!Array.isArray(o)) o = [o];
            o.length = o.length;

            // here is where you can attach additional functionality, such as searching and sorting...
            return o;
        };
        // Utility functions End
        //### PARSER LIBRARY END

        // Quick fail if not xml (or if this is a node)
        if (!xml.nodeType) return;
        if (xml.nodeType == 3 || xml.nodeType == 4) return xml.nodeValue;

        // Find xml root node
        var root = xml.nodeType == 9 ? xml.documentElement : xml;

        // Convert xml to json
        var out = parseXML(root, true /* simple */);

        // Clean-up memory
        xml = null;
        root = null;

        // Send output
        return out;
    };

    //构建xmldoc对象
    function loadXML(xmlString) {
        //构建xmldoc对象

        var xmlDoc = null;

        if (window.DOMParser) {
            //IE9+,FF,webkit
            try {
                let domParser = new DOMParser();
                xmlDoc = domParser.parseFromString(xmlString, "text/xml");
            } catch (e) { }
        } else if (!window.DOMParser && window.ActiveXObject) {
            //window.DOMParser 判断是否是非ie浏览器
            var xmlDomVersions = ["MSXML2.DOMDocument", "Microsoft.XMLDOM"];
            for (var i = 0; i < xmlDomVersions.length; i++) {
                try {
                    xmlDoc = new ActiveXObject(xmlDomVersions[i]);
                    xmlDoc.async = false;
                    xmlDoc.loadXML(xmlString); //loadXML方法载入xml字符串
                    break;
                } catch (e) {
                    continue;
                }
            }
        } else {
            return null;
        }

        return xmlDoc;
    }
    //颜色阶梯过渡（均匀渐变）Gradient算法
    //Gradient = Start+ (End-Start) / Step * N

    function gradientColor(startColor, endColor, step) {
        if (startColor && endColor) {
            if (startColor[0] !== '#') {
                startColor = this.colorHex(startColor);
            }
            if (endColor[0] !== '#') {
                endColor = this.colorHex(endColor);
            }
            var startRGB = this.colorRgb(startColor);//转换为rgb数组模式
            var startR = startRGB[0];
            var startG = startRGB[1];
            var startB = startRGB[2];

            var endRGB = this.colorRgb(endColor);
            var endR = endRGB[0];
            var endG = endRGB[1];
            var endB = endRGB[2];

            var sR = (endR - startR) / step;//总差值
            var sG = (endG - startG) / step;
            var sB = (endB - startB) / step;

            var colorArr = [];
            for (var i = 0; i < step; i++) {
                //计算每一步的hex值
                var hex = this.colorHex('rgb(' + parseInt((sR * i + startR)) + ',' + parseInt((sG * i + startG)) + ',' + parseInt((sB * i + startB)) + ')');
                colorArr.push(hex);
            }
            return colorArr;
        }
        return this;
    }

    // 将hex表示方式转换为rgb表示方式(这里返回rgb数组模式)
    gradientColor.prototype.colorRgb = function (sColor) {
        var reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;
        var sColor = sColor.toLowerCase();
        if (sColor && reg.test(sColor)) {
            if (sColor.length === 4) {
                var sColorNew = "#";
                for (var i = 1; i < 4; i += 1) {
                    sColorNew += sColor.slice(i, i + 1).concat(sColor.slice(i, i + 1));
                }
                sColor = sColorNew;
            }
            //处理六位的颜色值
            var sColorChange = [];
            for (var i = 1; i < 7; i += 2) {
                sColorChange.push(parseInt("0x" + sColor.slice(i, i + 2)));
            }
            return sColorChange;
        } else {
            return sColor;
        }
    };

    // 将rgb表示方式转换为hex表示方式
    gradientColor.prototype.colorHex = function (rgb) {
        var _this = rgb;
        var reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;
        if (/^(rgb|RGB)/.test(_this)) {
            var str = _this.replace(/(rgb|RGB)*/g, "");
            str = str.replace("(", "").replace(")", "");
            var aColor = str.split(",");
            var strHex = "#";
            for (var i = 0; i < aColor.length; i++) {
                var hex = Number(aColor[i]).toString(16);
                hex = hex.length === 1 ? 0 + '' + hex : hex;// 保证每个rgb的值为2位
                if (hex === "0") {
                    hex += hex;
                }
                strHex += hex;
            }
            if (strHex.length !== 7) {
                strHex = _this;
            }
            return strHex;
        } else if (reg.test(_this)) {
            var aNum = _this.replace(/#/, "").split("");
            if (aNum.length === 6) {
                return _this;
            } else if (aNum.length === 3) {
                var numHex = "#";
                for (var i = 0; i < aNum.length; i += 1) {
                    numHex += (aNum[i] + aNum[i]);
                }
                return numHex;
            }
        } else {
            return _this;
        }
    };

    // 判断是否为手机浏览器
    Core.prototype.getBrowser = function () {
        var ua = navigator.userAgent.toLowerCase();
        var btypeInfo = (ua.match(/firefox|chrome|safari|opera/g) || "other")[0];
        if ((ua.match(/msie|trident/g) || [])[0]) {
            btypeInfo = "msie";
        }
        var pc = "";
        var prefix = "";
        var plat = "";
        //如果没有触摸事件 判定为PC
        var isTocuh = ("ontouchstart" in window) || (ua.indexOf("touch") !== -1) || (ua.indexOf("mobile") !== -1);
        if (isTocuh) {
            if (ua.indexOf("ipad") !== -1) {
                pc = "pad";
            } else if (ua.indexOf("mobile") !== -1) {
                pc = "mobile";
            } else if (ua.indexOf("android") !== -1) {
                pc = "androidPad";
            } else {
                pc = "pc";
            }
        } else {
            pc = "pc";
        }
        switch (btypeInfo) {
            case "chrome":
            case "safari":
            case "mobile":
                prefix = "webkit";
                break;
            case "msie":
                prefix = "ms";
                break;
            case "firefox":
                prefix = "Moz";
                break;
            case "opera":
                prefix = "O";
                break;
            default:
                prefix = "webkit";
                break
        }
        plat = (ua.indexOf("android") > 0) ? "android" : navigator.platform.toLowerCase();
        return {
            version: (ua.match(/[\s\S]+(?:rv|it|ra|ie)[\/: ]([\d.]+)/) || [])[1],     //版本
            plat: plat,                   //系统
            type: btypeInfo,              //浏览器
            pc: pc,
            prefix: prefix,                //前缀
            isMobile: (pc == "pc") ? false : true              //是否是移动端
        };
    };

    /**
    *
    * 这个方法用于创建颜色。
    *
    * @alias Color 
    * @constructor
    *
    */
    function Color(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
    }

    /**
    * 矢量切片颜色转化
    * @returns {Promise.<Object>} 返回一个Cesium的颜色对象。
    */
    Color.prototype.VectorColorTransformation = function (obj, entity) {
        var Color = obj;
        //填充颜色设置
        if (Color && Color.toString().charAt(0) == "[" && Color.toString().charAt(Color.length - 1) == "]") {
            var material = styleOption.fillColor.replace(/\[/, '').replace(/\]/, '');
            Color = entity.properties[material];
        }
        if (!this._core.isnull(Color)) {
            if (this._core.isHtmlColor(Color)) {
                Color = this.colorFromHtmlColor(Color);
            } else {
                if (/^rgb/.test(Color)) {
                    Color = this.rgbaStringToRgbaObj(Color);
                }
                if (Color.r != undefined) {
                    if (Color.r > 1) {
                        Color.r = Color.r / 255;
                    }
                    if (Color.g > 1) {
                        Color.g = Color.g / 255;
                    }
                    if (Color.b > 1) {
                        Color.b = Color.b / 255;
                    }
                    if (Color.a > 1) {
                        Color.a = Color.a / 255;
                    }
                    Color = this.createColor(Color.r, Color.g, Color.b, Color.a);
                } else if (Color.red != undefined) {
                    if (Color.red > 1) {
                        Color.red = Color.red / 255;
                    }
                    if (Color.green > 1) {
                        Color.green = Color.green / 255;
                    }
                    if (Color.blue > 1) {
                        Color.blue = Color.blue / 255;
                    }
                    if (Color.alpha > 1) {
                        Color.alpha = Color.alpha / 255;
                    }
                    Color = this.createColor(Color.red, Color.green, Color.blue, Color.alpha);
                }
            }
        }
        return Color;
    };
    /**
    * 这个方法用于创建颜色
    *@param {number} [red] 红色组件。
    * @param {number} [green] 绿色组件。
    * @param {number} [blue] 蓝色组件。
    * @param {number} [alphae] alphea组件。
    * @returns {Promise.<Object>} 返回一个Cesium的颜色对象。
    */
    Color.prototype.createColorTransformation = function (obj) {
        var Color = obj;
        //填充颜色设置
        if (!this._core.isnull(Color)) {
            if (Color.toString().charAt(0) == "[" && Color.toString().charAt(Color.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(Color)) {
                    Color = this.colorFromHtmlColor(Color);
                } else {
                    if (/^rgb/.test(Color)) {
                        Color = this.rgbaStringToRgbaObj(Color);
                    }
                    if (Color.r > 1) {
                        Color.r = Color.r / 255;
                    }
                    if (Color.g > 1) {
                        Color.g = Color.g / 255;
                    }
                    if (Color.b > 1) {
                        Color.b = Color.b / 255;
                    }
                    if (Color.a > 1) {
                        Color.a = Color.a / 255;
                    }
                    Color = this.createColor(Color.r, Color.g, Color.b, Color.a);
                }
            }
        }
        return Color;
    };


    /**
    * 这个方法用于创建颜色
    *@param {number} [red] 红色组件。
    * @param {number} [green] 绿色组件。
    * @param {number} [blue] 蓝色组件。
    * @param {number} [alphae] alphea组件。
    * @returns {Promise.<Object>} 返回一个Cesium的颜色对象。
    */
    Color.prototype.createColor = function (red, green, blue, alpha) {
        var Color = new this._cesium.Color(red, green, blue, alpha);
        return Color;
    };
    /**
    * 16进制颜色转为RGB格式
    *@param {String} [htmlcolor] 红色组件。
    * @returns {Object} 返回一个Cesium的颜色对象。
    */
    Color.prototype.colorFromHtmlColor = function (htmlcolor) {
        if (typeof htmlcolor == 'object') {
            if (htmlcolor.color) {
                return htmlcolor.color;
            }
            return undefined;
        }
        ///#AFEEEE
        var reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6}|[0-9a-fA-f]{8})$/;
        htmlcolor = htmlcolor.toLowerCase();
        if (!reg.test(htmlcolor)) {
            console.log('不是有效的html颜色', htmlcolor);
            return;
        }
        if (htmlcolor.length == 4) {
            var sColorNew = "#";
            for (var i = 1; i < 4; i += 1) {
                sColorNew += htmlcolor.slice(i, i + 1).concat(htmlcolor.slice(i, i + 1));
            }
            htmlcolor = sColorNew;
        }
        //处理六位的颜色值
        var sColorChange = [];
        for (var i = 1; i < 7; i += 2) {
            sColorChange.push(parseInt("0x" + htmlcolor.slice(i, i + 2)));
        }
        //处理八位颜色值加透明度
        if (htmlcolor.length == 9) {
            var opity = parseInt(htmlcolor.substr(7, 2)) / 100;
            return this.createColor(sColorChange[0] / 255, sColorChange[1] / 255, sColorChange[2] / 255, opity);
        }
        return this.createColor(sColorChange[0] / 255, sColorChange[1] / 255, sColorChange[2] / 255, 1);
    };
    /**
     * rgb 颜色转16进制
     */
    Color.prototype.toHtmlColor = function (color) {
        //color = color.toString().replace(/rgb|RGB|rgba|RGBA/,'');
        var rgb = color.split(',');
        var r = parseInt(rgb[0].split('(')[1]);
        var g = parseInt(rgb[1]);
        var b = parseInt(rgb[2].split(')')[0]);
        var hex = "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
        return hex;
    };
    /**
    * 转为rgb颜色对象
    */
    Color.prototype.rgbaStringToRgbaObj = function (color) {
        if (/^rgb/.test(color)) {
            //rgba(28, 63, 169, 1)
            color = color.replace(/rgba\(/g, ""),
                color = color.replace(/rgb\(/g, "");
            color = color.replace(/\)/g, "");
            var colors = color.split(",");
            color = {};
            if (colors.length == 3) {
                color.r = parseFloat(colors[0]);
                color.g = parseFloat(colors[1]);
                color.b = parseFloat(colors[2]);
                color.a = 1;
            }
            else if (colors.length == 4) {
                color.r = parseFloat(colors[0]);
                color.g = parseFloat(colors[1]);
                color.b = parseFloat(colors[2]);
                color.a = parseFloat(colors[3]);
            }
        }
        return color;
    };
    /**
     * 仿照te修改
     *
     * 这个方法用于创建颜色
     *@param {number} [red] 红。
     * @param {number} [green] 绿。
     * @param {number} [blue] 蓝。
     * @param {number} [alpha] 透明度。
     * @returns {Promise.<Object>} 返回一个Cesium的颜色对象。
     */
    Color.prototype.CreateColor = function (red, green, blue, alpha) {
        var Color = new this._cesium.Color(red, green, blue, alpha);
        return Color;
    };

    /**
    *
    * 创建等高线。
    *
    * @alias ElevationContour 
    * @constructor
    *
    */
    function ElevationContour(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
    }


    /**
    * 这个方法用于创建等高线
    * 
    */
    ElevationContour.prototype.createElevationContour = function (hasContour, selectedShading, option) {
        var _this = this;
        var elevation = {};
        _this.item = elevation;
        var minHeight = this._core.defaultValue(option.min, -414.0);
        var maxHeight = _this._core.defaultValue(option.max, 8844);
        _this.item.selectedShading = selectedShading;
        var hasContour = hasContour;
        var globe = _this._viewer.scene.globe;
        var material;
        if (hasContour) {
            if (selectedShading === 'elevation') {
                material = new _this._cesium.Material({
                    fabric: {
                        type: 'ElevationColorContour',
                        materials: {
                            contourMaterial: {
                                type: 'ElevationContour'
                            },
                            elevationRampMaterial: {
                                type: 'ElevationRamp'
                            }
                        },
                        components: {
                            diffuse: 'contourMaterial.alpha == 0.0 ? elevationRampMaterial.diffuse : contourMaterial.diffuse',
                            alpha: 'max(contourMaterial.alpha, elevationRampMaterial.alpha)'
                        }
                    },
                    translucent: false
                });
                _this.item.shadingUniforms = material.materials.elevationRampMaterial.uniforms;
                _this.item.shadingUniforms.minimumHeight = minHeight;
                _this.item.shadingUniforms.maximumHeight = maxHeight;
                _this.item.contourUniforms = material.materials.contourMaterial.uniforms;
            } else if (selectedShading === 'slope') {
                material = new _this._cesium.Material({
                    fabric: {
                        type: 'SlopeColorContour',
                        materials: {
                            contourMaterial: {
                                type: 'ElevationContour'
                            },
                            slopeRampMaterial: {
                                type: 'SlopeRamp'
                            }
                        },
                        components: {
                            diffuse: 'contourMaterial.alpha == 0.0 ? slopeRampMaterial.diffuse : contourMaterial.diffuse',
                            alpha: 'max(contourMaterial.alpha, slopeRampMaterial.alpha)'
                        }
                    },
                    translucent: false
                });
                _this.item.shadingUniforms = material.materials.slopeRampMaterial.uniforms;
                _this.item.contourUniforms = material.materials.contourMaterial.uniforms;
            } else if (selectedShading === 'aspect') {
                material = new _this._cesium.Material({
                    fabric: {
                        type: 'AspectColorContour',
                        materials: {
                            contourMaterial: {
                                type: 'ElevationContour'
                            },
                            aspectRampMaterial: {
                                type: 'AspectRamp'
                            }
                        },
                        components: {
                            diffuse: 'contourMaterial.alpha == 0.0 ? aspectRampMaterial.diffuse : contourMaterial.diffuse',
                            alpha: 'max(contourMaterial.alpha, aspectRampMaterial.alpha)'
                        }
                    },
                    translucent: false
                });
                _this.item.shadingUniforms = material.materials.aspectRampMaterial.uniforms;
                _this.item.contourUniforms = material.materials.contourMaterial.uniforms;
            } else {
                material = _this._cesium.Material.fromType('ElevationContour');
                _this.item.contourUniforms = material.uniforms;
            }
            _this.item.contourUniforms.width = _this._core.defaultValue(option.width, 2.0);
            _this.item.contourUniforms.spacing = _this._core.defaultValue(option.spacing, 150.0);
            _this.item.contourUniforms.color = _this._cesium.Color.fromCssColorString(_this._core.defaultValue(option.lineColor, '#ff0000'));
        } else if (selectedShading === 'elevation') {
            material = _this._cesium.Material.fromType('ElevationRamp');
            _this.item.shadingUniforms = material.uniforms;
            _this.item.shadingUniforms.minimumHeight = minHeight;
            _this.item.shadingUniforms.maximumHeight = maxHeight;
        } else if (selectedShading === 'slope') {
            material = _this._cesium.Material.fromType('SlopeRamp');
            _this.item.shadingUniforms = material.uniforms;
        } else if (selectedShading === 'aspect') {
            material = _this._cesium.Material.fromType('AspectRamp');
            _this.item.shadingUniforms = material.uniforms;
        }
        if (selectedShading !== 'none') {
            if (option) {
                _this.item.shadingUniforms.image = _this._core.getColorRamp(selectedShading, option.colorArr, option.min, option.max);
            } else {
                _this.item.shadingUniforms.image = _this._core.getColorRamp(selectedShading);
            }
        }
        globe.material = undefined;
        _this._viewer.render();
        globe.material = material;
        _this.item.material = globe.material;
        return this;
    };
    /**
    * 这个方法用于创建坡度无线分析
    * 
    */
    ElevationContour.prototype.executeMaterial = function (method) {
        var _this = this;
        var elevation = {};
        _this.item = elevation;
        var minHeight = -414.0;// approximate dead sea elevation
        var maxHeight = 8777.0;// approximate everest elevation
        _this.item.selectedShading = method;
        _this.item.shadingUniforms = {};
        var globe = this._viewer.scene.globe;
        var material;
        if (_this.item.selectedShading === 'elevation') {
            material = this._cesium.Material.fromType('ElevationRamp');
            _this.item.shadingUniforms = material.uniforms;
            _this.item.shadingUniforms.minHeight = minHeight;
            _this.item.shadingUniforms.maxHeight = maxHeight;
        } else if (_this.item.selectedShading === 'slope') {
            material = this._cesium.Material.fromType('SlopeRamp');
            _this.item.shadingUniforms = material.uniforms;
        } else if (_this.item.selectedShading === 'aspect') {
            material = this._cesium.Material.fromType('AspectRamp');
            _this.item.shadingUniforms = material.uniforms;
        }
        if (_this.item.selectedShading !== 'none') {
            _this.item.shadingUniforms.image = this._core.getColorRamp(_this.item.selectedShading);
        }
        globe.material = material;
        _this.item.material = globe.material;
        return this;
    };
    /**
    * 设置线的间距
    * @param {Object} [elevation] elevation对象
    * @returns {spacing} spacing设置间距。
    * @returns {Object} 返回一个等高线或坡度对象。
    */
    ElevationContour.prototype.setSpacing = function (spacing) {
        try {
            //contourUniforms.spacing = parseFloat(newValue);
            this.item.contourUniforms.spacing = parseFloat(spacing);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
    * 设置等高线坡度颜色
    * @param {Object} [elevation] elevation对象
    * @returns {htmlColor} htmlColor颜色。
    * @returns {Object} 返回一个Label对象。
    */
    ElevationContour.prototype.setMaterialColor = function (htmlColor) {
        try {
            this.item.contourUniforms.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
            //this.item.contourUniforms.color = this._cesium.Color.GOLD.clone()
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
    * 设置线的宽度
    * @param {Object} [elevation] elevation对象
    * @param {double} [width] 线宽
    * @returns {Object} 返回一个等高线或坡度对象。
    */
    ElevationContour.prototype.setWidth = function (width) {
        try {
            //contourUniforms.spacing = parseFloat(newValue);
            this.item.contourUniforms.width = parseFloat(width);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
    * 这个方法用于创建坡度有线分析
    * 
    */
    ElevationContour.prototype.executeContourMaterial = function (method) {
        var _this = this;
        var elevation = {};
        _this.item = elevation;
        var minHeight = -414.0;// approximate dead sea elevation
        var maxHeight = 8777.0;// approximate everest elevation
        _this.item.selectedShading = method;
        var globe = _this._viewer.scene.globe;
        var material;
        if (_this.item.selectedShading === 'elevation') {
            material = new this._cesium.Material({
                fabric: {
                    type: 'ElevationColorContour',
                    materials: {
                        contourMaterial: {
                            type: 'ElevationContour'
                        },
                        elevationRampMaterial: {
                            type: 'ElevationRamp'
                        }
                    },
                    components: {
                        diffuse: 'contourMaterial.alpha == 0.0 ? elevationRampMaterial.diffuse : contourMaterial.diffuse',
                        alpha: 'max(contourMaterial.alpha, elevationRampMaterial.alpha)'
                    }
                },
                translucent: false
            });
            _this.item.shadingUniforms = material.materials.elevationRampMaterial.uniforms;
            _this.item.shadingUniforms.minHeight = minHeight;
            _this.item.shadingUniforms.maxHeight = maxHeight;
            _this.item.contourUniforms = material.materials.contourMaterial.uniforms;
        } else if (_this.item.selectedShading === 'slope') {
            material = getSlopeContourMaterial();
            _this.item.shadingUniforms = material.materials.slopeRampMaterial.uniforms;
            _this.item.contourUniforms = material.materials.contourMaterial.uniforms;
        } else if (_this.item.selectedShading === 'aspect') {
            material = getAspectContourMaterial();
            _this.item.shadingUniforms = material.materials.aspectRampMaterial.uniforms;
            _this.item.contourUniforms = material.materials.contourMaterial.uniforms;
        } else {
            material = this._cesium.Material.fromType('ElevationContour');
            _this.item.contourUniforms = material.uniforms;
        }
        if (_this.item.selectedShading !== 'none') {
            _this.item.shadingUniforms.image = this._core.getColorRamp(_this.item.selectedShading);
        }
        _this.item.contourUniforms.width = 2.0;
        _this.item.contourUniforms.spacing = 150.0;
        _this.item.contourUniforms.color = this._cesium.Color.fromRandom({ alpha: 1.0 }, this._cesium.Color.RED.clone());
        globe.material = material;
        _this.item.material = globe.material;
        return this;
    };
    Object.defineProperties(ElevationContour.prototype, {
        /**
         * 获取或设置矩形
         */
        elevation: {
            get: function () {
                return this.item;
            },
            set: function (item) {
                this.item = item;
            }
        }
    });

    /**
    *
    * 获取高程绘制剖面分析
    *
    * @alias createTerrainProfile 
    * @constructor
    *
    */
    function createTerrainProfile(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }
    /**
    * 获取高程绘制剖面分析
    * @param {Array} [pIGeometry] 一个经纬度数组例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
    * @returns {Promise.<Array>} 返回一个高程数组。
    */
    createTerrainProfile.prototype.createTerrainProfile = function (pIGeometry) {
        var gcd = [];
        for (var i = 0; i < pIGeometry.length; i++) {
            var cartographic = this._cesium.Ellipsoid.WGS84.cartesianToCartographic(pIGeometry[i]);
            gcd.push(cartographic.height);
        }
        return gcd;
    };

    /* Used as a safe reference for `undefined` in pre-ES5 environments. */
    var undefined$1;

    /* Used as the semantic version number. */
    var VERSION$1 = '4.17.21';

    /* Used as the size to enable large array optimizations. */
    var LARGE_ARRAY_SIZE = 200;

    /* Error message constants. */
    var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',
      FUNC_ERROR_TEXT = 'Expected a function',
      INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`';

    /* Used to stand-in for `undefined` hash values. */
    var HASH_UNDEFINED = '__lodash_hash_undefined__';

    /* Used as the maximum memoize cache size. */
    var MAX_MEMOIZE_SIZE = 500;

    /* Used as the internal argument placeholder. */
    var PLACEHOLDER = '__lodash_placeholder__';

    /* Used to compose bitmasks for cloning. */
    var CLONE_DEEP_FLAG = 1,
      CLONE_FLAT_FLAG = 2,
      CLONE_SYMBOLS_FLAG = 4;

    /* Used to compose bitmasks for value comparisons. */
    var COMPARE_PARTIAL_FLAG = 1,
      COMPARE_UNORDERED_FLAG = 2;

    /* Used to compose bitmasks for function metadata. */
    var WRAP_BIND_FLAG = 1,
      WRAP_BIND_KEY_FLAG = 2,
      WRAP_CURRY_BOUND_FLAG = 4,
      WRAP_CURRY_FLAG = 8,
      WRAP_CURRY_RIGHT_FLAG = 16,
      WRAP_PARTIAL_FLAG = 32,
      WRAP_PARTIAL_RIGHT_FLAG = 64,
      WRAP_ARY_FLAG = 128,
      WRAP_REARG_FLAG = 256,
      WRAP_FLIP_FLAG = 512;

    /* Used as default options for `_.truncate`. */
    var DEFAULT_TRUNC_LENGTH = 30,
      DEFAULT_TRUNC_OMISSION = '...';

    /* Used to detect hot functions by number of calls within a span of milliseconds. */
    var HOT_COUNT = 800,
      HOT_SPAN = 16;

    /* Used to indicate the type of lazy iteratees. */
    var LAZY_FILTER_FLAG = 1,
      LAZY_MAP_FLAG = 2,
      LAZY_WHILE_FLAG = 3;

    /* Used as references for various `Number` constants. */
    var INFINITY = 1 / 0,
      MAX_SAFE_INTEGER = 9007199254740991,
      MAX_INTEGER = 1.7976931348623157e+308,
      NAN = 0 / 0;

    /* Used as references for the maximum length and index of an array. */
    var MAX_ARRAY_LENGTH = 4294967295,
      MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
      HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;

    /* Used to associate wrap methods with their bit flags. */
    var wrapFlags = [
      ['ary', WRAP_ARY_FLAG],
      ['bind', WRAP_BIND_FLAG],
      ['bindKey', WRAP_BIND_KEY_FLAG],
      ['curry', WRAP_CURRY_FLAG],
      ['curryRight', WRAP_CURRY_RIGHT_FLAG],
      ['flip', WRAP_FLIP_FLAG],
      ['partial', WRAP_PARTIAL_FLAG],
      ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
      ['rearg', WRAP_REARG_FLAG]
    ];

    /* `Object#toString` result references. */
    var argsTag = '[object Arguments]',
      arrayTag = '[object Array]',
      asyncTag = '[object AsyncFunction]',
      boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      domExcTag = '[object DOMException]',
      errorTag = '[object Error]',
      funcTag = '[object Function]',
      genTag = '[object GeneratorFunction]',
      mapTag = '[object Map]',
      numberTag = '[object Number]',
      nullTag = '[object Null]',
      objectTag = '[object Object]',
      promiseTag = '[object Promise]',
      proxyTag = '[object Proxy]',
      regexpTag = '[object RegExp]',
      setTag = '[object Set]',
      stringTag = '[object String]',
      symbolTag = '[object Symbol]',
      undefinedTag = '[object Undefined]',
      weakMapTag = '[object WeakMap]',
      weakSetTag = '[object WeakSet]';

    var arrayBufferTag = '[object ArrayBuffer]',
      dataViewTag = '[object DataView]',
      float32Tag = '[object Float32Array]',
      float64Tag = '[object Float64Array]',
      int8Tag = '[object Int8Array]',
      int16Tag = '[object Int16Array]',
      int32Tag = '[object Int32Array]',
      uint8Tag = '[object Uint8Array]',
      uint8ClampedTag = '[object Uint8ClampedArray]',
      uint16Tag = '[object Uint16Array]',
      uint32Tag = '[object Uint32Array]';

    /* Used to match empty string literals in compiled template source. */
    var reEmptyStringLeading = /\b__p \+= '';/g,
      reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
      reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;

    /* Used to match HTML entities and HTML characters. */
    var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
      reUnescapedHtml = /[&<>"']/g,
      reHasEscapedHtml = RegExp(reEscapedHtml.source),
      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);

    /* Used to match template delimiters. */
    var reEscape = /<%-([\s\S]+?)%>/g,
      reEvaluate = /<%([\s\S]+?)%>/g,
      reInterpolate = /<%=([\s\S]+?)%>/g;

    /* Used to match property names within property paths. */
    var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
      reIsPlainProp = /^\w*$/,
      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

    /*
     * Used to match `RegExp`
     * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
     */
    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
      reHasRegExpChar = RegExp(reRegExpChar.source);

    /* Used to match leading whitespace. */
    var reTrimStart = /^\s+/;

    /* Used to match a single whitespace character. */
    var reWhitespace = /\s/;

    /* Used to match wrap detail comments. */
    var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
      reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
      reSplitDetails = /,? & /;

    /* Used to match words composed of alphanumeric characters. */
    var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;

    /*
     * Used to validate the `validate` option in `_.template` variable.
     *
     * Forbids characters which could potentially change the meaning of the function argument definition:
     * - "()," (modification of function parameters)
     * - "=" (default value)
     * - "[]{}" (destructuring of function parameters)
     * - "/" (beginning of a comment)
     * - whitespace
     */
    var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;

    /* Used to match backslashes in property paths. */
    var reEscapeChar = /\\(\\)?/g;

    /*
     * Used to match
     * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
     */
    var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;

    /* Used to match `RegExp` flags from their coerced string values. */
    var reFlags = /\w*$/;

    /* Used to detect bad signed hexadecimal string values. */
    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

    /* Used to detect binary string values. */
    var reIsBinary = /^0b[01]+$/i;

    /* Used to detect host constructors (Safari). */
    var reIsHostCtor = /^\[object .+?Constructor\]$/;

    /* Used to detect octal string values. */
    var reIsOctal = /^0o[0-7]+$/i;

    /* Used to detect unsigned integer values. */
    var reIsUint = /^(?:0|[1-9]\d*)$/;

    /* Used to match Latin Unicode letters (excluding mathematical operators). */
    var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;

    /* Used to ensure capturing order of template delimiters. */
    var reNoMatch = /($^)/;

    /* Used to match unescaped characters in compiled string literals. */
    var reUnescapedString = /['\n\r\u2028\u2029\\]/g;

    /* Used to compose unicode character classes. */
    var rsAstralRange = '\\ud800-\\udfff',
      rsComboMarksRange = '\\u0300-\\u036f',
      reComboHalfMarksRange = '\\ufe20-\\ufe2f',
      rsComboSymbolsRange = '\\u20d0-\\u20ff',
      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
      rsDingbatRange = '\\u2700-\\u27bf',
      rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
      rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
      rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
      rsPunctuationRange = '\\u2000-\\u206f',
      rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
      rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
      rsVarRange = '\\ufe0e\\ufe0f',
      rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;

    /* Used to compose unicode capture groups. */
    var rsApos = "['\u2019]",
      rsAstral = '[' + rsAstralRange + ']',
      rsBreak = '[' + rsBreakRange + ']',
      rsCombo = '[' + rsComboRange + ']',
      rsDigits = '\\d+',
      rsDingbat = '[' + rsDingbatRange + ']',
      rsLower = '[' + rsLowerRange + ']',
      rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
      rsFitz = '\\ud83c[\\udffb-\\udfff]',
      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
      rsNonAstral = '[^' + rsAstralRange + ']',
      rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
      rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
      rsUpper = '[' + rsUpperRange + ']',
      rsZWJ = '\\u200d';

    /* Used to compose unicode regexes. */
    var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
      rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
      rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
      rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
      reOptMod = rsModifier + '?',
      rsOptVar = '[' + rsVarRange + ']?',
      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
      rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
      rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
      rsSeq = rsOptVar + reOptMod + rsOptJoin,
      rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

    /* Used to match apostrophes. */
    var reApos = RegExp(rsApos, 'g');

    /*
     * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
     * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
     */
    var reComboMark = RegExp(rsCombo, 'g');

    /* Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
    var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');

    /* Used to match complex or compound words. */
    var reUnicodeWord = RegExp([
      rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
      rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
      rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
      rsUpper + '+' + rsOptContrUpper,
      rsOrdUpper,
      rsOrdLower,
      rsDigits,
      rsEmoji
    ].join('|'), 'g');

    /* Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
    var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']');

    /* Used to detect strings that need a more robust regexp to match words. */
    var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;

    /* Used to assign default `context` object properties. */
    var contextProps = [
      'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',
      'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',
      'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',
      'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
      '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'
    ];

    /* Used to make template sourceURLs easier to identify. */
    var templateCounter = -1;

    /* Used to identify `toStringTag` values of typed arrays. */
    var typedArrayTags = {};
    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
      typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
      typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
      typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
      typedArrayTags[uint32Tag] = true;
    typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
      typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
      typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
      typedArrayTags[errorTag] = typedArrayTags[funcTag] =
      typedArrayTags[mapTag] = typedArrayTags[numberTag] =
      typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
      typedArrayTags[setTag] = typedArrayTags[stringTag] =
      typedArrayTags[weakMapTag] = false;

    /* Used to identify `toStringTag` values supported by `_.clone`. */
    var cloneableTags = {};
    cloneableTags[argsTag] = cloneableTags[arrayTag] =
      cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
      cloneableTags[boolTag] = cloneableTags[dateTag] =
      cloneableTags[float32Tag] = cloneableTags[float64Tag] =
      cloneableTags[int8Tag] = cloneableTags[int16Tag] =
      cloneableTags[int32Tag] = cloneableTags[mapTag] =
      cloneableTags[numberTag] = cloneableTags[objectTag] =
      cloneableTags[regexpTag] = cloneableTags[setTag] =
      cloneableTags[stringTag] = cloneableTags[symbolTag] =
      cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
      cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
    cloneableTags[errorTag] = cloneableTags[funcTag] =
      cloneableTags[weakMapTag] = false;

    /* Used to map Latin Unicode letters to basic Latin letters. */
    var deburredLetters = {
      // Latin-1 Supplement block.
      '\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
      '\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
      '\xc7': 'C', '\xe7': 'c',
      '\xd0': 'D', '\xf0': 'd',
      '\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
      '\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
      '\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
      '\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i',
      '\xd1': 'N', '\xf1': 'n',
      '\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
      '\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
      '\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
      '\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
      '\xdd': 'Y', '\xfd': 'y', '\xff': 'y',
      '\xc6': 'Ae', '\xe6': 'ae',
      '\xde': 'Th', '\xfe': 'th',
      '\xdf': 'ss',
      // Latin Extended-A block.
      '\u0100': 'A', '\u0102': 'A', '\u0104': 'A',
      '\u0101': 'a', '\u0103': 'a', '\u0105': 'a',
      '\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
      '\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
      '\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
      '\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
      '\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
      '\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
      '\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
      '\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
      '\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
      '\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
      '\u0134': 'J', '\u0135': 'j',
      '\u0136': 'K', '\u0137': 'k', '\u0138': 'k',
      '\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
      '\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
      '\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
      '\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
      '\u014c': 'O', '\u014e': 'O', '\u0150': 'O',
      '\u014d': 'o', '\u014f': 'o', '\u0151': 'o',
      '\u0154': 'R', '\u0156': 'R', '\u0158': 'R',
      '\u0155': 'r', '\u0157': 'r', '\u0159': 'r',
      '\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
      '\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's',
      '\u0162': 'T', '\u0164': 'T', '\u0166': 'T',
      '\u0163': 't', '\u0165': 't', '\u0167': 't',
      '\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
      '\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
      '\u0174': 'W', '\u0175': 'w',
      '\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y',
      '\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z',
      '\u017a': 'z', '\u017c': 'z', '\u017e': 'z',
      '\u0132': 'IJ', '\u0133': 'ij',
      '\u0152': 'Oe', '\u0153': 'oe',
      '\u0149': "'n", '\u017f': 's'
    };

    /* Used to map characters to HTML entities. */
    var htmlEscapes = {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
      '"': '&quot;',
      "'": '&#39;'
    };

    /* Used to map HTML entities to characters. */
    var htmlUnescapes = {
      '&amp;': '&',
      '&lt;': '<',
      '&gt;': '>',
      '&quot;': '"',
      '&#39;': "'"
    };

    /* Used to escape characters for inclusion in compiled string literals. */
    var stringEscapes = {
      '\\': '\\',
      "'": "'",
      '\n': 'n',
      '\r': 'r',
      '\u2028': 'u2028',
      '\u2029': 'u2029'
    };

    /* Built-in method references without a dependency on `root`. */
    var freeParseFloat = parseFloat,
      freeParseInt = parseInt;

    /* Detect free variable `global` from Node.js. */
    var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

    /* Detect free variable `self`. */
    var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

    /* Used as a reference to the global object. */
    var root = freeGlobal || freeSelf || Function('return this')();

    /* Detect free variable `exports`. */
    var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

    /* Detect free variable `module`. */
    var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

    /* Detect the popular CommonJS extension `module.exports`. */
    var moduleExports = freeModule && freeModule.exports === freeExports;

    /* Detect free variable `process` from Node.js. */
    var freeProcess = moduleExports && freeGlobal.process;

    /* Used to access faster Node.js helpers. */
    var nodeUtil = (function () {
      try {
        // Use `util.types` for Node.js 10+.
        var types = freeModule && freeModule.require && freeModule.require('util').types;

        if (types) {
          return types;
        }

        // Legacy `process.binding('util')` for Node.js < 10.
        return freeProcess && freeProcess.binding && freeProcess.binding('util');
      } catch (e) { }
    }());

    /* Node.js helper references. */
    var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
      nodeIsDate = nodeUtil && nodeUtil.isDate,
      nodeIsMap = nodeUtil && nodeUtil.isMap,
      nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
      nodeIsSet = nodeUtil && nodeUtil.isSet,
      nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

    /*--------------------------------------------------------------------------*/

    /*
     * A faster alternative to `Function#apply`, this function invokes `func`
     * with the `this` binding of `thisArg` and the arguments of `args`.
     *
     * @private
     * @param {Function} func The function to invoke.
     * @param {*} thisArg The `this` binding of `func`.
     * @param {Array} args The arguments to invoke `func` with.
     * @returns {*} Returns the result of `func`.
     */
    function apply(func, thisArg, args) {
      switch (args.length) {
        case 0: return func.call(thisArg);
        case 1: return func.call(thisArg, args[0]);
        case 2: return func.call(thisArg, args[0], args[1]);
        case 3: return func.call(thisArg, args[0], args[1], args[2]);
      }
      return func.apply(thisArg, args);
    }

    /*
     * A specialized version of `baseAggregator` for arrays.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} setter The function to set `accumulator` values.
     * @param {Function} iteratee The iteratee to transform keys.
     * @param {Object} accumulator The initial aggregated object.
     * @returns {Function} Returns `accumulator`.
     */
    function arrayAggregator(array, setter, iteratee, accumulator) {
      var index = -1,
        length = array == null ? 0 : array.length;

      while (++index < length) {
        var value = array[index];
        setter(accumulator, value, iteratee(value), array);
      }
      return accumulator;
    }

    /*
     * A specialized version of `_.forEach` for arrays without support for
     * iteratee shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array} Returns `array`.
     */
    function arrayEach(array, iteratee) {
      var index = -1,
        length = array == null ? 0 : array.length;

      while (++index < length) {
        if (iteratee(array[index], index, array) === false) {
          break;
        }
      }
      return array;
    }

    /*
     * A specialized version of `_.forEachRight` for arrays without support for
     * iteratee shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array} Returns `array`.
     */
    function arrayEachRight(array, iteratee) {
      var length = array == null ? 0 : array.length;

      while (length--) {
        if (iteratee(array[length], length, array) === false) {
          break;
        }
      }
      return array;
    }

    /*
     * A specialized version of `_.every` for arrays without support for
     * iteratee shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} predicate The function invoked per iteration.
     * @returns {boolean} Returns `true` if all elements pass the predicate check,
     *  else `false`.
     */
    function arrayEvery(array, predicate) {
      var index = -1,
        length = array == null ? 0 : array.length;

      while (++index < length) {
        if (!predicate(array[index], index, array)) {
          return false;
        }
      }
      return true;
    }

    /*
     * A specialized version of `_.filter` for arrays without support for
     * iteratee shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} predicate The function invoked per iteration.
     * @returns {Array} Returns the new filtered array.
     */
    function arrayFilter(array, predicate) {
      var index = -1,
        length = array == null ? 0 : array.length,
        resIndex = 0,
        result = [];

      while (++index < length) {
        var value = array[index];
        if (predicate(value, index, array)) {
          result[resIndex++] = value;
        }
      }
      return result;
    }

    /*
     * A specialized version of `_.includes` for arrays without support for
     * specifying an index to search from.
     *
     * @private
     * @param {Array} [array] The array to inspect.
     * @param {*} target The value to search for.
     * @returns {boolean} Returns `true` if `target` is found, else `false`.
     */
    function arrayIncludes(array, value) {
      var length = array == null ? 0 : array.length;
      return !!length && baseIndexOf(array, value, 0) > -1;
    }

    /*
     * This function is like `arrayIncludes` except that it accepts a comparator.
     *
     * @private
     * @param {Array} [array] The array to inspect.
     * @param {*} target The value to search for.
     * @param {Function} comparator The comparator invoked per element.
     * @returns {boolean} Returns `true` if `target` is found, else `false`.
     */
    function arrayIncludesWith(array, value, comparator) {
      var index = -1,
        length = array == null ? 0 : array.length;

      while (++index < length) {
        if (comparator(value, array[index])) {
          return true;
        }
      }
      return false;
    }

    /*
     * A specialized version of `_.map` for arrays without support for iteratee
     * shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array} Returns the new mapped array.
     */
    function arrayMap(array, iteratee) {
      var index = -1,
        length = array == null ? 0 : array.length,
        result = Array(length);

      while (++index < length) {
        result[index] = iteratee(array[index], index, array);
      }
      return result;
    }

    /*
     * Appends the elements of `values` to `array`.
     *
     * @private
     * @param {Array} array The array to modify.
     * @param {Array} values The values to append.
     * @returns {Array} Returns `array`.
     */
    function arrayPush(array, values) {
      var index = -1,
        length = values.length,
        offset = array.length;

      while (++index < length) {
        array[offset + index] = values[index];
      }
      return array;
    }

    /*
     * A specialized version of `_.reduce` for arrays without support for
     * iteratee shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @param {*} [accumulator] The initial value.
     * @param {boolean} [initAccum] Specify using the first element of `array` as
     *  the initial value.
     * @returns {*} Returns the accumulated value.
     */
    function arrayReduce(array, iteratee, accumulator, initAccum) {
      var index = -1,
        length = array == null ? 0 : array.length;

      if (initAccum && length) {
        accumulator = array[++index];
      }
      while (++index < length) {
        accumulator = iteratee(accumulator, array[index], index, array);
      }
      return accumulator;
    }

    /*
     * A specialized version of `_.reduceRight` for arrays without support for
     * iteratee shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @param {*} [accumulator] The initial value.
     * @param {boolean} [initAccum] Specify using the last element of `array` as
     *  the initial value.
     * @returns {*} Returns the accumulated value.
     */
    function arrayReduceRight(array, iteratee, accumulator, initAccum) {
      var length = array == null ? 0 : array.length;
      if (initAccum && length) {
        accumulator = array[--length];
      }
      while (length--) {
        accumulator = iteratee(accumulator, array[length], length, array);
      }
      return accumulator;
    }

    /*
     * A specialized version of `_.some` for arrays without support for iteratee
     * shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} predicate The function invoked per iteration.
     * @returns {boolean} Returns `true` if any element passes the predicate check,
     *  else `false`.
     */
    function arraySome(array, predicate) {
      var index = -1,
        length = array == null ? 0 : array.length;

      while (++index < length) {
        if (predicate(array[index], index, array)) {
          return true;
        }
      }
      return false;
    }

    /*
     * Gets the size of an ASCII `string`.
     *
     * @private
     * @param {string} string The string inspect.
     * @returns {number} Returns the string size.
     */
    var asciiSize = baseProperty('length');

    /*
     * Converts an ASCII `string` to an array.
     *
     * @private
     * @param {string} string The string to convert.
     * @returns {Array} Returns the converted array.
     */
    function asciiToArray(string) {
      return string.split('');
    }

    /*
     * Splits an ASCII `string` into an array of its words.
     *
     * @private
     * @param {string} The string to inspect.
     * @returns {Array} Returns the words of `string`.
     */
    function asciiWords(string) {
      return string.match(reAsciiWord) || [];
    }

    /*
     * The base implementation of methods like `_.findKey` and `_.findLastKey`,
     * without support for iteratee shorthands, which iterates over `collection`
     * using `eachFunc`.
     *
     * @private
     * @param {Array|Object} collection The collection to inspect.
     * @param {Function} predicate The function invoked per iteration.
     * @param {Function} eachFunc The function to iterate over `collection`.
     * @returns {*} Returns the found element or its key, else `undefined`.
     */
    function baseFindKey(collection, predicate, eachFunc) {
      var result;
      eachFunc(collection, function (value, key, collection) {
        if (predicate(value, key, collection)) {
          result = key;
          return false;
        }
      });
      return result;
    }

    /*
     * The base implementation of `_.findIndex` and `_.findLastIndex` without
     * support for iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {Function} predicate The function invoked per iteration.
     * @param {number} fromIndex The index to search from.
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {number} Returns the index of the matched value, else `-1`.
     */
    function baseFindIndex(array, predicate, fromIndex, fromRight) {
      var length = array.length,
        index = fromIndex + (fromRight ? 1 : -1);

      while ((fromRight ? index-- : ++index < length)) {
        if (predicate(array[index], index, array)) {
          return index;
        }
      }
      return -1;
    }

    /*
     * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @param {number} fromIndex The index to search from.
     * @returns {number} Returns the index of the matched value, else `-1`.
     */
    function baseIndexOf(array, value, fromIndex) {
      return value === value
        ? strictIndexOf(array, value, fromIndex)
        : baseFindIndex(array, baseIsNaN, fromIndex);
    }

    /*
     * This function is like `baseIndexOf` except that it accepts a comparator.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @param {number} fromIndex The index to search from.
     * @param {Function} comparator The comparator invoked per element.
     * @returns {number} Returns the index of the matched value, else `-1`.
     */
    function baseIndexOfWith(array, value, fromIndex, comparator) {
      var index = fromIndex - 1,
        length = array.length;

      while (++index < length) {
        if (comparator(array[index], value)) {
          return index;
        }
      }
      return -1;
    }

    /*
     * The base implementation of `_.isNaN` without support for number objects.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
     */
    function baseIsNaN(value) {
      return value !== value;
    }

    /*
     * The base implementation of `_.mean` and `_.meanBy` without support for
     * iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {number} Returns the mean.
     */
    function baseMean(array, iteratee) {
      var length = array == null ? 0 : array.length;
      return length ? (baseSum(array, iteratee) / length) : NAN;
    }

    /*
     * The base implementation of `_.property` without support for deep paths.
     *
     * @private
     * @param {string} key The key of the property to get.
     * @returns {Function} Returns the new accessor function.
     */
    function baseProperty(key) {
      return function (object) {
        return object == null ? undefined$1 : object[key];
      };
    }

    /*
     * The base implementation of `_.propertyOf` without support for deep paths.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Function} Returns the new accessor function.
     */
    function basePropertyOf(object) {
      return function (key) {
        return object == null ? undefined$1 : object[key];
      };
    }

    /*
     * The base implementation of `_.reduce` and `_.reduceRight`, without support
     * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
     *
     * @private
     * @param {Array|Object} collection The collection to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @param {*} accumulator The initial value.
     * @param {boolean} initAccum Specify using the first or last element of
     *  `collection` as the initial value.
     * @param {Function} eachFunc The function to iterate over `collection`.
     * @returns {*} Returns the accumulated value.
     */
    function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
      eachFunc(collection, function (value, index, collection) {
        accumulator = initAccum
          ? (initAccum = false, value)
          : iteratee(accumulator, value, index, collection);
      });
      return accumulator;
    }

    /*
     * The base implementation of `_.sortBy` which uses `comparer` to define the
     * sort order of `array` and replaces criteria objects with their corresponding
     * values.
     *
     * @private
     * @param {Array} array The array to sort.
     * @param {Function} comparer The function to define sort order.
     * @returns {Array} Returns `array`.
     */
    function baseSortBy(array, comparer) {
      var length = array.length;

      array.sort(comparer);
      while (length--) {
        array[length] = array[length].value;
      }
      return array;
    }

    /*
     * The base implementation of `_.sum` and `_.sumBy` without support for
     * iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {number} Returns the sum.
     */
    function baseSum(array, iteratee) {
      var result,
        index = -1,
        length = array.length;

      while (++index < length) {
        var current = iteratee(array[index]);
        if (current !== undefined$1) {
          result = result === undefined$1 ? current : (result + current);
        }
      }
      return result;
    }

    /*
     * The base implementation of `_.times` without support for iteratee shorthands
     * or max array length checks.
     *
     * @private
     * @param {number} n The number of times to invoke `iteratee`.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array} Returns the array of results.
     */
    function baseTimes(n, iteratee) {
      var index = -1,
        result = Array(n);

      while (++index < n) {
        result[index] = iteratee(index);
      }
      return result;
    }

    /*
     * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
     * of key-value pairs for `object` corresponding to the property names of `props`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array} props The property names to get values for.
     * @returns {Object} Returns the key-value pairs.
     */
    function baseToPairs(object, props) {
      return arrayMap(props, function (key) {
        return [key, object[key]];
      });
    }

    /*
     * The base implementation of `_.trim`.
     *
     * @private
     * @param {string} string The string to trim.
     * @returns {string} Returns the trimmed string.
     */
    function baseTrim(string) {
      return string
        ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
        : string;
    }

    /*
     * The base implementation of `_.unary` without support for storing metadata.
     *
     * @private
     * @param {Function} func The function to cap arguments for.
     * @returns {Function} Returns the new capped function.
     */
    function baseUnary(func) {
      return function (value) {
        return func(value);
      };
    }

    /*
     * The base implementation of `_.values` and `_.valuesIn` which creates an
     * array of `object` property values corresponding to the property names
     * of `props`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array} props The property names to get values for.
     * @returns {Object} Returns the array of property values.
     */
    function baseValues(object, props) {
      return arrayMap(props, function (key) {
        return object[key];
      });
    }

    /*
     * Checks if a `cache` value for `key` exists.
     *
     * @private
     * @param {Object} cache The cache to query.
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */
    function cacheHas(cache, key) {
      return cache.has(key);
    }

    /*
     * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
     * that is not found in the character symbols.
     *
     * @private
     * @param {Array} strSymbols The string symbols to inspect.
     * @param {Array} chrSymbols The character symbols to find.
     * @returns {number} Returns the index of the first unmatched string symbol.
     */
    function charsStartIndex(strSymbols, chrSymbols) {
      var index = -1,
        length = strSymbols.length;

      while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) { }
      return index;
    }

    /*
     * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
     * that is not found in the character symbols.
     *
     * @private
     * @param {Array} strSymbols The string symbols to inspect.
     * @param {Array} chrSymbols The character symbols to find.
     * @returns {number} Returns the index of the last unmatched string symbol.
     */
    function charsEndIndex(strSymbols, chrSymbols) {
      var index = strSymbols.length;

      while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) { }
      return index;
    }

    /*
     * Gets the number of `placeholder` occurrences in `array`.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {*} placeholder The placeholder to search for.
     * @returns {number} Returns the placeholder count.
     */
    function countHolders(array, placeholder) {
      var length = array.length,
        result = 0;

      while (length--) {
        if (array[length] === placeholder) {
          ++result;
        }
      }
      return result;
    }

    /*
     * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
     * letters to basic Latin letters.
     *
     * @private
     * @param {string} letter The matched letter to deburr.
     * @returns {string} Returns the deburred letter.
     */
    var deburrLetter = basePropertyOf(deburredLetters);

    /*
     * Used by `_.escape` to convert characters to HTML entities.
     *
     * @private
     * @param {string} chr The matched character to escape.
     * @returns {string} Returns the escaped character.
     */
    var escapeHtmlChar = basePropertyOf(htmlEscapes);

    /*
     * Used by `_.template` to escape characters for inclusion in compiled string literals.
     *
     * @private
     * @param {string} chr The matched character to escape.
     * @returns {string} Returns the escaped character.
     */
    function escapeStringChar(chr) {
      return '\\' + stringEscapes[chr];
    }

    /*
     * Gets the value at `key` of `object`.
     *
     * @private
     * @param {Object} [object] The object to query.
     * @param {string} key The key of the property to get.
     * @returns {*} Returns the property value.
     */
    function getValue(object, key) {
      return object == null ? undefined$1 : object[key];
    }

    /*
     * Checks if `string` contains Unicode symbols.
     *
     * @private
     * @param {string} string The string to inspect.
     * @returns {boolean} Returns `true` if a symbol is found, else `false`.
     */
    function hasUnicode(string) {
      return reHasUnicode.test(string);
    }

    /*
     * Checks if `string` contains a word composed of Unicode symbols.
     *
     * @private
     * @param {string} string The string to inspect.
     * @returns {boolean} Returns `true` if a word is found, else `false`.
     */
    function hasUnicodeWord(string) {
      return reHasUnicodeWord.test(string);
    }

    /*
     * Converts `iterator` to an array.
     *
     * @private
     * @param {Object} iterator The iterator to convert.
     * @returns {Array} Returns the converted array.
     */
    function iteratorToArray(iterator) {
      var data,
        result = [];

      while (!(data = iterator.next()).done) {
        result.push(data.value);
      }
      return result;
    }

    /*
     * Converts `map` to its key-value pairs.
     *
     * @private
     * @param {Object} map The map to convert.
     * @returns {Array} Returns the key-value pairs.
     */
    function mapToArray(map) {
      var index = -1,
        result = Array(map.size);

      map.forEach(function (value, key) {
        result[++index] = [key, value];
      });
      return result;
    }

    /*
     * Creates a unary function that invokes `func` with its argument transformed.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {Function} transform The argument transform.
     * @returns {Function} Returns the new function.
     */
    function overArg(func, transform) {
      return function (arg) {
        return func(transform(arg));
      };
    }

    /*
     * Replaces all `placeholder` elements in `array` with an internal placeholder
     * and returns an array of their indexes.
     *
     * @private
     * @param {Array} array The array to modify.
     * @param {*} placeholder The placeholder to replace.
     * @returns {Array} Returns the new array of placeholder indexes.
     */
    function replaceHolders(array, placeholder) {
      var index = -1,
        length = array.length,
        resIndex = 0,
        result = [];

      while (++index < length) {
        var value = array[index];
        if (value === placeholder || value === PLACEHOLDER) {
          array[index] = PLACEHOLDER;
          result[resIndex++] = index;
        }
      }
      return result;
    }

    /*
     * Converts `set` to an array of its values.
     *
     * @private
     * @param {Object} set The set to convert.
     * @returns {Array} Returns the values.
     */
    function setToArray(set) {
      var index = -1,
        result = Array(set.size);

      set.forEach(function (value) {
        result[++index] = value;
      });
      return result;
    }

    /*
     * Converts `set` to its value-value pairs.
     *
     * @private
     * @param {Object} set The set to convert.
     * @returns {Array} Returns the value-value pairs.
     */
    function setToPairs(set) {
      var index = -1,
        result = Array(set.size);

      set.forEach(function (value) {
        result[++index] = [value, value];
      });
      return result;
    }

    /*
     * A specialized version of `_.indexOf` which performs strict equality
     * comparisons of values, i.e. `===`.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @param {number} fromIndex The index to search from.
     * @returns {number} Returns the index of the matched value, else `-1`.
     */
    function strictIndexOf(array, value, fromIndex) {
      var index = fromIndex - 1,
        length = array.length;

      while (++index < length) {
        if (array[index] === value) {
          return index;
        }
      }
      return -1;
    }

    /*
     * A specialized version of `_.lastIndexOf` which performs strict equality
     * comparisons of values, i.e. `===`.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @param {number} fromIndex The index to search from.
     * @returns {number} Returns the index of the matched value, else `-1`.
     */
    function strictLastIndexOf(array, value, fromIndex) {
      var index = fromIndex + 1;
      while (index--) {
        if (array[index] === value) {
          return index;
        }
      }
      return index;
    }

    /*
     * Gets the number of symbols in `string`.
     *
     * @private
     * @param {string} string The string to inspect.
     * @returns {number} Returns the string size.
     */
    function stringSize(string) {
      return hasUnicode(string)
        ? unicodeSize(string)
        : asciiSize(string);
    }

    /*
     * Converts `string` to an array.
     *
     * @private
     * @param {string} string The string to convert.
     * @returns {Array} Returns the converted array.
     */
    function stringToArray(string) {
      return hasUnicode(string)
        ? unicodeToArray(string)
        : asciiToArray(string);
    }

    /*
     * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
     * character of `string`.
     *
     * @private
     * @param {string} string The string to inspect.
     * @returns {number} Returns the index of the last non-whitespace character.
     */
    function trimmedEndIndex(string) {
      var index = string.length;

      while (index-- && reWhitespace.test(string.charAt(index))) { }
      return index;
    }

    /*
     * Used by `_.unescape` to convert HTML entities to characters.
     *
     * @private
     * @param {string} chr The matched character to unescape.
     * @returns {string} Returns the unescaped character.
     */
    var unescapeHtmlChar = basePropertyOf(htmlUnescapes);

    /*
     * Gets the size of a Unicode `string`.
     *
     * @private
     * @param {string} string The string inspect.
     * @returns {number} Returns the string size.
     */
    function unicodeSize(string) {
      var result = reUnicode.lastIndex = 0;
      while (reUnicode.test(string)) {
        ++result;
      }
      return result;
    }

    /*
     * Converts a Unicode `string` to an array.
     *
     * @private
     * @param {string} string The string to convert.
     * @returns {Array} Returns the converted array.
     */
    function unicodeToArray(string) {
      return string.match(reUnicode) || [];
    }

    /*
     * Splits a Unicode `string` into an array of its words.
     *
     * @private
     * @param {string} The string to inspect.
     * @returns {Array} Returns the words of `string`.
     */
    function unicodeWords(string) {
      return string.match(reUnicodeWord) || [];
    }

    /*--------------------------------------------------------------------------*/

    /*
     * Create a new pristine `lodash` function using the `context` object.
     *
     * @static
     * @memberOf _
     * @since 1.1.0
     *  Util
     * @param {Object} [context=root] The context object.
     * @returns {Function} Returns a new `lodash` function.
     * @example
     *
     * _.mixin({ 'foo': _.constant('foo') });
     *
     * var lodash = _.runInContext();
     * lodash.mixin({ 'bar': lodash.constant('bar') });
     *
     * _.isFunction(_.foo);
     * // => true
     * _.isFunction(_.bar);
     * // => false
     *
     * lodash.isFunction(lodash.foo);
     * // => false
     * lodash.isFunction(lodash.bar);
     * // => true
     *
     * // Create a suped-up `defer` in Node.js.
     * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
     */
    var runInContext = (function runInContext(context) {
      context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));

      /* Built-in constructor references. */
      var Array = context.Array,
        Date = context.Date,
        Error = context.Error,
        Function = context.Function,
        Math = context.Math,
        Object = context.Object,
        RegExp = context.RegExp,
        String = context.String,
        TypeError = context.TypeError;

      /* Used for built-in method references. */
      var arrayProto = Array.prototype,
        funcProto = Function.prototype,
        objectProto = Object.prototype;

      /* Used to detect overreaching core-js shims. */
      var coreJsData = context['__core-js_shared__'];

      /* Used to resolve the decompiled source of functions. */
      var funcToString = funcProto.toString;

      /* Used to check objects for own properties. */
      var hasOwnProperty = objectProto.hasOwnProperty;

      /* Used to generate unique IDs. */
      var idCounter = 0;

      /* Used to detect methods masquerading as native. */
      var maskSrcKey = (function () {
        var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
        return uid ? ('Symbol(src)_1.' + uid) : '';
      }());

      /*
       * Used to resolve the
       * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
       * of values.
       */
      var nativeObjectToString = objectProto.toString;

      /* Used to infer the `Object` constructor. */
      var objectCtorString = funcToString.call(Object);

      /* Used to restore the original `_` reference in `_.noConflict`. */
      var oldDash = root._;

      /* Used to detect if a method is native. */
      var reIsNative = RegExp('^' +
        funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
          .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
      );

      /* Built-in value references. */
      var Buffer = moduleExports ? context.Buffer : undefined$1,
        Symbol = context.Symbol,
        Uint8Array = context.Uint8Array,
        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined$1,
        getPrototype = overArg(Object.getPrototypeOf, Object),
        objectCreate = Object.create,
        propertyIsEnumerable = objectProto.propertyIsEnumerable,
        splice = arrayProto.splice,
        spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined$1,
        symIterator = Symbol ? Symbol.iterator : undefined$1,
        symToStringTag = Symbol ? Symbol.toStringTag : undefined$1;

      var defineProperty = (function () {
        try {
          var func = getNative(Object, 'defineProperty');
          func({}, '', {});
          return func;
        } catch (e) { }
      }());

      /* Mocked built-ins. */
      var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,
        ctxNow = Date && Date.now !== root.Date.now && Date.now,
        ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;

      /* Built-in method references for those with the same name as other `lodash` methods. */
      var nativeCeil = Math.ceil,
        nativeFloor = Math.floor,
        nativeGetSymbols = Object.getOwnPropertySymbols,
        nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined$1,
        nativeIsFinite = context.isFinite,
        nativeJoin = arrayProto.join,
        nativeKeys = overArg(Object.keys, Object),
        nativeMax = Math.max,
        nativeMin = Math.min,
        nativeNow = Date.now,
        nativeParseInt = context.parseInt,
        nativeRandom = Math.random,
        nativeReverse = arrayProto.reverse;

      /* Built-in method references that are verified to be native. */
      var DataView = getNative(context, 'DataView'),
        Map = getNative(context, 'Map'),
        Promise = getNative(context, 'Promise'),
        Set = getNative(context, 'Set'),
        WeakMap = getNative(context, 'WeakMap'),
        nativeCreate = getNative(Object, 'create');

      /* Used to store function metadata. */
      var metaMap = WeakMap && new WeakMap;

      /* Used to lookup unminified function names. */
      var realNames = {};

      /* Used to detect maps, sets, and weakmaps. */
      var dataViewCtorString = toSource(DataView),
        mapCtorString = toSource(Map),
        promiseCtorString = toSource(Promise),
        setCtorString = toSource(Set),
        weakMapCtorString = toSource(WeakMap);

      /* Used to convert symbols to primitives and strings. */
      var symbolProto = Symbol ? Symbol.prototype : undefined$1,
        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined$1,
        symbolToString = symbolProto ? symbolProto.toString : undefined$1;

      /*------------------------------------------------------------------------*/

      /*
       * Creates a `lodash` object which wraps `value` to enable implicit method
       * chain sequences. Methods that operate on and return arrays, collections,
       * and functions can be chained together. Methods that retrieve a single value
       * or may return a primitive value will automatically end the chain sequence
       * and return the unwrapped value. Otherwise, the value must be unwrapped
       * with `_#value`.
       *
       * Explicit chain sequences, which must be unwrapped with `_#value`, may be
       * enabled using `_.chain`.
       *
       * The execution of chained methods is lazy, that is, it's deferred until
       * `_#value` is implicitly or explicitly called.
       *
       * Lazy evaluation allows several methods to support shortcut fusion.
       * Shortcut fusion is an optimization to merge iteratee calls; this avoids
       * the creation of intermediate arrays and can greatly reduce the number of
       * iteratee executions. Sections of a chain sequence qualify for shortcut
       * fusion if the section is applied to an array and iteratees accept only
       * one argument. The heuristic for whether a section qualifies for shortcut
       * fusion is subject to change.
       *
       * Chaining is supported in custom builds as long as the `_#value` method is
       * directly or indirectly included in the build.
       *
       * In addition to lodash methods, wrappers have `Array` and `String` methods.
       *
       * The wrapper `Array` methods are:
       * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
       *
       * The wrapper `String` methods are:
       * `replace` and `split`
       *
       * The wrapper methods that support shortcut fusion are:
       * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
       * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
       * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
       *
       * The chainable wrapper methods are:
       * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
       * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
       * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
       * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
       * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
       * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
       * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
       * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
       * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
       * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
       * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
       * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
       * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
       * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
       * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
       * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
       * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
       * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
       * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
       * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
       * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
       * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
       * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
       * `zipObject`, `zipObjectDeep`, and `zipWith`
       *
       * The wrapper methods that are **not** chainable by default are:
       * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
       * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
       * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
       * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
       * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
       * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
       * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
       * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
       * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
       * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
       * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
       * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
       * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
       * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
       * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
       * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
       * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
       * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
       * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
       * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
       * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
       * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
       * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
       * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
       * `upperFirst`, `value`, and `words`
       *
       * @name _
       * @constructor
       *  Seq
       * @param {*} value The value to wrap in a `lodash` instance.
       * @returns {Object} Returns the new `lodash` wrapper instance.
       * @example
       *
       * function square(n) {
       *   return n * n;
       * }
       *
       * var wrapped = _([1, 2, 3]);
       *
       * // Returns an unwrapped value.
       * wrapped.reduce(_.add);
       * // => 6
       *
       * // Returns a wrapped value.
       * var squares = wrapped.map(square);
       *
       * _.isArray(squares);
       * // => false
       *
       * _.isArray(squares.value());
       * // => true
       */
      function lodash(value) {
        if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
          if (value instanceof LodashWrapper) {
            return value;
          }
          if (hasOwnProperty.call(value, '__wrapped__')) {
            return wrapperClone(value);
          }
        }
        return new LodashWrapper(value);
      }

      /*
       * The base implementation of `_.create` without support for assigning
       * properties to the created object.
       *
       * @private
       * @param {Object} proto The object to inherit from.
       * @returns {Object} Returns the new object.
       */
      var baseCreate = (function () {
        function object() { }
        return function (proto) {
          if (!isObject(proto)) {
            return {};
          }
          if (objectCreate) {
            return objectCreate(proto);
          }
          object.prototype = proto;
          var result = new object;
          object.prototype = undefined$1;
          return result;
        };
      }());

      /*
       * The function whose prototype chain sequence wrappers inherit from.
       *
       * @private
       */
      function baseLodash() {
        // No operation performed.
      }

      /*
       * The base constructor for creating `lodash` wrapper objects.
       *
       * @private
       * @param {*} value The value to wrap.
       * @param {boolean} [chainAll] Enable explicit method chain sequences.
       */
      function LodashWrapper(value, chainAll) {
        this.__wrapped__ = value;
        this.__actions__ = [];
        this.__chain__ = !!chainAll;
        this.__index__ = 0;
        this.__values__ = undefined$1;
      }

      /*
       * By default, the template delimiters used by lodash are like those in
       * embedded Ruby (ERB) as well as ES2015 template strings. Change the
       * following template settings to use alternative delimiters.
       *
       * @static
       * @memberOf _
       * @type {Object}
       */
      lodash.templateSettings = {

        /*
         * Used to detect `data` property values to be HTML-escaped.
         *
         * @memberOf _.templateSettings
         * @type {RegExp}
         */
        'escape': reEscape,

        /*
         * Used to detect code to be evaluated.
         *
         * @memberOf _.templateSettings
         * @type {RegExp}
         */
        'evaluate': reEvaluate,

        /*
         * Used to detect `data` property values to inject.
         *
         * @memberOf _.templateSettings
         * @type {RegExp}
         */
        'interpolate': reInterpolate,

        /*
         * Used to reference the data object in the template text.
         *
         * @memberOf _.templateSettings
         * @type {string}
         */
        'variable': '',

        /*
         * Used to import variables into the compiled template.
         *
         * @memberOf _.templateSettings
         * @type {Object}
         */
        'imports': {

          /*
           * A reference to the `lodash` function.
           *
           * @memberOf _.templateSettings.imports
           * @type {Function}
           */
          '_': lodash
        }
      };

      // Ensure wrappers are instances of `baseLodash`.
      lodash.prototype = baseLodash.prototype;
      lodash.prototype.constructor = lodash;

      LodashWrapper.prototype = baseCreate(baseLodash.prototype);
      LodashWrapper.prototype.constructor = LodashWrapper;

      /*------------------------------------------------------------------------*/

      /*
       * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
       *
       * @private
       * @constructor
       * @param {*} value The value to wrap.
       */
      function LazyWrapper(value) {
        this.__wrapped__ = value;
        this.__actions__ = [];
        this.__dir__ = 1;
        this.__filtered__ = false;
        this.__iteratees__ = [];
        this.__takeCount__ = MAX_ARRAY_LENGTH;
        this.__views__ = [];
      }

      /*
       * Creates a clone of the lazy wrapper object.
       *
       * @private
       * @name clone
       * @memberOf LazyWrapper
       * @returns {Object} Returns the cloned `LazyWrapper` object.
       */
      function lazyClone() {
        var result = new LazyWrapper(this.__wrapped__);
        result.__actions__ = copyArray(this.__actions__);
        result.__dir__ = this.__dir__;
        result.__filtered__ = this.__filtered__;
        result.__iteratees__ = copyArray(this.__iteratees__);
        result.__takeCount__ = this.__takeCount__;
        result.__views__ = copyArray(this.__views__);
        return result;
      }

      /*
       * Reverses the direction of lazy iteration.
       *
       * @private
       * @name reverse
       * @memberOf LazyWrapper
       * @returns {Object} Returns the new reversed `LazyWrapper` object.
       */
      function lazyReverse() {
        if (this.__filtered__) {
          var result = new LazyWrapper(this);
          result.__dir__ = -1;
          result.__filtered__ = true;
        } else {
          result = this.clone();
          result.__dir__ *= -1;
        }
        return result;
      }

      /*
       * Extracts the unwrapped value from its lazy wrapper.
       *
       * @private
       * @name value
       * @memberOf LazyWrapper
       * @returns {*} Returns the unwrapped value.
       */
      function lazyValue() {
        var array = this.__wrapped__.value(),
          dir = this.__dir__,
          isArr = isArray(array),
          isRight = dir < 0,
          arrLength = isArr ? array.length : 0,
          view = getView(0, arrLength, this.__views__),
          start = view.start,
          end = view.end,
          length = end - start,
          index = isRight ? end : (start - 1),
          iteratees = this.__iteratees__,
          iterLength = iteratees.length,
          resIndex = 0,
          takeCount = nativeMin(length, this.__takeCount__);

        if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
          return baseWrapperValue(array, this.__actions__);
        }
        var result = [];

        outer:
        while (length-- && resIndex < takeCount) {
          index += dir;

          var iterIndex = -1,
            value = array[index];

          while (++iterIndex < iterLength) {
            var data = iteratees[iterIndex],
              iteratee = data.iteratee,
              type = data.type,
              computed = iteratee(value);

            if (type == LAZY_MAP_FLAG) {
              value = computed;
            } else if (!computed) {
              if (type == LAZY_FILTER_FLAG) {
                continue outer;
              } else {
                break outer;
              }
            }
          }
          result[resIndex++] = value;
        }
        return result;
      }

      // Ensure `LazyWrapper` is an instance of `baseLodash`.
      LazyWrapper.prototype = baseCreate(baseLodash.prototype);
      LazyWrapper.prototype.constructor = LazyWrapper;

      /*------------------------------------------------------------------------*/

      /*
       * Creates a hash object.
       *
       * @private
       * @constructor
       * @param {Array} [entries] The key-value pairs to cache.
       */
      function Hash(entries) {
        var index = -1,
          length = entries == null ? 0 : entries.length;

        this.clear();
        while (++index < length) {
          var entry = entries[index];
          this.set(entry[0], entry[1]);
        }
      }

      /*
       * Removes all key-value entries from the hash.
       *
       * @private
       * @name clear
       * @memberOf Hash
       */
      function hashClear() {
        this.__data__ = nativeCreate ? nativeCreate(null) : {};
        this.size = 0;
      }

      /*
       * Removes `key` and its value from the hash.
       *
       * @private
       * @name delete
       * @memberOf Hash
       * @param {Object} hash The hash to modify.
       * @param {string} key The key of the value to remove.
       * @returns {boolean} Returns `true` if the entry was removed, else `false`.
       */
      function hashDelete(key) {
        var result = this.has(key) && delete this.__data__[key];
        this.size -= result ? 1 : 0;
        return result;
      }

      /*
       * Gets the hash value for `key`.
       *
       * @private
       * @name get
       * @memberOf Hash
       * @param {string} key The key of the value to get.
       * @returns {*} Returns the entry value.
       */
      function hashGet(key) {
        var data = this.__data__;
        if (nativeCreate) {
          var result = data[key];
          return result === HASH_UNDEFINED ? undefined$1 : result;
        }
        return hasOwnProperty.call(data, key) ? data[key] : undefined$1;
      }

      /*
       * Checks if a hash value for `key` exists.
       *
       * @private
       * @name has
       * @memberOf Hash
       * @param {string} key The key of the entry to check.
       * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
       */
      function hashHas(key) {
        var data = this.__data__;
        return nativeCreate ? (data[key] !== undefined$1) : hasOwnProperty.call(data, key);
      }

      /*
       * Sets the hash `key` to `value`.
       *
       * @private
       * @name set
       * @memberOf Hash
       * @param {string} key The key of the value to set.
       * @param {*} value The value to set.
       * @returns {Object} Returns the hash instance.
       */
      function hashSet(key, value) {
        var data = this.__data__;
        this.size += this.has(key) ? 0 : 1;
        data[key] = (nativeCreate && value === undefined$1) ? HASH_UNDEFINED : value;
        return this;
      }

      // Add methods to `Hash`.
      Hash.prototype.clear = hashClear;
      Hash.prototype['delete'] = hashDelete;
      Hash.prototype.get = hashGet;
      Hash.prototype.has = hashHas;
      Hash.prototype.set = hashSet;

      /*------------------------------------------------------------------------*/

      /*
       * Creates an list cache object.
       *
       * @private
       * @constructor
       * @param {Array} [entries] The key-value pairs to cache.
       */
      function ListCache(entries) {
        var index = -1,
          length = entries == null ? 0 : entries.length;

        this.clear();
        while (++index < length) {
          var entry = entries[index];
          this.set(entry[0], entry[1]);
        }
      }

      /*
       * Removes all key-value entries from the list cache.
       *
       * @private
       * @name clear
       * @memberOf ListCache
       */
      function listCacheClear() {
        this.__data__ = [];
        this.size = 0;
      }

      /*
       * Removes `key` and its value from the list cache.
       *
       * @private
       * @name delete
       * @memberOf ListCache
       * @param {string} key The key of the value to remove.
       * @returns {boolean} Returns `true` if the entry was removed, else `false`.
       */
      function listCacheDelete(key) {
        var data = this.__data__,
          index = assocIndexOf(data, key);

        if (index < 0) {
          return false;
        }
        var lastIndex = data.length - 1;
        if (index == lastIndex) {
          data.pop();
        } else {
          splice.call(data, index, 1);
        }
        --this.size;
        return true;
      }

      /*
       * Gets the list cache value for `key`.
       *
       * @private
       * @name get
       * @memberOf ListCache
       * @param {string} key The key of the value to get.
       * @returns {*} Returns the entry value.
       */
      function listCacheGet(key) {
        var data = this.__data__,
          index = assocIndexOf(data, key);

        return index < 0 ? undefined$1 : data[index][1];
      }

      /*
       * Checks if a list cache value for `key` exists.
       *
       * @private
       * @name has
       * @memberOf ListCache
       * @param {string} key The key of the entry to check.
       * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
       */
      function listCacheHas(key) {
        return assocIndexOf(this.__data__, key) > -1;
      }

      /*
       * Sets the list cache `key` to `value`.
       *
       * @private
       * @name set
       * @memberOf ListCache
       * @param {string} key The key of the value to set.
       * @param {*} value The value to set.
       * @returns {Object} Returns the list cache instance.
       */
      function listCacheSet(key, value) {
        var data = this.__data__,
          index = assocIndexOf(data, key);

        if (index < 0) {
          ++this.size;
          data.push([key, value]);
        } else {
          data[index][1] = value;
        }
        return this;
      }

      // Add methods to `ListCache`.
      ListCache.prototype.clear = listCacheClear;
      ListCache.prototype['delete'] = listCacheDelete;
      ListCache.prototype.get = listCacheGet;
      ListCache.prototype.has = listCacheHas;
      ListCache.prototype.set = listCacheSet;

      /*------------------------------------------------------------------------*/

      /*
       * Creates a map cache object to store key-value pairs.
       *
       * @private
       * @constructor
       * @param {Array} [entries] The key-value pairs to cache.
       */
      function MapCache(entries) {
        var index = -1,
          length = entries == null ? 0 : entries.length;

        this.clear();
        while (++index < length) {
          var entry = entries[index];
          this.set(entry[0], entry[1]);
        }
      }

      /*
       * Removes all key-value entries from the map.
       *
       * @private
       * @name clear
       * @memberOf MapCache
       */
      function mapCacheClear() {
        this.size = 0;
        this.__data__ = {
          'hash': new Hash,
          'map': new (Map || ListCache),
          'string': new Hash
        };
      }

      /*
       * Removes `key` and its value from the map.
       *
       * @private
       * @name delete
       * @memberOf MapCache
       * @param {string} key The key of the value to remove.
       * @returns {boolean} Returns `true` if the entry was removed, else `false`.
       */
      function mapCacheDelete(key) {
        var result = getMapData(this, key)['delete'](key);
        this.size -= result ? 1 : 0;
        return result;
      }

      /*
       * Gets the map value for `key`.
       *
       * @private
       * @name get
       * @memberOf MapCache
       * @param {string} key The key of the value to get.
       * @returns {*} Returns the entry value.
       */
      function mapCacheGet(key) {
        return getMapData(this, key).get(key);
      }

      /*
       * Checks if a map value for `key` exists.
       *
       * @private
       * @name has
       * @memberOf MapCache
       * @param {string} key The key of the entry to check.
       * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
       */
      function mapCacheHas(key) {
        return getMapData(this, key).has(key);
      }

      /*
       * Sets the map `key` to `value`.
       *
       * @private
       * @name set
       * @memberOf MapCache
       * @param {string} key The key of the value to set.
       * @param {*} value The value to set.
       * @returns {Object} Returns the map cache instance.
       */
      function mapCacheSet(key, value) {
        var data = getMapData(this, key),
          size = data.size;

        data.set(key, value);
        this.size += data.size == size ? 0 : 1;
        return this;
      }

      // Add methods to `MapCache`.
      MapCache.prototype.clear = mapCacheClear;
      MapCache.prototype['delete'] = mapCacheDelete;
      MapCache.prototype.get = mapCacheGet;
      MapCache.prototype.has = mapCacheHas;
      MapCache.prototype.set = mapCacheSet;

      /*------------------------------------------------------------------------*/

      /*
       *
       * Creates an array cache object to store unique values.
       *
       * @private
       * @constructor
       * @param {Array} [values] The values to cache.
       */
      function SetCache(values) {
        var index = -1,
          length = values == null ? 0 : values.length;

        this.__data__ = new MapCache;
        while (++index < length) {
          this.add(values[index]);
        }
      }

      /*
       * Adds `value` to the array cache.
       *
       * @private
       * @name add
       * @memberOf SetCache
       * @alias push
       * @param {*} value The value to cache.
       * @returns {Object} Returns the cache instance.
       */
      function setCacheAdd(value) {
        this.__data__.set(value, HASH_UNDEFINED);
        return this;
      }

      /*
       * Checks if `value` is in the array cache.
       *
       * @private
       * @name has
       * @memberOf SetCache
       * @param {*} value The value to search for.
       * @returns {number} Returns `true` if `value` is found, else `false`.
       */
      function setCacheHas(value) {
        return this.__data__.has(value);
      }

      // Add methods to `SetCache`.
      SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
      SetCache.prototype.has = setCacheHas;

      /*------------------------------------------------------------------------*/

      /*
       * Creates a stack cache object to store key-value pairs.
       *
       * @private
       * @constructor
       * @param {Array} [entries] The key-value pairs to cache.
       */
      function Stack(entries) {
        var data = this.__data__ = new ListCache(entries);
        this.size = data.size;
      }

      /*
       * Removes all key-value entries from the stack.
       *
       * @private
       * @name clear
       * @memberOf Stack
       */
      function stackClear() {
        this.__data__ = new ListCache;
        this.size = 0;
      }

      /*
       * Removes `key` and its value from the stack.
       *
       * @private
       * @name delete
       * @memberOf Stack
       * @param {string} key The key of the value to remove.
       * @returns {boolean} Returns `true` if the entry was removed, else `false`.
       */
      function stackDelete(key) {
        var data = this.__data__,
          result = data['delete'](key);

        this.size = data.size;
        return result;
      }

      /*
       * Gets the stack value for `key`.
       *
       * @private
       * @name get
       * @memberOf Stack
       * @param {string} key The key of the value to get.
       * @returns {*} Returns the entry value.
       */
      function stackGet(key) {
        return this.__data__.get(key);
      }

      /*
       * Checks if a stack value for `key` exists.
       *
       * @private
       * @name has
       * @memberOf Stack
       * @param {string} key The key of the entry to check.
       * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
       */
      function stackHas(key) {
        return this.__data__.has(key);
      }

      /*
       * Sets the stack `key` to `value`.
       *
       * @private
       * @name set
       * @memberOf Stack
       * @param {string} key The key of the value to set.
       * @param {*} value The value to set.
       * @returns {Object} Returns the stack cache instance.
       */
      function stackSet(key, value) {
        var data = this.__data__;
        if (data instanceof ListCache) {
          var pairs = data.__data__;
          if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
            pairs.push([key, value]);
            this.size = ++data.size;
            return this;
          }
          data = this.__data__ = new MapCache(pairs);
        }
        data.set(key, value);
        this.size = data.size;
        return this;
      }

      // Add methods to `Stack`.
      Stack.prototype.clear = stackClear;
      Stack.prototype['delete'] = stackDelete;
      Stack.prototype.get = stackGet;
      Stack.prototype.has = stackHas;
      Stack.prototype.set = stackSet;

      /*------------------------------------------------------------------------*/

      /*
       * Creates an array of the enumerable property names of the array-like `value`.
       *
       * @private
       * @param {*} value The value to query.
       * @param {boolean} inherited Specify returning inherited property names.
       * @returns {Array} Returns the array of property names.
       */
      function arrayLikeKeys(value, inherited) {
        var isArr = isArray(value),
          isArg = !isArr && isArguments(value),
          isBuff = !isArr && !isArg && isBuffer(value),
          isType = !isArr && !isArg && !isBuff && isTypedArray(value),
          skipIndexes = isArr || isArg || isBuff || isType,
          result = skipIndexes ? baseTimes(value.length, String) : [],
          length = result.length;

        for (var key in value) {
          if ((inherited || hasOwnProperty.call(value, key)) &&
            !(skipIndexes && (
              // Safari 9 has enumerable `arguments.length` in strict mode.
              key == 'length' ||
              // Node.js 0.10 has enumerable non-index properties on buffers.
              (isBuff && (key == 'offset' || key == 'parent')) ||
              // PhantomJS 2 has enumerable non-index properties on typed arrays.
              (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
              // Skip index properties.
              isIndex(key, length)
            ))) {
            result.push(key);
          }
        }
        return result;
      }

      /*
       * A specialized version of `_.sample` for arrays.
       *
       * @private
       * @param {Array} array The array to sample.
       * @returns {*} Returns the random element.
       */
      function arraySample(array) {
        var length = array.length;
        return length ? array[baseRandom(0, length - 1)] : undefined$1;
      }

      /*
       * A specialized version of `_.sampleSize` for arrays.
       *
       * @private
       * @param {Array} array The array to sample.
       * @param {number} n The number of elements to sample.
       * @returns {Array} Returns the random elements.
       */
      function arraySampleSize(array, n) {
        return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
      }

      /*
       * A specialized version of `_.shuffle` for arrays.
       *
       * @private
       * @param {Array} array The array to shuffle.
       * @returns {Array} Returns the new shuffled array.
       */
      function arrayShuffle(array) {
        return shuffleSelf(copyArray(array));
      }

      /*
       * This function is like `assignValue` except that it doesn't assign
       * `undefined` values.
       *
       * @private
       * @param {Object} object The object to modify.
       * @param {string} key The key of the property to assign.
       * @param {*} value The value to assign.
       */
      function assignMergeValue(object, key, value) {
        if ((value !== undefined$1 && !eq(object[key], value)) ||
          (value === undefined$1 && !(key in object))) {
          baseAssignValue(object, key, value);
        }
      }

      /*
       * Assigns `value` to `key` of `object` if the existing value is not equivalent
       * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
       * for equality comparisons.
       *
       * @private
       * @param {Object} object The object to modify.
       * @param {string} key The key of the property to assign.
       * @param {*} value The value to assign.
       */
      function assignValue(object, key, value) {
        var objValue = object[key];
        if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
          (value === undefined$1 && !(key in object))) {
          baseAssignValue(object, key, value);
        }
      }

      /*
       * Gets the index at which the `key` is found in `array` of key-value pairs.
       *
       * @private
       * @param {Array} array The array to inspect.
       * @param {*} key The key to search for.
       * @returns {number} Returns the index of the matched value, else `-1`.
       */
      function assocIndexOf(array, key) {
        var length = array.length;
        while (length--) {
          if (eq(array[length][0], key)) {
            return length;
          }
        }
        return -1;
      }

      /*
       * Aggregates elements of `collection` on `accumulator` with keys transformed
       * by `iteratee` and values set by `setter`.
       *
       * @private
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} setter The function to set `accumulator` values.
       * @param {Function} iteratee The iteratee to transform keys.
       * @param {Object} accumulator The initial aggregated object.
       * @returns {Function} Returns `accumulator`.
       */
      function baseAggregator(collection, setter, iteratee, accumulator) {
        baseEach(collection, function (value, key, collection) {
          setter(accumulator, value, iteratee(value), collection);
        });
        return accumulator;
      }

      /*
       * The base implementation of `_.assign` without support for multiple sources
       * or `customizer` functions.
       *
       * @private
       * @param {Object} object The destination object.
       * @param {Object} source The source object.
       * @returns {Object} Returns `object`.
       */
      function baseAssign(object, source) {
        return object && copyObject(source, keys(source), object);
      }

      /*
       * The base implementation of `_.assignIn` without support for multiple sources
       * or `customizer` functions.
       *
       * @private
       * @param {Object} object The destination object.
       * @param {Object} source The source object.
       * @returns {Object} Returns `object`.
       */
      function baseAssignIn(object, source) {
        return object && copyObject(source, keysIn(source), object);
      }

      /*
       * The base implementation of `assignValue` and `assignMergeValue` without
       * value checks.
       *
       * @private
       * @param {Object} object The object to modify.
       * @param {string} key The key of the property to assign.
       * @param {*} value The value to assign.
       */
      function baseAssignValue(object, key, value) {
        if (key == '__proto__' && defineProperty) {
          defineProperty(object, key, {
            'configurable': true,
            'enumerable': true,
            'value': value,
            'writable': true
          });
        } else {
          object[key] = value;
        }
      }

      /*
       * The base implementation of `_.at` without support for individual paths.
       *
       * @private
       * @param {Object} object The object to iterate over.
       * @param {string[]} paths The property paths to pick.
       * @returns {Array} Returns the picked elements.
       */
      function baseAt(object, paths) {
        var index = -1,
          length = paths.length,
          result = Array(length),
          skip = object == null;

        while (++index < length) {
          result[index] = skip ? undefined$1 : get(object, paths[index]);
        }
        return result;
      }

      /*
       * The base implementation of `_.clamp` which doesn't coerce arguments.
       *
       * @private
       * @param {number} number The number to clamp.
       * @param {number} [lower] The lower bound.
       * @param {number} upper The upper bound.
       * @returns {number} Returns the clamped number.
       */
      function baseClamp(number, lower, upper) {
        if (number === number) {
          if (upper !== undefined$1) {
            number = number <= upper ? number : upper;
          }
          if (lower !== undefined$1) {
            number = number >= lower ? number : lower;
          }
        }
        return number;
      }

      /*
       * The base implementation of `_.clone` and `_.cloneDeep` which tracks
       * traversed objects.
       *
       * @private
       * @param {*} value The value to clone.
       * @param {boolean} bitmask The bitmask flags.
       *  1 - Deep clone
       *  2 - Flatten inherited properties
       *  4 - Clone symbols
       * @param {Function} [customizer] The function to customize cloning.
       * @param {string} [key] The key of `value`.
       * @param {Object} [object] The parent object of `value`.
       * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
       * @returns {*} Returns the cloned value.
       */
      function baseClone(value, bitmask, customizer, key, object, stack) {
        var result,
          isDeep = bitmask & CLONE_DEEP_FLAG,
          isFlat = bitmask & CLONE_FLAT_FLAG,
          isFull = bitmask & CLONE_SYMBOLS_FLAG;

        if (customizer) {
          result = object ? customizer(value, key, object, stack) : customizer(value);
        }
        if (result !== undefined$1) {
          return result;
        }
        if (!isObject(value)) {
          return value;
        }
        var isArr = isArray(value);
        if (isArr) {
          result = initCloneArray(value);
          if (!isDeep) {
            return copyArray(value, result);
          }
        } else {
          var tag = getTag(value),
            isFunc = tag == funcTag || tag == genTag;

          if (isBuffer(value)) {
            return cloneBuffer(value, isDeep);
          }
          if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
            result = (isFlat || isFunc) ? {} : initCloneObject(value);
            if (!isDeep) {
              return isFlat
                ? copySymbolsIn(value, baseAssignIn(result, value))
                : copySymbols(value, baseAssign(result, value));
            }
          } else {
            if (!cloneableTags[tag]) {
              return object ? value : {};
            }
            result = initCloneByTag(value, tag, isDeep);
          }
        }
        // Check for circular references and return its corresponding clone.
        stack || (stack = new Stack);
        var stacked = stack.get(value);
        if (stacked) {
          return stacked;
        }
        stack.set(value, result);

        if (isSet(value)) {
          value.forEach(function (subValue) {
            result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
          });
        } else if (isMap(value)) {
          value.forEach(function (subValue, key) {
            result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
          });
        }

        var keysFunc = isFull
          ? (isFlat ? getAllKeysIn : getAllKeys)
          : (isFlat ? keysIn : keys);

        var props = isArr ? undefined$1 : keysFunc(value);
        arrayEach(props || value, function (subValue, key) {
          if (props) {
            key = subValue;
            subValue = value[key];
          }
          // Recursively populate clone (susceptible to call stack limits).
          assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
        });
        return result;
      }

      /*
       * The base implementation of `_.conforms` which doesn't clone `source`.
       *
       * @private
       * @param {Object} source The object of property predicates to conform to.
       * @returns {Function} Returns the new spec function.
       */
      function baseConforms(source) {
        var props = keys(source);
        return function (object) {
          return baseConformsTo(object, source, props);
        };
      }

      /*
       * The base implementation of `_.conformsTo` which accepts `props` to check.
       *
       * @private
       * @param {Object} object The object to inspect.
       * @param {Object} source The object of property predicates to conform to.
       * @returns {boolean} Returns `true` if `object` conforms, else `false`.
       */
      function baseConformsTo(object, source, props) {
        var length = props.length;
        if (object == null) {
          return !length;
        }
        object = Object(object);
        while (length--) {
          var key = props[length],
            predicate = source[key],
            value = object[key];

          if ((value === undefined$1 && !(key in object)) || !predicate(value)) {
            return false;
          }
        }
        return true;
      }

      /*
       * The base implementation of `_.delay` and `_.defer` which accepts `args`
       * to provide to `func`.
       *
       * @private
       * @param {Function} func The function to delay.
       * @param {number} wait The number of milliseconds to delay invocation.
       * @param {Array} args The arguments to provide to `func`.
       * @returns {number|Object} Returns the timer id or timeout object.
       */
      function baseDelay(func, wait, args) {
        if (typeof func != 'function') {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        return setTimeout(function () { func.apply(undefined$1, args); }, wait);
      }

      /*
       * The base implementation of methods like `_.difference` without support
       * for excluding multiple arrays or iteratee shorthands.
       *
       * @private
       * @param {Array} array The array to inspect.
       * @param {Array} values The values to exclude.
       * @param {Function} [iteratee] The iteratee invoked per element.
       * @param {Function} [comparator] The comparator invoked per element.
       * @returns {Array} Returns the new array of filtered values.
       */
      function baseDifference(array, values, iteratee, comparator) {
        var index = -1,
          includes = arrayIncludes,
          isCommon = true,
          length = array.length,
          result = [],
          valuesLength = values.length;

        if (!length) {
          return result;
        }
        if (iteratee) {
          values = arrayMap(values, baseUnary(iteratee));
        }
        if (comparator) {
          includes = arrayIncludesWith;
          isCommon = false;
        }
        else if (values.length >= LARGE_ARRAY_SIZE) {
          includes = cacheHas;
          isCommon = false;
          values = new SetCache(values);
        }
        outer:
        while (++index < length) {
          var value = array[index],
            computed = iteratee == null ? value : iteratee(value);

          value = (comparator || value !== 0) ? value : 0;
          if (isCommon && computed === computed) {
            var valuesIndex = valuesLength;
            while (valuesIndex--) {
              if (values[valuesIndex] === computed) {
                continue outer;
              }
            }
            result.push(value);
          }
          else if (!includes(values, computed, comparator)) {
            result.push(value);
          }
        }
        return result;
      }

      /*
       * The base implementation of `_.forEach` without support for iteratee shorthands.
       *
       * @private
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} iteratee The function invoked per iteration.
       * @returns {Array|Object} Returns `collection`.
       */
      var baseEach = createBaseEach(baseForOwn);

      /*
       * The base implementation of `_.forEachRight` without support for iteratee shorthands.
       *
       * @private
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} iteratee The function invoked per iteration.
       * @returns {Array|Object} Returns `collection`.
       */
      var baseEachRight = createBaseEach(baseForOwnRight, true);

      /*
       * The base implementation of `_.every` without support for iteratee shorthands.
       *
       * @private
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} predicate The function invoked per iteration.
       * @returns {boolean} Returns `true` if all elements pass the predicate check,
       *  else `false`
       */
      function baseEvery(collection, predicate) {
        var result = true;
        baseEach(collection, function (value, index, collection) {
          result = !!predicate(value, index, collection);
          return result;
        });
        return result;
      }

      /*
       * The base implementation of methods like `_.max` and `_.min` which accepts a
       * `comparator` to determine the extremum value.
       *
       * @private
       * @param {Array} array The array to iterate over.
       * @param {Function} iteratee The iteratee invoked per iteration.
       * @param {Function} comparator The comparator used to compare values.
       * @returns {*} Returns the extremum value.
       */
      function baseExtremum(array, iteratee, comparator) {
        var index = -1,
          length = array.length;

        while (++index < length) {
          var value = array[index],
            current = iteratee(value);

          if (current != null && (computed === undefined$1
            ? (current === current && !isSymbol(current))
            : comparator(current, computed)
          )) {
            var computed = current,
              result = value;
          }
        }
        return result;
      }

      /*
       * The base implementation of `_.fill` without an iteratee call guard.
       *
       * @private
       * @param {Array} array The array to fill.
       * @param {*} value The value to fill `array` with.
       * @param {number} [start=0] The start position.
       * @param {number} [end=array.length] The end position.
       * @returns {Array} Returns `array`.
       */
      function baseFill(array, value, start, end) {
        var length = array.length;

        start = toInteger(start);
        if (start < 0) {
          start = -start > length ? 0 : (length + start);
        }
        end = (end === undefined$1 || end > length) ? length : toInteger(end);
        if (end < 0) {
          end += length;
        }
        end = start > end ? 0 : toLength(end);
        while (start < end) {
          array[start++] = value;
        }
        return array;
      }

      /*
       * The base implementation of `_.filter` without support for iteratee shorthands.
       *
       * @private
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} predicate The function invoked per iteration.
       * @returns {Array} Returns the new filtered array.
       */
      function baseFilter(collection, predicate) {
        var result = [];
        baseEach(collection, function (value, index, collection) {
          if (predicate(value, index, collection)) {
            result.push(value);
          }
        });
        return result;
      }

      /*
       * The base implementation of `_.flatten` with support for restricting flattening.
       *
       * @private
       * @param {Array} array The array to flatten.
       * @param {number} depth The maximum recursion depth.
       * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
       * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
       * @param {Array} [result=[]] The initial result value.
       * @returns {Array} Returns the new flattened array.
       */
      function baseFlatten(array, depth, predicate, isStrict, result) {
        var index = -1,
          length = array.length;

        predicate || (predicate = isFlattenable);
        result || (result = []);

        while (++index < length) {
          var value = array[index];
          if (depth > 0 && predicate(value)) {
            if (depth > 1) {
              // Recursively flatten arrays (susceptible to call stack limits).
              baseFlatten(value, depth - 1, predicate, isStrict, result);
            } else {
              arrayPush(result, value);
            }
          } else if (!isStrict) {
            result[result.length] = value;
          }
        }
        return result;
      }

      /*
       * The base implementation of `baseForOwn` which iterates over `object`
       * properties returned by `keysFunc` and invokes `iteratee` for each property.
       * Iteratee functions may exit iteration early by explicitly returning `false`.
       *
       * @private
       * @param {Object} object The object to iterate over.
       * @param {Function} iteratee The function invoked per iteration.
       * @param {Function} keysFunc The function to get the keys of `object`.
       * @returns {Object} Returns `object`.
       */
      var baseFor = createBaseFor();

      /*
       * This function is like `baseFor` except that it iterates over properties
       * in the opposite order.
       *
       * @private
       * @param {Object} object The object to iterate over.
       * @param {Function} iteratee The function invoked per iteration.
       * @param {Function} keysFunc The function to get the keys of `object`.
       * @returns {Object} Returns `object`.
       */
      var baseForRight = createBaseFor(true);

      /*
       * The base implementation of `_.forOwn` without support for iteratee shorthands.
       *
       * @private
       * @param {Object} object The object to iterate over.
       * @param {Function} iteratee The function invoked per iteration.
       * @returns {Object} Returns `object`.
       */
      function baseForOwn(object, iteratee) {
        return object && baseFor(object, iteratee, keys);
      }

      /*
       * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
       *
       * @private
       * @param {Object} object The object to iterate over.
       * @param {Function} iteratee The function invoked per iteration.
       * @returns {Object} Returns `object`.
       */
      function baseForOwnRight(object, iteratee) {
        return object && baseForRight(object, iteratee, keys);
      }

      /*
       * The base implementation of `_.functions` which creates an array of
       * `object` function property names filtered from `props`.
       *
       * @private
       * @param {Object} object The object to inspect.
       * @param {Array} props The property names to filter.
       * @returns {Array} Returns the function names.
       */
      function baseFunctions(object, props) {
        return arrayFilter(props, function (key) {
          return isFunction(object[key]);
        });
      }

      /*
       * The base implementation of `_.get` without support for default values.
       *
       * @private
       * @param {Object} object The object to query.
       * @param {Array|string} path The path of the property to get.
       * @returns {*} Returns the resolved value.
       */
      function baseGet(object, path) {
        path = castPath(path, object);

        var index = 0,
          length = path.length;

        while (object != null && index < length) {
          object = object[toKey(path[index++])];
        }
        return (index && index == length) ? object : undefined$1;
      }

      /*
       * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
       * `keysFunc` and `symbolsFunc` to get the enumerable property names and
       * symbols of `object`.
       *
       * @private
       * @param {Object} object The object to query.
       * @param {Function} keysFunc The function to get the keys of `object`.
       * @param {Function} symbolsFunc The function to get the symbols of `object`.
       * @returns {Array} Returns the array of property names and symbols.
       */
      function baseGetAllKeys(object, keysFunc, symbolsFunc) {
        var result = keysFunc(object);
        return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
      }

      /*
       * The base implementation of `getTag` without fallbacks for buggy environments.
       *
       * @private
       * @param {*} value The value to query.
       * @returns {string} Returns the `toStringTag`.
       */
      function baseGetTag(value) {
        if (value == null) {
          return value === undefined$1 ? undefinedTag : nullTag;
        }
        return (symToStringTag && symToStringTag in Object(value))
          ? getRawTag(value)
          : objectToString(value);
      }

      /*
       * The base implementation of `_.gt` which doesn't coerce arguments.
       *
       * @private
       * @param {*} value The value to compare.
       * @param {*} other The other value to compare.
       * @returns {boolean} Returns `true` if `value` is greater than `other`,
       *  else `false`.
       */
      function baseGt(value, other) {
        return value > other;
      }

      /*
       * The base implementation of `_.has` without support for deep paths.
       *
       * @private
       * @param {Object} [object] The object to query.
       * @param {Array|string} key The key to check.
       * @returns {boolean} Returns `true` if `key` exists, else `false`.
       */
      function baseHas(object, key) {
        return object != null && hasOwnProperty.call(object, key);
      }

      /*
       * The base implementation of `_.hasIn` without support for deep paths.
       *
       * @private
       * @param {Object} [object] The object to query.
       * @param {Array|string} key The key to check.
       * @returns {boolean} Returns `true` if `key` exists, else `false`.
       */
      function baseHasIn(object, key) {
        return object != null && key in Object(object);
      }

      /*
       * The base implementation of `_.inRange` which doesn't coerce arguments.
       *
       * @private
       * @param {number} number The number to check.
       * @param {number} start The start of the range.
       * @param {number} end The end of the range.
       * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
       */
      function baseInRange(number, start, end) {
        return number >= nativeMin(start, end) && number < nativeMax(start, end);
      }

      /*
       * The base implementation of methods like `_.intersection`, without support
       * for iteratee shorthands, that accepts an array of arrays to inspect.
       *
       * @private
       * @param {Array} arrays The arrays to inspect.
       * @param {Function} [iteratee] The iteratee invoked per element.
       * @param {Function} [comparator] The comparator invoked per element.
       * @returns {Array} Returns the new array of shared values.
       */
      function baseIntersection(arrays, iteratee, comparator) {
        var includes = comparator ? arrayIncludesWith : arrayIncludes,
          length = arrays[0].length,
          othLength = arrays.length,
          othIndex = othLength,
          caches = Array(othLength),
          maxLength = Infinity,
          result = [];

        while (othIndex--) {
          var array = arrays[othIndex];
          if (othIndex && iteratee) {
            array = arrayMap(array, baseUnary(iteratee));
          }
          maxLength = nativeMin(array.length, maxLength);
          caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
            ? new SetCache(othIndex && array)
            : undefined$1;
        }
        array = arrays[0];

        var index = -1,
          seen = caches[0];

        outer:
        while (++index < length && result.length < maxLength) {
          var value = array[index],
            computed = iteratee ? iteratee(value) : value;

          value = (comparator || value !== 0) ? value : 0;
          if (!(seen
            ? cacheHas(seen, computed)
            : includes(result, computed, comparator)
          )) {
            othIndex = othLength;
            while (--othIndex) {
              var cache = caches[othIndex];
              if (!(cache
                ? cacheHas(cache, computed)
                : includes(arrays[othIndex], computed, comparator))
              ) {
                continue outer;
              }
            }
            if (seen) {
              seen.push(computed);
            }
            result.push(value);
          }
        }
        return result;
      }

      /*
       * The base implementation of `_.invert` and `_.invertBy` which inverts
       * `object` with values transformed by `iteratee` and set by `setter`.
       *
       * @private
       * @param {Object} object The object to iterate over.
       * @param {Function} setter The function to set `accumulator` values.
       * @param {Function} iteratee The iteratee to transform values.
       * @param {Object} accumulator The initial inverted object.
       * @returns {Function} Returns `accumulator`.
       */
      function baseInverter(object, setter, iteratee, accumulator) {
        baseForOwn(object, function (value, key, object) {
          setter(accumulator, iteratee(value), key, object);
        });
        return accumulator;
      }

      /*
       * The base implementation of `_.invoke` without support for individual
       * method arguments.
       *
       * @private
       * @param {Object} object The object to query.
       * @param {Array|string} path The path of the method to invoke.
       * @param {Array} args The arguments to invoke the method with.
       * @returns {*} Returns the result of the invoked method.
       */
      function baseInvoke(object, path, args) {
        path = castPath(path, object);
        object = parent(object, path);
        var func = object == null ? object : object[toKey(last(path))];
        return func == null ? undefined$1 : apply(func, object, args);
      }

      /*
       * The base implementation of `_.isArguments`.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is an `arguments` object,
       */
      function baseIsArguments(value) {
        return isObjectLike(value) && baseGetTag(value) == argsTag;
      }

      /*
       * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
       */
      function baseIsArrayBuffer(value) {
        return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
      }

      /*
       * The base implementation of `_.isDate` without Node.js optimizations.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
       */
      function baseIsDate(value) {
        return isObjectLike(value) && baseGetTag(value) == dateTag;
      }

      /*
       * The base implementation of `_.isEqual` which supports partial comparisons
       * and tracks traversed objects.
       *
       * @private
       * @param {*} value The value to compare.
       * @param {*} other The other value to compare.
       * @param {boolean} bitmask The bitmask flags.
       *  1 - Unordered comparison
       *  2 - Partial comparison
       * @param {Function} [customizer] The function to customize comparisons.
       * @param {Object} [stack] Tracks traversed `value` and `other` objects.
       * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
       */
      function baseIsEqual(value, other, bitmask, customizer, stack) {
        if (value === other) {
          return true;
        }
        if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
          return value !== value && other !== other;
        }
        return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
      }

      /*
       * A specialized version of `baseIsEqual` for arrays and objects which performs
       * deep comparisons and tracks traversed objects enabling objects with circular
       * references to be compared.
       *
       * @private
       * @param {Object} object The object to compare.
       * @param {Object} other The other object to compare.
       * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
       * @param {Function} customizer The function to customize comparisons.
       * @param {Function} equalFunc The function to determine equivalents of values.
       * @param {Object} [stack] Tracks traversed `object` and `other` objects.
       * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
       */
      function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
        var objIsArr = isArray(object),
          othIsArr = isArray(other),
          objTag = objIsArr ? arrayTag : getTag(object),
          othTag = othIsArr ? arrayTag : getTag(other);

        objTag = objTag == argsTag ? objectTag : objTag;
        othTag = othTag == argsTag ? objectTag : othTag;

        var objIsObj = objTag == objectTag,
          othIsObj = othTag == objectTag,
          isSameTag = objTag == othTag;

        if (isSameTag && isBuffer(object)) {
          if (!isBuffer(other)) {
            return false;
          }
          objIsArr = true;
          objIsObj = false;
        }
        if (isSameTag && !objIsObj) {
          stack || (stack = new Stack);
          return (objIsArr || isTypedArray(object))
            ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
            : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
        }
        if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
          var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
            othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

          if (objIsWrapped || othIsWrapped) {
            var objUnwrapped = objIsWrapped ? object.value() : object,
              othUnwrapped = othIsWrapped ? other.value() : other;

            stack || (stack = new Stack);
            return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
          }
        }
        if (!isSameTag) {
          return false;
        }
        stack || (stack = new Stack);
        return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
      }

      /*
       * The base implementation of `_.isMap` without Node.js optimizations.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a map, else `false`.
       */
      function baseIsMap(value) {
        return isObjectLike(value) && getTag(value) == mapTag;
      }

      /*
       * The base implementation of `_.isMatch` without support for iteratee shorthands.
       *
       * @private
       * @param {Object} object The object to inspect.
       * @param {Object} source The object of property values to match.
       * @param {Array} matchData The property names, values, and compare flags to match.
       * @param {Function} [customizer] The function to customize comparisons.
       * @returns {boolean} Returns `true` if `object` is a match, else `false`.
       */
      function baseIsMatch(object, source, matchData, customizer) {
        var index = matchData.length,
          length = index,
          noCustomizer = !customizer;

        if (object == null) {
          return !length;
        }
        object = Object(object);
        while (index--) {
          var data = matchData[index];
          if ((noCustomizer && data[2])
            ? data[1] !== object[data[0]]
            : !(data[0] in object)
          ) {
            return false;
          }
        }
        while (++index < length) {
          data = matchData[index];
          var key = data[0],
            objValue = object[key],
            srcValue = data[1];

          if (noCustomizer && data[2]) {
            if (objValue === undefined$1 && !(key in object)) {
              return false;
            }
          } else {
            var stack = new Stack;
            if (customizer) {
              var result = customizer(objValue, srcValue, key, object, source, stack);
            }
            if (!(result === undefined$1
              ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
              : result
            )) {
              return false;
            }
          }
        }
        return true;
      }

      /*
       * The base implementation of `_.isNative` without bad shim checks.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a native function,
       *  else `false`.
       */
      function baseIsNative(value) {
        if (!isObject(value) || isMasked(value)) {
          return false;
        }
        var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
        return pattern.test(toSource(value));
      }

      /*
       * The base implementation of `_.isRegExp` without Node.js optimizations.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
       */
      function baseIsRegExp(value) {
        return isObjectLike(value) && baseGetTag(value) == regexpTag;
      }

      /*
       * The base implementation of `_.isSet` without Node.js optimizations.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a set, else `false`.
       */
      function baseIsSet(value) {
        return isObjectLike(value) && getTag(value) == setTag;
      }

      /*
       * The base implementation of `_.isTypedArray` without Node.js optimizations.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
       */
      function baseIsTypedArray(value) {
        return isObjectLike(value) &&
          isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
      }

      /*
       * The base implementation of `_.iteratee`.
       *
       * @private
       * @param {*} [value=_.identity] The value to convert to an iteratee.
       * @returns {Function} Returns the iteratee.
       */
      function baseIteratee(value) {
        // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
        // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
        if (typeof value == 'function') {
          return value;
        }
        if (value == null) {
          return identity;
        }
        if (typeof value == 'object') {
          return isArray(value)
            ? baseMatchesProperty(value[0], value[1])
            : baseMatches(value);
        }
        return property(value);
      }

      /*
       * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
       *
       * @private
       * @param {Object} object The object to query.
       * @returns {Array} Returns the array of property names.
       */
      function baseKeys(object) {
        if (!isPrototype(object)) {
          return nativeKeys(object);
        }
        var result = [];
        for (var key in Object(object)) {
          if (hasOwnProperty.call(object, key) && key != 'constructor') {
            result.push(key);
          }
        }
        return result;
      }

      /*
       * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
       *
       * @private
       * @param {Object} object The object to query.
       * @returns {Array} Returns the array of property names.
       */
      function baseKeysIn(object) {
        if (!isObject(object)) {
          return nativeKeysIn(object);
        }
        var isProto = isPrototype(object),
          result = [];

        for (var key in object) {
          if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
            result.push(key);
          }
        }
        return result;
      }

      /*
       * The base implementation of `_.lt` which doesn't coerce arguments.
       *
       * @private
       * @param {*} value The value to compare.
       * @param {*} other The other value to compare.
       * @returns {boolean} Returns `true` if `value` is less than `other`,
       *  else `false`.
       */
      function baseLt(value, other) {
        return value < other;
      }

      /*
       * The base implementation of `_.map` without support for iteratee shorthands.
       *
       * @private
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} iteratee The function invoked per iteration.
       * @returns {Array} Returns the new mapped array.
       */
      function baseMap(collection, iteratee) {
        var index = -1,
          result = isArrayLike(collection) ? Array(collection.length) : [];

        baseEach(collection, function (value, key, collection) {
          result[++index] = iteratee(value, key, collection);
        });
        return result;
      }

      /*
       * The base implementation of `_.matches` which doesn't clone `source`.
       *
       * @private
       * @param {Object} source The object of property values to match.
       * @returns {Function} Returns the new spec function.
       */
      function baseMatches(source) {
        var matchData = getMatchData(source);
        if (matchData.length == 1 && matchData[0][2]) {
          return matchesStrictComparable(matchData[0][0], matchData[0][1]);
        }
        return function (object) {
          return object === source || baseIsMatch(object, source, matchData);
        };
      }

      /*
       * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
       *
       * @private
       * @param {string} path The path of the property to get.
       * @param {*} srcValue The value to match.
       * @returns {Function} Returns the new spec function.
       */
      function baseMatchesProperty(path, srcValue) {
        if (isKey(path) && isStrictComparable(srcValue)) {
          return matchesStrictComparable(toKey(path), srcValue);
        }
        return function (object) {
          var objValue = get(object, path);
          return (objValue === undefined$1 && objValue === srcValue)
            ? hasIn(object, path)
            : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
        };
      }

      /*
       * The base implementation of `_.merge` without support for multiple sources.
       *
       * @private
       * @param {Object} object The destination object.
       * @param {Object} source The source object.
       * @param {number} srcIndex The index of `source`.
       * @param {Function} [customizer] The function to customize merged values.
       * @param {Object} [stack] Tracks traversed source values and their merged
       *  counterparts.
       */
      function baseMerge(object, source, srcIndex, customizer, stack) {
        if (object === source) {
          return;
        }
        baseFor(source, function (srcValue, key) {
          stack || (stack = new Stack);
          if (isObject(srcValue)) {
            baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
          }
          else {
            var newValue = customizer
              ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
              : undefined$1;

            if (newValue === undefined$1) {
              newValue = srcValue;
            }
            assignMergeValue(object, key, newValue);
          }
        }, keysIn);
      }

      /*
       * A specialized version of `baseMerge` for arrays and objects which performs
       * deep merges and tracks traversed objects enabling objects with circular
       * references to be merged.
       *
       * @private
       * @param {Object} object The destination object.
       * @param {Object} source The source object.
       * @param {string} key The key of the value to merge.
       * @param {number} srcIndex The index of `source`.
       * @param {Function} mergeFunc The function to merge values.
       * @param {Function} [customizer] The function to customize assigned values.
       * @param {Object} [stack] Tracks traversed source values and their merged
       *  counterparts.
       */
      function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
        var objValue = safeGet(object, key),
          srcValue = safeGet(source, key),
          stacked = stack.get(srcValue);

        if (stacked) {
          assignMergeValue(object, key, stacked);
          return;
        }
        var newValue = customizer
          ? customizer(objValue, srcValue, (key + ''), object, source, stack)
          : undefined$1;

        var isCommon = newValue === undefined$1;

        if (isCommon) {
          var isArr = isArray(srcValue),
            isBuff = !isArr && isBuffer(srcValue),
            isTyped = !isArr && !isBuff && isTypedArray(srcValue);

          newValue = srcValue;
          if (isArr || isBuff || isTyped) {
            if (isArray(objValue)) {
              newValue = objValue;
            }
            else if (isArrayLikeObject(objValue)) {
              newValue = copyArray(objValue);
            }
            else if (isBuff) {
              isCommon = false;
              newValue = cloneBuffer(srcValue, true);
            }
            else if (isTyped) {
              isCommon = false;
              newValue = cloneTypedArray(srcValue, true);
            }
            else {
              newValue = [];
            }
          }
          else if (isPlainObject(srcValue) || isArguments(srcValue)) {
            newValue = objValue;
            if (isArguments(objValue)) {
              newValue = toPlainObject(objValue);
            }
            else if (!isObject(objValue) || isFunction(objValue)) {
              newValue = initCloneObject(srcValue);
            }
          }
          else {
            isCommon = false;
          }
        }
        if (isCommon) {
          // Recursively merge objects and arrays (susceptible to call stack limits).
          stack.set(srcValue, newValue);
          mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
          stack['delete'](srcValue);
        }
        assignMergeValue(object, key, newValue);
      }

      /*
       * The base implementation of `_.nth` which doesn't coerce arguments.
       *
       * @private
       * @param {Array} array The array to query.
       * @param {number} n The index of the element to return.
       * @returns {*} Returns the nth element of `array`.
       */
      function baseNth(array, n) {
        var length = array.length;
        if (!length) {
          return;
        }
        n += n < 0 ? length : 0;
        return isIndex(n, length) ? array[n] : undefined$1;
      }

      /*
       * The base implementation of `_.orderBy` without param guards.
       *
       * @private
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
       * @param {string[]} orders The sort orders of `iteratees`.
       * @returns {Array} Returns the new sorted array.
       */
      function baseOrderBy(collection, iteratees, orders) {
        if (iteratees.length) {
          iteratees = arrayMap(iteratees, function (iteratee) {
            if (isArray(iteratee)) {
              return function (value) {
                return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
              }
            }
            return iteratee;
          });
        } else {
          iteratees = [identity];
        }

        var index = -1;
        iteratees = arrayMap(iteratees, baseUnary(getIteratee()));

        var result = baseMap(collection, function (value, key, collection) {
          var criteria = arrayMap(iteratees, function (iteratee) {
            return iteratee(value);
          });
          return { 'criteria': criteria, 'index': ++index, 'value': value };
        });

        return baseSortBy(result, function (object, other) {
          return compareMultiple(object, other, orders);
        });
      }

      /*
       * The base implementation of `_.pick` without support for individual
       * property identifiers.
       *
       * @private
       * @param {Object} object The source object.
       * @param {string[]} paths The property paths to pick.
       * @returns {Object} Returns the new object.
       */
      function basePick(object, paths) {
        return basePickBy(object, paths, function (value, path) {
          return hasIn(object, path);
        });
      }

      /*
       * The base implementation of  `_.pickBy` without support for iteratee shorthands.
       *
       * @private
       * @param {Object} object The source object.
       * @param {string[]} paths The property paths to pick.
       * @param {Function} predicate The function invoked per property.
       * @returns {Object} Returns the new object.
       */
      function basePickBy(object, paths, predicate) {
        var index = -1,
          length = paths.length,
          result = {};

        while (++index < length) {
          var path = paths[index],
            value = baseGet(object, path);

          if (predicate(value, path)) {
            baseSet(result, castPath(path, object), value);
          }
        }
        return result;
      }

      /*
       * A specialized version of `baseProperty` which supports deep paths.
       *
       * @private
       * @param {Array|string} path The path of the property to get.
       * @returns {Function} Returns the new accessor function.
       */
      function basePropertyDeep(path) {
        return function (object) {
          return baseGet(object, path);
        };
      }

      /*
       * The base implementation of `_.pullAllBy` without support for iteratee
       * shorthands.
       *
       * @private
       * @param {Array} array The array to modify.
       * @param {Array} values The values to remove.
       * @param {Function} [iteratee] The iteratee invoked per element.
       * @param {Function} [comparator] The comparator invoked per element.
       * @returns {Array} Returns `array`.
       */
      function basePullAll(array, values, iteratee, comparator) {
        var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
          index = -1,
          length = values.length,
          seen = array;

        if (array === values) {
          values = copyArray(values);
        }
        if (iteratee) {
          seen = arrayMap(array, baseUnary(iteratee));
        }
        while (++index < length) {
          var fromIndex = 0,
            value = values[index],
            computed = iteratee ? iteratee(value) : value;

          while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
            if (seen !== array) {
              splice.call(seen, fromIndex, 1);
            }
            splice.call(array, fromIndex, 1);
          }
        }
        return array;
      }

      /*
       * The base implementation of `_.pullAt` without support for individual
       * indexes or capturing the removed elements.
       *
       * @private
       * @param {Array} array The array to modify.
       * @param {number[]} indexes The indexes of elements to remove.
       * @returns {Array} Returns `array`.
       */
      function basePullAt(array, indexes) {
        var length = array ? indexes.length : 0,
          lastIndex = length - 1;

        while (length--) {
          var index = indexes[length];
          if (length == lastIndex || index !== previous) {
            var previous = index;
            if (isIndex(index)) {
              splice.call(array, index, 1);
            } else {
              baseUnset(array, index);
            }
          }
        }
        return array;
      }

      /*
       * The base implementation of `_.random` without support for returning
       * floating-point numbers.
       *
       * @private
       * @param {number} lower The lower bound.
       * @param {number} upper The upper bound.
       * @returns {number} Returns the random number.
       */
      function baseRandom(lower, upper) {
        return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
      }

      /*
       * The base implementation of `_.range` and `_.rangeRight` which doesn't
       * coerce arguments.
       *
       * @private
       * @param {number} start The start of the range.
       * @param {number} end The end of the range.
       * @param {number} step The value to increment or decrement by.
       * @param {boolean} [fromRight] Specify iterating from right to left.
       * @returns {Array} Returns the range of numbers.
       */
      function baseRange(start, end, step, fromRight) {
        var index = -1,
          length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
          result = Array(length);

        while (length--) {
          result[fromRight ? length : ++index] = start;
          start += step;
        }
        return result;
      }

      /*
       * The base implementation of `_.repeat` which doesn't coerce arguments.
       *
       * @private
       * @param {string} string The string to repeat.
       * @param {number} n The number of times to repeat the string.
       * @returns {string} Returns the repeated string.
       */
      function baseRepeat(string, n) {
        var result = '';
        if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
          return result;
        }
        // Leverage the exponentiation by squaring algorithm for a faster repeat.
        // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
        do {
          if (n % 2) {
            result += string;
          }
          n = nativeFloor(n / 2);
          if (n) {
            string += string;
          }
        } while (n);

        return result;
      }

      /*
       * The base implementation of `_.rest` which doesn't validate or coerce arguments.
       *
       * @private
       * @param {Function} func The function to apply a rest parameter to.
       * @param {number} [start=func.length-1] The start position of the rest parameter.
       * @returns {Function} Returns the new function.
       */
      function baseRest(func, start) {
        return setToString(overRest(func, start, identity), func + '');
      }

      /*
       * The base implementation of `_.sample`.
       *
       * @private
       * @param {Array|Object} collection The collection to sample.
       * @returns {*} Returns the random element.
       */
      function baseSample(collection) {
        return arraySample(values(collection));
      }

      /*
       * The base implementation of `_.sampleSize` without param guards.
       *
       * @private
       * @param {Array|Object} collection The collection to sample.
       * @param {number} n The number of elements to sample.
       * @returns {Array} Returns the random elements.
       */
      function baseSampleSize(collection, n) {
        var array = values(collection);
        return shuffleSelf(array, baseClamp(n, 0, array.length));
      }

      /*
       * The base implementation of `_.set`.
       *
       * @private
       * @param {Object} object The object to modify.
       * @param {Array|string} path The path of the property to set.
       * @param {*} value The value to set.
       * @param {Function} [customizer] The function to customize path creation.
       * @returns {Object} Returns `object`.
       */
      function baseSet(object, path, value, customizer) {
        if (!isObject(object)) {
          return object;
        }
        path = castPath(path, object);

        var index = -1,
          length = path.length,
          lastIndex = length - 1,
          nested = object;

        while (nested != null && ++index < length) {
          var key = toKey(path[index]),
            newValue = value;

          if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
            return object;
          }

          if (index != lastIndex) {
            var objValue = nested[key];
            newValue = customizer ? customizer(objValue, key, nested) : undefined$1;
            if (newValue === undefined$1) {
              newValue = isObject(objValue)
                ? objValue
                : (isIndex(path[index + 1]) ? [] : {});
            }
          }
          assignValue(nested, key, newValue);
          nested = nested[key];
        }
        return object;
      }

      /*
       * The base implementation of `setData` without support for hot loop shorting.
       *
       * @private
       * @param {Function} func The function to associate metadata with.
       * @param {*} data The metadata.
       * @returns {Function} Returns `func`.
       */
      var baseSetData = !metaMap ? identity : function (func, data) {
        metaMap.set(func, data);
        return func;
      };

      /*
       * The base implementation of `setToString` without support for hot loop shorting.
       *
       * @private
       * @param {Function} func The function to modify.
       * @param {Function} string The `toString` result.
       * @returns {Function} Returns `func`.
       */
      var baseSetToString = !defineProperty ? identity : function (func, string) {
        return defineProperty(func, 'toString', {
          'configurable': true,
          'enumerable': false,
          'value': constant(string),
          'writable': true
        });
      };

      /*
       * The base implementation of `_.shuffle`.
       *
       * @private
       * @param {Array|Object} collection The collection to shuffle.
       * @returns {Array} Returns the new shuffled array.
       */
      function baseShuffle(collection) {
        return shuffleSelf(values(collection));
      }

      /*
       * The base implementation of `_.slice` without an iteratee call guard.
       *
       * @private
       * @param {Array} array The array to slice.
       * @param {number} [start=0] The start position.
       * @param {number} [end=array.length] The end position.
       * @returns {Array} Returns the slice of `array`.
       */
      function baseSlice(array, start, end) {
        var index = -1,
          length = array.length;

        if (start < 0) {
          start = -start > length ? 0 : (length + start);
        }
        end = end > length ? length : end;
        if (end < 0) {
          end += length;
        }
        length = start > end ? 0 : ((end - start) >>> 0);
        start >>>= 0;

        var result = Array(length);
        while (++index < length) {
          result[index] = array[index + start];
        }
        return result;
      }

      /*
       * The base implementation of `_.some` without support for iteratee shorthands.
       *
       * @private
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} predicate The function invoked per iteration.
       * @returns {boolean} Returns `true` if any element passes the predicate check,
       *  else `false`.
       */
      function baseSome(collection, predicate) {
        var result;

        baseEach(collection, function (value, index, collection) {
          result = predicate(value, index, collection);
          return !result;
        });
        return !!result;
      }

      /*
       * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
       * performs a binary search of `array` to determine the index at which `value`
       * should be inserted into `array` in order to maintain its sort order.
       *
       * @private
       * @param {Array} array The sorted array to inspect.
       * @param {*} value The value to evaluate.
       * @param {boolean} [retHighest] Specify returning the highest qualified index.
       * @returns {number} Returns the index at which `value` should be inserted
       *  into `array`.
       */
      function baseSortedIndex(array, value, retHighest) {
        var low = 0,
          high = array == null ? low : array.length;

        if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
          while (low < high) {
            var mid = (low + high) >>> 1,
              computed = array[mid];

            if (computed !== null && !isSymbol(computed) &&
              (retHighest ? (computed <= value) : (computed < value))) {
              low = mid + 1;
            } else {
              high = mid;
            }
          }
          return high;
        }
        return baseSortedIndexBy(array, value, identity, retHighest);
      }

      /*
       * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
       * which invokes `iteratee` for `value` and each element of `array` to compute
       * their sort ranking. The iteratee is invoked with one argument; (value).
       *
       * @private
       * @param {Array} array The sorted array to inspect.
       * @param {*} value The value to evaluate.
       * @param {Function} iteratee The iteratee invoked per element.
       * @param {boolean} [retHighest] Specify returning the highest qualified index.
       * @returns {number} Returns the index at which `value` should be inserted
       *  into `array`.
       */
      function baseSortedIndexBy(array, value, iteratee, retHighest) {
        var low = 0,
          high = array == null ? 0 : array.length;
        if (high === 0) {
          return 0;
        }

        value = iteratee(value);
        var valIsNaN = value !== value,
          valIsNull = value === null,
          valIsSymbol = isSymbol(value),
          valIsUndefined = value === undefined$1;

        while (low < high) {
          var mid = nativeFloor((low + high) / 2),
            computed = iteratee(array[mid]),
            othIsDefined = computed !== undefined$1,
            othIsNull = computed === null,
            othIsReflexive = computed === computed,
            othIsSymbol = isSymbol(computed);

          if (valIsNaN) {
            var setLow = retHighest || othIsReflexive;
          } else if (valIsUndefined) {
            setLow = othIsReflexive && (retHighest || othIsDefined);
          } else if (valIsNull) {
            setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
          } else if (valIsSymbol) {
            setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
          } else if (othIsNull || othIsSymbol) {
            setLow = false;
          } else {
            setLow = retHighest ? (computed <= value) : (computed < value);
          }
          if (setLow) {
            low = mid + 1;
          } else {
            high = mid;
          }
        }
        return nativeMin(high, MAX_ARRAY_INDEX);
      }

      /*
       * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
       * support for iteratee shorthands.
       *
       * @private
       * @param {Array} array The array to inspect.
       * @param {Function} [iteratee] The iteratee invoked per element.
       * @returns {Array} Returns the new duplicate free array.
       */
      function baseSortedUniq(array, iteratee) {
        var index = -1,
          length = array.length,
          resIndex = 0,
          result = [];

        while (++index < length) {
          var value = array[index],
            computed = iteratee ? iteratee(value) : value;

          if (!index || !eq(computed, seen)) {
            var seen = computed;
            result[resIndex++] = value === 0 ? 0 : value;
          }
        }
        return result;
      }

      /*
       * The base implementation of `_.toNumber` which doesn't ensure correct
       * conversions of binary, hexadecimal, or octal string values.
       *
       * @private
       * @param {*} value The value to process.
       * @returns {number} Returns the number.
       */
      function baseToNumber(value) {
        if (typeof value == 'number') {
          return value;
        }
        if (isSymbol(value)) {
          return NAN;
        }
        return +value;
      }

      /*
       * The base implementation of `_.toString` which doesn't convert nullish
       * values to empty strings.
       *
       * @private
       * @param {*} value The value to process.
       * @returns {string} Returns the string.
       */
      function baseToString(value) {
        // Exit early for strings to avoid a performance hit in some environments.
        if (typeof value == 'string') {
          return value;
        }
        if (isArray(value)) {
          // Recursively convert values (susceptible to call stack limits).
          return arrayMap(value, baseToString) + '';
        }
        if (isSymbol(value)) {
          return symbolToString ? symbolToString.call(value) : '';
        }
        var result = (value + '');
        return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
      }

      /*
       * The base implementation of `_.uniqBy` without support for iteratee shorthands.
       *
       * @private
       * @param {Array} array The array to inspect.
       * @param {Function} [iteratee] The iteratee invoked per element.
       * @param {Function} [comparator] The comparator invoked per element.
       * @returns {Array} Returns the new duplicate free array.
       */
      function baseUniq(array, iteratee, comparator) {
        var index = -1,
          includes = arrayIncludes,
          length = array.length,
          isCommon = true,
          result = [],
          seen = result;

        if (comparator) {
          isCommon = false;
          includes = arrayIncludesWith;
        }
        else if (length >= LARGE_ARRAY_SIZE) {
          var set = iteratee ? null : createSet(array);
          if (set) {
            return setToArray(set);
          }
          isCommon = false;
          includes = cacheHas;
          seen = new SetCache;
        }
        else {
          seen = iteratee ? [] : result;
        }
        outer:
        while (++index < length) {
          var value = array[index],
            computed = iteratee ? iteratee(value) : value;

          value = (comparator || value !== 0) ? value : 0;
          if (isCommon && computed === computed) {
            var seenIndex = seen.length;
            while (seenIndex--) {
              if (seen[seenIndex] === computed) {
                continue outer;
              }
            }
            if (iteratee) {
              seen.push(computed);
            }
            result.push(value);
          }
          else if (!includes(seen, computed, comparator)) {
            if (seen !== result) {
              seen.push(computed);
            }
            result.push(value);
          }
        }
        return result;
      }

      /*
       * The base implementation of `_.unset`.
       *
       * @private
       * @param {Object} object The object to modify.
       * @param {Array|string} path The property path to unset.
       * @returns {boolean} Returns `true` if the property is deleted, else `false`.
       */
      function baseUnset(object, path) {
        path = castPath(path, object);
        object = parent(object, path);
        return object == null || delete object[toKey(last(path))];
      }

      /*
       * The base implementation of `_.update`.
       *
       * @private
       * @param {Object} object The object to modify.
       * @param {Array|string} path The path of the property to update.
       * @param {Function} updater The function to produce the updated value.
       * @param {Function} [customizer] The function to customize path creation.
       * @returns {Object} Returns `object`.
       */
      function baseUpdate(object, path, updater, customizer) {
        return baseSet(object, path, updater(baseGet(object, path)), customizer);
      }

      /*
       * The base implementation of methods like `_.dropWhile` and `_.takeWhile`
       * without support for iteratee shorthands.
       *
       * @private
       * @param {Array} array The array to query.
       * @param {Function} predicate The function invoked per iteration.
       * @param {boolean} [isDrop] Specify dropping elements instead of taking them.
       * @param {boolean} [fromRight] Specify iterating from right to left.
       * @returns {Array} Returns the slice of `array`.
       */
      function baseWhile(array, predicate, isDrop, fromRight) {
        var length = array.length,
          index = fromRight ? length : -1;

        while ((fromRight ? index-- : ++index < length) &&
          predicate(array[index], index, array)) { }

        return isDrop
          ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))
          : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));
      }

      /*
       * The base implementation of `wrapperValue` which returns the result of
       * performing a sequence of actions on the unwrapped `value`, where each
       * successive action is supplied the return value of the previous.
       *
       * @private
       * @param {*} value The unwrapped value.
       * @param {Array} actions Actions to perform to resolve the unwrapped value.
       * @returns {*} Returns the resolved value.
       */
      function baseWrapperValue(value, actions) {
        var result = value;
        if (result instanceof LazyWrapper) {
          result = result.value();
        }
        return arrayReduce(actions, function (result, action) {
          return action.func.apply(action.thisArg, arrayPush([result], action.args));
        }, result);
      }

      /*
       * The base implementation of methods like `_.xor`, without support for
       * iteratee shorthands, that accepts an array of arrays to inspect.
       *
       * @private
       * @param {Array} arrays The arrays to inspect.
       * @param {Function} [iteratee] The iteratee invoked per element.
       * @param {Function} [comparator] The comparator invoked per element.
       * @returns {Array} Returns the new array of values.
       */
      function baseXor(arrays, iteratee, comparator) {
        var length = arrays.length;
        if (length < 2) {
          return length ? baseUniq(arrays[0]) : [];
        }
        var index = -1,
          result = Array(length);

        while (++index < length) {
          var array = arrays[index],
            othIndex = -1;

          while (++othIndex < length) {
            if (othIndex != index) {
              result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
            }
          }
        }
        return baseUniq(baseFlatten(result, 1), iteratee, comparator);
      }

      /*
       * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
       *
       * @private
       * @param {Array} props The property identifiers.
       * @param {Array} values The property values.
       * @param {Function} assignFunc The function to assign values.
       * @returns {Object} Returns the new object.
       */
      function baseZipObject(props, values, assignFunc) {
        var index = -1,
          length = props.length,
          valsLength = values.length,
          result = {};

        while (++index < length) {
          var value = index < valsLength ? values[index] : undefined$1;
          assignFunc(result, props[index], value);
        }
        return result;
      }

      /*
       * Casts `value` to an empty array if it's not an array like object.
       *
       * @private
       * @param {*} value The value to inspect.
       * @returns {Array|Object} Returns the cast array-like object.
       */
      function castArrayLikeObject(value) {
        return isArrayLikeObject(value) ? value : [];
      }

      /*
       * Casts `value` to `identity` if it's not a function.
       *
       * @private
       * @param {*} value The value to inspect.
       * @returns {Function} Returns cast function.
       */
      function castFunction(value) {
        return typeof value == 'function' ? value : identity;
      }

      /*
       * Casts `value` to a path array if it's not one.
       *
       * @private
       * @param {*} value The value to inspect.
       * @param {Object} [object] The object to query keys on.
       * @returns {Array} Returns the cast property path array.
       */
      function castPath(value, object) {
        if (isArray(value)) {
          return value;
        }
        return isKey(value, object) ? [value] : stringToPath(toString(value));
      }

      /*
       * A `baseRest` alias which can be replaced with `identity` by module
       * replacement plugins.
       *
       * @private
       * @type {Function}
       * @param {Function} func The function to apply a rest parameter to.
       * @returns {Function} Returns the new function.
       */
      var castRest = baseRest;

      /*
       * Casts `array` to a slice if it's needed.
       *
       * @private
       * @param {Array} array The array to inspect.
       * @param {number} start The start position.
       * @param {number} [end=array.length] The end position.
       * @returns {Array} Returns the cast slice.
       */
      function castSlice(array, start, end) {
        var length = array.length;
        end = end === undefined$1 ? length : end;
        return (!start && end >= length) ? array : baseSlice(array, start, end);
      }

      /*
       * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).
       *
       * @private
       * @param {number|Object} id The timer id or timeout object of the timer to clear.
       */
      var clearTimeout = ctxClearTimeout || function (id) {
        return root.clearTimeout(id);
      };

      /*
       * Creates a clone of  `buffer`.
       *
       * @private
       * @param {Buffer} buffer The buffer to clone.
       * @param {boolean} [isDeep] Specify a deep clone.
       * @returns {Buffer} Returns the cloned buffer.
       */
      function cloneBuffer(buffer, isDeep) {
        if (isDeep) {
          return buffer.slice();
        }
        var length = buffer.length,
          result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);

        buffer.copy(result);
        return result;
      }

      /*
       * Creates a clone of `arrayBuffer`.
       *
       * @private
       * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
       * @returns {ArrayBuffer} Returns the cloned array buffer.
       */
      function cloneArrayBuffer(arrayBuffer) {
        var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
        new Uint8Array(result).set(new Uint8Array(arrayBuffer));
        return result;
      }

      /*
       * Creates a clone of `dataView`.
       *
       * @private
       * @param {Object} dataView The data view to clone.
       * @param {boolean} [isDeep] Specify a deep clone.
       * @returns {Object} Returns the cloned data view.
       */
      function cloneDataView(dataView, isDeep) {
        var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
        return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
      }

      /*
       * Creates a clone of `regexp`.
       *
       * @private
       * @param {Object} regexp The regexp to clone.
       * @returns {Object} Returns the cloned regexp.
       */
      function cloneRegExp(regexp) {
        var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
        result.lastIndex = regexp.lastIndex;
        return result;
      }

      /*
       * Creates a clone of the `symbol` object.
       *
       * @private
       * @param {Object} symbol The symbol object to clone.
       * @returns {Object} Returns the cloned symbol object.
       */
      function cloneSymbol(symbol) {
        return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
      }

      /*
       * Creates a clone of `typedArray`.
       *
       * @private
       * @param {Object} typedArray The typed array to clone.
       * @param {boolean} [isDeep] Specify a deep clone.
       * @returns {Object} Returns the cloned typed array.
       */
      function cloneTypedArray(typedArray, isDeep) {
        var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
        return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
      }

      /*
       * Compares values to sort them in ascending order.
       *
       * @private
       * @param {*} value The value to compare.
       * @param {*} other The other value to compare.
       * @returns {number} Returns the sort order indicator for `value`.
       */
      function compareAscending(value, other) {
        if (value !== other) {
          var valIsDefined = value !== undefined$1,
            valIsNull = value === null,
            valIsReflexive = value === value,
            valIsSymbol = isSymbol(value);

          var othIsDefined = other !== undefined$1,
            othIsNull = other === null,
            othIsReflexive = other === other,
            othIsSymbol = isSymbol(other);

          if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
            (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
            (valIsNull && othIsDefined && othIsReflexive) ||
            (!valIsDefined && othIsReflexive) ||
            !valIsReflexive) {
            return 1;
          }
          if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
            (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
            (othIsNull && valIsDefined && valIsReflexive) ||
            (!othIsDefined && valIsReflexive) ||
            !othIsReflexive) {
            return -1;
          }
        }
        return 0;
      }

      /*
       * Used by `_.orderBy` to compare multiple properties of a value to another
       * and stable sort them.
       *
       * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
       * specify an order of "desc" for descending or "asc" for ascending sort order
       * of corresponding values.
       *
       * @private
       * @param {Object} object The object to compare.
       * @param {Object} other The other object to compare.
       * @param {boolean[]|string[]} orders The order to sort by for each property.
       * @returns {number} Returns the sort order indicator for `object`.
       */
      function compareMultiple(object, other, orders) {
        var index = -1,
          objCriteria = object.criteria,
          othCriteria = other.criteria,
          length = objCriteria.length,
          ordersLength = orders.length;

        while (++index < length) {
          var result = compareAscending(objCriteria[index], othCriteria[index]);
          if (result) {
            if (index >= ordersLength) {
              return result;
            }
            var order = orders[index];
            return result * (order == 'desc' ? -1 : 1);
          }
        }
        // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
        // that causes it, under certain circumstances, to provide the same value for
        // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
        // for more details.
        //
        // This also ensures a stable sort in V8 and other engines.
        // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
        return object.index - other.index;
      }

      /*
       * Creates an array that is the composition of partially applied arguments,
       * placeholders, and provided arguments into a single array of arguments.
       *
       * @private
       * @param {Array} args The provided arguments.
       * @param {Array} partials The arguments to prepend to those provided.
       * @param {Array} holders The `partials` placeholder indexes.
       * @param {boolean} [isCurried] Specify composing for a curried function.
       * @returns {Array} Returns the new array of composed arguments.
       */
      function composeArgs(args, partials, holders, isCurried) {
        var argsIndex = -1,
          argsLength = args.length,
          holdersLength = holders.length,
          leftIndex = -1,
          leftLength = partials.length,
          rangeLength = nativeMax(argsLength - holdersLength, 0),
          result = Array(leftLength + rangeLength),
          isUncurried = !isCurried;

        while (++leftIndex < leftLength) {
          result[leftIndex] = partials[leftIndex];
        }
        while (++argsIndex < holdersLength) {
          if (isUncurried || argsIndex < argsLength) {
            result[holders[argsIndex]] = args[argsIndex];
          }
        }
        while (rangeLength--) {
          result[leftIndex++] = args[argsIndex++];
        }
        return result;
      }

      /*
       * This function is like `composeArgs` except that the arguments composition
       * is tailored for `_.partialRight`.
       *
       * @private
       * @param {Array} args The provided arguments.
       * @param {Array} partials The arguments to append to those provided.
       * @param {Array} holders The `partials` placeholder indexes.
       * @param {boolean} [isCurried] Specify composing for a curried function.
       * @returns {Array} Returns the new array of composed arguments.
       */
      function composeArgsRight(args, partials, holders, isCurried) {
        var argsIndex = -1,
          argsLength = args.length,
          holdersIndex = -1,
          holdersLength = holders.length,
          rightIndex = -1,
          rightLength = partials.length,
          rangeLength = nativeMax(argsLength - holdersLength, 0),
          result = Array(rangeLength + rightLength),
          isUncurried = !isCurried;

        while (++argsIndex < rangeLength) {
          result[argsIndex] = args[argsIndex];
        }
        var offset = argsIndex;
        while (++rightIndex < rightLength) {
          result[offset + rightIndex] = partials[rightIndex];
        }
        while (++holdersIndex < holdersLength) {
          if (isUncurried || argsIndex < argsLength) {
            result[offset + holders[holdersIndex]] = args[argsIndex++];
          }
        }
        return result;
      }

      /*
       * Copies the values of `source` to `array`.
       *
       * @private
       * @param {Array} source The array to copy values from.
       * @param {Array} [array=[]] The array to copy values to.
       * @returns {Array} Returns `array`.
       */
      function copyArray(source, array) {
        var index = -1,
          length = source.length;

        array || (array = Array(length));
        while (++index < length) {
          array[index] = source[index];
        }
        return array;
      }

      /*
       * Copies properties of `source` to `object`.
       *
       * @private
       * @param {Object} source The object to copy properties from.
       * @param {Array} props The property identifiers to copy.
       * @param {Object} [object={}] The object to copy properties to.
       * @param {Function} [customizer] The function to customize copied values.
       * @returns {Object} Returns `object`.
       */
      function copyObject(source, props, object, customizer) {
        var isNew = !object;
        object || (object = {});

        var index = -1,
          length = props.length;

        while (++index < length) {
          var key = props[index];

          var newValue = customizer
            ? customizer(object[key], source[key], key, object, source)
            : undefined$1;

          if (newValue === undefined$1) {
            newValue = source[key];
          }
          if (isNew) {
            baseAssignValue(object, key, newValue);
          } else {
            assignValue(object, key, newValue);
          }
        }
        return object;
      }

      /*
       * Copies own symbols of `source` to `object`.
       *
       * @private
       * @param {Object} source The object to copy symbols from.
       * @param {Object} [object={}] The object to copy symbols to.
       * @returns {Object} Returns `object`.
       */
      function copySymbols(source, object) {
        return copyObject(source, getSymbols(source), object);
      }

      /*
       * Copies own and inherited symbols of `source` to `object`.
       *
       * @private
       * @param {Object} source The object to copy symbols from.
       * @param {Object} [object={}] The object to copy symbols to.
       * @returns {Object} Returns `object`.
       */
      function copySymbolsIn(source, object) {
        return copyObject(source, getSymbolsIn(source), object);
      }

      /*
       * Creates a function like `_.groupBy`.
       *
       * @private
       * @param {Function} setter The function to set accumulator values.
       * @param {Function} [initializer] The accumulator object initializer.
       * @returns {Function} Returns the new aggregator function.
       */
      function createAggregator(setter, initializer) {
        return function (collection, iteratee) {
          var func = isArray(collection) ? arrayAggregator : baseAggregator,
            accumulator = initializer ? initializer() : {};

          return func(collection, setter, getIteratee(iteratee, 2), accumulator);
        };
      }

      /*
       * Creates a function like `_.assign`.
       *
       * @private
       * @param {Function} assigner The function to assign values.
       * @returns {Function} Returns the new assigner function.
       */
      function createAssigner(assigner) {
        return baseRest(function (object, sources) {
          var index = -1,
            length = sources.length,
            customizer = length > 1 ? sources[length - 1] : undefined$1,
            guard = length > 2 ? sources[2] : undefined$1;

          customizer = (assigner.length > 3 && typeof customizer == 'function')
            ? (length--, customizer)
            : undefined$1;

          if (guard && isIterateeCall(sources[0], sources[1], guard)) {
            customizer = length < 3 ? undefined$1 : customizer;
            length = 1;
          }
          object = Object(object);
          while (++index < length) {
            var source = sources[index];
            if (source) {
              assigner(object, source, index, customizer);
            }
          }
          return object;
        });
      }

      /*
       * Creates a `baseEach` or `baseEachRight` function.
       *
       * @private
       * @param {Function} eachFunc The function to iterate over a collection.
       * @param {boolean} [fromRight] Specify iterating from right to left.
       * @returns {Function} Returns the new base function.
       */
      function createBaseEach(eachFunc, fromRight) {
        return function (collection, iteratee) {
          if (collection == null) {
            return collection;
          }
          if (!isArrayLike(collection)) {
            return eachFunc(collection, iteratee);
          }
          var length = collection.length,
            index = fromRight ? length : -1,
            iterable = Object(collection);

          while ((fromRight ? index-- : ++index < length)) {
            if (iteratee(iterable[index], index, iterable) === false) {
              break;
            }
          }
          return collection;
        };
      }

      /*
       * Creates a base function for methods like `_.forIn` and `_.forOwn`.
       *
       * @private
       * @param {boolean} [fromRight] Specify iterating from right to left.
       * @returns {Function} Returns the new base function.
       */
      function createBaseFor(fromRight) {
        return function (object, iteratee, keysFunc) {
          var index = -1,
            iterable = Object(object),
            props = keysFunc(object),
            length = props.length;

          while (length--) {
            var key = props[fromRight ? length : ++index];
            if (iteratee(iterable[key], key, iterable) === false) {
              break;
            }
          }
          return object;
        };
      }

      /*
       * Creates a function that wraps `func` to invoke it with the optional `this`
       * binding of `thisArg`.
       *
       * @private
       * @param {Function} func The function to wrap.
       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
       * @param {*} [thisArg] The `this` binding of `func`.
       * @returns {Function} Returns the new wrapped function.
       */
      function createBind(func, bitmask, thisArg) {
        var isBind = bitmask & WRAP_BIND_FLAG,
          Ctor = createCtor(func);

        function wrapper() {
          var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
          return fn.apply(isBind ? thisArg : this, arguments);
        }
        return wrapper;
      }

      /*
       * Creates a function like `_.lowerFirst`.
       *
       * @private
       * @param {string} methodName The name of the `String` case method to use.
       * @returns {Function} Returns the new case function.
       */
      function createCaseFirst(methodName) {
        return function (string) {
          string = toString(string);

          var strSymbols = hasUnicode(string)
            ? stringToArray(string)
            : undefined$1;

          var chr = strSymbols
            ? strSymbols[0]
            : string.charAt(0);

          var trailing = strSymbols
            ? castSlice(strSymbols, 1).join('')
            : string.slice(1);

          return chr[methodName]() + trailing;
        };
      }

      /*
       * Creates a function like `_.camelCase`.
       *
       * @private
       * @param {Function} callback The function to combine each word.
       * @returns {Function} Returns the new compounder function.
       */
      function createCompounder(callback) {
        return function (string) {
          return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
        };
      }

      /*
       * Creates a function that produces an instance of `Ctor` regardless of
       * whether it was invoked as part of a `new` expression or by `call` or `apply`.
       *
       * @private
       * @param {Function} Ctor The constructor to wrap.
       * @returns {Function} Returns the new wrapped function.
       */
      function createCtor(Ctor) {
        return function () {
          // Use a `switch` statement to work with class constructors. See
          // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
          // for more details.
          var args = arguments;
          switch (args.length) {
            case 0: return new Ctor;
            case 1: return new Ctor(args[0]);
            case 2: return new Ctor(args[0], args[1]);
            case 3: return new Ctor(args[0], args[1], args[2]);
            case 4: return new Ctor(args[0], args[1], args[2], args[3]);
            case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);
            case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
            case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
          }
          var thisBinding = baseCreate(Ctor.prototype),
            result = Ctor.apply(thisBinding, args);

          // Mimic the constructor's `return` behavior.
          // See https://es5.github.io/#x13.2.2 for more details.
          return isObject(result) ? result : thisBinding;
        };
      }

      /*
       * Creates a function that wraps `func` to enable currying.
       *
       * @private
       * @param {Function} func The function to wrap.
       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
       * @param {number} arity The arity of `func`.
       * @returns {Function} Returns the new wrapped function.
       */
      function createCurry(func, bitmask, arity) {
        var Ctor = createCtor(func);

        function wrapper() {
          var length = arguments.length,
            args = Array(length),
            index = length,
            placeholder = getHolder(wrapper);

          while (index--) {
            args[index] = arguments[index];
          }
          var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
            ? []
            : replaceHolders(args, placeholder);

          length -= holders.length;
          if (length < arity) {
            return createRecurry(
              func, bitmask, createHybrid, wrapper.placeholder, undefined$1,
              args, holders, undefined$1, undefined$1, arity - length);
          }
          var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
          return apply(fn, this, args);
        }
        return wrapper;
      }

      /*
       * Creates a `_.find` or `_.findLast` function.
       *
       * @private
       * @param {Function} findIndexFunc The function to find the collection index.
       * @returns {Function} Returns the new find function.
       */
      function createFind(findIndexFunc) {
        return function (collection, predicate, fromIndex) {
          var iterable = Object(collection);
          if (!isArrayLike(collection)) {
            var iteratee = getIteratee(predicate, 3);
            collection = keys(collection);
            predicate = function (key) { return iteratee(iterable[key], key, iterable); };
          }
          var index = findIndexFunc(collection, predicate, fromIndex);
          return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined$1;
        };
      }

      /*
       * Creates a `_.flow` or `_.flowRight` function.
       *
       * @private
       * @param {boolean} [fromRight] Specify iterating from right to left.
       * @returns {Function} Returns the new flow function.
       */
      function createFlow(fromRight) {
        return flatRest(function (funcs) {
          var length = funcs.length,
            index = length,
            prereq = LodashWrapper.prototype.thru;

          if (fromRight) {
            funcs.reverse();
          }
          while (index--) {
            var func = funcs[index];
            if (typeof func != 'function') {
              throw new TypeError(FUNC_ERROR_TEXT);
            }
            if (prereq && !wrapper && getFuncName(func) == 'wrapper') {
              var wrapper = new LodashWrapper([], true);
            }
          }
          index = wrapper ? index : length;
          while (++index < length) {
            func = funcs[index];

            var funcName = getFuncName(func),
              data = funcName == 'wrapper' ? getData(func) : undefined$1;

            if (data && isLaziable(data[0]) &&
              data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
              !data[4].length && data[9] == 1
            ) {
              wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
            } else {
              wrapper = (func.length == 1 && isLaziable(func))
                ? wrapper[funcName]()
                : wrapper.thru(func);
            }
          }
          return function () {
            var args = arguments,
              value = args[0];

            if (wrapper && args.length == 1 && isArray(value)) {
              return wrapper.plant(value).value();
            }
            var index = 0,
              result = length ? funcs[index].apply(this, args) : value;

            while (++index < length) {
              result = funcs[index].call(this, result);
            }
            return result;
          };
        });
      }

      /*
       * Creates a function that wraps `func` to invoke it with optional `this`
       * binding of `thisArg`, partial application, and currying.
       *
       * @private
       * @param {Function|string} func The function or method name to wrap.
       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
       * @param {*} [thisArg] The `this` binding of `func`.
       * @param {Array} [partials] The arguments to prepend to those provided to
       *  the new function.
       * @param {Array} [holders] The `partials` placeholder indexes.
       * @param {Array} [partialsRight] The arguments to append to those provided
       *  to the new function.
       * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
       * @param {Array} [argPos] The argument positions of the new function.
       * @param {number} [ary] The arity cap of `func`.
       * @param {number} [arity] The arity of `func`.
       * @returns {Function} Returns the new wrapped function.
       */
      function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
        var isAry = bitmask & WRAP_ARY_FLAG,
          isBind = bitmask & WRAP_BIND_FLAG,
          isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
          isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
          isFlip = bitmask & WRAP_FLIP_FLAG,
          Ctor = isBindKey ? undefined$1 : createCtor(func);

        function wrapper() {
          var length = arguments.length,
            args = Array(length),
            index = length;

          while (index--) {
            args[index] = arguments[index];
          }
          if (isCurried) {
            var placeholder = getHolder(wrapper),
              holdersCount = countHolders(args, placeholder);
          }
          if (partials) {
            args = composeArgs(args, partials, holders, isCurried);
          }
          if (partialsRight) {
            args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
          }
          length -= holdersCount;
          if (isCurried && length < arity) {
            var newHolders = replaceHolders(args, placeholder);
            return createRecurry(
              func, bitmask, createHybrid, wrapper.placeholder, thisArg,
              args, newHolders, argPos, ary, arity - length
            );
          }
          var thisBinding = isBind ? thisArg : this,
            fn = isBindKey ? thisBinding[func] : func;

          length = args.length;
          if (argPos) {
            args = reorder(args, argPos);
          } else if (isFlip && length > 1) {
            args.reverse();
          }
          if (isAry && ary < length) {
            args.length = ary;
          }
          if (this && this !== root && this instanceof wrapper) {
            fn = Ctor || createCtor(fn);
          }
          return fn.apply(thisBinding, args);
        }
        return wrapper;
      }

      /*
       * Creates a function like `_.invertBy`.
       *
       * @private
       * @param {Function} setter The function to set accumulator values.
       * @param {Function} toIteratee The function to resolve iteratees.
       * @returns {Function} Returns the new inverter function.
       */
      function createInverter(setter, toIteratee) {
        return function (object, iteratee) {
          return baseInverter(object, setter, toIteratee(iteratee), {});
        };
      }

      /*
       * Creates a function that performs a mathematical operation on two values.
       *
       * @private
       * @param {Function} operator The function to perform the operation.
       * @param {number} [defaultValue] The value used for `undefined` arguments.
       * @returns {Function} Returns the new mathematical operation function.
       */
      function createMathOperation(operator, defaultValue) {
        return function (value, other) {
          var result;
          if (value === undefined$1 && other === undefined$1) {
            return defaultValue;
          }
          if (value !== undefined$1) {
            result = value;
          }
          if (other !== undefined$1) {
            if (result === undefined$1) {
              return other;
            }
            if (typeof value == 'string' || typeof other == 'string') {
              value = baseToString(value);
              other = baseToString(other);
            } else {
              value = baseToNumber(value);
              other = baseToNumber(other);
            }
            result = operator(value, other);
          }
          return result;
        };
      }

      /*
       * Creates a function like `_.over`.
       *
       * @private
       * @param {Function} arrayFunc The function to iterate over iteratees.
       * @returns {Function} Returns the new over function.
       */
      function createOver(arrayFunc) {
        return flatRest(function (iteratees) {
          iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
          return baseRest(function (args) {
            var thisArg = this;
            return arrayFunc(iteratees, function (iteratee) {
              return apply(iteratee, thisArg, args);
            });
          });
        });
      }

      /*
       * Creates the padding for `string` based on `length`. The `chars` string
       * is truncated if the number of characters exceeds `length`.
       *
       * @private
       * @param {number} length The padding length.
       * @param {string} [chars=' '] The string used as padding.
       * @returns {string} Returns the padding for `string`.
       */
      function createPadding(length, chars) {
        chars = chars === undefined$1 ? ' ' : baseToString(chars);

        var charsLength = chars.length;
        if (charsLength < 2) {
          return charsLength ? baseRepeat(chars, length) : chars;
        }
        var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
        return hasUnicode(chars)
          ? castSlice(stringToArray(result), 0, length).join('')
          : result.slice(0, length);
      }

      /*
       * Creates a function that wraps `func` to invoke it with the `this` binding
       * of `thisArg` and `partials` prepended to the arguments it receives.
       *
       * @private
       * @param {Function} func The function to wrap.
       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
       * @param {*} thisArg The `this` binding of `func`.
       * @param {Array} partials The arguments to prepend to those provided to
       *  the new function.
       * @returns {Function} Returns the new wrapped function.
       */
      function createPartial(func, bitmask, thisArg, partials) {
        var isBind = bitmask & WRAP_BIND_FLAG,
          Ctor = createCtor(func);

        function wrapper() {
          var argsIndex = -1,
            argsLength = arguments.length,
            leftIndex = -1,
            leftLength = partials.length,
            args = Array(leftLength + argsLength),
            fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;

          while (++leftIndex < leftLength) {
            args[leftIndex] = partials[leftIndex];
          }
          while (argsLength--) {
            args[leftIndex++] = arguments[++argsIndex];
          }
          return apply(fn, isBind ? thisArg : this, args);
        }
        return wrapper;
      }

      /*
       * Creates a `_.range` or `_.rangeRight` function.
       *
       * @private
       * @param {boolean} [fromRight] Specify iterating from right to left.
       * @returns {Function} Returns the new range function.
       */
      function createRange(fromRight) {
        return function (start, end, step) {
          if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {
            end = step = undefined$1;
          }
          // Ensure the sign of `-0` is preserved.
          start = toFinite(start);
          if (end === undefined$1) {
            end = start;
            start = 0;
          } else {
            end = toFinite(end);
          }
          step = step === undefined$1 ? (start < end ? 1 : -1) : toFinite(step);
          return baseRange(start, end, step, fromRight);
        };
      }

      /*
       * Creates a function that performs a relational operation on two values.
       *
       * @private
       * @param {Function} operator The function to perform the operation.
       * @returns {Function} Returns the new relational operation function.
       */
      function createRelationalOperation(operator) {
        return function (value, other) {
          if (!(typeof value == 'string' && typeof other == 'string')) {
            value = toNumber(value);
            other = toNumber(other);
          }
          return operator(value, other);
        };
      }

      /*
       * Creates a function that wraps `func` to continue currying.
       *
       * @private
       * @param {Function} func The function to wrap.
       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
       * @param {Function} wrapFunc The function to create the `func` wrapper.
       * @param {*} placeholder The placeholder value.
       * @param {*} [thisArg] The `this` binding of `func`.
       * @param {Array} [partials] The arguments to prepend to those provided to
       *  the new function.
       * @param {Array} [holders] The `partials` placeholder indexes.
       * @param {Array} [argPos] The argument positions of the new function.
       * @param {number} [ary] The arity cap of `func`.
       * @param {number} [arity] The arity of `func`.
       * @returns {Function} Returns the new wrapped function.
       */
      function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
        var isCurry = bitmask & WRAP_CURRY_FLAG,
          newHolders = isCurry ? holders : undefined$1,
          newHoldersRight = isCurry ? undefined$1 : holders,
          newPartials = isCurry ? partials : undefined$1,
          newPartialsRight = isCurry ? undefined$1 : partials;

        bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
        bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);

        if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
          bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
        }
        var newData = [
          func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
          newHoldersRight, argPos, ary, arity
        ];

        var result = wrapFunc.apply(undefined$1, newData);
        if (isLaziable(func)) {
          setData(result, newData);
        }
        result.placeholder = placeholder;
        return setWrapToString(result, func, bitmask);
      }

      /*
       * Creates a function like `_.round`.
       *
       * @private
       * @param {string} methodName The name of the `Math` method to use when rounding.
       * @returns {Function} Returns the new round function.
       */
      function createRound(methodName) {
        var func = Math[methodName];
        return function (number, precision) {
          number = toNumber(number);
          precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
          if (precision && nativeIsFinite(number)) {
            // Shift with exponential notation to avoid floating-point issues.
            // See [MDN](https://mdn.io/round#Examples) for more details.
            var pair = (toString(number) + 'e').split('e'),
              value = func(pair[0] + 'e' + (+pair[1] + precision));

            pair = (toString(value) + 'e').split('e');
            return +(pair[0] + 'e' + (+pair[1] - precision));
          }
          return func(number);
        };
      }

      /*
       * Creates a set object of `values`.
       *
       * @private
       * @param {Array} values The values to add to the set.
       * @returns {Object} Returns the new set.
       */
      var createSet = !(Set && (1 / setToArray(new Set([, -0]))[1]) == INFINITY) ? noop : function (values) {
        return new Set(values);
      };

      /*
       * Creates a `_.toPairs` or `_.toPairsIn` function.
       *
       * @private
       * @param {Function} keysFunc The function to get the keys of a given object.
       * @returns {Function} Returns the new pairs function.
       */
      function createToPairs(keysFunc) {
        return function (object) {
          var tag = getTag(object);
          if (tag == mapTag) {
            return mapToArray(object);
          }
          if (tag == setTag) {
            return setToPairs(object);
          }
          return baseToPairs(object, keysFunc(object));
        };
      }

      /*
       * Creates a function that either curries or invokes `func` with optional
       * `this` binding and partially applied arguments.
       *
       * @private
       * @param {Function|string} func The function or method name to wrap.
       * @param {number} bitmask The bitmask flags.
       *    1 - `_.bind`
       *    2 - `_.bindKey`
       *    4 - `_.curry` or `_.curryRight` of a bound function
       *    8 - `_.curry`
       *   16 - `_.curryRight`
       *   32 - `_.partial`
       *   64 - `_.partialRight`
       *  128 - `_.rearg`
       *  256 - `_.ary`
       *  512 - `_.flip`
       * @param {*} [thisArg] The `this` binding of `func`.
       * @param {Array} [partials] The arguments to be partially applied.
       * @param {Array} [holders] The `partials` placeholder indexes.
       * @param {Array} [argPos] The argument positions of the new function.
       * @param {number} [ary] The arity cap of `func`.
       * @param {number} [arity] The arity of `func`.
       * @returns {Function} Returns the new wrapped function.
       */
      function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
        var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
        if (!isBindKey && typeof func != 'function') {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        var length = partials ? partials.length : 0;
        if (!length) {
          bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
          partials = holders = undefined$1;
        }
        ary = ary === undefined$1 ? ary : nativeMax(toInteger(ary), 0);
        arity = arity === undefined$1 ? arity : toInteger(arity);
        length -= holders ? holders.length : 0;

        if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
          var partialsRight = partials,
            holdersRight = holders;

          partials = holders = undefined$1;
        }
        var data = isBindKey ? undefined$1 : getData(func);

        var newData = [
          func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
          argPos, ary, arity
        ];

        if (data) {
          mergeData(newData, data);
        }
        func = newData[0];
        bitmask = newData[1];
        thisArg = newData[2];
        partials = newData[3];
        holders = newData[4];
        arity = newData[9] = newData[9] === undefined$1
          ? (isBindKey ? 0 : func.length)
          : nativeMax(newData[9] - length, 0);

        if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
          bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
        }
        if (!bitmask || bitmask == WRAP_BIND_FLAG) {
          var result = createBind(func, bitmask, thisArg);
        } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
          result = createCurry(func, bitmask, arity);
        } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
          result = createPartial(func, bitmask, thisArg, partials);
        } else {
          result = createHybrid.apply(undefined$1, newData);
        }
        var setter = data ? baseSetData : setData;
        return setWrapToString(setter(result, newData), func, bitmask);
      }

      /*
       * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
       * of source objects to the destination object for all destination properties
       * that resolve to `undefined`.
       *
       * @private
       * @param {*} objValue The destination value.
       * @param {*} srcValue The source value.
       * @param {string} key The key of the property to assign.
       * @param {Object} object The parent object of `objValue`.
       * @returns {*} Returns the value to assign.
       */
      function customDefaultsAssignIn(objValue, srcValue, key, object) {
        if (objValue === undefined$1 ||
          (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
          return srcValue;
        }
        return objValue;
      }

      /*
       * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
       * objects into destination objects that are passed thru.
       *
       * @private
       * @param {*} objValue The destination value.
       * @param {*} srcValue The source value.
       * @param {string} key The key of the property to merge.
       * @param {Object} object The parent object of `objValue`.
       * @param {Object} source The parent object of `srcValue`.
       * @param {Object} [stack] Tracks traversed source values and their merged
       *  counterparts.
       * @returns {*} Returns the value to assign.
       */
      function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
        if (isObject(objValue) && isObject(srcValue)) {
          // Recursively merge objects and arrays (susceptible to call stack limits).
          stack.set(srcValue, objValue);
          baseMerge(objValue, srcValue, undefined$1, customDefaultsMerge, stack);
          stack['delete'](srcValue);
        }
        return objValue;
      }

      /*
       * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
       * objects.
       *
       * @private
       * @param {*} value The value to inspect.
       * @param {string} key The key of the property to inspect.
       * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
       */
      function customOmitClone(value) {
        return isPlainObject(value) ? undefined$1 : value;
      }

      /*
       * A specialized version of `baseIsEqualDeep` for arrays with support for
       * partial deep comparisons.
       *
       * @private
       * @param {Array} array The array to compare.
       * @param {Array} other The other array to compare.
       * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
       * @param {Function} customizer The function to customize comparisons.
       * @param {Function} equalFunc The function to determine equivalents of values.
       * @param {Object} stack Tracks traversed `array` and `other` objects.
       * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
       */
      function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
        var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
          arrLength = array.length,
          othLength = other.length;

        if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
          return false;
        }
        // Check that cyclic values are equal.
        var arrStacked = stack.get(array);
        var othStacked = stack.get(other);
        if (arrStacked && othStacked) {
          return arrStacked == other && othStacked == array;
        }
        var index = -1,
          result = true,
          seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined$1;

        stack.set(array, other);
        stack.set(other, array);

        // Ignore non-index properties.
        while (++index < arrLength) {
          var arrValue = array[index],
            othValue = other[index];

          if (customizer) {
            var compared = isPartial
              ? customizer(othValue, arrValue, index, other, array, stack)
              : customizer(arrValue, othValue, index, array, other, stack);
          }
          if (compared !== undefined$1) {
            if (compared) {
              continue;
            }
            result = false;
            break;
          }
          // Recursively compare arrays (susceptible to call stack limits).
          if (seen) {
            if (!arraySome(other, function (othValue, othIndex) {
              if (!cacheHas(seen, othIndex) &&
                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
                return seen.push(othIndex);
              }
            })) {
              result = false;
              break;
            }
          } else if (!(
            arrValue === othValue ||
            equalFunc(arrValue, othValue, bitmask, customizer, stack)
          )) {
            result = false;
            break;
          }
        }
        stack['delete'](array);
        stack['delete'](other);
        return result;
      }

      /*
       * A specialized version of `baseIsEqualDeep` for comparing objects of
       * the same `toStringTag`.
       *
       * **Note:** This function only supports comparing values with tags of
       * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
       *
       * @private
       * @param {Object} object The object to compare.
       * @param {Object} other The other object to compare.
       * @param {string} tag The `toStringTag` of the objects to compare.
       * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
       * @param {Function} customizer The function to customize comparisons.
       * @param {Function} equalFunc The function to determine equivalents of values.
       * @param {Object} stack Tracks traversed `object` and `other` objects.
       * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
       */
      function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
        switch (tag) {
          case dataViewTag:
            if ((object.byteLength != other.byteLength) ||
              (object.byteOffset != other.byteOffset)) {
              return false;
            }
            object = object.buffer;
            other = other.buffer;

          case arrayBufferTag:
            if ((object.byteLength != other.byteLength) ||
              !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
              return false;
            }
            return true;

          case boolTag:
          case dateTag:
          case numberTag:
            // Coerce booleans to `1` or `0` and dates to milliseconds.
            // Invalid dates are coerced to `NaN`.
            return eq(+object, +other);

          case errorTag:
            return object.name == other.name && object.message == other.message;

          case regexpTag:
          case stringTag:
            // Coerce regexes to strings and treat strings, primitives and objects,
            // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
            // for more details.
            return object == (other + '');

          case mapTag:
            var convert = mapToArray;

          case setTag:
            var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
            convert || (convert = setToArray);

            if (object.size != other.size && !isPartial) {
              return false;
            }
            // Assume cyclic values are equal.
            var stacked = stack.get(object);
            if (stacked) {
              return stacked == other;
            }
            bitmask |= COMPARE_UNORDERED_FLAG;

            // Recursively compare objects (susceptible to call stack limits).
            stack.set(object, other);
            var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
            stack['delete'](object);
            return result;

          case symbolTag:
            if (symbolValueOf) {
              return symbolValueOf.call(object) == symbolValueOf.call(other);
            }
        }
        return false;
      }

      /*
       * A specialized version of `baseIsEqualDeep` for objects with support for
       * partial deep comparisons.
       *
       * @private
       * @param {Object} object The object to compare.
       * @param {Object} other The other object to compare.
       * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
       * @param {Function} customizer The function to customize comparisons.
       * @param {Function} equalFunc The function to determine equivalents of values.
       * @param {Object} stack Tracks traversed `object` and `other` objects.
       * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
       */
      function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
        var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
          objProps = getAllKeys(object),
          objLength = objProps.length,
          othProps = getAllKeys(other),
          othLength = othProps.length;

        if (objLength != othLength && !isPartial) {
          return false;
        }
        var index = objLength;
        while (index--) {
          var key = objProps[index];
          if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
            return false;
          }
        }
        // Check that cyclic values are equal.
        var objStacked = stack.get(object);
        var othStacked = stack.get(other);
        if (objStacked && othStacked) {
          return objStacked == other && othStacked == object;
        }
        var result = true;
        stack.set(object, other);
        stack.set(other, object);

        var skipCtor = isPartial;
        while (++index < objLength) {
          key = objProps[index];
          var objValue = object[key],
            othValue = other[key];

          if (customizer) {
            var compared = isPartial
              ? customizer(othValue, objValue, key, other, object, stack)
              : customizer(objValue, othValue, key, object, other, stack);
          }
          // Recursively compare objects (susceptible to call stack limits).
          if (!(compared === undefined$1
            ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
            : compared
          )) {
            result = false;
            break;
          }
          skipCtor || (skipCtor = key == 'constructor');
        }
        if (result && !skipCtor) {
          var objCtor = object.constructor,
            othCtor = other.constructor;

          // Non `Object` object instances with different constructors are not equal.
          if (objCtor != othCtor &&
            ('constructor' in object && 'constructor' in other) &&
            !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
              typeof othCtor == 'function' && othCtor instanceof othCtor)) {
            result = false;
          }
        }
        stack['delete'](object);
        stack['delete'](other);
        return result;
      }

      /*
       * A specialized version of `baseRest` which flattens the rest array.
       *
       * @private
       * @param {Function} func The function to apply a rest parameter to.
       * @returns {Function} Returns the new function.
       */
      function flatRest(func) {
        return setToString(overRest(func, undefined$1, flatten), func + '');
      }

      /*
       * Creates an array of own enumerable property names and symbols of `object`.
       *
       * @private
       * @param {Object} object The object to query.
       * @returns {Array} Returns the array of property names and symbols.
       */
      function getAllKeys(object) {
        return baseGetAllKeys(object, keys, getSymbols);
      }

      /*
       * Creates an array of own and inherited enumerable property names and
       * symbols of `object`.
       *
       * @private
       * @param {Object} object The object to query.
       * @returns {Array} Returns the array of property names and symbols.
       */
      function getAllKeysIn(object) {
        return baseGetAllKeys(object, keysIn, getSymbolsIn);
      }

      /*
       * Gets metadata for `func`.
       *
       * @private
       * @param {Function} func The function to query.
       * @returns {*} Returns the metadata for `func`.
       */
      var getData = !metaMap ? noop : function (func) {
        return metaMap.get(func);
      };

      /*
       * Gets the name of `func`.
       *
       * @private
       * @param {Function} func The function to query.
       * @returns {string} Returns the function name.
       */
      function getFuncName(func) {
        var result = (func.name + ''),
          array = realNames[result],
          length = hasOwnProperty.call(realNames, result) ? array.length : 0;

        while (length--) {
          var data = array[length],
            otherFunc = data.func;
          if (otherFunc == null || otherFunc == func) {
            return data.name;
          }
        }
        return result;
      }

      /*
       * Gets the argument placeholder value for `func`.
       *
       * @private
       * @param {Function} func The function to inspect.
       * @returns {*} Returns the placeholder value.
       */
      function getHolder(func) {
        var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;
        return object.placeholder;
      }

      /*
       * Gets the appropriate "iteratee" function. If `_.iteratee` is customized,
       * this function returns the custom method, otherwise it returns `baseIteratee`.
       * If arguments are provided, the chosen function is invoked with them and
       * its result is returned.
       *
       * @private
       * @param {*} [value] The value to convert to an iteratee.
       * @param {number} [arity] The arity of the created iteratee.
       * @returns {Function} Returns the chosen function or its result.
       */
      function getIteratee() {
        var result = lodash.iteratee || iteratee;
        result = result === iteratee ? baseIteratee : result;
        return arguments.length ? result(arguments[0], arguments[1]) : result;
      }

      /*
       * Gets the data for `map`.
       *
       * @private
       * @param {Object} map The map to query.
       * @param {string} key The reference key.
       * @returns {*} Returns the map data.
       */
      function getMapData(map, key) {
        var data = map.__data__;
        return isKeyable(key)
          ? data[typeof key == 'string' ? 'string' : 'hash']
          : data.map;
      }

      /*
       * Gets the property names, values, and compare flags of `object`.
       *
       * @private
       * @param {Object} object The object to query.
       * @returns {Array} Returns the match data of `object`.
       */
      function getMatchData(object) {
        var result = keys(object),
          length = result.length;

        while (length--) {
          var key = result[length],
            value = object[key];

          result[length] = [key, value, isStrictComparable(value)];
        }
        return result;
      }

      /*
       * Gets the native function at `key` of `object`.
       *
       * @private
       * @param {Object} object The object to query.
       * @param {string} key The key of the method to get.
       * @returns {*} Returns the function if it's native, else `undefined`.
       */
      function getNative(object, key) {
        var value = getValue(object, key);
        return baseIsNative(value) ? value : undefined$1;
      }

      /*
       * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
       *
       * @private
       * @param {*} value The value to query.
       * @returns {string} Returns the raw `toStringTag`.
       */
      function getRawTag(value) {
        var isOwn = hasOwnProperty.call(value, symToStringTag),
          tag = value[symToStringTag];

        try {
          value[symToStringTag] = undefined$1;
          var unmasked = true;
        } catch (e) { }

        var result = nativeObjectToString.call(value);
        if (unmasked) {
          if (isOwn) {
            value[symToStringTag] = tag;
          } else {
            delete value[symToStringTag];
          }
        }
        return result;
      }

      /*
       * Creates an array of the own enumerable symbols of `object`.
       *
       * @private
       * @param {Object} object The object to query.
       * @returns {Array} Returns the array of symbols.
       */
      var getSymbols = !nativeGetSymbols ? stubArray : function (object) {
        if (object == null) {
          return [];
        }
        object = Object(object);
        return arrayFilter(nativeGetSymbols(object), function (symbol) {
          return propertyIsEnumerable.call(object, symbol);
        });
      };

      /*
       * Creates an array of the own and inherited enumerable symbols of `object`.
       *
       * @private
       * @param {Object} object The object to query.
       * @returns {Array} Returns the array of symbols.
       */
      var getSymbolsIn = !nativeGetSymbols ? stubArray : function (object) {
        var result = [];
        while (object) {
          arrayPush(result, getSymbols(object));
          object = getPrototype(object);
        }
        return result;
      };

      /*
       * Gets the `toStringTag` of `value`.
       *
       * @private
       * @param {*} value The value to query.
       * @returns {string} Returns the `toStringTag`.
       */
      var getTag = baseGetTag;

      // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
      if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
        (Map && getTag(new Map) != mapTag) ||
        (Promise && getTag(Promise.resolve()) != promiseTag) ||
        (Set && getTag(new Set) != setTag) ||
        (WeakMap && getTag(new WeakMap) != weakMapTag)) {
        getTag = function (value) {
          var result = baseGetTag(value),
            Ctor = result == objectTag ? value.constructor : undefined$1,
            ctorString = Ctor ? toSource(Ctor) : '';

          if (ctorString) {
            switch (ctorString) {
              case dataViewCtorString: return dataViewTag;
              case mapCtorString: return mapTag;
              case promiseCtorString: return promiseTag;
              case setCtorString: return setTag;
              case weakMapCtorString: return weakMapTag;
            }
          }
          return result;
        };
      }

      /*
       * Gets the view, applying any `transforms` to the `start` and `end` positions.
       *
       * @private
       * @param {number} start The start of the view.
       * @param {number} end The end of the view.
       * @param {Array} transforms The transformations to apply to the view.
       * @returns {Object} Returns an object containing the `start` and `end`
       *  positions of the view.
       */
      function getView(start, end, transforms) {
        var index = -1,
          length = transforms.length;

        while (++index < length) {
          var data = transforms[index],
            size = data.size;

          switch (data.type) {
            case 'drop': start += size; break;
            case 'dropRight': end -= size; break;
            case 'take': end = nativeMin(end, start + size); break;
            case 'takeRight': start = nativeMax(start, end - size); break;
          }
        }
        return { 'start': start, 'end': end };
      }

      /*
       * Extracts wrapper details from the `source` body comment.
       *
       * @private
       * @param {string} source The source to inspect.
       * @returns {Array} Returns the wrapper details.
       */
      function getWrapDetails(source) {
        var match = source.match(reWrapDetails);
        return match ? match[1].split(reSplitDetails) : [];
      }

      /*
       * Checks if `path` exists on `object`.
       *
       * @private
       * @param {Object} object The object to query.
       * @param {Array|string} path The path to check.
       * @param {Function} hasFunc The function to check properties.
       * @returns {boolean} Returns `true` if `path` exists, else `false`.
       */
      function hasPath(object, path, hasFunc) {
        path = castPath(path, object);

        var index = -1,
          length = path.length,
          result = false;

        while (++index < length) {
          var key = toKey(path[index]);
          if (!(result = object != null && hasFunc(object, key))) {
            break;
          }
          object = object[key];
        }
        if (result || ++index != length) {
          return result;
        }
        length = object == null ? 0 : object.length;
        return !!length && isLength(length) && isIndex(key, length) &&
          (isArray(object) || isArguments(object));
      }

      /*
       * Initializes an array clone.
       *
       * @private
       * @param {Array} array The array to clone.
       * @returns {Array} Returns the initialized clone.
       */
      function initCloneArray(array) {
        var length = array.length,
          result = new array.constructor(length);

        // Add properties assigned by `RegExp#exec`.
        if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
          result.index = array.index;
          result.input = array.input;
        }
        return result;
      }

      /*
       * Initializes an object clone.
       *
       * @private
       * @param {Object} object The object to clone.
       * @returns {Object} Returns the initialized clone.
       */
      function initCloneObject(object) {
        return (typeof object.constructor == 'function' && !isPrototype(object))
          ? baseCreate(getPrototype(object))
          : {};
      }

      /*
       * Initializes an object clone based on its `toStringTag`.
       *
       * **Note:** This function only supports cloning values with tags of
       * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
       *
       * @private
       * @param {Object} object The object to clone.
       * @param {string} tag The `toStringTag` of the object to clone.
       * @param {boolean} [isDeep] Specify a deep clone.
       * @returns {Object} Returns the initialized clone.
       */
      function initCloneByTag(object, tag, isDeep) {
        var Ctor = object.constructor;
        switch (tag) {
          case arrayBufferTag:
            return cloneArrayBuffer(object);

          case boolTag:
          case dateTag:
            return new Ctor(+object);

          case dataViewTag:
            return cloneDataView(object, isDeep);

          case float32Tag: case float64Tag:
          case int8Tag: case int16Tag: case int32Tag:
          case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
            return cloneTypedArray(object, isDeep);

          case mapTag:
            return new Ctor;

          case numberTag:
          case stringTag:
            return new Ctor(object);

          case regexpTag:
            return cloneRegExp(object);

          case setTag:
            return new Ctor;

          case symbolTag:
            return cloneSymbol(object);
        }
      }

      /*
       * Inserts wrapper `details` in a comment at the top of the `source` body.
       *
       * @private
       * @param {string} source The source to modify.
       * @returns {Array} details The details to insert.
       * @returns {string} Returns the modified source.
       */
      function insertWrapDetails(source, details) {
        var length = details.length;
        if (!length) {
          return source;
        }
        var lastIndex = length - 1;
        details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
        details = details.join(length > 2 ? ', ' : ' ');
        return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
      }

      /*
       * Checks if `value` is a flattenable `arguments` object or array.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
       */
      function isFlattenable(value) {
        return isArray(value) || isArguments(value) ||
          !!(spreadableSymbol && value && value[spreadableSymbol]);
      }

      /*
       * Checks if `value` is a valid array-like index.
       *
       * @private
       * @param {*} value The value to check.
       * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
       * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
       */
      function isIndex(value, length) {
        var type = typeof value;
        length = length == null ? MAX_SAFE_INTEGER : length;

        return !!length &&
          (type == 'number' ||
            (type != 'symbol' && reIsUint.test(value))) &&
          (value > -1 && value % 1 == 0 && value < length);
      }

      /*
       * Checks if the given arguments are from an iteratee call.
       *
       * @private
       * @param {*} value The potential iteratee value argument.
       * @param {*} index The potential iteratee index or key argument.
       * @param {*} object The potential iteratee object argument.
       * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
       *  else `false`.
       */
      function isIterateeCall(value, index, object) {
        if (!isObject(object)) {
          return false;
        }
        var type = typeof index;
        if (type == 'number'
          ? (isArrayLike(object) && isIndex(index, object.length))
          : (type == 'string' && index in object)
        ) {
          return eq(object[index], value);
        }
        return false;
      }

      /*
       * Checks if `value` is a property name and not a property path.
       *
       * @private
       * @param {*} value The value to check.
       * @param {Object} [object] The object to query keys on.
       * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
       */
      function isKey(value, object) {
        if (isArray(value)) {
          return false;
        }
        var type = typeof value;
        if (type == 'number' || type == 'symbol' || type == 'boolean' ||
          value == null || isSymbol(value)) {
          return true;
        }
        return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
          (object != null && value in Object(object));
      }

      /*
       * Checks if `value` is suitable for use as unique object key.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
       */
      function isKeyable(value) {
        var type = typeof value;
        return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
          ? (value !== '__proto__')
          : (value === null);
      }

      /*
       * Checks if `func` has a lazy counterpart.
       *
       * @private
       * @param {Function} func The function to check.
       * @returns {boolean} Returns `true` if `func` has a lazy counterpart,
       *  else `false`.
       */
      function isLaziable(func) {
        var funcName = getFuncName(func),
          other = lodash[funcName];

        if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {
          return false;
        }
        if (func === other) {
          return true;
        }
        var data = getData(other);
        return !!data && func === data[0];
      }

      /*
       * Checks if `func` has its source masked.
       *
       * @private
       * @param {Function} func The function to check.
       * @returns {boolean} Returns `true` if `func` is masked, else `false`.
       */
      function isMasked(func) {
        return !!maskSrcKey && (maskSrcKey in func);
      }

      /*
       * Checks if `func` is capable of being masked.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `func` is maskable, else `false`.
       */
      var isMaskable = coreJsData ? isFunction : stubFalse;

      /*
       * Checks if `value` is likely a prototype object.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
       */
      function isPrototype(value) {
        var Ctor = value && value.constructor,
          proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;

        return value === proto;
      }

      /*
       * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` if suitable for strict
       *  equality comparisons, else `false`.
       */
      function isStrictComparable(value) {
        return value === value && !isObject(value);
      }

      /*
       * A specialized version of `matchesProperty` for source values suitable
       * for strict equality comparisons, i.e. `===`.
       *
       * @private
       * @param {string} key The key of the property to get.
       * @param {*} srcValue The value to match.
       * @returns {Function} Returns the new spec function.
       */
      function matchesStrictComparable(key, srcValue) {
        return function (object) {
          if (object == null) {
            return false;
          }
          return object[key] === srcValue &&
            (srcValue !== undefined$1 || (key in Object(object)));
        };
      }

      /*
       * A specialized version of `_.memoize` which clears the memoized function's
       * cache when it exceeds `MAX_MEMOIZE_SIZE`.
       *
       * @private
       * @param {Function} func The function to have its output memoized.
       * @returns {Function} Returns the new memoized function.
       */
      function memoizeCapped(func) {
        var result = memoize(func, function (key) {
          if (cache.size === MAX_MEMOIZE_SIZE) {
            cache.clear();
          }
          return key;
        });

        var cache = result.cache;
        return result;
      }

      /*
       * Merges the function metadata of `source` into `data`.
       *
       * Merging metadata reduces the number of wrappers used to invoke a function.
       * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
       * may be applied regardless of execution order. Methods like `_.ary` and
       * `_.rearg` modify function arguments, making the order in which they are
       * executed important, preventing the merging of metadata. However, we make
       * an exception for a safe combined case where curried functions have `_.ary`
       * and or `_.rearg` applied.
       *
       * @private
       * @param {Array} data The destination metadata.
       * @param {Array} source The source metadata.
       * @returns {Array} Returns `data`.
       */
      function mergeData(data, source) {
        var bitmask = data[1],
          srcBitmask = source[1],
          newBitmask = bitmask | srcBitmask,
          isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);

        var isCombo =
          ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
          ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
          ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));

        // Exit early if metadata can't be merged.
        if (!(isCommon || isCombo)) {
          return data;
        }
        // Use source `thisArg` if available.
        if (srcBitmask & WRAP_BIND_FLAG) {
          data[2] = source[2];
          // Set when currying a bound function.
          newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
        }
        // Compose partial arguments.
        var value = source[3];
        if (value) {
          var partials = data[3];
          data[3] = partials ? composeArgs(partials, value, source[4]) : value;
          data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
        }
        // Compose partial right arguments.
        value = source[5];
        if (value) {
          partials = data[5];
          data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
          data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
        }
        // Use source `argPos` if available.
        value = source[7];
        if (value) {
          data[7] = value;
        }
        // Use source `ary` if it's smaller.
        if (srcBitmask & WRAP_ARY_FLAG) {
          data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
        }
        // Use source `arity` if one is not provided.
        if (data[9] == null) {
          data[9] = source[9];
        }
        // Use source `func` and merge bitmasks.
        data[0] = source[0];
        data[1] = newBitmask;

        return data;
      }

      /*
       * This function is like
       * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
       * except that it includes inherited enumerable properties.
       *
       * @private
       * @param {Object} object The object to query.
       * @returns {Array} Returns the array of property names.
       */
      function nativeKeysIn(object) {
        var result = [];
        if (object != null) {
          for (var key in Object(object)) {
            result.push(key);
          }
        }
        return result;
      }

      /*
       * Converts `value` to a string using `Object.prototype.toString`.
       *
       * @private
       * @param {*} value The value to convert.
       * @returns {string} Returns the converted string.
       */
      function objectToString(value) {
        return nativeObjectToString.call(value);
      }

      /*
       * A specialized version of `baseRest` which transforms the rest array.
       *
       * @private
       * @param {Function} func The function to apply a rest parameter to.
       * @param {number} [start=func.length-1] The start position of the rest parameter.
       * @param {Function} transform The rest array transform.
       * @returns {Function} Returns the new function.
       */
      function overRest(func, start, transform) {
        start = nativeMax(start === undefined$1 ? (func.length - 1) : start, 0);
        return function () {
          var args = arguments,
            index = -1,
            length = nativeMax(args.length - start, 0),
            array = Array(length);

          while (++index < length) {
            array[index] = args[start + index];
          }
          index = -1;
          var otherArgs = Array(start + 1);
          while (++index < start) {
            otherArgs[index] = args[index];
          }
          otherArgs[start] = transform(array);
          return apply(func, this, otherArgs);
        };
      }

      /*
       * Gets the parent value at `path` of `object`.
       *
       * @private
       * @param {Object} object The object to query.
       * @param {Array} path The path to get the parent value of.
       * @returns {*} Returns the parent value.
       */
      function parent(object, path) {
        return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
      }

      /*
       * Reorder `array` according to the specified indexes where the element at
       * the first index is assigned as the first element, the element at
       * the second index is assigned as the second element, and so on.
       *
       * @private
       * @param {Array} array The array to reorder.
       * @param {Array} indexes The arranged array indexes.
       * @returns {Array} Returns `array`.
       */
      function reorder(array, indexes) {
        var arrLength = array.length,
          length = nativeMin(indexes.length, arrLength),
          oldArray = copyArray(array);

        while (length--) {
          var index = indexes[length];
          array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined$1;
        }
        return array;
      }

      /*
       * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
       *
       * @private
       * @param {Object} object The object to query.
       * @param {string} key The key of the property to get.
       * @returns {*} Returns the property value.
       */
      function safeGet(object, key) {
        if (key === 'constructor' && typeof object[key] === 'function') {
          return;
        }

        if (key == '__proto__') {
          return;
        }

        return object[key];
      }

      /*
       * Sets metadata for `func`.
       *
       * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
       * period of time, it will trip its breaker and transition to an identity
       * function to avoid garbage collection pauses in V8. See
       * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
       * for more details.
       *
       * @private
       * @param {Function} func The function to associate metadata with.
       * @param {*} data The metadata.
       * @returns {Function} Returns `func`.
       */
      var setData = shortOut(baseSetData);

      /*
       * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).
       *
       * @private
       * @param {Function} func The function to delay.
       * @param {number} wait The number of milliseconds to delay invocation.
       * @returns {number|Object} Returns the timer id or timeout object.
       */
      var setTimeout = ctxSetTimeout || function (func, wait) {
        return root.setTimeout(func, wait);
      };

      /*
       * Sets the `toString` method of `func` to return `string`.
       *
       * @private
       * @param {Function} func The function to modify.
       * @param {Function} string The `toString` result.
       * @returns {Function} Returns `func`.
       */
      var setToString = shortOut(baseSetToString);

      /*
       * Sets the `toString` method of `wrapper` to mimic the source of `reference`
       * with wrapper details in a comment at the top of the source body.
       *
       * @private
       * @param {Function} wrapper The function to modify.
       * @param {Function} reference The reference function.
       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
       * @returns {Function} Returns `wrapper`.
       */
      function setWrapToString(wrapper, reference, bitmask) {
        var source = (reference + '');
        return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
      }

      /*
       * Creates a function that'll short out and invoke `identity` instead
       * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
       * milliseconds.
       *
       * @private
       * @param {Function} func The function to restrict.
       * @returns {Function} Returns the new shortable function.
       */
      function shortOut(func) {
        var count = 0,
          lastCalled = 0;

        return function () {
          var stamp = nativeNow(),
            remaining = HOT_SPAN - (stamp - lastCalled);

          lastCalled = stamp;
          if (remaining > 0) {
            if (++count >= HOT_COUNT) {
              return arguments[0];
            }
          } else {
            count = 0;
          }
          return func.apply(undefined$1, arguments);
        };
      }

      /*
       * A specialized version of `_.shuffle` which mutates and sets the size of `array`.
       *
       * @private
       * @param {Array} array The array to shuffle.
       * @param {number} [size=array.length] The size of `array`.
       * @returns {Array} Returns `array`.
       */
      function shuffleSelf(array, size) {
        var index = -1,
          length = array.length,
          lastIndex = length - 1;

        size = size === undefined$1 ? length : size;
        while (++index < size) {
          var rand = baseRandom(index, lastIndex),
            value = array[rand];

          array[rand] = array[index];
          array[index] = value;
        }
        array.length = size;
        return array;
      }

      /*
       * Converts `string` to a property path array.
       *
       * @private
       * @param {string} string The string to convert.
       * @returns {Array} Returns the property path array.
       */
      var stringToPath = memoizeCapped(function (string) {
        var result = [];
        if (string.charCodeAt(0) === 46 /* . */) {
          result.push('');
        }
        string.replace(rePropName, function (match, number, quote, subString) {
          result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
        });
        return result;
      });

      /*
       * Converts `value` to a string key if it's not a string or symbol.
       *
       * @private
       * @param {*} value The value to inspect.
       * @returns {string|symbol} Returns the key.
       */
      function toKey(value) {
        if (typeof value == 'string' || isSymbol(value)) {
          return value;
        }
        var result = (value + '');
        return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
      }

      /*
       * Converts `func` to its source code.
       *
       * @private
       * @param {Function} func The function to convert.
       * @returns {string} Returns the source code.
       */
      function toSource(func) {
        if (func != null) {
          try {
            return funcToString.call(func);
          } catch (e) { }
          try {
            return (func + '');
          } catch (e) { }
        }
        return '';
      }

      /*
       * Updates wrapper `details` based on `bitmask` flags.
       *
       * @private
       * @returns {Array} details The details to modify.
       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
       * @returns {Array} Returns `details`.
       */
      function updateWrapDetails(details, bitmask) {
        arrayEach(wrapFlags, function (pair) {
          var value = '_.' + pair[0];
          if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
            details.push(value);
          }
        });
        return details.sort();
      }

      /*
       * Creates a clone of `wrapper`.
       *
       * @private
       * @param {Object} wrapper The wrapper to clone.
       * @returns {Object} Returns the cloned wrapper.
       */
      function wrapperClone(wrapper) {
        if (wrapper instanceof LazyWrapper) {
          return wrapper.clone();
        }
        var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
        result.__actions__ = copyArray(wrapper.__actions__);
        result.__index__ = wrapper.__index__;
        result.__values__ = wrapper.__values__;
        return result;
      }

      /*------------------------------------------------------------------------*/

      /*
       * Creates an array of elements split into groups the length of `size`.
       * If `array` can't be split evenly, the final chunk will be the remaining
       * elements.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Array
       * @param {Array} array The array to process.
       * @param {number} [size=1] The length of each chunk
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {Array} Returns the new array of chunks.
       * @example
       *
       * _.chunk(['a', 'b', 'c', 'd'], 2);
       * // => [['a', 'b'], ['c', 'd']]
       *
       * _.chunk(['a', 'b', 'c', 'd'], 3);
       * // => [['a', 'b', 'c'], ['d']]
       */
      function chunk(array, size, guard) {
        if ((guard ? isIterateeCall(array, size, guard) : size === undefined$1)) {
          size = 1;
        } else {
          size = nativeMax(toInteger(size), 0);
        }
        var length = array == null ? 0 : array.length;
        if (!length || size < 1) {
          return [];
        }
        var index = 0,
          resIndex = 0,
          result = Array(nativeCeil(length / size));

        while (index < length) {
          result[resIndex++] = baseSlice(array, index, (index += size));
        }
        return result;
      }

      /*
       * Creates an array with all falsey values removed. The values `false`, `null`,
       * `0`, `""`, `undefined`, and `NaN` are falsey.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {Array} array The array to compact.
       * @returns {Array} Returns the new array of filtered values.
       * @example
       *
       * _.compact([0, 1, false, 2, '', 3]);
       * // => [1, 2, 3]
       */
      function compact(array) {
        var index = -1,
          length = array == null ? 0 : array.length,
          resIndex = 0,
          result = [];

        while (++index < length) {
          var value = array[index];
          if (value) {
            result[resIndex++] = value;
          }
        }
        return result;
      }

      /*
       * Creates a new array concatenating `array` with any additional arrays
       * and/or values.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to concatenate.
       * @param {...*} [values] The values to concatenate.
       * @returns {Array} Returns the new concatenated array.
       * @example
       *
       * var array = [1];
       * var other = _.concat(array, 2, [3], [[4]]);
       *
       * console.log(other);
       * // => [1, 2, 3, [4]]
       *
       * console.log(array);
       * // => [1]
       */
      function concat() {
        var length = arguments.length;
        if (!length) {
          return [];
        }
        var args = Array(length - 1),
          array = arguments[0],
          index = length;

        while (index--) {
          args[index - 1] = arguments[index];
        }
        return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
      }

      /*
       * Creates an array of `array` values not included in the other given arrays
       * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
       * for equality comparisons. The order and references of result values are
       * determined by the first array.
       *
       * **Note:** Unlike `_.pullAll`, this method returns a new array.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {...Array} [values] The values to exclude.
       * @returns {Array} Returns the new array of filtered values.
       * @see _.without, _.xor
       * @example
       *
       * _.difference([2, 1], [2, 3]);
       * // => [1]
       */
      var difference = baseRest(function (array, values) {
        return isArrayLikeObject(array)
          ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
          : [];
      });

      /*
       * This method is like `_.difference` except that it accepts `iteratee` which
       * is invoked for each element of `array` and `values` to generate the criterion
       * by which they're compared. The order and references of result values are
       * determined by the first array. The iteratee is invoked with one argument:
       * (value).
       *
       * **Note:** Unlike `_.pullAllBy`, this method returns a new array.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {...Array} [values] The values to exclude.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {Array} Returns the new array of filtered values.
       * @example
       *
       * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
       * // => [1.2]
       *
       * // The `_.property` iteratee shorthand.
       * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
       * // => [{ 'x': 2 }]
       */
      var differenceBy = baseRest(function (array, values) {
        var iteratee = last(values);
        if (isArrayLikeObject(iteratee)) {
          iteratee = undefined$1;
        }
        return isArrayLikeObject(array)
          ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))
          : [];
      });

      /*
       * This method is like `_.difference` except that it accepts `comparator`
       * which is invoked to compare elements of `array` to `values`. The order and
       * references of result values are determined by the first array. The comparator
       * is invoked with two arguments: (arrVal, othVal).
       *
       * **Note:** Unlike `_.pullAllWith`, this method returns a new array.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {...Array} [values] The values to exclude.
       * @param {Function} [comparator] The comparator invoked per element.
       * @returns {Array} Returns the new array of filtered values.
       * @example
       *
       * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
       *
       * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
       * // => [{ 'x': 2, 'y': 1 }]
       */
      var differenceWith = baseRest(function (array, values) {
        var comparator = last(values);
        if (isArrayLikeObject(comparator)) {
          comparator = undefined$1;
        }
        return isArrayLikeObject(array)
          ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined$1, comparator)
          : [];
      });

      /*
       * Creates a slice of `array` with `n` elements dropped from the beginning.
       *
       * @static
       * @memberOf _
       * @since 0.5.0
       *  Array
       * @param {Array} array The array to query.
       * @param {number} [n=1] The number of elements to drop.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {Array} Returns the slice of `array`.
       * @example
       *
       * _.drop([1, 2, 3]);
       * // => [2, 3]
       *
       * _.drop([1, 2, 3], 2);
       * // => [3]
       *
       * _.drop([1, 2, 3], 5);
       * // => []
       *
       * _.drop([1, 2, 3], 0);
       * // => [1, 2, 3]
       */
      function drop(array, n, guard) {
        var length = array == null ? 0 : array.length;
        if (!length) {
          return [];
        }
        n = (guard || n === undefined$1) ? 1 : toInteger(n);
        return baseSlice(array, n < 0 ? 0 : n, length);
      }

      /*
       * Creates a slice of `array` with `n` elements dropped from the end.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Array
       * @param {Array} array The array to query.
       * @param {number} [n=1] The number of elements to drop.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {Array} Returns the slice of `array`.
       * @example
       *
       * _.dropRight([1, 2, 3]);
       * // => [1, 2]
       *
       * _.dropRight([1, 2, 3], 2);
       * // => [1]
       *
       * _.dropRight([1, 2, 3], 5);
       * // => []
       *
       * _.dropRight([1, 2, 3], 0);
       * // => [1, 2, 3]
       */
      function dropRight(array, n, guard) {
        var length = array == null ? 0 : array.length;
        if (!length) {
          return [];
        }
        n = (guard || n === undefined$1) ? 1 : toInteger(n);
        n = length - n;
        return baseSlice(array, 0, n < 0 ? 0 : n);
      }

      /*
       * Creates a slice of `array` excluding elements dropped from the end.
       * Elements are dropped until `predicate` returns falsey. The predicate is
       * invoked with three arguments: (value, index, array).
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Array
       * @param {Array} array The array to query.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the slice of `array`.
       * @example
       *
       * var users = [
       *   { 'user': 'barney',  'active': true },
       *   { 'user': 'fred',    'active': false },
       *   { 'user': 'pebbles', 'active': false }
       * ];
       *
       * _.dropRightWhile(users, function(o) { return !o.active; });
       * // => objects for ['barney']
       *
       * // The `_.matches` iteratee shorthand.
       * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
       * // => objects for ['barney', 'fred']
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.dropRightWhile(users, ['active', false]);
       * // => objects for ['barney']
       *
       * // The `_.property` iteratee shorthand.
       * _.dropRightWhile(users, 'active');
       * // => objects for ['barney', 'fred', 'pebbles']
       */
      function dropRightWhile(array, predicate) {
        return (array && array.length)
          ? baseWhile(array, getIteratee(predicate, 3), true, true)
          : [];
      }

      /*
       * Creates a slice of `array` excluding elements dropped from the beginning.
       * Elements are dropped until `predicate` returns falsey. The predicate is
       * invoked with three arguments: (value, index, array).
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Array
       * @param {Array} array The array to query.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the slice of `array`.
       * @example
       *
       * var users = [
       *   { 'user': 'barney',  'active': false },
       *   { 'user': 'fred',    'active': false },
       *   { 'user': 'pebbles', 'active': true }
       * ];
       *
       * _.dropWhile(users, function(o) { return !o.active; });
       * // => objects for ['pebbles']
       *
       * // The `_.matches` iteratee shorthand.
       * _.dropWhile(users, { 'user': 'barney', 'active': false });
       * // => objects for ['fred', 'pebbles']
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.dropWhile(users, ['active', false]);
       * // => objects for ['pebbles']
       *
       * // The `_.property` iteratee shorthand.
       * _.dropWhile(users, 'active');
       * // => objects for ['barney', 'fred', 'pebbles']
       */
      function dropWhile(array, predicate) {
        return (array && array.length)
          ? baseWhile(array, getIteratee(predicate, 3), true)
          : [];
      }

      /*
       * Fills elements of `array` with `value` from `start` up to, but not
       * including, `end`.
       *
       * **Note:** This method mutates `array`.
       *
       * @static
       * @memberOf _
       * @since 3.2.0
       *  Array
       * @param {Array} array The array to fill.
       * @param {*} value The value to fill `array` with.
       * @param {number} [start=0] The start position.
       * @param {number} [end=array.length] The end position.
       * @returns {Array} Returns `array`.
       * @example
       *
       * var array = [1, 2, 3];
       *
       * _.fill(array, 'a');
       * console.log(array);
       * // => ['a', 'a', 'a']
       *
       * _.fill(Array(3), 2);
       * // => [2, 2, 2]
       *
       * _.fill([4, 6, 8, 10], '*', 1, 3);
       * // => [4, '*', '*', 10]
       */
      function fill(array, value, start, end) {
        var length = array == null ? 0 : array.length;
        if (!length) {
          return [];
        }
        if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
          start = 0;
          end = length;
        }
        return baseFill(array, value, start, end);
      }

      /*
       * This method is like `_.find` except that it returns the index of the first
       * element `predicate` returns truthy for instead of the element itself.
       *
       * @static
       * @memberOf _
       * @since 1.1.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @param {number} [fromIndex=0] The index to search from.
       * @returns {number} Returns the index of the found element, else `-1`.
       * @example
       *
       * var users = [
       *   { 'user': 'barney',  'active': false },
       *   { 'user': 'fred',    'active': false },
       *   { 'user': 'pebbles', 'active': true }
       * ];
       *
       * _.findIndex(users, function(o) { return o.user == 'barney'; });
       * // => 0
       *
       * // The `_.matches` iteratee shorthand.
       * _.findIndex(users, { 'user': 'fred', 'active': false });
       * // => 1
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.findIndex(users, ['active', false]);
       * // => 0
       *
       * // The `_.property` iteratee shorthand.
       * _.findIndex(users, 'active');
       * // => 2
       */
      function findIndex(array, predicate, fromIndex) {
        var length = array == null ? 0 : array.length;
        if (!length) {
          return -1;
        }
        var index = fromIndex == null ? 0 : toInteger(fromIndex);
        if (index < 0) {
          index = nativeMax(length + index, 0);
        }
        return baseFindIndex(array, getIteratee(predicate, 3), index);
      }

      /*
       * This method is like `_.findIndex` except that it iterates over elements
       * of `collection` from right to left.
       *
       * @static
       * @memberOf _
       * @since 2.0.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @param {number} [fromIndex=array.length-1] The index to search from.
       * @returns {number} Returns the index of the found element, else `-1`.
       * @example
       *
       * var users = [
       *   { 'user': 'barney',  'active': true },
       *   { 'user': 'fred',    'active': false },
       *   { 'user': 'pebbles', 'active': false }
       * ];
       *
       * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
       * // => 2
       *
       * // The `_.matches` iteratee shorthand.
       * _.findLastIndex(users, { 'user': 'barney', 'active': true });
       * // => 0
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.findLastIndex(users, ['active', false]);
       * // => 2
       *
       * // The `_.property` iteratee shorthand.
       * _.findLastIndex(users, 'active');
       * // => 0
       */
      function findLastIndex(array, predicate, fromIndex) {
        var length = array == null ? 0 : array.length;
        if (!length) {
          return -1;
        }
        var index = length - 1;
        if (fromIndex !== undefined$1) {
          index = toInteger(fromIndex);
          index = fromIndex < 0
            ? nativeMax(length + index, 0)
            : nativeMin(index, length - 1);
        }
        return baseFindIndex(array, getIteratee(predicate, 3), index, true);
      }

      /*
       * Flattens `array` a single level deep.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {Array} array The array to flatten.
       * @returns {Array} Returns the new flattened array.
       * @example
       *
       * _.flatten([1, [2, [3, [4]], 5]]);
       * // => [1, 2, [3, [4]], 5]
       */
      function flatten(array) {
        var length = array == null ? 0 : array.length;
        return length ? baseFlatten(array, 1) : [];
      }

      /*
       * Recursively flattens `array`.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Array
       * @param {Array} array The array to flatten.
       * @returns {Array} Returns the new flattened array.
       * @example
       *
       * _.flattenDeep([1, [2, [3, [4]], 5]]);
       * // => [1, 2, 3, 4, 5]
       */
      function flattenDeep(array) {
        var length = array == null ? 0 : array.length;
        return length ? baseFlatten(array, INFINITY) : [];
      }

      /*
       * Recursively flatten `array` up to `depth` times.
       *
       * @static
       * @memberOf _
       * @since 4.4.0
       *  Array
       * @param {Array} array The array to flatten.
       * @param {number} [depth=1] The maximum recursion depth.
       * @returns {Array} Returns the new flattened array.
       * @example
       *
       * var array = [1, [2, [3, [4]], 5]];
       *
       * _.flattenDepth(array, 1);
       * // => [1, 2, [3, [4]], 5]
       *
       * _.flattenDepth(array, 2);
       * // => [1, 2, 3, [4], 5]
       */
      function flattenDepth(array, depth) {
        var length = array == null ? 0 : array.length;
        if (!length) {
          return [];
        }
        depth = depth === undefined$1 ? 1 : toInteger(depth);
        return baseFlatten(array, depth);
      }

      /*
       * The inverse of `_.toPairs`; this method returns an object composed
       * from key-value `pairs`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} pairs The key-value pairs.
       * @returns {Object} Returns the new object.
       * @example
       *
       * _.fromPairs([['a', 1], ['b', 2]]);
       * // => { 'a': 1, 'b': 2 }
       */
      function fromPairs(pairs) {
        var index = -1,
          length = pairs == null ? 0 : pairs.length,
          result = {};

        while (++index < length) {
          var pair = pairs[index];
          result[pair[0]] = pair[1];
        }
        return result;
      }

      /*
       * Gets the first element of `array`.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       * @alias first
       *  Array
       * @param {Array} array The array to query.
       * @returns {*} Returns the first element of `array`.
       * @example
       *
       * _.head([1, 2, 3]);
       * // => 1
       *
       * _.head([]);
       * // => undefined
       */
      function head(array) {
        return (array && array.length) ? array[0] : undefined$1;
      }

      /*
       * Gets the index at which the first occurrence of `value` is found in `array`
       * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
       * for equality comparisons. If `fromIndex` is negative, it's used as the
       * offset from the end of `array`.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {*} value The value to search for.
       * @param {number} [fromIndex=0] The index to search from.
       * @returns {number} Returns the index of the matched value, else `-1`.
       * @example
       *
       * _.indexOf([1, 2, 1, 2], 2);
       * // => 1
       *
       * // Search from the `fromIndex`.
       * _.indexOf([1, 2, 1, 2], 2, 2);
       * // => 3
       */
      function indexOf(array, value, fromIndex) {
        var length = array == null ? 0 : array.length;
        if (!length) {
          return -1;
        }
        var index = fromIndex == null ? 0 : toInteger(fromIndex);
        if (index < 0) {
          index = nativeMax(length + index, 0);
        }
        return baseIndexOf(array, value, index);
      }

      /*
       * Gets all but the last element of `array`.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {Array} array The array to query.
       * @returns {Array} Returns the slice of `array`.
       * @example
       *
       * _.initial([1, 2, 3]);
       * // => [1, 2]
       */
      function initial(array) {
        var length = array == null ? 0 : array.length;
        return length ? baseSlice(array, 0, -1) : [];
      }

      /*
       * Creates an array of unique values that are included in all given arrays
       * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
       * for equality comparisons. The order and references of result values are
       * determined by the first array.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {...Array} [arrays] The arrays to inspect.
       * @returns {Array} Returns the new array of intersecting values.
       * @example
       *
       * _.intersection([2, 1], [2, 3]);
       * // => [2]
       */
      var intersection = baseRest(function (arrays) {
        var mapped = arrayMap(arrays, castArrayLikeObject);
        return (mapped.length && mapped[0] === arrays[0])
          ? baseIntersection(mapped)
          : [];
      });

      /*
       * This method is like `_.intersection` except that it accepts `iteratee`
       * which is invoked for each element of each `arrays` to generate the criterion
       * by which they're compared. The order and references of result values are
       * determined by the first array. The iteratee is invoked with one argument:
       * (value).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {...Array} [arrays] The arrays to inspect.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {Array} Returns the new array of intersecting values.
       * @example
       *
       * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
       * // => [2.1]
       *
       * // The `_.property` iteratee shorthand.
       * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
       * // => [{ 'x': 1 }]
       */
      var intersectionBy = baseRest(function (arrays) {
        var iteratee = last(arrays),
          mapped = arrayMap(arrays, castArrayLikeObject);

        if (iteratee === last(mapped)) {
          iteratee = undefined$1;
        } else {
          mapped.pop();
        }
        return (mapped.length && mapped[0] === arrays[0])
          ? baseIntersection(mapped, getIteratee(iteratee, 2))
          : [];
      });

      /*
       * This method is like `_.intersection` except that it accepts `comparator`
       * which is invoked to compare elements of `arrays`. The order and references
       * of result values are determined by the first array. The comparator is
       * invoked with two arguments: (arrVal, othVal).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {...Array} [arrays] The arrays to inspect.
       * @param {Function} [comparator] The comparator invoked per element.
       * @returns {Array} Returns the new array of intersecting values.
       * @example
       *
       * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
       * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
       *
       * _.intersectionWith(objects, others, _.isEqual);
       * // => [{ 'x': 1, 'y': 2 }]
       */
      var intersectionWith = baseRest(function (arrays) {
        var comparator = last(arrays),
          mapped = arrayMap(arrays, castArrayLikeObject);

        comparator = typeof comparator == 'function' ? comparator : undefined$1;
        if (comparator) {
          mapped.pop();
        }
        return (mapped.length && mapped[0] === arrays[0])
          ? baseIntersection(mapped, undefined$1, comparator)
          : [];
      });

      /*
       * Converts all elements in `array` into a string separated by `separator`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to convert.
       * @param {string} [separator=','] The element separator.
       * @returns {string} Returns the joined string.
       * @example
       *
       * _.join(['a', 'b', 'c'], '~');
       * // => 'a~b~c'
       */
      function join(array, separator) {
        return array == null ? '' : nativeJoin.call(array, separator);
      }

      /*
       * Gets the last element of `array`.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {Array} array The array to query.
       * @returns {*} Returns the last element of `array`.
       * @example
       *
       * _.last([1, 2, 3]);
       * // => 3
       */
      function last(array) {
        var length = array == null ? 0 : array.length;
        return length ? array[length - 1] : undefined$1;
      }

      /*
       * This method is like `_.indexOf` except that it iterates over elements of
       * `array` from right to left.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {*} value The value to search for.
       * @param {number} [fromIndex=array.length-1] The index to search from.
       * @returns {number} Returns the index of the matched value, else `-1`.
       * @example
       *
       * _.lastIndexOf([1, 2, 1, 2], 2);
       * // => 3
       *
       * // Search from the `fromIndex`.
       * _.lastIndexOf([1, 2, 1, 2], 2, 2);
       * // => 1
       */
      function lastIndexOf(array, value, fromIndex) {
        var length = array == null ? 0 : array.length;
        if (!length) {
          return -1;
        }
        var index = length;
        if (fromIndex !== undefined$1) {
          index = toInteger(fromIndex);
          index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
        }
        return value === value
          ? strictLastIndexOf(array, value, index)
          : baseFindIndex(array, baseIsNaN, index, true);
      }

      /*
       * Gets the element at index `n` of `array`. If `n` is negative, the nth
       * element from the end is returned.
       *
       * @static
       * @memberOf _
       * @since 4.11.0
       *  Array
       * @param {Array} array The array to query.
       * @param {number} [n=0] The index of the element to return.
       * @returns {*} Returns the nth element of `array`.
       * @example
       *
       * var array = ['a', 'b', 'c', 'd'];
       *
       * _.nth(array, 1);
       * // => 'b'
       *
       * _.nth(array, -2);
       * // => 'c';
       */
      function nth(array, n) {
        return (array && array.length) ? baseNth(array, toInteger(n)) : undefined$1;
      }

      /*
       * Removes all given values from `array` using
       * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
       * for equality comparisons.
       *
       * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`
       * to remove elements from an array by predicate.
       *
       * @static
       * @memberOf _
       * @since 2.0.0
       *  Array
       * @param {Array} array The array to modify.
       * @param {...*} [values] The values to remove.
       * @returns {Array} Returns `array`.
       * @example
       *
       * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
       *
       * _.pull(array, 'a', 'c');
       * console.log(array);
       * // => ['b', 'b']
       */
      var pull = baseRest(pullAll);

      /*
       * This method is like `_.pull` except that it accepts an array of values to remove.
       *
       * **Note:** Unlike `_.difference`, this method mutates `array`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to modify.
       * @param {Array} values The values to remove.
       * @returns {Array} Returns `array`.
       * @example
       *
       * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
       *
       * _.pullAll(array, ['a', 'c']);
       * console.log(array);
       * // => ['b', 'b']
       */
      function pullAll(array, values) {
        return (array && array.length && values && values.length)
          ? basePullAll(array, values)
          : array;
      }

      /*
       * This method is like `_.pullAll` except that it accepts `iteratee` which is
       * invoked for each element of `array` and `values` to generate the criterion
       * by which they're compared. The iteratee is invoked with one argument: (value).
       *
       * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to modify.
       * @param {Array} values The values to remove.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {Array} Returns `array`.
       * @example
       *
       * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
       *
       * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
       * console.log(array);
       * // => [{ 'x': 2 }]
       */
      function pullAllBy(array, values, iteratee) {
        return (array && array.length && values && values.length)
          ? basePullAll(array, values, getIteratee(iteratee, 2))
          : array;
      }

      /*
       * This method is like `_.pullAll` except that it accepts `comparator` which
       * is invoked to compare elements of `array` to `values`. The comparator is
       * invoked with two arguments: (arrVal, othVal).
       *
       * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
       *
       * @static
       * @memberOf _
       * @since 4.6.0
       *  Array
       * @param {Array} array The array to modify.
       * @param {Array} values The values to remove.
       * @param {Function} [comparator] The comparator invoked per element.
       * @returns {Array} Returns `array`.
       * @example
       *
       * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
       *
       * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
       * console.log(array);
       * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
       */
      function pullAllWith(array, values, comparator) {
        return (array && array.length && values && values.length)
          ? basePullAll(array, values, undefined$1, comparator)
          : array;
      }

      /*
       * Removes elements from `array` corresponding to `indexes` and returns an
       * array of removed elements.
       *
       * **Note:** Unlike `_.at`, this method mutates `array`.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Array
       * @param {Array} array The array to modify.
       * @param {...(number|number[])} [indexes] The indexes of elements to remove.
       * @returns {Array} Returns the new array of removed elements.
       * @example
       *
       * var array = ['a', 'b', 'c', 'd'];
       * var pulled = _.pullAt(array, [1, 3]);
       *
       * console.log(array);
       * // => ['a', 'c']
       *
       * console.log(pulled);
       * // => ['b', 'd']
       */
      var pullAt = flatRest(function (array, indexes) {
        var length = array == null ? 0 : array.length,
          result = baseAt(array, indexes);

        basePullAt(array, arrayMap(indexes, function (index) {
          return isIndex(index, length) ? +index : index;
        }).sort(compareAscending));

        return result;
      });

      /*
       * Removes all elements from `array` that `predicate` returns truthy for
       * and returns an array of the removed elements. The predicate is invoked
       * with three arguments: (value, index, array).
       *
       * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
       * to pull elements from an array by value.
       *
       * @static
       * @memberOf _
       * @since 2.0.0
       *  Array
       * @param {Array} array The array to modify.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the new array of removed elements.
       * @example
       *
       * var array = [1, 2, 3, 4];
       * var evens = _.remove(array, function(n) {
       *   return n % 2 == 0;
       * });
       *
       * console.log(array);
       * // => [1, 3]
       *
       * console.log(evens);
       * // => [2, 4]
       */
      function remove(array, predicate) {
        var result = [];
        if (!(array && array.length)) {
          return result;
        }
        var index = -1,
          indexes = [],
          length = array.length;

        predicate = getIteratee(predicate, 3);
        while (++index < length) {
          var value = array[index];
          if (predicate(value, index, array)) {
            result.push(value);
            indexes.push(index);
          }
        }
        basePullAt(array, indexes);
        return result;
      }

      /*
       * Reverses `array` so that the first element becomes the last, the second
       * element becomes the second to last, and so on.
       *
       * **Note:** This method mutates `array` and is based on
       * [`Array#reverse`](https://mdn.io/Array/reverse).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to modify.
       * @returns {Array} Returns `array`.
       * @example
       *
       * var array = [1, 2, 3];
       *
       * _.reverse(array);
       * // => [3, 2, 1]
       *
       * console.log(array);
       * // => [3, 2, 1]
       */
      function reverse(array) {
        return array == null ? array : nativeReverse.call(array);
      }

      /*
       * Creates a slice of `array` from `start` up to, but not including, `end`.
       *
       * **Note:** This method is used instead of
       * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
       * returned.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Array
       * @param {Array} array The array to slice.
       * @param {number} [start=0] The start position.
       * @param {number} [end=array.length] The end position.
       * @returns {Array} Returns the slice of `array`.
       */
      function slice(array, start, end) {
        var length = array == null ? 0 : array.length;
        if (!length) {
          return [];
        }
        if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
          start = 0;
          end = length;
        }
        else {
          start = start == null ? 0 : toInteger(start);
          end = end === undefined$1 ? length : toInteger(end);
        }
        return baseSlice(array, start, end);
      }

      /*
       * Uses a binary search to determine the lowest index at which `value`
       * should be inserted into `array` in order to maintain its sort order.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {Array} array The sorted array to inspect.
       * @param {*} value The value to evaluate.
       * @returns {number} Returns the index at which `value` should be inserted
       *  into `array`.
       * @example
       *
       * _.sortedIndex([30, 50], 40);
       * // => 1
       */
      function sortedIndex(array, value) {
        return baseSortedIndex(array, value);
      }

      /*
       * This method is like `_.sortedIndex` except that it accepts `iteratee`
       * which is invoked for `value` and each element of `array` to compute their
       * sort ranking. The iteratee is invoked with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The sorted array to inspect.
       * @param {*} value The value to evaluate.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {number} Returns the index at which `value` should be inserted
       *  into `array`.
       * @example
       *
       * var objects = [{ 'x': 4 }, { 'x': 5 }];
       *
       * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
       * // => 0
       *
       * // The `_.property` iteratee shorthand.
       * _.sortedIndexBy(objects, { 'x': 4 }, 'x');
       * // => 0
       */
      function sortedIndexBy(array, value, iteratee) {
        return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));
      }

      /*
       * This method is like `_.indexOf` except that it performs a binary
       * search on a sorted `array`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {*} value The value to search for.
       * @returns {number} Returns the index of the matched value, else `-1`.
       * @example
       *
       * _.sortedIndexOf([4, 5, 5, 5, 6], 5);
       * // => 1
       */
      function sortedIndexOf(array, value) {
        var length = array == null ? 0 : array.length;
        if (length) {
          var index = baseSortedIndex(array, value);
          if (index < length && eq(array[index], value)) {
            return index;
          }
        }
        return -1;
      }

      /*
       * This method is like `_.sortedIndex` except that it returns the highest
       * index at which `value` should be inserted into `array` in order to
       * maintain its sort order.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Array
       * @param {Array} array The sorted array to inspect.
       * @param {*} value The value to evaluate.
       * @returns {number} Returns the index at which `value` should be inserted
       *  into `array`.
       * @example
       *
       * _.sortedLastIndex([4, 5, 5, 5, 6], 5);
       * // => 4
       */
      function sortedLastIndex(array, value) {
        return baseSortedIndex(array, value, true);
      }

      /*
       * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
       * which is invoked for `value` and each element of `array` to compute their
       * sort ranking. The iteratee is invoked with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The sorted array to inspect.
       * @param {*} value The value to evaluate.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {number} Returns the index at which `value` should be inserted
       *  into `array`.
       * @example
       *
       * var objects = [{ 'x': 4 }, { 'x': 5 }];
       *
       * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
       * // => 1
       *
       * // The `_.property` iteratee shorthand.
       * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
       * // => 1
       */
      function sortedLastIndexBy(array, value, iteratee) {
        return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);
      }

      /*
       * This method is like `_.lastIndexOf` except that it performs a binary
       * search on a sorted `array`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {*} value The value to search for.
       * @returns {number} Returns the index of the matched value, else `-1`.
       * @example
       *
       * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
       * // => 3
       */
      function sortedLastIndexOf(array, value) {
        var length = array == null ? 0 : array.length;
        if (length) {
          var index = baseSortedIndex(array, value, true) - 1;
          if (eq(array[index], value)) {
            return index;
          }
        }
        return -1;
      }

      /*
       * This method is like `_.uniq` except that it's designed and optimized
       * for sorted arrays.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to inspect.
       * @returns {Array} Returns the new duplicate free array.
       * @example
       *
       * _.sortedUniq([1, 1, 2]);
       * // => [1, 2]
       */
      function sortedUniq(array) {
        return (array && array.length)
          ? baseSortedUniq(array)
          : [];
      }

      /*
       * This method is like `_.uniqBy` except that it's designed and optimized
       * for sorted arrays.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {Function} [iteratee] The iteratee invoked per element.
       * @returns {Array} Returns the new duplicate free array.
       * @example
       *
       * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
       * // => [1.1, 2.3]
       */
      function sortedUniqBy(array, iteratee) {
        return (array && array.length)
          ? baseSortedUniq(array, getIteratee(iteratee, 2))
          : [];
      }

      /*
       * Gets all but the first element of `array`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to query.
       * @returns {Array} Returns the slice of `array`.
       * @example
       *
       * _.tail([1, 2, 3]);
       * // => [2, 3]
       */
      function tail(array) {
        var length = array == null ? 0 : array.length;
        return length ? baseSlice(array, 1, length) : [];
      }

      /*
       * Creates a slice of `array` with `n` elements taken from the beginning.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {Array} array The array to query.
       * @param {number} [n=1] The number of elements to take.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {Array} Returns the slice of `array`.
       * @example
       *
       * _.take([1, 2, 3]);
       * // => [1]
       *
       * _.take([1, 2, 3], 2);
       * // => [1, 2]
       *
       * _.take([1, 2, 3], 5);
       * // => [1, 2, 3]
       *
       * _.take([1, 2, 3], 0);
       * // => []
       */
      function take(array, n, guard) {
        if (!(array && array.length)) {
          return [];
        }
        n = (guard || n === undefined$1) ? 1 : toInteger(n);
        return baseSlice(array, 0, n < 0 ? 0 : n);
      }

      /*
       * Creates a slice of `array` with `n` elements taken from the end.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Array
       * @param {Array} array The array to query.
       * @param {number} [n=1] The number of elements to take.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {Array} Returns the slice of `array`.
       * @example
       *
       * _.takeRight([1, 2, 3]);
       * // => [3]
       *
       * _.takeRight([1, 2, 3], 2);
       * // => [2, 3]
       *
       * _.takeRight([1, 2, 3], 5);
       * // => [1, 2, 3]
       *
       * _.takeRight([1, 2, 3], 0);
       * // => []
       */
      function takeRight(array, n, guard) {
        var length = array == null ? 0 : array.length;
        if (!length) {
          return [];
        }
        n = (guard || n === undefined$1) ? 1 : toInteger(n);
        n = length - n;
        return baseSlice(array, n < 0 ? 0 : n, length);
      }

      /*
       * Creates a slice of `array` with elements taken from the end. Elements are
       * taken until `predicate` returns falsey. The predicate is invoked with
       * three arguments: (value, index, array).
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Array
       * @param {Array} array The array to query.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the slice of `array`.
       * @example
       *
       * var users = [
       *   { 'user': 'barney',  'active': true },
       *   { 'user': 'fred',    'active': false },
       *   { 'user': 'pebbles', 'active': false }
       * ];
       *
       * _.takeRightWhile(users, function(o) { return !o.active; });
       * // => objects for ['fred', 'pebbles']
       *
       * // The `_.matches` iteratee shorthand.
       * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
       * // => objects for ['pebbles']
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.takeRightWhile(users, ['active', false]);
       * // => objects for ['fred', 'pebbles']
       *
       * // The `_.property` iteratee shorthand.
       * _.takeRightWhile(users, 'active');
       * // => []
       */
      function takeRightWhile(array, predicate) {
        return (array && array.length)
          ? baseWhile(array, getIteratee(predicate, 3), false, true)
          : [];
      }

      /*
       * Creates a slice of `array` with elements taken from the beginning. Elements
       * are taken until `predicate` returns falsey. The predicate is invoked with
       * three arguments: (value, index, array).
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Array
       * @param {Array} array The array to query.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the slice of `array`.
       * @example
       *
       * var users = [
       *   { 'user': 'barney',  'active': false },
       *   { 'user': 'fred',    'active': false },
       *   { 'user': 'pebbles', 'active': true }
       * ];
       *
       * _.takeWhile(users, function(o) { return !o.active; });
       * // => objects for ['barney', 'fred']
       *
       * // The `_.matches` iteratee shorthand.
       * _.takeWhile(users, { 'user': 'barney', 'active': false });
       * // => objects for ['barney']
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.takeWhile(users, ['active', false]);
       * // => objects for ['barney', 'fred']
       *
       * // The `_.property` iteratee shorthand.
       * _.takeWhile(users, 'active');
       * // => []
       */
      function takeWhile(array, predicate) {
        return (array && array.length)
          ? baseWhile(array, getIteratee(predicate, 3))
          : [];
      }

      /*
       * Creates an array of unique values, in order, from all given arrays using
       * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
       * for equality comparisons.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {...Array} [arrays] The arrays to inspect.
       * @returns {Array} Returns the new array of combined values.
       * @example
       *
       * _.union([2], [1, 2]);
       * // => [2, 1]
       */
      var union = baseRest(function (arrays) {
        return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
      });

      /*
       * This method is like `_.union` except that it accepts `iteratee` which is
       * invoked for each element of each `arrays` to generate the criterion by
       * which uniqueness is computed. Result values are chosen from the first
       * array in which the value occurs. The iteratee is invoked with one argument:
       * (value).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {...Array} [arrays] The arrays to inspect.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {Array} Returns the new array of combined values.
       * @example
       *
       * _.unionBy([2.1], [1.2, 2.3], Math.floor);
       * // => [2.1, 1.2]
       *
       * // The `_.property` iteratee shorthand.
       * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
       * // => [{ 'x': 1 }, { 'x': 2 }]
       */
      var unionBy = baseRest(function (arrays) {
        var iteratee = last(arrays);
        if (isArrayLikeObject(iteratee)) {
          iteratee = undefined$1;
        }
        return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));
      });

      /*
       * This method is like `_.union` except that it accepts `comparator` which
       * is invoked to compare elements of `arrays`. Result values are chosen from
       * the first array in which the value occurs. The comparator is invoked
       * with two arguments: (arrVal, othVal).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {...Array} [arrays] The arrays to inspect.
       * @param {Function} [comparator] The comparator invoked per element.
       * @returns {Array} Returns the new array of combined values.
       * @example
       *
       * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
       * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
       *
       * _.unionWith(objects, others, _.isEqual);
       * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
       */
      var unionWith = baseRest(function (arrays) {
        var comparator = last(arrays);
        comparator = typeof comparator == 'function' ? comparator : undefined$1;
        return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined$1, comparator);
      });

      /*
       * Creates a duplicate-free version of an array, using
       * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
       * for equality comparisons, in which only the first occurrence of each element
       * is kept. The order of result values is determined by the order they occur
       * in the array.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {Array} array The array to inspect.
       * @returns {Array} Returns the new duplicate free array.
       * @example
       *
       * _.uniq([2, 1, 2]);
       * // => [2, 1]
       */
      function uniq(array) {
        return (array && array.length) ? baseUniq(array) : [];
      }

      /*
       * This method is like `_.uniq` except that it accepts `iteratee` which is
       * invoked for each element in `array` to generate the criterion by which
       * uniqueness is computed. The order of result values is determined by the
       * order they occur in the array. The iteratee is invoked with one argument:
       * (value).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {Array} Returns the new duplicate free array.
       * @example
       *
       * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
       * // => [2.1, 1.2]
       *
       * // The `_.property` iteratee shorthand.
       * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
       * // => [{ 'x': 1 }, { 'x': 2 }]
       */
      function uniqBy(array, iteratee) {
        return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];
      }

      /*
       * This method is like `_.uniq` except that it accepts `comparator` which
       * is invoked to compare elements of `array`. The order of result values is
       * determined by the order they occur in the array.The comparator is invoked
       * with two arguments: (arrVal, othVal).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {Function} [comparator] The comparator invoked per element.
       * @returns {Array} Returns the new duplicate free array.
       * @example
       *
       * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
       *
       * _.uniqWith(objects, _.isEqual);
       * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
       */
      function uniqWith(array, comparator) {
        comparator = typeof comparator == 'function' ? comparator : undefined$1;
        return (array && array.length) ? baseUniq(array, undefined$1, comparator) : [];
      }

      /*
       * This method is like `_.zip` except that it accepts an array of grouped
       * elements and creates an array regrouping the elements to their pre-zip
       * configuration.
       *
       * @static
       * @memberOf _
       * @since 1.2.0
       *  Array
       * @param {Array} array The array of grouped elements to process.
       * @returns {Array} Returns the new array of regrouped elements.
       * @example
       *
       * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
       * // => [['a', 1, true], ['b', 2, false]]
       *
       * _.unzip(zipped);
       * // => [['a', 'b'], [1, 2], [true, false]]
       */
      function unzip(array) {
        if (!(array && array.length)) {
          return [];
        }
        var length = 0;
        array = arrayFilter(array, function (group) {
          if (isArrayLikeObject(group)) {
            length = nativeMax(group.length, length);
            return true;
          }
        });
        return baseTimes(length, function (index) {
          return arrayMap(array, baseProperty(index));
        });
      }

      /*
       * This method is like `_.unzip` except that it accepts `iteratee` to specify
       * how regrouped values should be combined. The iteratee is invoked with the
       * elements of each group: (...group).
       *
       * @static
       * @memberOf _
       * @since 3.8.0
       *  Array
       * @param {Array} array The array of grouped elements to process.
       * @param {Function} [iteratee=_.identity] The function to combine
       *  regrouped values.
       * @returns {Array} Returns the new array of regrouped elements.
       * @example
       *
       * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
       * // => [[1, 10, 100], [2, 20, 200]]
       *
       * _.unzipWith(zipped, _.add);
       * // => [3, 30, 300]
       */
      function unzipWith(array, iteratee) {
        if (!(array && array.length)) {
          return [];
        }
        var result = unzip(array);
        if (iteratee == null) {
          return result;
        }
        return arrayMap(result, function (group) {
          return apply(iteratee, undefined$1, group);
        });
      }

      /*
       * Creates an array excluding all given values using
       * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
       * for equality comparisons.
       *
       * **Note:** Unlike `_.pull`, this method returns a new array.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {Array} array The array to inspect.
       * @param {...*} [values] The values to exclude.
       * @returns {Array} Returns the new array of filtered values.
       * @see _.difference, _.xor
       * @example
       *
       * _.without([2, 1, 2, 3], 1, 2);
       * // => [3]
       */
      var without = baseRest(function (array, values) {
        return isArrayLikeObject(array)
          ? baseDifference(array, values)
          : [];
      });

      /*
       * Creates an array of unique values that is the
       * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
       * of the given arrays. The order of result values is determined by the order
       * they occur in the arrays.
       *
       * @static
       * @memberOf _
       * @since 2.4.0
       *  Array
       * @param {...Array} [arrays] The arrays to inspect.
       * @returns {Array} Returns the new array of filtered values.
       * @see _.difference, _.without
       * @example
       *
       * _.xor([2, 1], [2, 3]);
       * // => [1, 3]
       */
      var xor = baseRest(function (arrays) {
        return baseXor(arrayFilter(arrays, isArrayLikeObject));
      });

      /*
       * This method is like `_.xor` except that it accepts `iteratee` which is
       * invoked for each element of each `arrays` to generate the criterion by
       * which by which they're compared. The order of result values is determined
       * by the order they occur in the arrays. The iteratee is invoked with one
       * argument: (value).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {...Array} [arrays] The arrays to inspect.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {Array} Returns the new array of filtered values.
       * @example
       *
       * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
       * // => [1.2, 3.4]
       *
       * // The `_.property` iteratee shorthand.
       * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
       * // => [{ 'x': 2 }]
       */
      var xorBy = baseRest(function (arrays) {
        var iteratee = last(arrays);
        if (isArrayLikeObject(iteratee)) {
          iteratee = undefined$1;
        }
        return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));
      });

      /*
       * This method is like `_.xor` except that it accepts `comparator` which is
       * invoked to compare elements of `arrays`. The order of result values is
       * determined by the order they occur in the arrays. The comparator is invoked
       * with two arguments: (arrVal, othVal).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Array
       * @param {...Array} [arrays] The arrays to inspect.
       * @param {Function} [comparator] The comparator invoked per element.
       * @returns {Array} Returns the new array of filtered values.
       * @example
       *
       * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
       * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
       *
       * _.xorWith(objects, others, _.isEqual);
       * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
       */
      var xorWith = baseRest(function (arrays) {
        var comparator = last(arrays);
        comparator = typeof comparator == 'function' ? comparator : undefined$1;
        return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined$1, comparator);
      });

      /*
       * Creates an array of grouped elements, the first of which contains the
       * first elements of the given arrays, the second of which contains the
       * second elements of the given arrays, and so on.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Array
       * @param {...Array} [arrays] The arrays to process.
       * @returns {Array} Returns the new array of grouped elements.
       * @example
       *
       * _.zip(['a', 'b'], [1, 2], [true, false]);
       * // => [['a', 1, true], ['b', 2, false]]
       */
      var zip = baseRest(unzip);

      /*
       * This method is like `_.fromPairs` except that it accepts two arrays,
       * one of property identifiers and one of corresponding values.
       *
       * @static
       * @memberOf _
       * @since 0.4.0
       *  Array
       * @param {Array} [props=[]] The property identifiers.
       * @param {Array} [values=[]] The property values.
       * @returns {Object} Returns the new object.
       * @example
       *
       * _.zipObject(['a', 'b'], [1, 2]);
       * // => { 'a': 1, 'b': 2 }
       */
      function zipObject(props, values) {
        return baseZipObject(props || [], values || [], assignValue);
      }

      /*
       * This method is like `_.zipObject` except that it supports property paths.
       *
       * @static
       * @memberOf _
       * @since 4.1.0
       *  Array
       * @param {Array} [props=[]] The property identifiers.
       * @param {Array} [values=[]] The property values.
       * @returns {Object} Returns the new object.
       * @example
       *
       * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
       * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
       */
      function zipObjectDeep(props, values) {
        return baseZipObject(props || [], values || [], baseSet);
      }

      /*
       * This method is like `_.zip` except that it accepts `iteratee` to specify
       * how grouped values should be combined. The iteratee is invoked with the
       * elements of each group: (...group).
       *
       * @static
       * @memberOf _
       * @since 3.8.0
       *  Array
       * @param {...Array} [arrays] The arrays to process.
       * @param {Function} [iteratee=_.identity] The function to combine
       *  grouped values.
       * @returns {Array} Returns the new array of grouped elements.
       * @example
       *
       * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
       *   return a + b + c;
       * });
       * // => [111, 222]
       */
      var zipWith = baseRest(function (arrays) {
        var length = arrays.length,
          iteratee = length > 1 ? arrays[length - 1] : undefined$1;

        iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined$1;
        return unzipWith(arrays, iteratee);
      });

      /*------------------------------------------------------------------------*/

      /*
       * Creates a `lodash` wrapper instance that wraps `value` with explicit method
       * chain sequences enabled. The result of such sequences must be unwrapped
       * with `_#value`.
       *
       * @static
       * @memberOf _
       * @since 1.3.0
       *  Seq
       * @param {*} value The value to wrap.
       * @returns {Object} Returns the new `lodash` wrapper instance.
       * @example
       *
       * var users = [
       *   { 'user': 'barney',  'age': 36 },
       *   { 'user': 'fred',    'age': 40 },
       *   { 'user': 'pebbles', 'age': 1 }
       * ];
       *
       * var youngest = _
       *   .chain(users)
       *   .sortBy('age')
       *   .map(function(o) {
       *     return o.user + ' is ' + o.age;
       *   })
       *   .head()
       *   .value();
       * // => 'pebbles is 1'
       */
      function chain(value) {
        var result = lodash(value);
        result.__chain__ = true;
        return result;
      }

      /*
       * This method invokes `interceptor` and returns `value`. The interceptor
       * is invoked with one argument; (value). The purpose of this method is to
       * "tap into" a method chain sequence in order to modify intermediate results.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Seq
       * @param {*} value The value to provide to `interceptor`.
       * @param {Function} interceptor The function to invoke.
       * @returns {*} Returns `value`.
       * @example
       *
       * _([1, 2, 3])
       *  .tap(function(array) {
       *    // Mutate input array.
       *    array.pop();
       *  })
       *  .reverse()
       *  .value();
       * // => [2, 1]
       */
      function tap(value, interceptor) {
        interceptor(value);
        return value;
      }

      /*
       * This method is like `_.tap` except that it returns the result of `interceptor`.
       * The purpose of this method is to "pass thru" values replacing intermediate
       * results in a method chain sequence.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Seq
       * @param {*} value The value to provide to `interceptor`.
       * @param {Function} interceptor The function to invoke.
       * @returns {*} Returns the result of `interceptor`.
       * @example
       *
       * _('  abc  ')
       *  .chain()
       *  .trim()
       *  .thru(function(value) {
       *    return [value];
       *  })
       *  .value();
       * // => ['abc']
       */
      function thru(value, interceptor) {
        return interceptor(value);
      }

      /*
       * This method is the wrapper version of `_.at`.
       *
       * @name at
       * @memberOf _
       * @since 1.0.0
       *  Seq
       * @param {...(string|string[])} [paths] The property paths to pick.
       * @returns {Object} Returns the new `lodash` wrapper instance.
       * @example
       *
       * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
       *
       * _(object).at(['a[0].b.c', 'a[1]']).value();
       * // => [3, 4]
       */
      var wrapperAt = flatRest(function (paths) {
        var length = paths.length,
          start = length ? paths[0] : 0,
          value = this.__wrapped__,
          interceptor = function (object) { return baseAt(object, paths); };

        if (length > 1 || this.__actions__.length ||
          !(value instanceof LazyWrapper) || !isIndex(start)) {
          return this.thru(interceptor);
        }
        value = value.slice(start, +start + (length ? 1 : 0));
        value.__actions__.push({
          'func': thru,
          'args': [interceptor],
          'thisArg': undefined$1
        });
        return new LodashWrapper(value, this.__chain__).thru(function (array) {
          if (length && !array.length) {
            array.push(undefined$1);
          }
          return array;
        });
      });

      /*
       * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.
       *
       * @name chain
       * @memberOf _
       * @since 0.1.0
       *  Seq
       * @returns {Object} Returns the new `lodash` wrapper instance.
       * @example
       *
       * var users = [
       *   { 'user': 'barney', 'age': 36 },
       *   { 'user': 'fred',   'age': 40 }
       * ];
       *
       * // A sequence without explicit chaining.
       * _(users).head();
       * // => { 'user': 'barney', 'age': 36 }
       *
       * // A sequence with explicit chaining.
       * _(users)
       *   .chain()
       *   .head()
       *   .pick('user')
       *   .value();
       * // => { 'user': 'barney' }
       */
      function wrapperChain() {
        return chain(this);
      }

      /*
       * Executes the chain sequence and returns the wrapped result.
       *
       * @name commit
       * @memberOf _
       * @since 3.2.0
       *  Seq
       * @returns {Object} Returns the new `lodash` wrapper instance.
       * @example
       *
       * var array = [1, 2];
       * var wrapped = _(array).push(3);
       *
       * console.log(array);
       * // => [1, 2]
       *
       * wrapped = wrapped.commit();
       * console.log(array);
       * // => [1, 2, 3]
       *
       * wrapped.last();
       * // => 3
       *
       * console.log(array);
       * // => [1, 2, 3]
       */
      function wrapperCommit() {
        return new LodashWrapper(this.value(), this.__chain__);
      }

      /*
       * Gets the next value on a wrapped object following the
       * [iterator protocol](https://mdn.io/iteration_protocols#iterator).
       *
       * @name next
       * @memberOf _
       * @since 4.0.0
       *  Seq
       * @returns {Object} Returns the next iterator value.
       * @example
       *
       * var wrapped = _([1, 2]);
       *
       * wrapped.next();
       * // => { 'done': false, 'value': 1 }
       *
       * wrapped.next();
       * // => { 'done': false, 'value': 2 }
       *
       * wrapped.next();
       * // => { 'done': true, 'value': undefined }
       */
      function wrapperNext() {
        if (this.__values__ === undefined$1) {
          this.__values__ = toArray(this.value());
        }
        var done = this.__index__ >= this.__values__.length,
          value = done ? undefined$1 : this.__values__[this.__index__++];

        return { 'done': done, 'value': value };
      }

      /*
       * Enables the wrapper to be iterable.
       *
       * @name Symbol.iterator
       * @memberOf _
       * @since 4.0.0
       *  Seq
       * @returns {Object} Returns the wrapper object.
       * @example
       *
       * var wrapped = _([1, 2]);
       *
       * wrapped[Symbol.iterator]() === wrapped;
       * // => true
       *
       * Array.from(wrapped);
       * // => [1, 2]
       */
      function wrapperToIterator() {
        return this;
      }

      /*
       * Creates a clone of the chain sequence planting `value` as the wrapped value.
       *
       * @name plant
       * @memberOf _
       * @since 3.2.0
       *  Seq
       * @param {*} value The value to plant.
       * @returns {Object} Returns the new `lodash` wrapper instance.
       * @example
       *
       * function square(n) {
       *   return n * n;
       * }
       *
       * var wrapped = _([1, 2]).map(square);
       * var other = wrapped.plant([3, 4]);
       *
       * other.value();
       * // => [9, 16]
       *
       * wrapped.value();
       * // => [1, 4]
       */
      function wrapperPlant(value) {
        var result,
          parent = this;

        while (parent instanceof baseLodash) {
          var clone = wrapperClone(parent);
          clone.__index__ = 0;
          clone.__values__ = undefined$1;
          if (result) {
            previous.__wrapped__ = clone;
          } else {
            result = clone;
          }
          var previous = clone;
          parent = parent.__wrapped__;
        }
        previous.__wrapped__ = value;
        return result;
      }

      /*
       * This method is the wrapper version of `_.reverse`.
       *
       * **Note:** This method mutates the wrapped array.
       *
       * @name reverse
       * @memberOf _
       * @since 0.1.0
       *  Seq
       * @returns {Object} Returns the new `lodash` wrapper instance.
       * @example
       *
       * var array = [1, 2, 3];
       *
       * _(array).reverse().value()
       * // => [3, 2, 1]
       *
       * console.log(array);
       * // => [3, 2, 1]
       */
      function wrapperReverse() {
        var value = this.__wrapped__;
        if (value instanceof LazyWrapper) {
          var wrapped = value;
          if (this.__actions__.length) {
            wrapped = new LazyWrapper(this);
          }
          wrapped = wrapped.reverse();
          wrapped.__actions__.push({
            'func': thru,
            'args': [reverse],
            'thisArg': undefined$1
          });
          return new LodashWrapper(wrapped, this.__chain__);
        }
        return this.thru(reverse);
      }

      /*
       * Executes the chain sequence to resolve the unwrapped value.
       *
       * @name value
       * @memberOf _
       * @since 0.1.0
       * @alias toJSON, valueOf
       *  Seq
       * @returns {*} Returns the resolved unwrapped value.
       * @example
       *
       * _([1, 2, 3]).value();
       * // => [1, 2, 3]
       */
      function wrapperValue() {
        return baseWrapperValue(this.__wrapped__, this.__actions__);
      }

      /*------------------------------------------------------------------------*/

      /*
       * Creates an object composed of keys generated from the results of running
       * each element of `collection` thru `iteratee`. The corresponding value of
       * each key is the number of times the key was returned by `iteratee`. The
       * iteratee is invoked with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 0.5.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
       * @returns {Object} Returns the composed aggregate object.
       * @example
       *
       * _.countBy([6.1, 4.2, 6.3], Math.floor);
       * // => { '4': 1, '6': 2 }
       *
       * // The `_.property` iteratee shorthand.
       * _.countBy(['one', 'two', 'three'], 'length');
       * // => { '3': 2, '5': 1 }
       */
      var countBy = createAggregator(function (result, value, key) {
        if (hasOwnProperty.call(result, key)) {
          ++result[key];
        } else {
          baseAssignValue(result, key, 1);
        }
      });

      /*
       * Checks if `predicate` returns truthy for **all** elements of `collection`.
       * Iteration is stopped once `predicate` returns falsey. The predicate is
       * invoked with three arguments: (value, index|key, collection).
       *
       * **Note:** This method returns `true` for
       * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because
       * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
       * elements of empty collections.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {boolean} Returns `true` if all elements pass the predicate check,
       *  else `false`.
       * @example
       *
       * _.every([true, 1, null, 'yes'], Boolean);
       * // => false
       *
       * var users = [
       *   { 'user': 'barney', 'age': 36, 'active': false },
       *   { 'user': 'fred',   'age': 40, 'active': false }
       * ];
       *
       * // The `_.matches` iteratee shorthand.
       * _.every(users, { 'user': 'barney', 'active': false });
       * // => false
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.every(users, ['active', false]);
       * // => true
       *
       * // The `_.property` iteratee shorthand.
       * _.every(users, 'active');
       * // => false
       */
      function every(collection, predicate, guard) {
        var func = isArray(collection) ? arrayEvery : baseEvery;
        if (guard && isIterateeCall(collection, predicate, guard)) {
          predicate = undefined$1;
        }
        return func(collection, getIteratee(predicate, 3));
      }

      /*
       * Iterates over elements of `collection`, returning an array of all elements
       * `predicate` returns truthy for. The predicate is invoked with three
       * arguments: (value, index|key, collection).
       *
       * **Note:** Unlike `_.remove`, this method returns a new array.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the new filtered array.
       * @see _.reject
       * @example
       *
       * var users = [
       *   { 'user': 'barney', 'age': 36, 'active': true },
       *   { 'user': 'fred',   'age': 40, 'active': false }
       * ];
       *
       * _.filter(users, function(o) { return !o.active; });
       * // => objects for ['fred']
       *
       * // The `_.matches` iteratee shorthand.
       * _.filter(users, { 'age': 36, 'active': true });
       * // => objects for ['barney']
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.filter(users, ['active', false]);
       * // => objects for ['fred']
       *
       * // The `_.property` iteratee shorthand.
       * _.filter(users, 'active');
       * // => objects for ['barney']
       *
       * // Combining several predicates using `_.overEvery` or `_.overSome`.
       * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));
       * // => objects for ['fred', 'barney']
       */
      function filter(collection, predicate) {
        var func = isArray(collection) ? arrayFilter : baseFilter;
        return func(collection, getIteratee(predicate, 3));
      }

      /*
       * Iterates over elements of `collection`, returning the first element
       * `predicate` returns truthy for. The predicate is invoked with three
       * arguments: (value, index|key, collection).
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object} collection The collection to inspect.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @param {number} [fromIndex=0] The index to search from.
       * @returns {*} Returns the matched element, else `undefined`.
       * @example
       *
       * var users = [
       *   { 'user': 'barney',  'age': 36, 'active': true },
       *   { 'user': 'fred',    'age': 40, 'active': false },
       *   { 'user': 'pebbles', 'age': 1,  'active': true }
       * ];
       *
       * _.find(users, function(o) { return o.age < 40; });
       * // => object for 'barney'
       *
       * // The `_.matches` iteratee shorthand.
       * _.find(users, { 'age': 1, 'active': true });
       * // => object for 'pebbles'
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.find(users, ['active', false]);
       * // => object for 'fred'
       *
       * // The `_.property` iteratee shorthand.
       * _.find(users, 'active');
       * // => object for 'barney'
       */
      var find = createFind(findIndex);

      /*
       * This method is like `_.find` except that it iterates over elements of
       * `collection` from right to left.
       *
       * @static
       * @memberOf _
       * @since 2.0.0
       *  Collection
       * @param {Array|Object} collection The collection to inspect.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @param {number} [fromIndex=collection.length-1] The index to search from.
       * @returns {*} Returns the matched element, else `undefined`.
       * @example
       *
       * _.findLast([1, 2, 3, 4], function(n) {
       *   return n % 2 == 1;
       * });
       * // => 3
       */
      var findLast = createFind(findLastIndex);

      /*
       * Creates a flattened array of values by running each element in `collection`
       * thru `iteratee` and flattening the mapped results. The iteratee is invoked
       * with three arguments: (value, index|key, collection).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the new flattened array.
       * @example
       *
       * function duplicate(n) {
       *   return [n, n];
       * }
       *
       * _.flatMap([1, 2], duplicate);
       * // => [1, 1, 2, 2]
       */
      function flatMap(collection, iteratee) {
        return baseFlatten(map(collection, iteratee), 1);
      }

      /*
       * This method is like `_.flatMap` except that it recursively flattens the
       * mapped results.
       *
       * @static
       * @memberOf _
       * @since 4.7.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the new flattened array.
       * @example
       *
       * function duplicate(n) {
       *   return [[[n, n]]];
       * }
       *
       * _.flatMapDeep([1, 2], duplicate);
       * // => [1, 1, 2, 2]
       */
      function flatMapDeep(collection, iteratee) {
        return baseFlatten(map(collection, iteratee), INFINITY);
      }

      /*
       * This method is like `_.flatMap` except that it recursively flattens the
       * mapped results up to `depth` times.
       *
       * @static
       * @memberOf _
       * @since 4.7.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @param {number} [depth=1] The maximum recursion depth.
       * @returns {Array} Returns the new flattened array.
       * @example
       *
       * function duplicate(n) {
       *   return [[[n, n]]];
       * }
       *
       * _.flatMapDepth([1, 2], duplicate, 2);
       * // => [[1, 1], [2, 2]]
       */
      function flatMapDepth(collection, iteratee, depth) {
        depth = depth === undefined$1 ? 1 : toInteger(depth);
        return baseFlatten(map(collection, iteratee), depth);
      }

      /*
       * Iterates over elements of `collection` and invokes `iteratee` for each element.
       * The iteratee is invoked with three arguments: (value, index|key, collection).
       * Iteratee functions may exit iteration early by explicitly returning `false`.
       *
       * **Note:** As with other "Collections" methods, objects with a "length"
       * property are iterated like arrays. To avoid this behavior use `_.forIn`
       * or `_.forOwn` for object iteration.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       * @alias each
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Array|Object} Returns `collection`.
       * @see _.forEachRight
       * @example
       *
       * _.forEach([1, 2], function(value) {
       *   console.log(value);
       * });
       * // => Logs `1` then `2`.
       *
       * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
       *   console.log(key);
       * });
       * // => Logs 'a' then 'b' (iteration order is not guaranteed).
       */
      function forEach(collection, iteratee) {
        var func = isArray(collection) ? arrayEach : baseEach;
        return func(collection, getIteratee(iteratee, 3));
      }

      /*
       * This method is like `_.forEach` except that it iterates over elements of
       * `collection` from right to left.
       *
       * @static
       * @memberOf _
       * @since 2.0.0
       * @alias eachRight
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Array|Object} Returns `collection`.
       * @see _.forEach
       * @example
       *
       * _.forEachRight([1, 2], function(value) {
       *   console.log(value);
       * });
       * // => Logs `2` then `1`.
       */
      function forEachRight(collection, iteratee) {
        var func = isArray(collection) ? arrayEachRight : baseEachRight;
        return func(collection, getIteratee(iteratee, 3));
      }

      /*
       * Creates an object composed of keys generated from the results of running
       * each element of `collection` thru `iteratee`. The order of grouped values
       * is determined by the order they occur in `collection`. The corresponding
       * value of each key is an array of elements responsible for generating the
       * key. The iteratee is invoked with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
       * @returns {Object} Returns the composed aggregate object.
       * @example
       *
       * _.groupBy([6.1, 4.2, 6.3], Math.floor);
       * // => { '4': [4.2], '6': [6.1, 6.3] }
       *
       * // The `_.property` iteratee shorthand.
       * _.groupBy(['one', 'two', 'three'], 'length');
       * // => { '3': ['one', 'two'], '5': ['three'] }
       */
      var groupBy = createAggregator(function (result, value, key) {
        if (hasOwnProperty.call(result, key)) {
          result[key].push(value);
        } else {
          baseAssignValue(result, key, [value]);
        }
      });

      /*
       * Checks if `value` is in `collection`. If `collection` is a string, it's
       * checked for a substring of `value`, otherwise
       * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
       * is used for equality comparisons. If `fromIndex` is negative, it's used as
       * the offset from the end of `collection`.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object|string} collection The collection to inspect.
       * @param {*} value The value to search for.
       * @param {number} [fromIndex=0] The index to search from.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
       * @returns {boolean} Returns `true` if `value` is found, else `false`.
       * @example
       *
       * _.includes([1, 2, 3], 1);
       * // => true
       *
       * _.includes([1, 2, 3], 1, 2);
       * // => false
       *
       * _.includes({ 'a': 1, 'b': 2 }, 1);
       * // => true
       *
       * _.includes('abcd', 'bc');
       * // => true
       */
      function includes(collection, value, fromIndex, guard) {
        collection = isArrayLike(collection) ? collection : values(collection);
        fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;

        var length = collection.length;
        if (fromIndex < 0) {
          fromIndex = nativeMax(length + fromIndex, 0);
        }
        return isString(collection)
          ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
          : (!!length && baseIndexOf(collection, value, fromIndex) > -1);
      }

      /*
       * Invokes the method at `path` of each element in `collection`, returning
       * an array of the results of each invoked method. Any additional arguments
       * are provided to each invoked method. If `path` is a function, it's invoked
       * for, and `this` bound to, each element in `collection`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Array|Function|string} path The path of the method to invoke or
       *  the function invoked per iteration.
       * @param {...*} [args] The arguments to invoke each method with.
       * @returns {Array} Returns the array of results.
       * @example
       *
       * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
       * // => [[1, 5, 7], [1, 2, 3]]
       *
       * _.invokeMap([123, 456], String.prototype.split, '');
       * // => [['1', '2', '3'], ['4', '5', '6']]
       */
      var invokeMap = baseRest(function (collection, path, args) {
        var index = -1,
          isFunc = typeof path == 'function',
          result = isArrayLike(collection) ? Array(collection.length) : [];

        baseEach(collection, function (value) {
          result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
        });
        return result;
      });

      /*
       * Creates an object composed of keys generated from the results of running
       * each element of `collection` thru `iteratee`. The corresponding value of
       * each key is the last element responsible for generating the key. The
       * iteratee is invoked with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
       * @returns {Object} Returns the composed aggregate object.
       * @example
       *
       * var array = [
       *   { 'dir': 'left', 'code': 97 },
       *   { 'dir': 'right', 'code': 100 }
       * ];
       *
       * _.keyBy(array, function(o) {
       *   return String.fromCharCode(o.code);
       * });
       * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
       *
       * _.keyBy(array, 'dir');
       * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
       */
      var keyBy = createAggregator(function (result, value, key) {
        baseAssignValue(result, key, value);
      });

      /*
       * Creates an array of values by running each element in `collection` thru
       * `iteratee`. The iteratee is invoked with three arguments:
       * (value, index|key, collection).
       *
       * Many lodash methods are guarded to work as iteratees for methods like
       * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
       *
       * The guarded methods are:
       * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
       * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
       * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
       * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the new mapped array.
       * @example
       *
       * function square(n) {
       *   return n * n;
       * }
       *
       * _.map([4, 8], square);
       * // => [16, 64]
       *
       * _.map({ 'a': 4, 'b': 8 }, square);
       * // => [16, 64] (iteration order is not guaranteed)
       *
       * var users = [
       *   { 'user': 'barney' },
       *   { 'user': 'fred' }
       * ];
       *
       * // The `_.property` iteratee shorthand.
       * _.map(users, 'user');
       * // => ['barney', 'fred']
       */
      function map(collection, iteratee) {
        var func = isArray(collection) ? arrayMap : baseMap;
        return func(collection, getIteratee(iteratee, 3));
      }

      /*
       * This method is like `_.sortBy` except that it allows specifying the sort
       * orders of the iteratees to sort by. If `orders` is unspecified, all values
       * are sorted in ascending order. Otherwise, specify an order of "desc" for
       * descending or "asc" for ascending sort order of corresponding values.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
       *  The iteratees to sort by.
       * @param {string[]} [orders] The sort orders of `iteratees`.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
       * @returns {Array} Returns the new sorted array.
       * @example
       *
       * var users = [
       *   { 'user': 'fred',   'age': 48 },
       *   { 'user': 'barney', 'age': 34 },
       *   { 'user': 'fred',   'age': 40 },
       *   { 'user': 'barney', 'age': 36 }
       * ];
       *
       * // Sort by `user` in ascending order and by `age` in descending order.
       * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
       * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
       */
      function orderBy(collection, iteratees, orders, guard) {
        if (collection == null) {
          return [];
        }
        if (!isArray(iteratees)) {
          iteratees = iteratees == null ? [] : [iteratees];
        }
        orders = guard ? undefined$1 : orders;
        if (!isArray(orders)) {
          orders = orders == null ? [] : [orders];
        }
        return baseOrderBy(collection, iteratees, orders);
      }

      /*
       * Creates an array of elements split into two groups, the first of which
       * contains elements `predicate` returns truthy for, the second of which
       * contains elements `predicate` returns falsey for. The predicate is
       * invoked with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the array of grouped elements.
       * @example
       *
       * var users = [
       *   { 'user': 'barney',  'age': 36, 'active': false },
       *   { 'user': 'fred',    'age': 40, 'active': true },
       *   { 'user': 'pebbles', 'age': 1,  'active': false }
       * ];
       *
       * _.partition(users, function(o) { return o.active; });
       * // => objects for [['fred'], ['barney', 'pebbles']]
       *
       * // The `_.matches` iteratee shorthand.
       * _.partition(users, { 'age': 1, 'active': false });
       * // => objects for [['pebbles'], ['barney', 'fred']]
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.partition(users, ['active', false]);
       * // => objects for [['barney', 'pebbles'], ['fred']]
       *
       * // The `_.property` iteratee shorthand.
       * _.partition(users, 'active');
       * // => objects for [['fred'], ['barney', 'pebbles']]
       */
      var partition = createAggregator(function (result, value, key) {
        result[key ? 0 : 1].push(value);
      }, function () { return [[], []]; });

      /*
       * Reduces `collection` to a value which is the accumulated result of running
       * each element in `collection` thru `iteratee`, where each successive
       * invocation is supplied the return value of the previous. If `accumulator`
       * is not given, the first element of `collection` is used as the initial
       * value. The iteratee is invoked with four arguments:
       * (accumulator, value, index|key, collection).
       *
       * Many lodash methods are guarded to work as iteratees for methods like
       * `_.reduce`, `_.reduceRight`, and `_.transform`.
       *
       * The guarded methods are:
       * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
       * and `sortBy`
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @param {*} [accumulator] The initial value.
       * @returns {*} Returns the accumulated value.
       * @see _.reduceRight
       * @example
       *
       * _.reduce([1, 2], function(sum, n) {
       *   return sum + n;
       * }, 0);
       * // => 3
       *
       * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
       *   (result[value] || (result[value] = [])).push(key);
       *   return result;
       * }, {});
       * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
       */
      function reduce(collection, iteratee, accumulator) {
        var func = isArray(collection) ? arrayReduce : baseReduce,
          initAccum = arguments.length < 3;

        return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);
      }

      /*
       * This method is like `_.reduce` except that it iterates over elements of
       * `collection` from right to left.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @param {*} [accumulator] The initial value.
       * @returns {*} Returns the accumulated value.
       * @see _.reduce
       * @example
       *
       * var array = [[0, 1], [2, 3], [4, 5]];
       *
       * _.reduceRight(array, function(flattened, other) {
       *   return flattened.concat(other);
       * }, []);
       * // => [4, 5, 2, 3, 0, 1]
       */
      function reduceRight(collection, iteratee, accumulator) {
        var func = isArray(collection) ? arrayReduceRight : baseReduce,
          initAccum = arguments.length < 3;

        return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);
      }

      /*
       * The opposite of `_.filter`; this method returns the elements of `collection`
       * that `predicate` does **not** return truthy for.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the new filtered array.
       * @see _.filter
       * @example
       *
       * var users = [
       *   { 'user': 'barney', 'age': 36, 'active': false },
       *   { 'user': 'fred',   'age': 40, 'active': true }
       * ];
       *
       * _.reject(users, function(o) { return !o.active; });
       * // => objects for ['fred']
       *
       * // The `_.matches` iteratee shorthand.
       * _.reject(users, { 'age': 40, 'active': true });
       * // => objects for ['barney']
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.reject(users, ['active', false]);
       * // => objects for ['fred']
       *
       * // The `_.property` iteratee shorthand.
       * _.reject(users, 'active');
       * // => objects for ['barney']
       */
      function reject(collection, predicate) {
        var func = isArray(collection) ? arrayFilter : baseFilter;
        return func(collection, negate(getIteratee(predicate, 3)));
      }

      /*
       * Gets a random element from `collection`.
       *
       * @static
       * @memberOf _
       * @since 2.0.0
       *  Collection
       * @param {Array|Object} collection The collection to sample.
       * @returns {*} Returns the random element.
       * @example
       *
       * _.sample([1, 2, 3, 4]);
       * // => 2
       */
      function sample(collection) {
        var func = isArray(collection) ? arraySample : baseSample;
        return func(collection);
      }

      /*
       * Gets `n` random elements at unique keys from `collection` up to the
       * size of `collection`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Collection
       * @param {Array|Object} collection The collection to sample.
       * @param {number} [n=1] The number of elements to sample.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {Array} Returns the random elements.
       * @example
       *
       * _.sampleSize([1, 2, 3], 2);
       * // => [3, 1]
       *
       * _.sampleSize([1, 2, 3], 4);
       * // => [2, 3, 1]
       */
      function sampleSize(collection, n, guard) {
        if ((guard ? isIterateeCall(collection, n, guard) : n === undefined$1)) {
          n = 1;
        } else {
          n = toInteger(n);
        }
        var func = isArray(collection) ? arraySampleSize : baseSampleSize;
        return func(collection, n);
      }

      /*
       * Creates an array of shuffled values, using a version of the
       * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object} collection The collection to shuffle.
       * @returns {Array} Returns the new shuffled array.
       * @example
       *
       * _.shuffle([1, 2, 3, 4]);
       * // => [4, 1, 3, 2]
       */
      function shuffle(collection) {
        var func = isArray(collection) ? arrayShuffle : baseShuffle;
        return func(collection);
      }

      /*
       * Gets the size of `collection` by returning its length for array-like
       * values or the number of own enumerable string keyed properties for objects.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object|string} collection The collection to inspect.
       * @returns {number} Returns the collection size.
       * @example
       *
       * _.size([1, 2, 3]);
       * // => 3
       *
       * _.size({ 'a': 1, 'b': 2 });
       * // => 2
       *
       * _.size('pebbles');
       * // => 7
       */
      function size(collection) {
        if (collection == null) {
          return 0;
        }
        if (isArrayLike(collection)) {
          return isString(collection) ? stringSize(collection) : collection.length;
        }
        var tag = getTag(collection);
        if (tag == mapTag || tag == setTag) {
          return collection.size;
        }
        return baseKeys(collection).length;
      }

      /*
       * Checks if `predicate` returns truthy for **any** element of `collection`.
       * Iteration is stopped once `predicate` returns truthy. The predicate is
       * invoked with three arguments: (value, index|key, collection).
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {boolean} Returns `true` if any element passes the predicate check,
       *  else `false`.
       * @example
       *
       * _.some([null, 0, 'yes', false], Boolean);
       * // => true
       *
       * var users = [
       *   { 'user': 'barney', 'active': true },
       *   { 'user': 'fred',   'active': false }
       * ];
       *
       * // The `_.matches` iteratee shorthand.
       * _.some(users, { 'user': 'barney', 'active': false });
       * // => false
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.some(users, ['active', false]);
       * // => true
       *
       * // The `_.property` iteratee shorthand.
       * _.some(users, 'active');
       * // => true
       */
      function some(collection, predicate, guard) {
        var func = isArray(collection) ? arraySome : baseSome;
        if (guard && isIterateeCall(collection, predicate, guard)) {
          predicate = undefined$1;
        }
        return func(collection, getIteratee(predicate, 3));
      }

      /*
       * Creates an array of elements, sorted in ascending order by the results of
       * running each element in a collection thru each iteratee. This method
       * performs a stable sort, that is, it preserves the original sort order of
       * equal elements. The iteratees are invoked with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Collection
       * @param {Array|Object} collection The collection to iterate over.
       * @param {...(Function|Function[])} [iteratees=[_.identity]]
       *  The iteratees to sort by.
       * @returns {Array} Returns the new sorted array.
       * @example
       *
       * var users = [
       *   { 'user': 'fred',   'age': 48 },
       *   { 'user': 'barney', 'age': 36 },
       *   { 'user': 'fred',   'age': 30 },
       *   { 'user': 'barney', 'age': 34 }
       * ];
       *
       * _.sortBy(users, [function(o) { return o.user; }]);
       * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]
       *
       * _.sortBy(users, ['user', 'age']);
       * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]
       */
      var sortBy = baseRest(function (collection, iteratees) {
        if (collection == null) {
          return [];
        }
        var length = iteratees.length;
        if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
          iteratees = [];
        } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
          iteratees = [iteratees[0]];
        }
        return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
      });

      /*------------------------------------------------------------------------*/

      /*
       * Gets the timestamp of the number of milliseconds that have elapsed since
       * the Unix epoch (1 January 1970 00:00:00 UTC).
       *
       * @static
       * @memberOf _
       * @since 2.4.0
       *  Date
       * @returns {number} Returns the timestamp.
       * @example
       *
       * _.defer(function(stamp) {
       *   console.log(_.now() - stamp);
       * }, _.now());
       * // => Logs the number of milliseconds it took for the deferred invocation.
       */
      var now = ctxNow || function () {
        return root.Date.now();
      };

      /*------------------------------------------------------------------------*/

      /*
       * The opposite of `_.before`; this method creates a function that invokes
       * `func` once it's called `n` or more times.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Function
       * @param {number} n The number of calls before `func` is invoked.
       * @param {Function} func The function to restrict.
       * @returns {Function} Returns the new restricted function.
       * @example
       *
       * var saves = ['profile', 'settings'];
       *
       * var done = _.after(saves.length, function() {
       *   console.log('done saving!');
       * });
       *
       * _.forEach(saves, function(type) {
       *   asyncSave({ 'type': type, 'complete': done });
       * });
       * // => Logs 'done saving!' after the two async saves have completed.
       */
      function after(n, func) {
        if (typeof func != 'function') {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        n = toInteger(n);
        return function () {
          if (--n < 1) {
            return func.apply(this, arguments);
          }
        };
      }

      /*
       * Creates a function that invokes `func`, with up to `n` arguments,
       * ignoring any additional arguments.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Function
       * @param {Function} func The function to cap arguments for.
       * @param {number} [n=func.length] The arity cap.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {Function} Returns the new capped function.
       * @example
       *
       * _.map(['6', '8', '10'], _.ary(parseInt, 1));
       * // => [6, 8, 10]
       */
      function ary(func, n, guard) {
        n = guard ? undefined$1 : n;
        n = (func && n == null) ? func.length : n;
        return createWrap(func, WRAP_ARY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, n);
      }

      /*
       * Creates a function that invokes `func`, with the `this` binding and arguments
       * of the created function, while it's called less than `n` times. Subsequent
       * calls to the created function return the result of the last `func` invocation.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Function
       * @param {number} n The number of calls at which `func` is no longer invoked.
       * @param {Function} func The function to restrict.
       * @returns {Function} Returns the new restricted function.
       * @example
       *
       * jQuery(element).on('click', _.before(5, addContactToList));
       * // => Allows adding up to 4 contacts to the list.
       */
      function before(n, func) {
        var result;
        if (typeof func != 'function') {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        n = toInteger(n);
        return function () {
          if (--n > 0) {
            result = func.apply(this, arguments);
          }
          if (n <= 1) {
            func = undefined$1;
          }
          return result;
        };
      }

      /*
       * Creates a function that invokes `func` with the `this` binding of `thisArg`
       * and `partials` prepended to the arguments it receives.
       *
       * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
       * may be used as a placeholder for partially applied arguments.
       *
       * **Note:** Unlike native `Function#bind`, this method doesn't set the "length"
       * property of bound functions.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Function
       * @param {Function} func The function to bind.
       * @param {*} thisArg The `this` binding of `func`.
       * @param {...*} [partials] The arguments to be partially applied.
       * @returns {Function} Returns the new bound function.
       * @example
       *
       * function greet(greeting, punctuation) {
       *   return greeting + ' ' + this.user + punctuation;
       * }
       *
       * var object = { 'user': 'fred' };
       *
       * var bound = _.bind(greet, object, 'hi');
       * bound('!');
       * // => 'hi fred!'
       *
       * // Bound with placeholders.
       * var bound = _.bind(greet, object, _, '!');
       * bound('hi');
       * // => 'hi fred!'
       */
      var bind = baseRest(function (func, thisArg, partials) {
        var bitmask = WRAP_BIND_FLAG;
        if (partials.length) {
          var holders = replaceHolders(partials, getHolder(bind));
          bitmask |= WRAP_PARTIAL_FLAG;
        }
        return createWrap(func, bitmask, thisArg, partials, holders);
      });

      /*
       * Creates a function that invokes the method at `object[key]` with `partials`
       * prepended to the arguments it receives.
       *
       * This method differs from `_.bind` by allowing bound functions to reference
       * methods that may be redefined or don't yet exist. See
       * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
       * for more details.
       *
       * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic
       * builds, may be used as a placeholder for partially applied arguments.
       *
       * @static
       * @memberOf _
       * @since 0.10.0
       *  Function
       * @param {Object} object The object to invoke the method on.
       * @param {string} key The key of the method.
       * @param {...*} [partials] The arguments to be partially applied.
       * @returns {Function} Returns the new bound function.
       * @example
       *
       * var object = {
       *   'user': 'fred',
       *   'greet': function(greeting, punctuation) {
       *     return greeting + ' ' + this.user + punctuation;
       *   }
       * };
       *
       * var bound = _.bindKey(object, 'greet', 'hi');
       * bound('!');
       * // => 'hi fred!'
       *
       * object.greet = function(greeting, punctuation) {
       *   return greeting + 'ya ' + this.user + punctuation;
       * };
       *
       * bound('!');
       * // => 'hiya fred!'
       *
       * // Bound with placeholders.
       * var bound = _.bindKey(object, 'greet', _, '!');
       * bound('hi');
       * // => 'hiya fred!'
       */
      var bindKey = baseRest(function (object, key, partials) {
        var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
        if (partials.length) {
          var holders = replaceHolders(partials, getHolder(bindKey));
          bitmask |= WRAP_PARTIAL_FLAG;
        }
        return createWrap(key, bitmask, object, partials, holders);
      });

      /*
       * Creates a function that accepts arguments of `func` and either invokes
       * `func` returning its result, if at least `arity` number of arguments have
       * been provided, or returns a function that accepts the remaining `func`
       * arguments, and so on. The arity of `func` may be specified if `func.length`
       * is not sufficient.
       *
       * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
       * may be used as a placeholder for provided arguments.
       *
       * **Note:** This method doesn't set the "length" property of curried functions.
       *
       * @static
       * @memberOf _
       * @since 2.0.0
       *  Function
       * @param {Function} func The function to curry.
       * @param {number} [arity=func.length] The arity of `func`.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {Function} Returns the new curried function.
       * @example
       *
       * var abc = function(a, b, c) {
       *   return [a, b, c];
       * };
       *
       * var curried = _.curry(abc);
       *
       * curried(1)(2)(3);
       * // => [1, 2, 3]
       *
       * curried(1, 2)(3);
       * // => [1, 2, 3]
       *
       * curried(1, 2, 3);
       * // => [1, 2, 3]
       *
       * // Curried with placeholders.
       * curried(1)(_, 3)(2);
       * // => [1, 2, 3]
       */
      function curry(func, arity, guard) {
        arity = guard ? undefined$1 : arity;
        var result = createWrap(func, WRAP_CURRY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);
        result.placeholder = curry.placeholder;
        return result;
      }

      /*
       * This method is like `_.curry` except that arguments are applied to `func`
       * in the manner of `_.partialRight` instead of `_.partial`.
       *
       * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
       * builds, may be used as a placeholder for provided arguments.
       *
       * **Note:** This method doesn't set the "length" property of curried functions.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Function
       * @param {Function} func The function to curry.
       * @param {number} [arity=func.length] The arity of `func`.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {Function} Returns the new curried function.
       * @example
       *
       * var abc = function(a, b, c) {
       *   return [a, b, c];
       * };
       *
       * var curried = _.curryRight(abc);
       *
       * curried(3)(2)(1);
       * // => [1, 2, 3]
       *
       * curried(2, 3)(1);
       * // => [1, 2, 3]
       *
       * curried(1, 2, 3);
       * // => [1, 2, 3]
       *
       * // Curried with placeholders.
       * curried(3)(1, _)(2);
       * // => [1, 2, 3]
       */
      function curryRight(func, arity, guard) {
        arity = guard ? undefined$1 : arity;
        var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);
        result.placeholder = curryRight.placeholder;
        return result;
      }

      /*
       * Creates a debounced function that delays invoking `func` until after `wait`
       * milliseconds have elapsed since the last time the debounced function was
       * invoked. The debounced function comes with a `cancel` method to cancel
       * delayed `func` invocations and a `flush` method to immediately invoke them.
       * Provide `options` to indicate whether `func` should be invoked on the
       * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
       * with the last arguments provided to the debounced function. Subsequent
       * calls to the debounced function return the result of the last `func`
       * invocation.
       *
       * **Note:** If `leading` and `trailing` options are `true`, `func` is
       * invoked on the trailing edge of the timeout only if the debounced function
       * is invoked more than once during the `wait` timeout.
       *
       * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
       * until to the next tick, similar to `setTimeout` with a timeout of `0`.
       *
       * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
       * for details over the differences between `_.debounce` and `_.throttle`.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Function
       * @param {Function} func The function to debounce.
       * @param {number} [wait=0] The number of milliseconds to delay.
       * @param {Object} [options={}] The options object.
       * @param {boolean} [options.leading=false]
       *  Specify invoking on the leading edge of the timeout.
       * @param {number} [options.maxWait]
       *  The maximum time `func` is allowed to be delayed before it's invoked.
       * @param {boolean} [options.trailing=true]
       *  Specify invoking on the trailing edge of the timeout.
       * @returns {Function} Returns the new debounced function.
       * @example
       *
       * // Avoid costly calculations while the window size is in flux.
       * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
       *
       * // Invoke `sendMail` when clicked, debouncing subsequent calls.
       * jQuery(element).on('click', _.debounce(sendMail, 300, {
       *   'leading': true,
       *   'trailing': false
       * }));
       *
       * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
       * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
       * var source = new EventSource('/stream');
       * jQuery(source).on('message', debounced);
       *
       * // Cancel the trailing debounced invocation.
       * jQuery(window).on('popstate', debounced.cancel);
       */
      function debounce(func, wait, options) {
        var lastArgs,
          lastThis,
          maxWait,
          result,
          timerId,
          lastCallTime,
          lastInvokeTime = 0,
          leading = false,
          maxing = false,
          trailing = true;

        if (typeof func != 'function') {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        wait = toNumber(wait) || 0;
        if (isObject(options)) {
          leading = !!options.leading;
          maxing = 'maxWait' in options;
          maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
          trailing = 'trailing' in options ? !!options.trailing : trailing;
        }

        function invokeFunc(time) {
          var args = lastArgs,
            thisArg = lastThis;

          lastArgs = lastThis = undefined$1;
          lastInvokeTime = time;
          result = func.apply(thisArg, args);
          return result;
        }

        function leadingEdge(time) {
          // Reset any `maxWait` timer.
          lastInvokeTime = time;
          // Start the timer for the trailing edge.
          timerId = setTimeout(timerExpired, wait);
          // Invoke the leading edge.
          return leading ? invokeFunc(time) : result;
        }

        function remainingWait(time) {
          var timeSinceLastCall = time - lastCallTime,
            timeSinceLastInvoke = time - lastInvokeTime,
            timeWaiting = wait - timeSinceLastCall;

          return maxing
            ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
            : timeWaiting;
        }

        function shouldInvoke(time) {
          var timeSinceLastCall = time - lastCallTime,
            timeSinceLastInvoke = time - lastInvokeTime;

          // Either this is the first call, activity has stopped and we're at the
          // trailing edge, the system time has gone backwards and we're treating
          // it as the trailing edge, or we've hit the `maxWait` limit.
          return (lastCallTime === undefined$1 || (timeSinceLastCall >= wait) ||
            (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
        }

        function timerExpired() {
          var time = now();
          if (shouldInvoke(time)) {
            return trailingEdge(time);
          }
          // Restart the timer.
          timerId = setTimeout(timerExpired, remainingWait(time));
        }

        function trailingEdge(time) {
          timerId = undefined$1;

          // Only invoke if we have `lastArgs` which means `func` has been
          // debounced at least once.
          if (trailing && lastArgs) {
            return invokeFunc(time);
          }
          lastArgs = lastThis = undefined$1;
          return result;
        }

        function cancel() {
          if (timerId !== undefined$1) {
            clearTimeout(timerId);
          }
          lastInvokeTime = 0;
          lastArgs = lastCallTime = lastThis = timerId = undefined$1;
        }

        function flush() {
          return timerId === undefined$1 ? result : trailingEdge(now());
        }

        function debounced() {
          var time = now(),
            isInvoking = shouldInvoke(time);

          lastArgs = arguments;
          lastThis = this;
          lastCallTime = time;

          if (isInvoking) {
            if (timerId === undefined$1) {
              return leadingEdge(lastCallTime);
            }
            if (maxing) {
              // Handle invocations in a tight loop.
              clearTimeout(timerId);
              timerId = setTimeout(timerExpired, wait);
              return invokeFunc(lastCallTime);
            }
          }
          if (timerId === undefined$1) {
            timerId = setTimeout(timerExpired, wait);
          }
          return result;
        }
        debounced.cancel = cancel;
        debounced.flush = flush;
        return debounced;
      }

      /*
       * Defers invoking the `func` until the current call stack has cleared. Any
       * additional arguments are provided to `func` when it's invoked.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Function
       * @param {Function} func The function to defer.
       * @param {...*} [args] The arguments to invoke `func` with.
       * @returns {number} Returns the timer id.
       * @example
       *
       * _.defer(function(text) {
       *   console.log(text);
       * }, 'deferred');
       * // => Logs 'deferred' after one millisecond.
       */
      var defer = baseRest(function (func, args) {
        return baseDelay(func, 1, args);
      });

      /*
       * Invokes `func` after `wait` milliseconds. Any additional arguments are
       * provided to `func` when it's invoked.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Function
       * @param {Function} func The function to delay.
       * @param {number} wait The number of milliseconds to delay invocation.
       * @param {...*} [args] The arguments to invoke `func` with.
       * @returns {number} Returns the timer id.
       * @example
       *
       * _.delay(function(text) {
       *   console.log(text);
       * }, 1000, 'later');
       * // => Logs 'later' after one second.
       */
      var delay = baseRest(function (func, wait, args) {
        return baseDelay(func, toNumber(wait) || 0, args);
      });

      /*
       * Creates a function that invokes `func` with arguments reversed.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Function
       * @param {Function} func The function to flip arguments for.
       * @returns {Function} Returns the new flipped function.
       * @example
       *
       * var flipped = _.flip(function() {
       *   return _.toArray(arguments);
       * });
       *
       * flipped('a', 'b', 'c', 'd');
       * // => ['d', 'c', 'b', 'a']
       */
      function flip(func) {
        return createWrap(func, WRAP_FLIP_FLAG);
      }

      /*
       * Creates a function that memoizes the result of `func`. If `resolver` is
       * provided, it determines the cache key for storing the result based on the
       * arguments provided to the memoized function. By default, the first argument
       * provided to the memoized function is used as the map cache key. The `func`
       * is invoked with the `this` binding of the memoized function.
       *
       * **Note:** The cache is exposed as the `cache` property on the memoized
       * function. Its creation may be customized by replacing the `_.memoize.Cache`
       * constructor with one whose instances implement the
       * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
       * method interface of `clear`, `delete`, `get`, `has`, and `set`.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Function
       * @param {Function} func The function to have its output memoized.
       * @param {Function} [resolver] The function to resolve the cache key.
       * @returns {Function} Returns the new memoized function.
       * @example
       *
       * var object = { 'a': 1, 'b': 2 };
       * var other = { 'c': 3, 'd': 4 };
       *
       * var values = _.memoize(_.values);
       * values(object);
       * // => [1, 2]
       *
       * values(other);
       * // => [3, 4]
       *
       * object.a = 2;
       * values(object);
       * // => [1, 2]
       *
       * // Modify the result cache.
       * values.cache.set(object, ['a', 'b']);
       * values(object);
       * // => ['a', 'b']
       *
       * // Replace `_.memoize.Cache`.
       * _.memoize.Cache = WeakMap;
       */
      function memoize(func, resolver) {
        if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        var memoized = function () {
          var args = arguments,
            key = resolver ? resolver.apply(this, args) : args[0],
            cache = memoized.cache;

          if (cache.has(key)) {
            return cache.get(key);
          }
          var result = func.apply(this, args);
          memoized.cache = cache.set(key, result) || cache;
          return result;
        };
        memoized.cache = new (memoize.Cache || MapCache);
        return memoized;
      }

      // Expose `MapCache`.
      memoize.Cache = MapCache;

      /*
       * Creates a function that negates the result of the predicate `func`. The
       * `func` predicate is invoked with the `this` binding and arguments of the
       * created function.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Function
       * @param {Function} predicate The predicate to negate.
       * @returns {Function} Returns the new negated function.
       * @example
       *
       * function isEven(n) {
       *   return n % 2 == 0;
       * }
       *
       * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
       * // => [1, 3, 5]
       */
      function negate(predicate) {
        if (typeof predicate != 'function') {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        return function () {
          var args = arguments;
          switch (args.length) {
            case 0: return !predicate.call(this);
            case 1: return !predicate.call(this, args[0]);
            case 2: return !predicate.call(this, args[0], args[1]);
            case 3: return !predicate.call(this, args[0], args[1], args[2]);
          }
          return !predicate.apply(this, args);
        };
      }

      /*
       * Creates a function that is restricted to invoking `func` once. Repeat calls
       * to the function return the value of the first invocation. The `func` is
       * invoked with the `this` binding and arguments of the created function.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Function
       * @param {Function} func The function to restrict.
       * @returns {Function} Returns the new restricted function.
       * @example
       *
       * var initialize = _.once(createApplication);
       * initialize();
       * initialize();
       * // => `createApplication` is invoked once
       */
      function once(func) {
        return before(2, func);
      }

      /*
       * Creates a function that invokes `func` with its arguments transformed.
       *
       * @static
       * @since 4.0.0
       * @memberOf _
       *  Function
       * @param {Function} func The function to wrap.
       * @param {...(Function|Function[])} [transforms=[_.identity]]
       *  The argument transforms.
       * @returns {Function} Returns the new function.
       * @example
       *
       * function doubled(n) {
       *   return n * 2;
       * }
       *
       * function square(n) {
       *   return n * n;
       * }
       *
       * var func = _.overArgs(function(x, y) {
       *   return [x, y];
       * }, [square, doubled]);
       *
       * func(9, 3);
       * // => [81, 6]
       *
       * func(10, 5);
       * // => [100, 10]
       */
      var overArgs = castRest(function (func, transforms) {
        transforms = (transforms.length == 1 && isArray(transforms[0]))
          ? arrayMap(transforms[0], baseUnary(getIteratee()))
          : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));

        var funcsLength = transforms.length;
        return baseRest(function (args) {
          var index = -1,
            length = nativeMin(args.length, funcsLength);

          while (++index < length) {
            args[index] = transforms[index].call(this, args[index]);
          }
          return apply(func, this, args);
        });
      });

      /*
       * Creates a function that invokes `func` with `partials` prepended to the
       * arguments it receives. This method is like `_.bind` except it does **not**
       * alter the `this` binding.
       *
       * The `_.partial.placeholder` value, which defaults to `_` in monolithic
       * builds, may be used as a placeholder for partially applied arguments.
       *
       * **Note:** This method doesn't set the "length" property of partially
       * applied functions.
       *
       * @static
       * @memberOf _
       * @since 0.2.0
       *  Function
       * @param {Function} func The function to partially apply arguments to.
       * @param {...*} [partials] The arguments to be partially applied.
       * @returns {Function} Returns the new partially applied function.
       * @example
       *
       * function greet(greeting, name) {
       *   return greeting + ' ' + name;
       * }
       *
       * var sayHelloTo = _.partial(greet, 'hello');
       * sayHelloTo('fred');
       * // => 'hello fred'
       *
       * // Partially applied with placeholders.
       * var greetFred = _.partial(greet, _, 'fred');
       * greetFred('hi');
       * // => 'hi fred'
       */
      var partial = baseRest(function (func, partials) {
        var holders = replaceHolders(partials, getHolder(partial));
        return createWrap(func, WRAP_PARTIAL_FLAG, undefined$1, partials, holders);
      });

      /*
       * This method is like `_.partial` except that partially applied arguments
       * are appended to the arguments it receives.
       *
       * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic
       * builds, may be used as a placeholder for partially applied arguments.
       *
       * **Note:** This method doesn't set the "length" property of partially
       * applied functions.
       *
       * @static
       * @memberOf _
       * @since 1.0.0
       *  Function
       * @param {Function} func The function to partially apply arguments to.
       * @param {...*} [partials] The arguments to be partially applied.
       * @returns {Function} Returns the new partially applied function.
       * @example
       *
       * function greet(greeting, name) {
       *   return greeting + ' ' + name;
       * }
       *
       * var greetFred = _.partialRight(greet, 'fred');
       * greetFred('hi');
       * // => 'hi fred'
       *
       * // Partially applied with placeholders.
       * var sayHelloTo = _.partialRight(greet, 'hello', _);
       * sayHelloTo('fred');
       * // => 'hello fred'
       */
      var partialRight = baseRest(function (func, partials) {
        var holders = replaceHolders(partials, getHolder(partialRight));
        return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined$1, partials, holders);
      });

      /*
       * Creates a function that invokes `func` with arguments arranged according
       * to the specified `indexes` where the argument value at the first index is
       * provided as the first argument, the argument value at the second index is
       * provided as the second argument, and so on.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Function
       * @param {Function} func The function to rearrange arguments for.
       * @param {...(number|number[])} indexes The arranged argument indexes.
       * @returns {Function} Returns the new function.
       * @example
       *
       * var rearged = _.rearg(function(a, b, c) {
       *   return [a, b, c];
       * }, [2, 0, 1]);
       *
       * rearged('b', 'c', 'a')
       * // => ['a', 'b', 'c']
       */
      var rearg = flatRest(function (func, indexes) {
        return createWrap(func, WRAP_REARG_FLAG, undefined$1, undefined$1, undefined$1, indexes);
      });

      /*
       * Creates a function that invokes `func` with the `this` binding of the
       * created function and arguments from `start` and beyond provided as
       * an array.
       *
       * **Note:** This method is based on the
       * [rest parameter](https://mdn.io/rest_parameters).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Function
       * @param {Function} func The function to apply a rest parameter to.
       * @param {number} [start=func.length-1] The start position of the rest parameter.
       * @returns {Function} Returns the new function.
       * @example
       *
       * var say = _.rest(function(what, names) {
       *   return what + ' ' + _.initial(names).join(', ') +
       *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);
       * });
       *
       * say('hello', 'fred', 'barney', 'pebbles');
       * // => 'hello fred, barney, & pebbles'
       */
      function rest(func, start) {
        if (typeof func != 'function') {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        start = start === undefined$1 ? start : toInteger(start);
        return baseRest(func, start);
      }

      /*
       * Creates a function that invokes `func` with the `this` binding of the
       * create function and an array of arguments much like
       * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
       *
       * **Note:** This method is based on the
       * [spread operator](https://mdn.io/spread_operator).
       *
       * @static
       * @memberOf _
       * @since 3.2.0
       *  Function
       * @param {Function} func The function to spread arguments over.
       * @param {number} [start=0] The start position of the spread.
       * @returns {Function} Returns the new function.
       * @example
       *
       * var say = _.spread(function(who, what) {
       *   return who + ' says ' + what;
       * });
       *
       * say(['fred', 'hello']);
       * // => 'fred says hello'
       *
       * var numbers = Promise.all([
       *   Promise.resolve(40),
       *   Promise.resolve(36)
       * ]);
       *
       * numbers.then(_.spread(function(x, y) {
       *   return x + y;
       * }));
       * // => a Promise of 76
       */
      function spread(func, start) {
        if (typeof func != 'function') {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        start = start == null ? 0 : nativeMax(toInteger(start), 0);
        return baseRest(function (args) {
          var array = args[start],
            otherArgs = castSlice(args, 0, start);

          if (array) {
            arrayPush(otherArgs, array);
          }
          return apply(func, this, otherArgs);
        });
      }

      /*
       * Creates a throttled function that only invokes `func` at most once per
       * every `wait` milliseconds. The throttled function comes with a `cancel`
       * method to cancel delayed `func` invocations and a `flush` method to
       * immediately invoke them. Provide `options` to indicate whether `func`
       * should be invoked on the leading and/or trailing edge of the `wait`
       * timeout. The `func` is invoked with the last arguments provided to the
       * throttled function. Subsequent calls to the throttled function return the
       * result of the last `func` invocation.
       *
       * **Note:** If `leading` and `trailing` options are `true`, `func` is
       * invoked on the trailing edge of the timeout only if the throttled function
       * is invoked more than once during the `wait` timeout.
       *
       * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
       * until to the next tick, similar to `setTimeout` with a timeout of `0`.
       *
       * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
       * for details over the differences between `_.throttle` and `_.debounce`.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Function
       * @param {Function} func The function to throttle.
       * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
       * @param {Object} [options={}] The options object.
       * @param {boolean} [options.leading=true]
       *  Specify invoking on the leading edge of the timeout.
       * @param {boolean} [options.trailing=true]
       *  Specify invoking on the trailing edge of the timeout.
       * @returns {Function} Returns the new throttled function.
       * @example
       *
       * // Avoid excessively updating the position while scrolling.
       * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
       *
       * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
       * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
       * jQuery(element).on('click', throttled);
       *
       * // Cancel the trailing throttled invocation.
       * jQuery(window).on('popstate', throttled.cancel);
       */
      function throttle(func, wait, options) {
        var leading = true,
          trailing = true;

        if (typeof func != 'function') {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        if (isObject(options)) {
          leading = 'leading' in options ? !!options.leading : leading;
          trailing = 'trailing' in options ? !!options.trailing : trailing;
        }
        return debounce(func, wait, {
          'leading': leading,
          'maxWait': wait,
          'trailing': trailing
        });
      }

      /*
       * Creates a function that accepts up to one argument, ignoring any
       * additional arguments.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Function
       * @param {Function} func The function to cap arguments for.
       * @returns {Function} Returns the new capped function.
       * @example
       *
       * _.map(['6', '8', '10'], _.unary(parseInt));
       * // => [6, 8, 10]
       */
      function unary(func) {
        return ary(func, 1);
      }

      /*
       * Creates a function that provides `value` to `wrapper` as its first
       * argument. Any additional arguments provided to the function are appended
       * to those provided to the `wrapper`. The wrapper is invoked with the `this`
       * binding of the created function.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Function
       * @param {*} value The value to wrap.
       * @param {Function} [wrapper=identity] The wrapper function.
       * @returns {Function} Returns the new function.
       * @example
       *
       * var p = _.wrap(_.escape, function(func, text) {
       *   return '<p>' + func(text) + '</p>';
       * });
       *
       * p('fred, barney, & pebbles');
       * // => '<p>fred, barney, &amp; pebbles</p>'
       */
      function wrap(value, wrapper) {
        return partial(castFunction(wrapper), value);
      }

      /*------------------------------------------------------------------------*/

      /*
       * Casts `value` as an array if it's not one.
       *
       * @static
       * @memberOf _
       * @since 4.4.0
       *  Lang
       * @param {*} value The value to inspect.
       * @returns {Array} Returns the cast array.
       * @example
       *
       * _.castArray(1);
       * // => [1]
       *
       * _.castArray({ 'a': 1 });
       * // => [{ 'a': 1 }]
       *
       * _.castArray('abc');
       * // => ['abc']
       *
       * _.castArray(null);
       * // => [null]
       *
       * _.castArray(undefined);
       * // => [undefined]
       *
       * _.castArray();
       * // => []
       *
       * var array = [1, 2, 3];
       * console.log(_.castArray(array) === array);
       * // => true
       */
      function castArray() {
        if (!arguments.length) {
          return [];
        }
        var value = arguments[0];
        return isArray(value) ? value : [value];
      }

      /*
       * Creates a shallow clone of `value`.
       *
       * **Note:** This method is loosely based on the
       * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
       * and supports cloning arrays, array buffers, booleans, date objects, maps,
       * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
       * arrays. The own enumerable properties of `arguments` objects are cloned
       * as plain objects. An empty object is returned for uncloneable values such
       * as error objects, functions, DOM nodes, and WeakMaps.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to clone.
       * @returns {*} Returns the cloned value.
       * @see _.cloneDeep
       * @example
       *
       * var objects = [{ 'a': 1 }, { 'b': 2 }];
       *
       * var shallow = _.clone(objects);
       * console.log(shallow[0] === objects[0]);
       * // => true
       */
      function clone(value) {
        return baseClone(value, CLONE_SYMBOLS_FLAG);
      }

      /*
       * This method is like `_.clone` except that it accepts `customizer` which
       * is invoked to produce the cloned value. If `customizer` returns `undefined`,
       * cloning is handled by the method instead. The `customizer` is invoked with
       * up to four arguments; (value [, index|key, object, stack]).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to clone.
       * @param {Function} [customizer] The function to customize cloning.
       * @returns {*} Returns the cloned value.
       * @see _.cloneDeepWith
       * @example
       *
       * function customizer(value) {
       *   if (_.isElement(value)) {
       *     return value.cloneNode(false);
       *   }
       * }
       *
       * var el = _.cloneWith(document.body, customizer);
       *
       * console.log(el === document.body);
       * // => false
       * console.log(el.nodeName);
       * // => 'BODY'
       * console.log(el.childNodes.length);
       * // => 0
       */
      function cloneWith(value, customizer) {
        customizer = typeof customizer == 'function' ? customizer : undefined$1;
        return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
      }

      /*
       * This method is like `_.clone` except that it recursively clones `value`.
       *
       * @static
       * @memberOf _
       * @since 1.0.0
       *  Lang
       * @param {*} value The value to recursively clone.
       * @returns {*} Returns the deep cloned value.
       * @see _.clone
       * @example
       *
       * var objects = [{ 'a': 1 }, { 'b': 2 }];
       *
       * var deep = _.cloneDeep(objects);
       * console.log(deep[0] === objects[0]);
       * // => false
       */
      function cloneDeep(value) {
        return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
      }

      /*
       * This method is like `_.cloneWith` except that it recursively clones `value`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to recursively clone.
       * @param {Function} [customizer] The function to customize cloning.
       * @returns {*} Returns the deep cloned value.
       * @see _.cloneWith
       * @example
       *
       * function customizer(value) {
       *   if (_.isElement(value)) {
       *     return value.cloneNode(true);
       *   }
       * }
       *
       * var el = _.cloneDeepWith(document.body, customizer);
       *
       * console.log(el === document.body);
       * // => false
       * console.log(el.nodeName);
       * // => 'BODY'
       * console.log(el.childNodes.length);
       * // => 20
       */
      function cloneDeepWith(value, customizer) {
        customizer = typeof customizer == 'function' ? customizer : undefined$1;
        return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
      }

      /*
       * Checks if `object` conforms to `source` by invoking the predicate
       * properties of `source` with the corresponding property values of `object`.
       *
       * **Note:** This method is equivalent to `_.conforms` when `source` is
       * partially applied.
       *
       * @static
       * @memberOf _
       * @since 4.14.0
       *  Lang
       * @param {Object} object The object to inspect.
       * @param {Object} source The object of property predicates to conform to.
       * @returns {boolean} Returns `true` if `object` conforms, else `false`.
       * @example
       *
       * var object = { 'a': 1, 'b': 2 };
       *
       * _.conformsTo(object, { 'b': function(n) { return n > 1; } });
       * // => true
       *
       * _.conformsTo(object, { 'b': function(n) { return n > 2; } });
       * // => false
       */
      function conformsTo(object, source) {
        return source == null || baseConformsTo(object, source, keys(source));
      }

      /*
       * Performs a
       * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
       * comparison between two values to determine if they are equivalent.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to compare.
       * @param {*} other The other value to compare.
       * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
       * @example
       *
       * var object = { 'a': 1 };
       * var other = { 'a': 1 };
       *
       * _.eq(object, object);
       * // => true
       *
       * _.eq(object, other);
       * // => false
       *
       * _.eq('a', 'a');
       * // => true
       *
       * _.eq('a', Object('a'));
       * // => false
       *
       * _.eq(NaN, NaN);
       * // => true
       */
      function eq(value, other) {
        return value === other || (value !== value && other !== other);
      }

      /*
       * Checks if `value` is greater than `other`.
       *
       * @static
       * @memberOf _
       * @since 3.9.0
       *  Lang
       * @param {*} value The value to compare.
       * @param {*} other The other value to compare.
       * @returns {boolean} Returns `true` if `value` is greater than `other`,
       *  else `false`.
       * @see _.lt
       * @example
       *
       * _.gt(3, 1);
       * // => true
       *
       * _.gt(3, 3);
       * // => false
       *
       * _.gt(1, 3);
       * // => false
       */
      var gt = createRelationalOperation(baseGt);

      /*
       * Checks if `value` is greater than or equal to `other`.
       *
       * @static
       * @memberOf _
       * @since 3.9.0
       *  Lang
       * @param {*} value The value to compare.
       * @param {*} other The other value to compare.
       * @returns {boolean} Returns `true` if `value` is greater than or equal to
       *  `other`, else `false`.
       * @see _.lte
       * @example
       *
       * _.gte(3, 1);
       * // => true
       *
       * _.gte(3, 3);
       * // => true
       *
       * _.gte(1, 3);
       * // => false
       */
      var gte = createRelationalOperation(function (value, other) {
        return value >= other;
      });

      /*
       * Checks if `value` is likely an `arguments` object.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is an `arguments` object,
       *  else `false`.
       * @example
       *
       * _.isArguments(function() { return arguments; }());
       * // => true
       *
       * _.isArguments([1, 2, 3]);
       * // => false
       */
      var isArguments = baseIsArguments(function () { return arguments; }()) ? baseIsArguments : function (value) {
        return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
          !propertyIsEnumerable.call(value, 'callee');
      };

      /*
       * Checks if `value` is classified as an `Array` object.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is an array, else `false`.
       * @example
       *
       * _.isArray([1, 2, 3]);
       * // => true
       *
       * _.isArray(document.body.children);
       * // => false
       *
       * _.isArray('abc');
       * // => false
       *
       * _.isArray(_.noop);
       * // => false
       */
      var isArray = Array.isArray;

      /*
       * Checks if `value` is classified as an `ArrayBuffer` object.
       *
       * @static
       * @memberOf _
       * @since 4.3.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
       * @example
       *
       * _.isArrayBuffer(new ArrayBuffer(2));
       * // => true
       *
       * _.isArrayBuffer(new Array(2));
       * // => false
       */
      var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;

      /*
       * Checks if `value` is array-like. A value is considered array-like if it's
       * not a function and has a `value.length` that's an integer greater than or
       * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
       * @example
       *
       * _.isArrayLike([1, 2, 3]);
       * // => true
       *
       * _.isArrayLike(document.body.children);
       * // => true
       *
       * _.isArrayLike('abc');
       * // => true
       *
       * _.isArrayLike(_.noop);
       * // => false
       */
      function isArrayLike(value) {
        return value != null && isLength(value.length) && !isFunction(value);
      }

      /*
       * This method is like `_.isArrayLike` except that it also checks if `value`
       * is an object.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is an array-like object,
       *  else `false`.
       * @example
       *
       * _.isArrayLikeObject([1, 2, 3]);
       * // => true
       *
       * _.isArrayLikeObject(document.body.children);
       * // => true
       *
       * _.isArrayLikeObject('abc');
       * // => false
       *
       * _.isArrayLikeObject(_.noop);
       * // => false
       */
      function isArrayLikeObject(value) {
        return isObjectLike(value) && isArrayLike(value);
      }

      /*
       * Checks if `value` is classified as a boolean primitive or object.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
       * @example
       *
       * _.isBoolean(false);
       * // => true
       *
       * _.isBoolean(null);
       * // => false
       */
      function isBoolean(value) {
        return value === true || value === false ||
          (isObjectLike(value) && baseGetTag(value) == boolTag);
      }

      /*
       * Checks if `value` is a buffer.
       *
       * @static
       * @memberOf _
       * @since 4.3.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
       * @example
       *
       * _.isBuffer(new Buffer(2));
       * // => true
       *
       * _.isBuffer(new Uint8Array(2));
       * // => false
       */
      var isBuffer = nativeIsBuffer || stubFalse;

      /*
       * Checks if `value` is classified as a `Date` object.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
       * @example
       *
       * _.isDate(new Date);
       * // => true
       *
       * _.isDate('Mon April 23 2012');
       * // => false
       */
      var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;

      /*
       * Checks if `value` is likely a DOM element.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
       * @example
       *
       * _.isElement(document.body);
       * // => true
       *
       * _.isElement('<body>');
       * // => false
       */
      function isElement(value) {
        return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
      }

      /*
       * Checks if `value` is an empty object, collection, map, or set.
       *
       * Objects are considered empty if they have no own enumerable string keyed
       * properties.
       *
       * Array-like values such as `arguments` objects, arrays, buffers, strings, or
       * jQuery-like collections are considered empty if they have a `length` of `0`.
       * Similarly, maps and sets are considered empty if they have a `size` of `0`.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is empty, else `false`.
       * @example
       *
       * _.isEmpty(null);
       * // => true
       *
       * _.isEmpty(true);
       * // => true
       *
       * _.isEmpty(1);
       * // => true
       *
       * _.isEmpty([1, 2, 3]);
       * // => false
       *
       * _.isEmpty({ 'a': 1 });
       * // => false
       */
      function isEmpty(value) {
        if (value == null) {
          return true;
        }
        if (isArrayLike(value) &&
          (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
            isBuffer(value) || isTypedArray(value) || isArguments(value))) {
          return !value.length;
        }
        var tag = getTag(value);
        if (tag == mapTag || tag == setTag) {
          return !value.size;
        }
        if (isPrototype(value)) {
          return !baseKeys(value).length;
        }
        for (var key in value) {
          if (hasOwnProperty.call(value, key)) {
            return false;
          }
        }
        return true;
      }

      /*
       * Performs a deep comparison between two values to determine if they are
       * equivalent.
       *
       * **Note:** This method supports comparing arrays, array buffers, booleans,
       * date objects, error objects, maps, numbers, `Object` objects, regexes,
       * sets, strings, symbols, and typed arrays. `Object` objects are compared
       * by their own, not inherited, enumerable properties. Functions and DOM
       * nodes are compared by strict equality, i.e. `===`.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to compare.
       * @param {*} other The other value to compare.
       * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
       * @example
       *
       * var object = { 'a': 1 };
       * var other = { 'a': 1 };
       *
       * _.isEqual(object, other);
       * // => true
       *
       * object === other;
       * // => false
       */
      function isEqual(value, other) {
        return baseIsEqual(value, other);
      }

      /*
       * This method is like `_.isEqual` except that it accepts `customizer` which
       * is invoked to compare values. If `customizer` returns `undefined`, comparisons
       * are handled by the method instead. The `customizer` is invoked with up to
       * six arguments: (objValue, othValue [, index|key, object, other, stack]).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to compare.
       * @param {*} other The other value to compare.
       * @param {Function} [customizer] The function to customize comparisons.
       * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
       * @example
       *
       * function isGreeting(value) {
       *   return /^h(?:i|ello)$/.test(value);
       * }
       *
       * function customizer(objValue, othValue) {
       *   if (isGreeting(objValue) && isGreeting(othValue)) {
       *     return true;
       *   }
       * }
       *
       * var array = ['hello', 'goodbye'];
       * var other = ['hi', 'goodbye'];
       *
       * _.isEqualWith(array, other, customizer);
       * // => true
       */
      function isEqualWith(value, other, customizer) {
        customizer = typeof customizer == 'function' ? customizer : undefined$1;
        var result = customizer ? customizer(value, other) : undefined$1;
        return result === undefined$1 ? baseIsEqual(value, other, undefined$1, customizer) : !!result;
      }

      /*
       * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
       * `SyntaxError`, `TypeError`, or `URIError` object.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is an error object, else `false`.
       * @example
       *
       * _.isError(new Error);
       * // => true
       *
       * _.isError(Error);
       * // => false
       */
      function isError(value) {
        if (!isObjectLike(value)) {
          return false;
        }
        var tag = baseGetTag(value);
        return tag == errorTag || tag == domExcTag ||
          (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));
      }

      /*
       * Checks if `value` is a finite primitive number.
       *
       * **Note:** This method is based on
       * [`Number.isFinite`](https://mdn.io/Number/isFinite).
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
       * @example
       *
       * _.isFinite(3);
       * // => true
       *
       * _.isFinite(Number.MIN_VALUE);
       * // => true
       *
       * _.isFinite(Infinity);
       * // => false
       *
       * _.isFinite('3');
       * // => false
       */
      function isFinite(value) {
        return typeof value == 'number' && nativeIsFinite(value);
      }

      /*
       * Checks if `value` is classified as a `Function` object.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a function, else `false`.
       * @example
       *
       * _.isFunction(_);
       * // => true
       *
       * _.isFunction(/abc/);
       * // => false
       */
      function isFunction(value) {
        if (!isObject(value)) {
          return false;
        }
        // The use of `Object#toString` avoids issues with the `typeof` operator
        // in Safari 9 which returns 'object' for typed arrays and other constructors.
        var tag = baseGetTag(value);
        return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
      }

      /*
       * Checks if `value` is an integer.
       *
       * **Note:** This method is based on
       * [`Number.isInteger`](https://mdn.io/Number/isInteger).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is an integer, else `false`.
       * @example
       *
       * _.isInteger(3);
       * // => true
       *
       * _.isInteger(Number.MIN_VALUE);
       * // => false
       *
       * _.isInteger(Infinity);
       * // => false
       *
       * _.isInteger('3');
       * // => false
       */
      function isInteger(value) {
        return typeof value == 'number' && value == toInteger(value);
      }

      /*
       * Checks if `value` is a valid array-like length.
       *
       * **Note:** This method is loosely based on
       * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
       * @example
       *
       * _.isLength(3);
       * // => true
       *
       * _.isLength(Number.MIN_VALUE);
       * // => false
       *
       * _.isLength(Infinity);
       * // => false
       *
       * _.isLength('3');
       * // => false
       */
      function isLength(value) {
        return typeof value == 'number' &&
          value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
      }

      /*
       * Checks if `value` is the
       * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
       * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is an object, else `false`.
       * @example
       *
       * _.isObject({});
       * // => true
       *
       * _.isObject([1, 2, 3]);
       * // => true
       *
       * _.isObject(_.noop);
       * // => true
       *
       * _.isObject(null);
       * // => false
       */
      function isObject(value) {
        var type = typeof value;
        return value != null && (type == 'object' || type == 'function');
      }

      /*
       * Checks if `value` is object-like. A value is object-like if it's not `null`
       * and has a `typeof` result of "object".
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
       * @example
       *
       * _.isObjectLike({});
       * // => true
       *
       * _.isObjectLike([1, 2, 3]);
       * // => true
       *
       * _.isObjectLike(_.noop);
       * // => false
       *
       * _.isObjectLike(null);
       * // => false
       */
      function isObjectLike(value) {
        return value != null && typeof value == 'object';
      }

      /*
       * Checks if `value` is classified as a `Map` object.
       *
       * @static
       * @memberOf _
       * @since 4.3.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a map, else `false`.
       * @example
       *
       * _.isMap(new Map);
       * // => true
       *
       * _.isMap(new WeakMap);
       * // => false
       */
      var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;

      /*
       * Performs a partial deep comparison between `object` and `source` to
       * determine if `object` contains equivalent property values.
       *
       * **Note:** This method is equivalent to `_.matches` when `source` is
       * partially applied.
       *
       * Partial comparisons will match empty array and empty object `source`
       * values against any array or object value, respectively. See `_.isEqual`
       * for a list of supported value comparisons.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Lang
       * @param {Object} object The object to inspect.
       * @param {Object} source The object of property values to match.
       * @returns {boolean} Returns `true` if `object` is a match, else `false`.
       * @example
       *
       * var object = { 'a': 1, 'b': 2 };
       *
       * _.isMatch(object, { 'b': 2 });
       * // => true
       *
       * _.isMatch(object, { 'b': 1 });
       * // => false
       */
      function isMatch(object, source) {
        return object === source || baseIsMatch(object, source, getMatchData(source));
      }

      /*
       * This method is like `_.isMatch` except that it accepts `customizer` which
       * is invoked to compare values. If `customizer` returns `undefined`, comparisons
       * are handled by the method instead. The `customizer` is invoked with five
       * arguments: (objValue, srcValue, index|key, object, source).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {Object} object The object to inspect.
       * @param {Object} source The object of property values to match.
       * @param {Function} [customizer] The function to customize comparisons.
       * @returns {boolean} Returns `true` if `object` is a match, else `false`.
       * @example
       *
       * function isGreeting(value) {
       *   return /^h(?:i|ello)$/.test(value);
       * }
       *
       * function customizer(objValue, srcValue) {
       *   if (isGreeting(objValue) && isGreeting(srcValue)) {
       *     return true;
       *   }
       * }
       *
       * var object = { 'greeting': 'hello' };
       * var source = { 'greeting': 'hi' };
       *
       * _.isMatchWith(object, source, customizer);
       * // => true
       */
      function isMatchWith(object, source, customizer) {
        customizer = typeof customizer == 'function' ? customizer : undefined$1;
        return baseIsMatch(object, source, getMatchData(source), customizer);
      }

      /*
       * Checks if `value` is `NaN`.
       *
       * **Note:** This method is based on
       * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as
       * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for
       * `undefined` and other non-number values.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
       * @example
       *
       * _.isNaN(NaN);
       * // => true
       *
       * _.isNaN(new Number(NaN));
       * // => true
       *
       * isNaN(undefined);
       * // => true
       *
       * _.isNaN(undefined);
       * // => false
       */
      function isNaN(value) {
        // An `NaN` primitive is the only value that is not equal to itself.
        // Perform the `toStringTag` check first to avoid errors with some
        // ActiveX objects in IE.
        return isNumber(value) && value != +value;
      }

      /*
       * Checks if `value` is a pristine native function.
       *
       * **Note:** This method can't reliably detect native functions in the presence
       * of the core-js package because core-js circumvents this kind of detection.
       * Despite multiple requests, the core-js maintainer has made it clear: any
       * attempt to fix the detection will be obstructed. As a result, we're left
       * with little choice but to throw an error. Unfortunately, this also affects
       * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
       * which rely on core-js.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a native function,
       *  else `false`.
       * @example
       *
       * _.isNative(Array.prototype.push);
       * // => true
       *
       * _.isNative(_);
       * // => false
       */
      function isNative(value) {
        if (isMaskable(value)) {
          throw new Error(CORE_ERROR_TEXT);
        }
        return baseIsNative(value);
      }

      /*
       * Checks if `value` is `null`.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is `null`, else `false`.
       * @example
       *
       * _.isNull(null);
       * // => true
       *
       * _.isNull(void 0);
       * // => false
       */
      function isNull(value) {
        return value === null;
      }

      /*
       * Checks if `value` is `null` or `undefined`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
       * @example
       *
       * _.isNil(null);
       * // => true
       *
       * _.isNil(void 0);
       * // => true
       *
       * _.isNil(NaN);
       * // => false
       */
      function isNil(value) {
        return value == null;
      }

      /*
       * Checks if `value` is classified as a `Number` primitive or object.
       *
       * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
       * classified as numbers, use the `_.isFinite` method.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a number, else `false`.
       * @example
       *
       * _.isNumber(3);
       * // => true
       *
       * _.isNumber(Number.MIN_VALUE);
       * // => true
       *
       * _.isNumber(Infinity);
       * // => true
       *
       * _.isNumber('3');
       * // => false
       */
      function isNumber(value) {
        return typeof value == 'number' ||
          (isObjectLike(value) && baseGetTag(value) == numberTag);
      }

      /*
       * Checks if `value` is a plain object, that is, an object created by the
       * `Object` constructor or one with a `[[Prototype]]` of `null`.
       *
       * @static
       * @memberOf _
       * @since 0.8.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       * }
       *
       * _.isPlainObject(new Foo);
       * // => false
       *
       * _.isPlainObject([1, 2, 3]);
       * // => false
       *
       * _.isPlainObject({ 'x': 0, 'y': 0 });
       * // => true
       *
       * _.isPlainObject(Object.create(null));
       * // => true
       */
      function isPlainObject(value) {
        if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
          return false;
        }
        var proto = getPrototype(value);
        if (proto === null) {
          return true;
        }
        var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
        return typeof Ctor == 'function' && Ctor instanceof Ctor &&
          funcToString.call(Ctor) == objectCtorString;
      }

      /*
       * Checks if `value` is classified as a `RegExp` object.
       *
       * @static
       * @memberOf _
       * @since 0.1.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
       * @example
       *
       * _.isRegExp(/abc/);
       * // => true
       *
       * _.isRegExp('/abc/');
       * // => false
       */
      var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;

      /*
       * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
       * double precision number which isn't the result of a rounded unsafe integer.
       *
       * **Note:** This method is based on
       * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
       * @example
       *
       * _.isSafeInteger(3);
       * // => true
       *
       * _.isSafeInteger(Number.MIN_VALUE);
       * // => false
       *
       * _.isSafeInteger(Infinity);
       * // => false
       *
       * _.isSafeInteger('3');
       * // => false
       */
      function isSafeInteger(value) {
        return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
      }

      /*
       * Checks if `value` is classified as a `Set` object.
       *
       * @static
       * @memberOf _
       * @since 4.3.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a set, else `false`.
       * @example
       *
       * _.isSet(new Set);
       * // => true
       *
       * _.isSet(new WeakSet);
       * // => false
       */
      var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;

      /*
       * Checks if `value` is classified as a `String` primitive or object.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a string, else `false`.
       * @example
       *
       * _.isString('abc');
       * // => true
       *
       * _.isString(1);
       * // => false
       */
      function isString(value) {
        return typeof value == 'string' ||
          (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
      }

      /*
       * Checks if `value` is classified as a `Symbol` primitive or object.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
       * @example
       *
       * _.isSymbol(Symbol.iterator);
       * // => true
       *
       * _.isSymbol('abc');
       * // => false
       */
      function isSymbol(value) {
        return typeof value == 'symbol' ||
          (isObjectLike(value) && baseGetTag(value) == symbolTag);
      }

      /*
       * Checks if `value` is classified as a typed array.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
       * @example
       *
       * _.isTypedArray(new Uint8Array);
       * // => true
       *
       * _.isTypedArray([]);
       * // => false
       */
      var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

      /*
       * Checks if `value` is `undefined`.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
       * @example
       *
       * _.isUndefined(void 0);
       * // => true
       *
       * _.isUndefined(null);
       * // => false
       */
      function isUndefined(value) {
        return value === undefined$1;
      }

      /*
       * Checks if `value` is classified as a `WeakMap` object.
       *
       * @static
       * @memberOf _
       * @since 4.3.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
       * @example
       *
       * _.isWeakMap(new WeakMap);
       * // => true
       *
       * _.isWeakMap(new Map);
       * // => false
       */
      function isWeakMap(value) {
        return isObjectLike(value) && getTag(value) == weakMapTag;
      }

      /*
       * Checks if `value` is classified as a `WeakSet` object.
       *
       * @static
       * @memberOf _
       * @since 4.3.0
       *  Lang
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.
       * @example
       *
       * _.isWeakSet(new WeakSet);
       * // => true
       *
       * _.isWeakSet(new Set);
       * // => false
       */
      function isWeakSet(value) {
        return isObjectLike(value) && baseGetTag(value) == weakSetTag;
      }

      /*
       * Checks if `value` is less than `other`.
       *
       * @static
       * @memberOf _
       * @since 3.9.0
       *  Lang
       * @param {*} value The value to compare.
       * @param {*} other The other value to compare.
       * @returns {boolean} Returns `true` if `value` is less than `other`,
       *  else `false`.
       * @see _.gt
       * @example
       *
       * _.lt(1, 3);
       * // => true
       *
       * _.lt(3, 3);
       * // => false
       *
       * _.lt(3, 1);
       * // => false
       */
      var lt = createRelationalOperation(baseLt);

      /*
       * Checks if `value` is less than or equal to `other`.
       *
       * @static
       * @memberOf _
       * @since 3.9.0
       *  Lang
       * @param {*} value The value to compare.
       * @param {*} other The other value to compare.
       * @returns {boolean} Returns `true` if `value` is less than or equal to
       *  `other`, else `false`.
       * @see _.gte
       * @example
       *
       * _.lte(1, 3);
       * // => true
       *
       * _.lte(3, 3);
       * // => true
       *
       * _.lte(3, 1);
       * // => false
       */
      var lte = createRelationalOperation(function (value, other) {
        return value <= other;
      });

      /*
       * Converts `value` to an array.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Lang
       * @param {*} value The value to convert.
       * @returns {Array} Returns the converted array.
       * @example
       *
       * _.toArray({ 'a': 1, 'b': 2 });
       * // => [1, 2]
       *
       * _.toArray('abc');
       * // => ['a', 'b', 'c']
       *
       * _.toArray(1);
       * // => []
       *
       * _.toArray(null);
       * // => []
       */
      function toArray(value) {
        if (!value) {
          return [];
        }
        if (isArrayLike(value)) {
          return isString(value) ? stringToArray(value) : copyArray(value);
        }
        if (symIterator && value[symIterator]) {
          return iteratorToArray(value[symIterator]());
        }
        var tag = getTag(value),
          func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);

        return func(value);
      }

      /*
       * Converts `value` to a finite number.
       *
       * @static
       * @memberOf _
       * @since 4.12.0
       *  Lang
       * @param {*} value The value to convert.
       * @returns {number} Returns the converted number.
       * @example
       *
       * _.toFinite(3.2);
       * // => 3.2
       *
       * _.toFinite(Number.MIN_VALUE);
       * // => 5e-324
       *
       * _.toFinite(Infinity);
       * // => 1.7976931348623157e+308
       *
       * _.toFinite('3.2');
       * // => 3.2
       */
      function toFinite(value) {
        if (!value) {
          return value === 0 ? value : 0;
        }
        value = toNumber(value);
        if (value === INFINITY || value === -INFINITY) {
          var sign = (value < 0 ? -1 : 1);
          return sign * MAX_INTEGER;
        }
        return value === value ? value : 0;
      }

      /*
       * Converts `value` to an integer.
       *
       * **Note:** This method is loosely based on
       * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to convert.
       * @returns {number} Returns the converted integer.
       * @example
       *
       * _.toInteger(3.2);
       * // => 3
       *
       * _.toInteger(Number.MIN_VALUE);
       * // => 0
       *
       * _.toInteger(Infinity);
       * // => 1.7976931348623157e+308
       *
       * _.toInteger('3.2');
       * // => 3
       */
      function toInteger(value) {
        var result = toFinite(value),
          remainder = result % 1;

        return result === result ? (remainder ? result - remainder : result) : 0;
      }

      /*
       * Converts `value` to an integer suitable for use as the length of an
       * array-like object.
       *
       * **Note:** This method is based on
       * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to convert.
       * @returns {number} Returns the converted integer.
       * @example
       *
       * _.toLength(3.2);
       * // => 3
       *
       * _.toLength(Number.MIN_VALUE);
       * // => 0
       *
       * _.toLength(Infinity);
       * // => 4294967295
       *
       * _.toLength('3.2');
       * // => 3
       */
      function toLength(value) {
        return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
      }

      /*
       * Converts `value` to a number.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to process.
       * @returns {number} Returns the number.
       * @example
       *
       * _.toNumber(3.2);
       * // => 3.2
       *
       * _.toNumber(Number.MIN_VALUE);
       * // => 5e-324
       *
       * _.toNumber(Infinity);
       * // => Infinity
       *
       * _.toNumber('3.2');
       * // => 3.2
       */
      function toNumber(value) {
        if (typeof value == 'number') {
          return value;
        }
        if (isSymbol(value)) {
          return NAN;
        }
        if (isObject(value)) {
          var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
          value = isObject(other) ? (other + '') : other;
        }
        if (typeof value != 'string') {
          return value === 0 ? value : +value;
        }
        value = baseTrim(value);
        var isBinary = reIsBinary.test(value);
        return (isBinary || reIsOctal.test(value))
          ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
          : (reIsBadHex.test(value) ? NAN : +value);
      }

      /*
       * Converts `value` to a plain object flattening inherited enumerable string
       * keyed properties of `value` to own properties of the plain object.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Lang
       * @param {*} value The value to convert.
       * @returns {Object} Returns the converted plain object.
       * @example
       *
       * function Foo() {
       *   this.b = 2;
       * }
       *
       * Foo.prototype.c = 3;
       *
       * _.assign({ 'a': 1 }, new Foo);
       * // => { 'a': 1, 'b': 2 }
       *
       * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
       * // => { 'a': 1, 'b': 2, 'c': 3 }
       */
      function toPlainObject(value) {
        return copyObject(value, keysIn(value));
      }

      /*
       * Converts `value` to a safe integer. A safe integer can be compared and
       * represented correctly.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to convert.
       * @returns {number} Returns the converted integer.
       * @example
       *
       * _.toSafeInteger(3.2);
       * // => 3
       *
       * _.toSafeInteger(Number.MIN_VALUE);
       * // => 0
       *
       * _.toSafeInteger(Infinity);
       * // => 9007199254740991
       *
       * _.toSafeInteger('3.2');
       * // => 3
       */
      function toSafeInteger(value) {
        return value
          ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
          : (value === 0 ? value : 0);
      }

      /*
       * Converts `value` to a string. An empty string is returned for `null`
       * and `undefined` values. The sign of `-0` is preserved.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Lang
       * @param {*} value The value to convert.
       * @returns {string} Returns the converted string.
       * @example
       *
       * _.toString(null);
       * // => ''
       *
       * _.toString(-0);
       * // => '-0'
       *
       * _.toString([1, 2, 3]);
       * // => '1,2,3'
       */
      function toString(value) {
        return value == null ? '' : baseToString(value);
      }

      /*------------------------------------------------------------------------*/

      /*
       * Assigns own enumerable string keyed properties of source objects to the
       * destination object. Source objects are applied from left to right.
       * Subsequent sources overwrite property assignments of previous sources.
       *
       * **Note:** This method mutates `object` and is loosely based on
       * [`Object.assign`](https://mdn.io/Object/assign).
       *
       * @static
       * @memberOf _
       * @since 0.10.0
       *  Object
       * @param {Object} object The destination object.
       * @param {...Object} [sources] The source objects.
       * @returns {Object} Returns `object`.
       * @see _.assignIn
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       * }
       *
       * function Bar() {
       *   this.c = 3;
       * }
       *
       * Foo.prototype.b = 2;
       * Bar.prototype.d = 4;
       *
       * _.assign({ 'a': 0 }, new Foo, new Bar);
       * // => { 'a': 1, 'c': 3 }
       */
      var assign = createAssigner(function (object, source) {
        if (isPrototype(source) || isArrayLike(source)) {
          copyObject(source, keys(source), object);
          return;
        }
        for (var key in source) {
          if (hasOwnProperty.call(source, key)) {
            assignValue(object, key, source[key]);
          }
        }
      });

      /*
       * This method is like `_.assign` except that it iterates over own and
       * inherited source properties.
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       * @alias extend
       *  Object
       * @param {Object} object The destination object.
       * @param {...Object} [sources] The source objects.
       * @returns {Object} Returns `object`.
       * @see _.assign
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       * }
       *
       * function Bar() {
       *   this.c = 3;
       * }
       *
       * Foo.prototype.b = 2;
       * Bar.prototype.d = 4;
       *
       * _.assignIn({ 'a': 0 }, new Foo, new Bar);
       * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
       */
      var assignIn = createAssigner(function (object, source) {
        copyObject(source, keysIn(source), object);
      });

      /*
       * This method is like `_.assignIn` except that it accepts `customizer`
       * which is invoked to produce the assigned values. If `customizer` returns
       * `undefined`, assignment is handled by the method instead. The `customizer`
       * is invoked with five arguments: (objValue, srcValue, key, object, source).
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       * @alias extendWith
       *  Object
       * @param {Object} object The destination object.
       * @param {...Object} sources The source objects.
       * @param {Function} [customizer] The function to customize assigned values.
       * @returns {Object} Returns `object`.
       * @see _.assignWith
       * @example
       *
       * function customizer(objValue, srcValue) {
       *   return _.isUndefined(objValue) ? srcValue : objValue;
       * }
       *
       * var defaults = _.partialRight(_.assignInWith, customizer);
       *
       * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
       * // => { 'a': 1, 'b': 2 }
       */
      var assignInWith = createAssigner(function (object, source, srcIndex, customizer) {
        copyObject(source, keysIn(source), object, customizer);
      });

      /*
       * This method is like `_.assign` except that it accepts `customizer`
       * which is invoked to produce the assigned values. If `customizer` returns
       * `undefined`, assignment is handled by the method instead. The `customizer`
       * is invoked with five arguments: (objValue, srcValue, key, object, source).
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Object
       * @param {Object} object The destination object.
       * @param {...Object} sources The source objects.
       * @param {Function} [customizer] The function to customize assigned values.
       * @returns {Object} Returns `object`.
       * @see _.assignInWith
       * @example
       *
       * function customizer(objValue, srcValue) {
       *   return _.isUndefined(objValue) ? srcValue : objValue;
       * }
       *
       * var defaults = _.partialRight(_.assignWith, customizer);
       *
       * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
       * // => { 'a': 1, 'b': 2 }
       */
      var assignWith = createAssigner(function (object, source, srcIndex, customizer) {
        copyObject(source, keys(source), object, customizer);
      });

      /*
       * Creates an array of values corresponding to `paths` of `object`.
       *
       * @static
       * @memberOf _
       * @since 1.0.0
       *  Object
       * @param {Object} object The object to iterate over.
       * @param {...(string|string[])} [paths] The property paths to pick.
       * @returns {Array} Returns the picked values.
       * @example
       *
       * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
       *
       * _.at(object, ['a[0].b.c', 'a[1]']);
       * // => [3, 4]
       */
      var at = flatRest(baseAt);

      /*
       * Creates an object that inherits from the `prototype` object. If a
       * `properties` object is given, its own enumerable string keyed properties
       * are assigned to the created object.
       *
       * @static
       * @memberOf _
       * @since 2.3.0
       *  Object
       * @param {Object} prototype The object to inherit from.
       * @param {Object} [properties] The properties to assign to the object.
       * @returns {Object} Returns the new object.
       * @example
       *
       * function Shape() {
       *   this.x = 0;
       *   this.y = 0;
       * }
       *
       * function Circle() {
       *   Shape.call(this);
       * }
       *
       * Circle.prototype = _.create(Shape.prototype, {
       *   'constructor': Circle
       * });
       *
       * var circle = new Circle;
       * circle instanceof Circle;
       * // => true
       *
       * circle instanceof Shape;
       * // => true
       */
      function create(prototype, properties) {
        var result = baseCreate(prototype);
        return properties == null ? result : baseAssign(result, properties);
      }

      /*
       * Assigns own and inherited enumerable string keyed properties of source
       * objects to the destination object for all destination properties that
       * resolve to `undefined`. Source objects are applied from left to right.
       * Once a property is set, additional values of the same property are ignored.
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Object
       * @param {Object} object The destination object.
       * @param {...Object} [sources] The source objects.
       * @returns {Object} Returns `object`.
       * @see _.defaultsDeep
       * @example
       *
       * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
       * // => { 'a': 1, 'b': 2 }
       */
      var defaults = baseRest(function (object, sources) {
        object = Object(object);

        var index = -1;
        var length = sources.length;
        var guard = length > 2 ? sources[2] : undefined$1;

        if (guard && isIterateeCall(sources[0], sources[1], guard)) {
          length = 1;
        }

        while (++index < length) {
          var source = sources[index];
          var props = keysIn(source);
          var propsIndex = -1;
          var propsLength = props.length;

          while (++propsIndex < propsLength) {
            var key = props[propsIndex];
            var value = object[key];

            if (value === undefined$1 ||
              (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
              object[key] = source[key];
            }
          }
        }

        return object;
      });

      /*
       * This method is like `_.defaults` except that it recursively assigns
       * default properties.
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @memberOf _
       * @since 3.10.0
       *  Object
       * @param {Object} object The destination object.
       * @param {...Object} [sources] The source objects.
       * @returns {Object} Returns `object`.
       * @see _.defaults
       * @example
       *
       * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
       * // => { 'a': { 'b': 2, 'c': 3 } }
       */
      var defaultsDeep = baseRest(function (args) {
        args.push(undefined$1, customDefaultsMerge);
        return apply(mergeWith, undefined$1, args);
      });

      /*
       * This method is like `_.find` except that it returns the key of the first
       * element `predicate` returns truthy for instead of the element itself.
       *
       * @static
       * @memberOf _
       * @since 1.1.0
       *  Object
       * @param {Object} object The object to inspect.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @returns {string|undefined} Returns the key of the matched element,
       *  else `undefined`.
       * @example
       *
       * var users = {
       *   'barney':  { 'age': 36, 'active': true },
       *   'fred':    { 'age': 40, 'active': false },
       *   'pebbles': { 'age': 1,  'active': true }
       * };
       *
       * _.findKey(users, function(o) { return o.age < 40; });
       * // => 'barney' (iteration order is not guaranteed)
       *
       * // The `_.matches` iteratee shorthand.
       * _.findKey(users, { 'age': 1, 'active': true });
       * // => 'pebbles'
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.findKey(users, ['active', false]);
       * // => 'fred'
       *
       * // The `_.property` iteratee shorthand.
       * _.findKey(users, 'active');
       * // => 'barney'
       */
      function findKey(object, predicate) {
        return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
      }

      /*
       * This method is like `_.findKey` except that it iterates over elements of
       * a collection in the opposite order.
       *
       * @static
       * @memberOf _
       * @since 2.0.0
       *  Object
       * @param {Object} object The object to inspect.
       * @param {Function} [predicate=_.identity] The function invoked per iteration.
       * @returns {string|undefined} Returns the key of the matched element,
       *  else `undefined`.
       * @example
       *
       * var users = {
       *   'barney':  { 'age': 36, 'active': true },
       *   'fred':    { 'age': 40, 'active': false },
       *   'pebbles': { 'age': 1,  'active': true }
       * };
       *
       * _.findLastKey(users, function(o) { return o.age < 40; });
       * // => returns 'pebbles' assuming `_.findKey` returns 'barney'
       *
       * // The `_.matches` iteratee shorthand.
       * _.findLastKey(users, { 'age': 36, 'active': true });
       * // => 'barney'
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.findLastKey(users, ['active', false]);
       * // => 'fred'
       *
       * // The `_.property` iteratee shorthand.
       * _.findLastKey(users, 'active');
       * // => 'pebbles'
       */
      function findLastKey(object, predicate) {
        return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
      }

      /*
       * Iterates over own and inherited enumerable string keyed properties of an
       * object and invokes `iteratee` for each property. The iteratee is invoked
       * with three arguments: (value, key, object). Iteratee functions may exit
       * iteration early by explicitly returning `false`.
       *
       * @static
       * @memberOf _
       * @since 0.3.0
       *  Object
       * @param {Object} object The object to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Object} Returns `object`.
       * @see _.forInRight
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       *   this.b = 2;
       * }
       *
       * Foo.prototype.c = 3;
       *
       * _.forIn(new Foo, function(value, key) {
       *   console.log(key);
       * });
       * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
       */
      function forIn(object, iteratee) {
        return object == null
          ? object
          : baseFor(object, getIteratee(iteratee, 3), keysIn);
      }

      /*
       * This method is like `_.forIn` except that it iterates over properties of
       * `object` in the opposite order.
       *
       * @static
       * @memberOf _
       * @since 2.0.0
       *  Object
       * @param {Object} object The object to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Object} Returns `object`.
       * @see _.forIn
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       *   this.b = 2;
       * }
       *
       * Foo.prototype.c = 3;
       *
       * _.forInRight(new Foo, function(value, key) {
       *   console.log(key);
       * });
       * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.
       */
      function forInRight(object, iteratee) {
        return object == null
          ? object
          : baseForRight(object, getIteratee(iteratee, 3), keysIn);
      }

      /*
       * Iterates over own enumerable string keyed properties of an object and
       * invokes `iteratee` for each property. The iteratee is invoked with three
       * arguments: (value, key, object). Iteratee functions may exit iteration
       * early by explicitly returning `false`.
       *
       * @static
       * @memberOf _
       * @since 0.3.0
       *  Object
       * @param {Object} object The object to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Object} Returns `object`.
       * @see _.forOwnRight
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       *   this.b = 2;
       * }
       *
       * Foo.prototype.c = 3;
       *
       * _.forOwn(new Foo, function(value, key) {
       *   console.log(key);
       * });
       * // => Logs 'a' then 'b' (iteration order is not guaranteed).
       */
      function forOwn(object, iteratee) {
        return object && baseForOwn(object, getIteratee(iteratee, 3));
      }

      /*
       * This method is like `_.forOwn` except that it iterates over properties of
       * `object` in the opposite order.
       *
       * @static
       * @memberOf _
       * @since 2.0.0
       *  Object
       * @param {Object} object The object to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Object} Returns `object`.
       * @see _.forOwn
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       *   this.b = 2;
       * }
       *
       * Foo.prototype.c = 3;
       *
       * _.forOwnRight(new Foo, function(value, key) {
       *   console.log(key);
       * });
       * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.
       */
      function forOwnRight(object, iteratee) {
        return object && baseForOwnRight(object, getIteratee(iteratee, 3));
      }

      /*
       * Creates an array of function property names from own enumerable properties
       * of `object`.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Object
       * @param {Object} object The object to inspect.
       * @returns {Array} Returns the function names.
       * @see _.functionsIn
       * @example
       *
       * function Foo() {
       *   this.a = _.constant('a');
       *   this.b = _.constant('b');
       * }
       *
       * Foo.prototype.c = _.constant('c');
       *
       * _.functions(new Foo);
       * // => ['a', 'b']
       */
      function functions(object) {
        return object == null ? [] : baseFunctions(object, keys(object));
      }

      /*
       * Creates an array of function property names from own and inherited
       * enumerable properties of `object`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Object
       * @param {Object} object The object to inspect.
       * @returns {Array} Returns the function names.
       * @see _.functions
       * @example
       *
       * function Foo() {
       *   this.a = _.constant('a');
       *   this.b = _.constant('b');
       * }
       *
       * Foo.prototype.c = _.constant('c');
       *
       * _.functionsIn(new Foo);
       * // => ['a', 'b', 'c']
       */
      function functionsIn(object) {
        return object == null ? [] : baseFunctions(object, keysIn(object));
      }

      /*
       * Gets the value at `path` of `object`. If the resolved value is
       * `undefined`, the `defaultValue` is returned in its place.
       *
       * @static
       * @memberOf _
       * @since 3.7.0
       *  Object
       * @param {Object} object The object to query.
       * @param {Array|string} path The path of the property to get.
       * @param {*} [defaultValue] The value returned for `undefined` resolved values.
       * @returns {*} Returns the resolved value.
       * @example
       *
       * var object = { 'a': [{ 'b': { 'c': 3 } }] };
       *
       * _.get(object, 'a[0].b.c');
       * // => 3
       *
       * _.get(object, ['a', '0', 'b', 'c']);
       * // => 3
       *
       * _.get(object, 'a.b.c', 'default');
       * // => 'default'
       */
      function get(object, path, defaultValue) {
        var result = object == null ? undefined$1 : baseGet(object, path);
        return result === undefined$1 ? defaultValue : result;
      }

      /*
       * Checks if `path` is a direct property of `object`.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Object
       * @param {Object} object The object to query.
       * @param {Array|string} path The path to check.
       * @returns {boolean} Returns `true` if `path` exists, else `false`.
       * @example
       *
       * var object = { 'a': { 'b': 2 } };
       * var other = _.create({ 'a': _.create({ 'b': 2 }) });
       *
       * _.has(object, 'a');
       * // => true
       *
       * _.has(object, 'a.b');
       * // => true
       *
       * _.has(object, ['a', 'b']);
       * // => true
       *
       * _.has(other, 'a');
       * // => false
       */
      function has(object, path) {
        return object != null && hasPath(object, path, baseHas);
      }

      /*
       * Checks if `path` is a direct or inherited property of `object`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Object
       * @param {Object} object The object to query.
       * @param {Array|string} path The path to check.
       * @returns {boolean} Returns `true` if `path` exists, else `false`.
       * @example
       *
       * var object = _.create({ 'a': _.create({ 'b': 2 }) });
       *
       * _.hasIn(object, 'a');
       * // => true
       *
       * _.hasIn(object, 'a.b');
       * // => true
       *
       * _.hasIn(object, ['a', 'b']);
       * // => true
       *
       * _.hasIn(object, 'b');
       * // => false
       */
      function hasIn(object, path) {
        return object != null && hasPath(object, path, baseHasIn);
      }

      /*
       * Creates an object composed of the inverted keys and values of `object`.
       * If `object` contains duplicate values, subsequent values overwrite
       * property assignments of previous values.
       *
       * @static
       * @memberOf _
       * @since 0.7.0
       *  Object
       * @param {Object} object The object to invert.
       * @returns {Object} Returns the new inverted object.
       * @example
       *
       * var object = { 'a': 1, 'b': 2, 'c': 1 };
       *
       * _.invert(object);
       * // => { '1': 'c', '2': 'b' }
       */
      var invert = createInverter(function (result, value, key) {
        if (value != null &&
          typeof value.toString != 'function') {
          value = nativeObjectToString.call(value);
        }

        result[value] = key;
      }, constant(identity));

      /*
       * This method is like `_.invert` except that the inverted object is generated
       * from the results of running each element of `object` thru `iteratee`. The
       * corresponding inverted value of each inverted key is an array of keys
       * responsible for generating the inverted value. The iteratee is invoked
       * with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 4.1.0
       *  Object
       * @param {Object} object The object to invert.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {Object} Returns the new inverted object.
       * @example
       *
       * var object = { 'a': 1, 'b': 2, 'c': 1 };
       *
       * _.invertBy(object);
       * // => { '1': ['a', 'c'], '2': ['b'] }
       *
       * _.invertBy(object, function(value) {
       *   return 'group' + value;
       * });
       * // => { 'group1': ['a', 'c'], 'group2': ['b'] }
       */
      var invertBy = createInverter(function (result, value, key) {
        if (value != null &&
          typeof value.toString != 'function') {
          value = nativeObjectToString.call(value);
        }

        if (hasOwnProperty.call(result, value)) {
          result[value].push(key);
        } else {
          result[value] = [key];
        }
      }, getIteratee);

      /*
       * Invokes the method at `path` of `object`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Object
       * @param {Object} object The object to query.
       * @param {Array|string} path The path of the method to invoke.
       * @param {...*} [args] The arguments to invoke the method with.
       * @returns {*} Returns the result of the invoked method.
       * @example
       *
       * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };
       *
       * _.invoke(object, 'a[0].b.c.slice', 1, 3);
       * // => [2, 3]
       */
      var invoke = baseRest(baseInvoke);

      /*
       * Creates an array of the own enumerable property names of `object`.
       *
       * **Note:** Non-object values are coerced to objects. See the
       * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
       * for more details.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Object
       * @param {Object} object The object to query.
       * @returns {Array} Returns the array of property names.
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       *   this.b = 2;
       * }
       *
       * Foo.prototype.c = 3;
       *
       * _.keys(new Foo);
       * // => ['a', 'b'] (iteration order is not guaranteed)
       *
       * _.keys('hi');
       * // => ['0', '1']
       */
      function keys(object) {
        return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
      }

      /*
       * Creates an array of the own and inherited enumerable property names of `object`.
       *
       * **Note:** Non-object values are coerced to objects.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Object
       * @param {Object} object The object to query.
       * @returns {Array} Returns the array of property names.
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       *   this.b = 2;
       * }
       *
       * Foo.prototype.c = 3;
       *
       * _.keysIn(new Foo);
       * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
       */
      function keysIn(object) {
        return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
      }

      /*
       * The opposite of `_.mapValues`; this method creates an object with the
       * same values as `object` and keys generated by running each own enumerable
       * string keyed property of `object` thru `iteratee`. The iteratee is invoked
       * with three arguments: (value, key, object).
       *
       * @static
       * @memberOf _
       * @since 3.8.0
       *  Object
       * @param {Object} object The object to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Object} Returns the new mapped object.
       * @see _.mapValues
       * @example
       *
       * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
       *   return key + value;
       * });
       * // => { 'a1': 1, 'b2': 2 }
       */
      function mapKeys(object, iteratee) {
        var result = {};
        iteratee = getIteratee(iteratee, 3);

        baseForOwn(object, function (value, key, object) {
          baseAssignValue(result, iteratee(value, key, object), value);
        });
        return result;
      }

      /*
       * Creates an object with the same keys as `object` and values generated
       * by running each own enumerable string keyed property of `object` thru
       * `iteratee`. The iteratee is invoked with three arguments:
       * (value, key, object).
       *
       * @static
       * @memberOf _
       * @since 2.4.0
       *  Object
       * @param {Object} object The object to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Object} Returns the new mapped object.
       * @see _.mapKeys
       * @example
       *
       * var users = {
       *   'fred':    { 'user': 'fred',    'age': 40 },
       *   'pebbles': { 'user': 'pebbles', 'age': 1 }
       * };
       *
       * _.mapValues(users, function(o) { return o.age; });
       * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
       *
       * // The `_.property` iteratee shorthand.
       * _.mapValues(users, 'age');
       * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
       */
      function mapValues(object, iteratee) {
        var result = {};
        iteratee = getIteratee(iteratee, 3);

        baseForOwn(object, function (value, key, object) {
          baseAssignValue(result, key, iteratee(value, key, object));
        });
        return result;
      }

      /*
       * This method is like `_.assign` except that it recursively merges own and
       * inherited enumerable string keyed properties of source objects into the
       * destination object. Source properties that resolve to `undefined` are
       * skipped if a destination value exists. Array and plain object properties
       * are merged recursively. Other objects and value types are overridden by
       * assignment. Source objects are applied from left to right. Subsequent
       * sources overwrite property assignments of previous sources.
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @memberOf _
       * @since 0.5.0
       *  Object
       * @param {Object} object The destination object.
       * @param {...Object} [sources] The source objects.
       * @returns {Object} Returns `object`.
       * @example
       *
       * var object = {
       *   'a': [{ 'b': 2 }, { 'd': 4 }]
       * };
       *
       * var other = {
       *   'a': [{ 'c': 3 }, { 'e': 5 }]
       * };
       *
       * _.merge(object, other);
       * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
       */
      var merge = createAssigner(function (object, source, srcIndex) {
        baseMerge(object, source, srcIndex);
      });

      /*
       * This method is like `_.merge` except that it accepts `customizer` which
       * is invoked to produce the merged values of the destination and source
       * properties. If `customizer` returns `undefined`, merging is handled by the
       * method instead. The `customizer` is invoked with six arguments:
       * (objValue, srcValue, key, object, source, stack).
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Object
       * @param {Object} object The destination object.
       * @param {...Object} sources The source objects.
       * @param {Function} customizer The function to customize assigned values.
       * @returns {Object} Returns `object`.
       * @example
       *
       * function customizer(objValue, srcValue) {
       *   if (_.isArray(objValue)) {
       *     return objValue.concat(srcValue);
       *   }
       * }
       *
       * var object = { 'a': [1], 'b': [2] };
       * var other = { 'a': [3], 'b': [4] };
       *
       * _.mergeWith(object, other, customizer);
       * // => { 'a': [1, 3], 'b': [2, 4] }
       */
      var mergeWith = createAssigner(function (object, source, srcIndex, customizer) {
        baseMerge(object, source, srcIndex, customizer);
      });

      /*
       * The opposite of `_.pick`; this method creates an object composed of the
       * own and inherited enumerable property paths of `object` that are not omitted.
       *
       * **Note:** This method is considerably slower than `_.pick`.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Object
       * @param {Object} object The source object.
       * @param {...(string|string[])} [paths] The property paths to omit.
       * @returns {Object} Returns the new object.
       * @example
       *
       * var object = { 'a': 1, 'b': '2', 'c': 3 };
       *
       * _.omit(object, ['a', 'c']);
       * // => { 'b': '2' }
       */
      var omit = flatRest(function (object, paths) {
        var result = {};
        if (object == null) {
          return result;
        }
        var isDeep = false;
        paths = arrayMap(paths, function (path) {
          path = castPath(path, object);
          isDeep || (isDeep = path.length > 1);
          return path;
        });
        copyObject(object, getAllKeysIn(object), result);
        if (isDeep) {
          result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
        }
        var length = paths.length;
        while (length--) {
          baseUnset(result, paths[length]);
        }
        return result;
      });

      /*
       * The opposite of `_.pickBy`; this method creates an object composed of
       * the own and inherited enumerable string keyed properties of `object` that
       * `predicate` doesn't return truthy for. The predicate is invoked with two
       * arguments: (value, key).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Object
       * @param {Object} object The source object.
       * @param {Function} [predicate=_.identity] The function invoked per property.
       * @returns {Object} Returns the new object.
       * @example
       *
       * var object = { 'a': 1, 'b': '2', 'c': 3 };
       *
       * _.omitBy(object, _.isNumber);
       * // => { 'b': '2' }
       */
      function omitBy(object, predicate) {
        return pickBy(object, negate(getIteratee(predicate)));
      }

      /*
       * Creates an object composed of the picked `object` properties.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Object
       * @param {Object} object The source object.
       * @param {...(string|string[])} [paths] The property paths to pick.
       * @returns {Object} Returns the new object.
       * @example
       *
       * var object = { 'a': 1, 'b': '2', 'c': 3 };
       *
       * _.pick(object, ['a', 'c']);
       * // => { 'a': 1, 'c': 3 }
       */
      var pick = flatRest(function (object, paths) {
        return object == null ? {} : basePick(object, paths);
      });

      /*
       * Creates an object composed of the `object` properties `predicate` returns
       * truthy for. The predicate is invoked with two arguments: (value, key).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Object
       * @param {Object} object The source object.
       * @param {Function} [predicate=_.identity] The function invoked per property.
       * @returns {Object} Returns the new object.
       * @example
       *
       * var object = { 'a': 1, 'b': '2', 'c': 3 };
       *
       * _.pickBy(object, _.isNumber);
       * // => { 'a': 1, 'c': 3 }
       */
      function pickBy(object, predicate) {
        if (object == null) {
          return {};
        }
        var props = arrayMap(getAllKeysIn(object), function (prop) {
          return [prop];
        });
        predicate = getIteratee(predicate);
        return basePickBy(object, props, function (value, path) {
          return predicate(value, path[0]);
        });
      }

      /*
       * This method is like `_.get` except that if the resolved value is a
       * function it's invoked with the `this` binding of its parent object and
       * its result is returned.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Object
       * @param {Object} object The object to query.
       * @param {Array|string} path The path of the property to resolve.
       * @param {*} [defaultValue] The value returned for `undefined` resolved values.
       * @returns {*} Returns the resolved value.
       * @example
       *
       * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
       *
       * _.result(object, 'a[0].b.c1');
       * // => 3
       *
       * _.result(object, 'a[0].b.c2');
       * // => 4
       *
       * _.result(object, 'a[0].b.c3', 'default');
       * // => 'default'
       *
       * _.result(object, 'a[0].b.c3', _.constant('default'));
       * // => 'default'
       */
      function result(object, path, defaultValue) {
        path = castPath(path, object);

        var index = -1,
          length = path.length;

        // Ensure the loop is entered when path is empty.
        if (!length) {
          length = 1;
          object = undefined$1;
        }
        while (++index < length) {
          var value = object == null ? undefined$1 : object[toKey(path[index])];
          if (value === undefined$1) {
            index = length;
            value = defaultValue;
          }
          object = isFunction(value) ? value.call(object) : value;
        }
        return object;
      }

      /*
       * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
       * it's created. Arrays are created for missing index properties while objects
       * are created for all other missing properties. Use `_.setWith` to customize
       * `path` creation.
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @memberOf _
       * @since 3.7.0
       *  Object
       * @param {Object} object The object to modify.
       * @param {Array|string} path The path of the property to set.
       * @param {*} value The value to set.
       * @returns {Object} Returns `object`.
       * @example
       *
       * var object = { 'a': [{ 'b': { 'c': 3 } }] };
       *
       * _.set(object, 'a[0].b.c', 4);
       * console.log(object.a[0].b.c);
       * // => 4
       *
       * _.set(object, ['x', '0', 'y', 'z'], 5);
       * console.log(object.x[0].y.z);
       * // => 5
       */
      function set(object, path, value) {
        return object == null ? object : baseSet(object, path, value);
      }

      /*
       * This method is like `_.set` except that it accepts `customizer` which is
       * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
       * path creation is handled by the method instead. The `customizer` is invoked
       * with three arguments: (nsValue, key, nsObject).
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Object
       * @param {Object} object The object to modify.
       * @param {Array|string} path The path of the property to set.
       * @param {*} value The value to set.
       * @param {Function} [customizer] The function to customize assigned values.
       * @returns {Object} Returns `object`.
       * @example
       *
       * var object = {};
       *
       * _.setWith(object, '[0][1]', 'a', Object);
       * // => { '0': { '1': 'a' } }
       */
      function setWith(object, path, value, customizer) {
        customizer = typeof customizer == 'function' ? customizer : undefined$1;
        return object == null ? object : baseSet(object, path, value, customizer);
      }

      /*
       * Creates an array of own enumerable string keyed-value pairs for `object`
       * which can be consumed by `_.fromPairs`. If `object` is a map or set, its
       * entries are returned.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       * @alias entries
       *  Object
       * @param {Object} object The object to query.
       * @returns {Array} Returns the key-value pairs.
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       *   this.b = 2;
       * }
       *
       * Foo.prototype.c = 3;
       *
       * _.toPairs(new Foo);
       * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)
       */
      var toPairs = createToPairs(keys);

      /*
       * Creates an array of own and inherited enumerable string keyed-value pairs
       * for `object` which can be consumed by `_.fromPairs`. If `object` is a map
       * or set, its entries are returned.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       * @alias entriesIn
       *  Object
       * @param {Object} object The object to query.
       * @returns {Array} Returns the key-value pairs.
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       *   this.b = 2;
       * }
       *
       * Foo.prototype.c = 3;
       *
       * _.toPairsIn(new Foo);
       * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)
       */
      var toPairsIn = createToPairs(keysIn);

      /*
       * An alternative to `_.reduce`; this method transforms `object` to a new
       * `accumulator` object which is the result of running each of its own
       * enumerable string keyed properties thru `iteratee`, with each invocation
       * potentially mutating the `accumulator` object. If `accumulator` is not
       * provided, a new object with the same `[[Prototype]]` will be used. The
       * iteratee is invoked with four arguments: (accumulator, value, key, object).
       * Iteratee functions may exit iteration early by explicitly returning `false`.
       *
       * @static
       * @memberOf _
       * @since 1.3.0
       *  Object
       * @param {Object} object The object to iterate over.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @param {*} [accumulator] The custom accumulator value.
       * @returns {*} Returns the accumulated value.
       * @example
       *
       * _.transform([2, 3, 4], function(result, n) {
       *   result.push(n *= n);
       *   return n % 2 == 0;
       * }, []);
       * // => [4, 9]
       *
       * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
       *   (result[value] || (result[value] = [])).push(key);
       * }, {});
       * // => { '1': ['a', 'c'], '2': ['b'] }
       */
      function transform(object, iteratee, accumulator) {
        var isArr = isArray(object),
          isArrLike = isArr || isBuffer(object) || isTypedArray(object);

        iteratee = getIteratee(iteratee, 4);
        if (accumulator == null) {
          var Ctor = object && object.constructor;
          if (isArrLike) {
            accumulator = isArr ? new Ctor : [];
          }
          else if (isObject(object)) {
            accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
          }
          else {
            accumulator = {};
          }
        }
        (isArrLike ? arrayEach : baseForOwn)(object, function (value, index, object) {
          return iteratee(accumulator, value, index, object);
        });
        return accumulator;
      }

      /*
       * Removes the property at `path` of `object`.
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Object
       * @param {Object} object The object to modify.
       * @param {Array|string} path The path of the property to unset.
       * @returns {boolean} Returns `true` if the property is deleted, else `false`.
       * @example
       *
       * var object = { 'a': [{ 'b': { 'c': 7 } }] };
       * _.unset(object, 'a[0].b.c');
       * // => true
       *
       * console.log(object);
       * // => { 'a': [{ 'b': {} }] };
       *
       * _.unset(object, ['a', '0', 'b', 'c']);
       * // => true
       *
       * console.log(object);
       * // => { 'a': [{ 'b': {} }] };
       */
      function unset(object, path) {
        return object == null ? true : baseUnset(object, path);
      }

      /*
       * This method is like `_.set` except that accepts `updater` to produce the
       * value to set. Use `_.updateWith` to customize `path` creation. The `updater`
       * is invoked with one argument: (value).
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @memberOf _
       * @since 4.6.0
       *  Object
       * @param {Object} object The object to modify.
       * @param {Array|string} path The path of the property to set.
       * @param {Function} updater The function to produce the updated value.
       * @returns {Object} Returns `object`.
       * @example
       *
       * var object = { 'a': [{ 'b': { 'c': 3 } }] };
       *
       * _.update(object, 'a[0].b.c', function(n) { return n * n; });
       * console.log(object.a[0].b.c);
       * // => 9
       *
       * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
       * console.log(object.x[0].y.z);
       * // => 0
       */
      function update(object, path, updater) {
        return object == null ? object : baseUpdate(object, path, castFunction(updater));
      }

      /*
       * This method is like `_.update` except that it accepts `customizer` which is
       * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
       * path creation is handled by the method instead. The `customizer` is invoked
       * with three arguments: (nsValue, key, nsObject).
       *
       * **Note:** This method mutates `object`.
       *
       * @static
       * @memberOf _
       * @since 4.6.0
       *  Object
       * @param {Object} object The object to modify.
       * @param {Array|string} path The path of the property to set.
       * @param {Function} updater The function to produce the updated value.
       * @param {Function} [customizer] The function to customize assigned values.
       * @returns {Object} Returns `object`.
       * @example
       *
       * var object = {};
       *
       * _.updateWith(object, '[0][1]', _.constant('a'), Object);
       * // => { '0': { '1': 'a' } }
       */
      function updateWith(object, path, updater, customizer) {
        customizer = typeof customizer == 'function' ? customizer : undefined$1;
        return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
      }

      /*
       * Creates an array of the own enumerable string keyed property values of `object`.
       *
       * **Note:** Non-object values are coerced to objects.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Object
       * @param {Object} object The object to query.
       * @returns {Array} Returns the array of property values.
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       *   this.b = 2;
       * }
       *
       * Foo.prototype.c = 3;
       *
       * _.values(new Foo);
       * // => [1, 2] (iteration order is not guaranteed)
       *
       * _.values('hi');
       * // => ['h', 'i']
       */
      function values(object) {
        return object == null ? [] : baseValues(object, keys(object));
      }

      /*
       * Creates an array of the own and inherited enumerable string keyed property
       * values of `object`.
       *
       * **Note:** Non-object values are coerced to objects.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Object
       * @param {Object} object The object to query.
       * @returns {Array} Returns the array of property values.
       * @example
       *
       * function Foo() {
       *   this.a = 1;
       *   this.b = 2;
       * }
       *
       * Foo.prototype.c = 3;
       *
       * _.valuesIn(new Foo);
       * // => [1, 2, 3] (iteration order is not guaranteed)
       */
      function valuesIn(object) {
        return object == null ? [] : baseValues(object, keysIn(object));
      }

      /*------------------------------------------------------------------------*/

      /*
       * Clamps `number` within the inclusive `lower` and `upper` bounds.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Number
       * @param {number} number The number to clamp.
       * @param {number} [lower] The lower bound.
       * @param {number} upper The upper bound.
       * @returns {number} Returns the clamped number.
       * @example
       *
       * _.clamp(-10, -5, 5);
       * // => -5
       *
       * _.clamp(10, -5, 5);
       * // => 5
       */
      function clamp(number, lower, upper) {
        if (upper === undefined$1) {
          upper = lower;
          lower = undefined$1;
        }
        if (upper !== undefined$1) {
          upper = toNumber(upper);
          upper = upper === upper ? upper : 0;
        }
        if (lower !== undefined$1) {
          lower = toNumber(lower);
          lower = lower === lower ? lower : 0;
        }
        return baseClamp(toNumber(number), lower, upper);
      }

      /*
       * Checks if `n` is between `start` and up to, but not including, `end`. If
       * `end` is not specified, it's set to `start` with `start` then set to `0`.
       * If `start` is greater than `end` the params are swapped to support
       * negative ranges.
       *
       * @static
       * @memberOf _
       * @since 3.3.0
       *  Number
       * @param {number} number The number to check.
       * @param {number} [start=0] The start of the range.
       * @param {number} end The end of the range.
       * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
       * @see _.range, _.rangeRight
       * @example
       *
       * _.inRange(3, 2, 4);
       * // => true
       *
       * _.inRange(4, 8);
       * // => true
       *
       * _.inRange(4, 2);
       * // => false
       *
       * _.inRange(2, 2);
       * // => false
       *
       * _.inRange(1.2, 2);
       * // => true
       *
       * _.inRange(5.2, 4);
       * // => false
       *
       * _.inRange(-3, -2, -6);
       * // => true
       */
      function inRange(number, start, end) {
        start = toFinite(start);
        if (end === undefined$1) {
          end = start;
          start = 0;
        } else {
          end = toFinite(end);
        }
        number = toNumber(number);
        return baseInRange(number, start, end);
      }

      /*
       * Produces a random number between the inclusive `lower` and `upper` bounds.
       * If only one argument is provided a number between `0` and the given number
       * is returned. If `floating` is `true`, or either `lower` or `upper` are
       * floats, a floating-point number is returned instead of an integer.
       *
       * **Note:** JavaScript follows the IEEE-754 standard for resolving
       * floating-point values which can produce unexpected results.
       *
       * @static
       * @memberOf _
       * @since 0.7.0
       *  Number
       * @param {number} [lower=0] The lower bound.
       * @param {number} [upper=1] The upper bound.
       * @param {boolean} [floating] Specify returning a floating-point number.
       * @returns {number} Returns the random number.
       * @example
       *
       * _.random(0, 5);
       * // => an integer between 0 and 5
       *
       * _.random(5);
       * // => also an integer between 0 and 5
       *
       * _.random(5, true);
       * // => a floating-point number between 0 and 5
       *
       * _.random(1.2, 5.2);
       * // => a floating-point number between 1.2 and 5.2
       */
      function random(lower, upper, floating) {
        if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {
          upper = floating = undefined$1;
        }
        if (floating === undefined$1) {
          if (typeof upper == 'boolean') {
            floating = upper;
            upper = undefined$1;
          }
          else if (typeof lower == 'boolean') {
            floating = lower;
            lower = undefined$1;
          }
        }
        if (lower === undefined$1 && upper === undefined$1) {
          lower = 0;
          upper = 1;
        }
        else {
          lower = toFinite(lower);
          if (upper === undefined$1) {
            upper = lower;
            lower = 0;
          } else {
            upper = toFinite(upper);
          }
        }
        if (lower > upper) {
          var temp = lower;
          lower = upper;
          upper = temp;
        }
        if (floating || lower % 1 || upper % 1) {
          var rand = nativeRandom();
          return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);
        }
        return baseRandom(lower, upper);
      }

      /*------------------------------------------------------------------------*/

      /*
       * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to convert.
       * @returns {string} Returns the camel cased string.
       * @example
       *
       * _.camelCase('Foo Bar');
       * // => 'fooBar'
       *
       * _.camelCase('--foo-bar--');
       * // => 'fooBar'
       *
       * _.camelCase('__FOO_BAR__');
       * // => 'fooBar'
       */
      var camelCase = createCompounder(function (result, word, index) {
        word = word.toLowerCase();
        return result + (index ? capitalize(word) : word);
      });

      /*
       * Converts the first character of `string` to upper case and the remaining
       * to lower case.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to capitalize.
       * @returns {string} Returns the capitalized string.
       * @example
       *
       * _.capitalize('FRED');
       * // => 'Fred'
       */
      function capitalize(string) {
        return upperFirst(toString(string).toLowerCase());
      }

      /*
       * Deburrs `string` by converting
       * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
       * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
       * letters to basic Latin letters and removing
       * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to deburr.
       * @returns {string} Returns the deburred string.
       * @example
       *
       * _.deburr('déjà vu');
       * // => 'deja vu'
       */
      function deburr(string) {
        string = toString(string);
        return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
      }

      /*
       * Checks if `string` ends with the given target string.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to inspect.
       * @param {string} [target] The string to search for.
       * @param {number} [position=string.length] The position to search up to.
       * @returns {boolean} Returns `true` if `string` ends with `target`,
       *  else `false`.
       * @example
       *
       * _.endsWith('abc', 'c');
       * // => true
       *
       * _.endsWith('abc', 'b');
       * // => false
       *
       * _.endsWith('abc', 'b', 2);
       * // => true
       */
      function endsWith(string, target, position) {
        string = toString(string);
        target = baseToString(target);

        var length = string.length;
        position = position === undefined$1
          ? length
          : baseClamp(toInteger(position), 0, length);

        var end = position;
        position -= target.length;
        return position >= 0 && string.slice(position, end) == target;
      }

      /*
       * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
       * corresponding HTML entities.
       *
       * **Note:** No other characters are escaped. To escape additional
       * characters use a third-party library like [_he_](https://mths.be/he).
       *
       * Though the ">" character is escaped for symmetry, characters like
       * ">" and "/" don't need escaping in HTML and have no special meaning
       * unless they're part of a tag or unquoted attribute value. See
       * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
       * (under "semi-related fun fact") for more details.
       *
       * When working with HTML you should always
       * [quote attribute values](http://wonko.com/post/html-escaping) to reduce
       * XSS vectors.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  String
       * @param {string} [string=''] The string to escape.
       * @returns {string} Returns the escaped string.
       * @example
       *
       * _.escape('fred, barney, & pebbles');
       * // => 'fred, barney, &amp; pebbles'
       */
      function escape(string) {
        string = toString(string);
        return (string && reHasUnescapedHtml.test(string))
          ? string.replace(reUnescapedHtml, escapeHtmlChar)
          : string;
      }

      /*
       * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
       * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to escape.
       * @returns {string} Returns the escaped string.
       * @example
       *
       * _.escapeRegExp('[lodash](https://lodash.com/)');
       * // => '\[lodash\]\(https://lodash\.com/\)'
       */
      function escapeRegExp(string) {
        string = toString(string);
        return (string && reHasRegExpChar.test(string))
          ? string.replace(reRegExpChar, '\\$&')
          : string;
      }

      /*
       * Converts `string` to
       * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to convert.
       * @returns {string} Returns the kebab cased string.
       * @example
       *
       * _.kebabCase('Foo Bar');
       * // => 'foo-bar'
       *
       * _.kebabCase('fooBar');
       * // => 'foo-bar'
       *
       * _.kebabCase('__FOO_BAR__');
       * // => 'foo-bar'
       */
      var kebabCase = createCompounder(function (result, word, index) {
        return result + (index ? '-' : '') + word.toLowerCase();
      });

      /*
       * Converts `string`, as space separated words, to lower case.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to convert.
       * @returns {string} Returns the lower cased string.
       * @example
       *
       * _.lowerCase('--Foo-Bar--');
       * // => 'foo bar'
       *
       * _.lowerCase('fooBar');
       * // => 'foo bar'
       *
       * _.lowerCase('__FOO_BAR__');
       * // => 'foo bar'
       */
      var lowerCase = createCompounder(function (result, word, index) {
        return result + (index ? ' ' : '') + word.toLowerCase();
      });

      /*
       * Converts the first character of `string` to lower case.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to convert.
       * @returns {string} Returns the converted string.
       * @example
       *
       * _.lowerFirst('Fred');
       * // => 'fred'
       *
       * _.lowerFirst('FRED');
       * // => 'fRED'
       */
      var lowerFirst = createCaseFirst('toLowerCase');

      /*
       * Pads `string` on the left and right sides if it's shorter than `length`.
       * Padding characters are truncated if they can't be evenly divided by `length`.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to pad.
       * @param {number} [length=0] The padding length.
       * @param {string} [chars=' '] The string used as padding.
       * @returns {string} Returns the padded string.
       * @example
       *
       * _.pad('abc', 8);
       * // => '  abc   '
       *
       * _.pad('abc', 8, '_-');
       * // => '_-abc_-_'
       *
       * _.pad('abc', 3);
       * // => 'abc'
       */
      function pad(string, length, chars) {
        string = toString(string);
        length = toInteger(length);

        var strLength = length ? stringSize(string) : 0;
        if (!length || strLength >= length) {
          return string;
        }
        var mid = (length - strLength) / 2;
        return (
          createPadding(nativeFloor(mid), chars) +
          string +
          createPadding(nativeCeil(mid), chars)
        );
      }

      /*
       * Pads `string` on the right side if it's shorter than `length`. Padding
       * characters are truncated if they exceed `length`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to pad.
       * @param {number} [length=0] The padding length.
       * @param {string} [chars=' '] The string used as padding.
       * @returns {string} Returns the padded string.
       * @example
       *
       * _.padEnd('abc', 6);
       * // => 'abc   '
       *
       * _.padEnd('abc', 6, '_-');
       * // => 'abc_-_'
       *
       * _.padEnd('abc', 3);
       * // => 'abc'
       */
      function padEnd(string, length, chars) {
        string = toString(string);
        length = toInteger(length);

        var strLength = length ? stringSize(string) : 0;
        return (length && strLength < length)
          ? (string + createPadding(length - strLength, chars))
          : string;
      }

      /*
       * Pads `string` on the left side if it's shorter than `length`. Padding
       * characters are truncated if they exceed `length`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to pad.
       * @param {number} [length=0] The padding length.
       * @param {string} [chars=' '] The string used as padding.
       * @returns {string} Returns the padded string.
       * @example
       *
       * _.padStart('abc', 6);
       * // => '   abc'
       *
       * _.padStart('abc', 6, '_-');
       * // => '_-_abc'
       *
       * _.padStart('abc', 3);
       * // => 'abc'
       */
      function padStart(string, length, chars) {
        string = toString(string);
        length = toInteger(length);

        var strLength = length ? stringSize(string) : 0;
        return (length && strLength < length)
          ? (createPadding(length - strLength, chars) + string)
          : string;
      }

      /*
       * Converts `string` to an integer of the specified radix. If `radix` is
       * `undefined` or `0`, a `radix` of `10` is used unless `value` is a
       * hexadecimal, in which case a `radix` of `16` is used.
       *
       * **Note:** This method aligns with the
       * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.
       *
       * @static
       * @memberOf _
       * @since 1.1.0
       *  String
       * @param {string} string The string to convert.
       * @param {number} [radix=10] The radix to interpret `value` by.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {number} Returns the converted integer.
       * @example
       *
       * _.parseInt('08');
       * // => 8
       *
       * _.map(['6', '08', '10'], _.parseInt);
       * // => [6, 8, 10]
       */
      function parseInt(string, radix, guard) {
        if (guard || radix == null) {
          radix = 0;
        } else if (radix) {
          radix = +radix;
        }
        return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);
      }

      /*
       * Repeats the given string `n` times.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to repeat.
       * @param {number} [n=1] The number of times to repeat the string.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {string} Returns the repeated string.
       * @example
       *
       * _.repeat('*', 3);
       * // => '***'
       *
       * _.repeat('abc', 2);
       * // => 'abcabc'
       *
       * _.repeat('abc', 0);
       * // => ''
       */
      function repeat(string, n, guard) {
        if ((guard ? isIterateeCall(string, n, guard) : n === undefined$1)) {
          n = 1;
        } else {
          n = toInteger(n);
        }
        return baseRepeat(toString(string), n);
      }

      /*
       * Replaces matches for `pattern` in `string` with `replacement`.
       *
       * **Note:** This method is based on
       * [`String#replace`](https://mdn.io/String/replace).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to modify.
       * @param {RegExp|string} pattern The pattern to replace.
       * @param {Function|string} replacement The match replacement.
       * @returns {string} Returns the modified string.
       * @example
       *
       * _.replace('Hi Fred', 'Fred', 'Barney');
       * // => 'Hi Barney'
       */
      function replace() {
        var args = arguments,
          string = toString(args[0]);

        return args.length < 3 ? string : string.replace(args[1], args[2]);
      }

      /*
       * Converts `string` to
       * [snake case](https://en.wikipedia.org/wiki/Snake_case).
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to convert.
       * @returns {string} Returns the snake cased string.
       * @example
       *
       * _.snakeCase('Foo Bar');
       * // => 'foo_bar'
       *
       * _.snakeCase('fooBar');
       * // => 'foo_bar'
       *
       * _.snakeCase('--FOO-BAR--');
       * // => 'foo_bar'
       */
      var snakeCase = createCompounder(function (result, word, index) {
        return result + (index ? '_' : '') + word.toLowerCase();
      });

      /*
       * Splits `string` by `separator`.
       *
       * **Note:** This method is based on
       * [`String#split`](https://mdn.io/String/split).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to split.
       * @param {RegExp|string} separator The separator pattern to split by.
       * @param {number} [limit] The length to truncate results to.
       * @returns {Array} Returns the string segments.
       * @example
       *
       * _.split('a-b-c', '-', 2);
       * // => ['a', 'b']
       */
      function split(string, separator, limit) {
        if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {
          separator = limit = undefined$1;
        }
        limit = limit === undefined$1 ? MAX_ARRAY_LENGTH : limit >>> 0;
        if (!limit) {
          return [];
        }
        string = toString(string);
        if (string && (
          typeof separator == 'string' ||
          (separator != null && !isRegExp(separator))
        )) {
          separator = baseToString(separator);
          if (!separator && hasUnicode(string)) {
            return castSlice(stringToArray(string), 0, limit);
          }
        }
        return string.split(separator, limit);
      }

      /*
       * Converts `string` to
       * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
       *
       * @static
       * @memberOf _
       * @since 3.1.0
       *  String
       * @param {string} [string=''] The string to convert.
       * @returns {string} Returns the start cased string.
       * @example
       *
       * _.startCase('--foo-bar--');
       * // => 'Foo Bar'
       *
       * _.startCase('fooBar');
       * // => 'Foo Bar'
       *
       * _.startCase('__FOO_BAR__');
       * // => 'FOO BAR'
       */
      var startCase = createCompounder(function (result, word, index) {
        return result + (index ? ' ' : '') + upperFirst(word);
      });

      /*
       * Checks if `string` starts with the given target string.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to inspect.
       * @param {string} [target] The string to search for.
       * @param {number} [position=0] The position to search from.
       * @returns {boolean} Returns `true` if `string` starts with `target`,
       *  else `false`.
       * @example
       *
       * _.startsWith('abc', 'a');
       * // => true
       *
       * _.startsWith('abc', 'b');
       * // => false
       *
       * _.startsWith('abc', 'b', 1);
       * // => true
       */
      function startsWith(string, target, position) {
        string = toString(string);
        position = position == null
          ? 0
          : baseClamp(toInteger(position), 0, string.length);

        target = baseToString(target);
        return string.slice(position, position + target.length) == target;
      }

      /*
       * Creates a compiled template function that can interpolate data properties
       * in "interpolate" delimiters, HTML-escape interpolated data properties in
       * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
       * properties may be accessed as free variables in the template. If a setting
       * object is given, it takes precedence over `_.templateSettings` values.
       *
       * **Note:** In the development build `_.template` utilizes
       * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
       * for easier debugging.
       *
       * For more information on precompiling templates see
       * [lodash's custom builds documentation](https://lodash.com/custom-builds).
       *
       * For more information on Chrome extension sandboxes see
       * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  String
       * @param {string} [string=''] The template string.
       * @param {Object} [options={}] The options object.
       * @param {RegExp} [options.escape=_.templateSettings.escape]
       *  The HTML "escape" delimiter.
       * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]
       *  The "evaluate" delimiter.
       * @param {Object} [options.imports=_.templateSettings.imports]
       *  An object to import into the template as free variables.
       * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]
       *  The "interpolate" delimiter.
       * @param {string} [options.sourceURL='lodash.templateSources[n]']
       *  The sourceURL of the compiled template.
       * @param {string} [options.variable='obj']
       *  The data object variable name.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {Function} Returns the compiled template function.
       * @example
       *
       * // Use the "interpolate" delimiter to create a compiled template.
       * var compiled = _.template('hello <%= user %>!');
       * compiled({ 'user': 'fred' });
       * // => 'hello fred!'
       *
       * // Use the HTML "escape" delimiter to escape data property values.
       * var compiled = _.template('<b><%- value %></b>');
       * compiled({ 'value': '<script>' });
       * // => '<b>&lt;script&gt;</b>'
       *
       * // Use the "evaluate" delimiter to execute JavaScript and generate HTML.
       * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
       * compiled({ 'users': ['fred', 'barney'] });
       * // => '<li>fred</li><li>barney</li>'
       *
       * // Use the internal `print` function in "evaluate" delimiters.
       * var compiled = _.template('<% print("hello " + user); %>!');
       * compiled({ 'user': 'barney' });
       * // => 'hello barney!'
       *
       * // Use the ES template literal delimiter as an "interpolate" delimiter.
       * // Disable support by replacing the "interpolate" delimiter.
       * var compiled = _.template('hello ${ user }!');
       * compiled({ 'user': 'pebbles' });
       * // => 'hello pebbles!'
       *
       * // Use backslashes to treat delimiters as plain text.
       * var compiled = _.template('<%= "\\<%- value %\\>" %>');
       * compiled({ 'value': 'ignored' });
       * // => '<%- value %>'
       *
       * // Use the `imports` option to import `jQuery` as `jq`.
       * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
       * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
       * compiled({ 'users': ['fred', 'barney'] });
       * // => '<li>fred</li><li>barney</li>'
       *
       * // Use the `sourceURL` option to specify a custom sourceURL for the template.
       * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
       * compiled(data);
       * // => Find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector.
       *
       * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.
       * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
       * compiled.source;
       * // => function(data) {
       * //   var __t, __p = '';
       * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
       * //   return __p;
       * // }
       *
       * // Use custom template delimiters.
       * _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
       * var compiled = _.template('hello {{ user }}!');
       * compiled({ 'user': 'mustache' });
       * // => 'hello mustache!'
       *
       * // Use the `source` property to inline compiled templates for meaningful
       * // line numbers in error messages and stack traces.
       * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\
       *   var JST = {\
       *     "main": ' + _.template(mainText).source + '\
       *   };\
       * ');
       */
      function template(string, options, guard) {
        // Based on John Resig's `tmpl` implementation
        // (http://ejohn.org/blog/javascript-micro-templating/)
        // and Laura Doktorova's doT.js (https://github.com/olado/doT).
        var settings = lodash.templateSettings;

        if (guard && isIterateeCall(string, options, guard)) {
          options = undefined$1;
        }
        string = toString(string);
        options = assignInWith({}, options, settings, customDefaultsAssignIn);

        var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),
          importsKeys = keys(imports),
          importsValues = baseValues(imports, importsKeys);

        var isEscaping,
          isEvaluating,
          index = 0,
          interpolate = options.interpolate || reNoMatch,
          source = "__p += '";

        // Compile the regexp to match each delimiter.
        var reDelimiters = RegExp(
          (options.escape || reNoMatch).source + '|' +
          interpolate.source + '|' +
          (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
          (options.evaluate || reNoMatch).source + '|$'
          , 'g');

        // Use a sourceURL for easier debugging.
        // The sourceURL gets injected into the source that's eval-ed, so be careful
        // to normalize all kinds of whitespace, so e.g. newlines (and unicode versions of it) can't sneak in
        // and escape the comment, thus injecting code that gets evaled.
        var sourceURL = '//# sourceURL=' +
          (hasOwnProperty.call(options, 'sourceURL')
            ? (options.sourceURL + '').replace(/\s/g, ' ')
            : ('lodash.templateSources[' + (++templateCounter) + ']')
          ) + '\n';

        string.replace(reDelimiters, function (match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
          interpolateValue || (interpolateValue = esTemplateValue);

          // Escape characters that can't be included in string literals.
          source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);

          // Replace delimiters with snippets.
          if (escapeValue) {
            isEscaping = true;
            source += "' +\n__e(" + escapeValue + ") +\n'";
          }
          if (evaluateValue) {
            isEvaluating = true;
            source += "';\n" + evaluateValue + ";\n__p += '";
          }
          if (interpolateValue) {
            source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
          }
          index = offset + match.length;

          // The JS engine embedded in Adobe products needs `match` returned in
          // order to produce the correct `offset` value.
          return match;
        });

        source += "';\n";

        // If `variable` is not specified wrap a with-statement around the generated
        // code to add the data object to the top of the scope chain.
        var variable = hasOwnProperty.call(options, 'variable') && options.variable;
        if (!variable) {
          source = 'with (obj) {\n' + source + '\n}\n';
        }
        // Throw an error if a forbidden character was found in `variable`, to prevent
        // potential command injection attacks.
        else if (reForbiddenIdentifierChars.test(variable)) {
          throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);
        }

        // Cleanup code by stripping empty strings.
        source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
          .replace(reEmptyStringMiddle, '$1')
          .replace(reEmptyStringTrailing, '$1;');

        // Frame code as the function body.
        source = 'function(' + (variable || 'obj') + ') {\n' +
          (variable
            ? ''
            : 'obj || (obj = {});\n'
          ) +
          "var __t, __p = ''" +
          (isEscaping
            ? ', __e = _.escape'
            : ''
          ) +
          (isEvaluating
            ? ', __j = Array.prototype.join;\n' +
            "function print() { __p += __j.call(arguments, '') }\n"
            : ';\n'
          ) +
          source +
          'return __p\n}';

        var result = attempt(function () {
          return Function(importsKeys, sourceURL + 'return ' + source)
            .apply(undefined$1, importsValues);
        });

        // Provide the compiled function's source by its `toString` method or
        // the `source` property as a convenience for inlining compiled templates.
        result.source = source;
        if (isError(result)) {
          throw result;
        }
        return result;
      }

      /*
       * Converts `string`, as a whole, to lower case just like
       * [String#toLowerCase](https://mdn.io/toLowerCase).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to convert.
       * @returns {string} Returns the lower cased string.
       * @example
       *
       * _.toLower('--Foo-Bar--');
       * // => '--foo-bar--'
       *
       * _.toLower('fooBar');
       * // => 'foobar'
       *
       * _.toLower('__FOO_BAR__');
       * // => '__foo_bar__'
       */
      function toLower(value) {
        return toString(value).toLowerCase();
      }

      /*
       * Converts `string`, as a whole, to upper case just like
       * [String#toUpperCase](https://mdn.io/toUpperCase).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to convert.
       * @returns {string} Returns the upper cased string.
       * @example
       *
       * _.toUpper('--foo-bar--');
       * // => '--FOO-BAR--'
       *
       * _.toUpper('fooBar');
       * // => 'FOOBAR'
       *
       * _.toUpper('__foo_bar__');
       * // => '__FOO_BAR__'
       */
      function toUpper(value) {
        return toString(value).toUpperCase();
      }

      /*
       * Removes leading and trailing whitespace or specified characters from `string`.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to trim.
       * @param {string} [chars=whitespace] The characters to trim.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {string} Returns the trimmed string.
       * @example
       *
       * _.trim('  abc  ');
       * // => 'abc'
       *
       * _.trim('-_-abc-_-', '_-');
       * // => 'abc'
       *
       * _.map(['  foo  ', '  bar  '], _.trim);
       * // => ['foo', 'bar']
       */
      function trim(string, chars, guard) {
        string = toString(string);
        if (string && (guard || chars === undefined$1)) {
          return baseTrim(string);
        }
        if (!string || !(chars = baseToString(chars))) {
          return string;
        }
        var strSymbols = stringToArray(string),
          chrSymbols = stringToArray(chars),
          start = charsStartIndex(strSymbols, chrSymbols),
          end = charsEndIndex(strSymbols, chrSymbols) + 1;

        return castSlice(strSymbols, start, end).join('');
      }

      /*
       * Removes trailing whitespace or specified characters from `string`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to trim.
       * @param {string} [chars=whitespace] The characters to trim.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {string} Returns the trimmed string.
       * @example
       *
       * _.trimEnd('  abc  ');
       * // => '  abc'
       *
       * _.trimEnd('-_-abc-_-', '_-');
       * // => '-_-abc'
       */
      function trimEnd(string, chars, guard) {
        string = toString(string);
        if (string && (guard || chars === undefined$1)) {
          return string.slice(0, trimmedEndIndex(string) + 1);
        }
        if (!string || !(chars = baseToString(chars))) {
          return string;
        }
        var strSymbols = stringToArray(string),
          end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;

        return castSlice(strSymbols, 0, end).join('');
      }

      /*
       * Removes leading whitespace or specified characters from `string`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to trim.
       * @param {string} [chars=whitespace] The characters to trim.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {string} Returns the trimmed string.
       * @example
       *
       * _.trimStart('  abc  ');
       * // => 'abc  '
       *
       * _.trimStart('-_-abc-_-', '_-');
       * // => 'abc-_-'
       */
      function trimStart(string, chars, guard) {
        string = toString(string);
        if (string && (guard || chars === undefined$1)) {
          return string.replace(reTrimStart, '');
        }
        if (!string || !(chars = baseToString(chars))) {
          return string;
        }
        var strSymbols = stringToArray(string),
          start = charsStartIndex(strSymbols, stringToArray(chars));

        return castSlice(strSymbols, start).join('');
      }

      /*
       * Truncates `string` if it's longer than the given maximum string length.
       * The last characters of the truncated string are replaced with the omission
       * string which defaults to "...".
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to truncate.
       * @param {Object} [options={}] The options object.
       * @param {number} [options.length=30] The maximum string length.
       * @param {string} [options.omission='...'] The string to indicate text is omitted.
       * @param {RegExp|string} [options.separator] The separator pattern to truncate to.
       * @returns {string} Returns the truncated string.
       * @example
       *
       * _.truncate('hi-diddly-ho there, neighborino');
       * // => 'hi-diddly-ho there, neighbo...'
       *
       * _.truncate('hi-diddly-ho there, neighborino', {
       *   'length': 24,
       *   'separator': ' '
       * });
       * // => 'hi-diddly-ho there,...'
       *
       * _.truncate('hi-diddly-ho there, neighborino', {
       *   'length': 24,
       *   'separator': /,? +/
       * });
       * // => 'hi-diddly-ho there...'
       *
       * _.truncate('hi-diddly-ho there, neighborino', {
       *   'omission': ' [...]'
       * });
       * // => 'hi-diddly-ho there, neig [...]'
       */
      function truncate(string, options) {
        var length = DEFAULT_TRUNC_LENGTH,
          omission = DEFAULT_TRUNC_OMISSION;

        if (isObject(options)) {
          var separator = 'separator' in options ? options.separator : separator;
          length = 'length' in options ? toInteger(options.length) : length;
          omission = 'omission' in options ? baseToString(options.omission) : omission;
        }
        string = toString(string);

        var strLength = string.length;
        if (hasUnicode(string)) {
          var strSymbols = stringToArray(string);
          strLength = strSymbols.length;
        }
        if (length >= strLength) {
          return string;
        }
        var end = length - stringSize(omission);
        if (end < 1) {
          return omission;
        }
        var result = strSymbols
          ? castSlice(strSymbols, 0, end).join('')
          : string.slice(0, end);

        if (separator === undefined$1) {
          return result + omission;
        }
        if (strSymbols) {
          end += (result.length - end);
        }
        if (isRegExp(separator)) {
          if (string.slice(end).search(separator)) {
            var match,
              substring = result;

            if (!separator.global) {
              separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');
            }
            separator.lastIndex = 0;
            while ((match = separator.exec(substring))) {
              var newEnd = match.index;
            }
            result = result.slice(0, newEnd === undefined$1 ? end : newEnd);
          }
        } else if (string.indexOf(baseToString(separator), end) != end) {
          var index = result.lastIndexOf(separator);
          if (index > -1) {
            result = result.slice(0, index);
          }
        }
        return result + omission;
      }

      /*
       * The inverse of `_.escape`; this method converts the HTML entities
       * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to
       * their corresponding characters.
       *
       * **Note:** No other HTML entities are unescaped. To unescape additional
       * HTML entities use a third-party library like [_he_](https://mths.be/he).
       *
       * @static
       * @memberOf _
       * @since 0.6.0
       *  String
       * @param {string} [string=''] The string to unescape.
       * @returns {string} Returns the unescaped string.
       * @example
       *
       * _.unescape('fred, barney, &amp; pebbles');
       * // => 'fred, barney, & pebbles'
       */
      function unescape(string) {
        string = toString(string);
        return (string && reHasEscapedHtml.test(string))
          ? string.replace(reEscapedHtml, unescapeHtmlChar)
          : string;
      }

      /*
       * Converts `string`, as space separated words, to upper case.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to convert.
       * @returns {string} Returns the upper cased string.
       * @example
       *
       * _.upperCase('--foo-bar');
       * // => 'FOO BAR'
       *
       * _.upperCase('fooBar');
       * // => 'FOO BAR'
       *
       * _.upperCase('__foo_bar__');
       * // => 'FOO BAR'
       */
      var upperCase = createCompounder(function (result, word, index) {
        return result + (index ? ' ' : '') + word.toUpperCase();
      });

      /*
       * Converts the first character of `string` to upper case.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  String
       * @param {string} [string=''] The string to convert.
       * @returns {string} Returns the converted string.
       * @example
       *
       * _.upperFirst('fred');
       * // => 'Fred'
       *
       * _.upperFirst('FRED');
       * // => 'FRED'
       */
      var upperFirst = createCaseFirst('toUpperCase');

      /*
       * Splits `string` into an array of its words.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  String
       * @param {string} [string=''] The string to inspect.
       * @param {RegExp|string} [pattern] The pattern to match words.
       * @param {Object} [guard] Enables use as an iteratee for methods like `_.map`.
       * @returns {Array} Returns the words of `string`.
       * @example
       *
       * _.words('fred, barney, & pebbles');
       * // => ['fred', 'barney', 'pebbles']
       *
       * _.words('fred, barney, & pebbles', /[^, ]+/g);
       * // => ['fred', 'barney', '&', 'pebbles']
       */
      function words(string, pattern, guard) {
        string = toString(string);
        pattern = guard ? undefined$1 : pattern;

        if (pattern === undefined$1) {
          return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
        }
        return string.match(pattern) || [];
      }

      /*------------------------------------------------------------------------*/

      /*
       * Attempts to invoke `func`, returning either the result or the caught error
       * object. Any additional arguments are provided to `func` when it's invoked.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Util
       * @param {Function} func The function to attempt.
       * @param {...*} [args] The arguments to invoke `func` with.
       * @returns {*} Returns the `func` result or error object.
       * @example
       *
       * // Avoid throwing errors for invalid selectors.
       * var elements = _.attempt(function(selector) {
       *   return document.querySelectorAll(selector);
       * }, '>_>');
       *
       * if (_.isError(elements)) {
       *   elements = [];
       * }
       */
      var attempt = baseRest(function (func, args) {
        try {
          return apply(func, undefined$1, args);
        } catch (e) {
          return isError(e) ? e : new Error(e);
        }
      });

      /*
       * Binds methods of an object to the object itself, overwriting the existing
       * method.
       *
       * **Note:** This method doesn't set the "length" property of bound functions.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Util
       * @param {Object} object The object to bind and assign the bound methods to.
       * @param {...(string|string[])} methodNames The object method names to bind.
       * @returns {Object} Returns `object`.
       * @example
       *
       * var view = {
       *   'label': 'docs',
       *   'click': function() {
       *     console.log('clicked ' + this.label);
       *   }
       * };
       *
       * _.bindAll(view, ['click']);
       * jQuery(element).on('click', view.click);
       * // => Logs 'clicked docs' when clicked.
       */
      var bindAll = flatRest(function (object, methodNames) {
        arrayEach(methodNames, function (key) {
          key = toKey(key);
          baseAssignValue(object, key, bind(object[key], object));
        });
        return object;
      });

      /*
       * Creates a function that iterates over `pairs` and invokes the corresponding
       * function of the first predicate to return truthy. The predicate-function
       * pairs are invoked with the `this` binding and arguments of the created
       * function.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Util
       * @param {Array} pairs The predicate-function pairs.
       * @returns {Function} Returns the new composite function.
       * @example
       *
       * var func = _.cond([
       *   [_.matches({ 'a': 1 }),           _.constant('matches A')],
       *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
       *   [_.stubTrue,                      _.constant('no match')]
       * ]);
       *
       * func({ 'a': 1, 'b': 2 });
       * // => 'matches A'
       *
       * func({ 'a': 0, 'b': 1 });
       * // => 'matches B'
       *
       * func({ 'a': '1', 'b': '2' });
       * // => 'no match'
       */
      function cond(pairs) {
        var length = pairs == null ? 0 : pairs.length,
          toIteratee = getIteratee();

        pairs = !length ? [] : arrayMap(pairs, function (pair) {
          if (typeof pair[1] != 'function') {
            throw new TypeError(FUNC_ERROR_TEXT);
          }
          return [toIteratee(pair[0]), pair[1]];
        });

        return baseRest(function (args) {
          var index = -1;
          while (++index < length) {
            var pair = pairs[index];
            if (apply(pair[0], this, args)) {
              return apply(pair[1], this, args);
            }
          }
        });
      }

      /*
       * Creates a function that invokes the predicate properties of `source` with
       * the corresponding property values of a given object, returning `true` if
       * all predicates return truthy, else `false`.
       *
       * **Note:** The created function is equivalent to `_.conformsTo` with
       * `source` partially applied.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Util
       * @param {Object} source The object of property predicates to conform to.
       * @returns {Function} Returns the new spec function.
       * @example
       *
       * var objects = [
       *   { 'a': 2, 'b': 1 },
       *   { 'a': 1, 'b': 2 }
       * ];
       *
       * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
       * // => [{ 'a': 1, 'b': 2 }]
       */
      function conforms(source) {
        return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
      }

      /*
       * Creates a function that returns `value`.
       *
       * @static
       * @memberOf _
       * @since 2.4.0
       *  Util
       * @param {*} value The value to return from the new function.
       * @returns {Function} Returns the new constant function.
       * @example
       *
       * var objects = _.times(2, _.constant({ 'a': 1 }));
       *
       * console.log(objects);
       * // => [{ 'a': 1 }, { 'a': 1 }]
       *
       * console.log(objects[0] === objects[1]);
       * // => true
       */
      function constant(value) {
        return function () {
          return value;
        };
      }

      /*
       * Checks `value` to determine whether a default value should be returned in
       * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
       * or `undefined`.
       *
       * @static
       * @memberOf _
       * @since 4.14.0
       *  Util
       * @param {*} value The value to check.
       * @param {*} defaultValue The default value.
       * @returns {*} Returns the resolved value.
       * @example
       *
       * _.defaultTo(1, 10);
       * // => 1
       *
       * _.defaultTo(undefined, 10);
       * // => 10
       */
      function defaultTo(value, defaultValue) {
        return (value == null || value !== value) ? defaultValue : value;
      }

      /*
       * Creates a function that returns the result of invoking the given functions
       * with the `this` binding of the created function, where each successive
       * invocation is supplied the return value of the previous.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Util
       * @param {...(Function|Function[])} [funcs] The functions to invoke.
       * @returns {Function} Returns the new composite function.
       * @see _.flowRight
       * @example
       *
       * function square(n) {
       *   return n * n;
       * }
       *
       * var addSquare = _.flow([_.add, square]);
       * addSquare(1, 2);
       * // => 9
       */
      var flow = createFlow();

      /*
       * This method is like `_.flow` except that it creates a function that
       * invokes the given functions from right to left.
       *
       * @static
       * @since 3.0.0
       * @memberOf _
       *  Util
       * @param {...(Function|Function[])} [funcs] The functions to invoke.
       * @returns {Function} Returns the new composite function.
       * @see _.flow
       * @example
       *
       * function square(n) {
       *   return n * n;
       * }
       *
       * var addSquare = _.flowRight([square, _.add]);
       * addSquare(1, 2);
       * // => 9
       */
      var flowRight = createFlow(true);

      /*
       * This method returns the first argument it receives.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Util
       * @param {*} value Any value.
       * @returns {*} Returns `value`.
       * @example
       *
       * var object = { 'a': 1 };
       *
       * console.log(_.identity(object) === object);
       * // => true
       */
      function identity(value) {
        return value;
      }

      /*
       * Creates a function that invokes `func` with the arguments of the created
       * function. If `func` is a property name, the created function returns the
       * property value for a given element. If `func` is an array or object, the
       * created function returns `true` for elements that contain the equivalent
       * source properties, otherwise it returns `false`.
       *
       * @static
       * @since 4.0.0
       * @memberOf _
       *  Util
       * @param {*} [func=_.identity] The value to convert to a callback.
       * @returns {Function} Returns the callback.
       * @example
       *
       * var users = [
       *   { 'user': 'barney', 'age': 36, 'active': true },
       *   { 'user': 'fred',   'age': 40, 'active': false }
       * ];
       *
       * // The `_.matches` iteratee shorthand.
       * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
       * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
       *
       * // The `_.matchesProperty` iteratee shorthand.
       * _.filter(users, _.iteratee(['user', 'fred']));
       * // => [{ 'user': 'fred', 'age': 40 }]
       *
       * // The `_.property` iteratee shorthand.
       * _.map(users, _.iteratee('user'));
       * // => ['barney', 'fred']
       *
       * // Create custom iteratee shorthands.
       * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
       *   return !_.isRegExp(func) ? iteratee(func) : function(string) {
       *     return func.test(string);
       *   };
       * });
       *
       * _.filter(['abc', 'def'], /ef/);
       * // => ['def']
       */
      function iteratee(func) {
        return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));
      }

      /*
       * Creates a function that performs a partial deep comparison between a given
       * object and `source`, returning `true` if the given object has equivalent
       * property values, else `false`.
       *
       * **Note:** The created function is equivalent to `_.isMatch` with `source`
       * partially applied.
       *
       * Partial comparisons will match empty array and empty object `source`
       * values against any array or object value, respectively. See `_.isEqual`
       * for a list of supported value comparisons.
       *
       * **Note:** Multiple values can be checked by combining several matchers
       * using `_.overSome`
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Util
       * @param {Object} source The object of property values to match.
       * @returns {Function} Returns the new spec function.
       * @example
       *
       * var objects = [
       *   { 'a': 1, 'b': 2, 'c': 3 },
       *   { 'a': 4, 'b': 5, 'c': 6 }
       * ];
       *
       * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
       * // => [{ 'a': 4, 'b': 5, 'c': 6 }]
       *
       * // Checking for several possible values
       * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));
       * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
       */
      function matches(source) {
        return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
      }

      /*
       * Creates a function that performs a partial deep comparison between the
       * value at `path` of a given object to `srcValue`, returning `true` if the
       * object value is equivalent, else `false`.
       *
       * **Note:** Partial comparisons will match empty array and empty object
       * `srcValue` values against any array or object value, respectively. See
       * `_.isEqual` for a list of supported value comparisons.
       *
       * **Note:** Multiple values can be checked by combining several matchers
       * using `_.overSome`
       *
       * @static
       * @memberOf _
       * @since 3.2.0
       *  Util
       * @param {Array|string} path The path of the property to get.
       * @param {*} srcValue The value to match.
       * @returns {Function} Returns the new spec function.
       * @example
       *
       * var objects = [
       *   { 'a': 1, 'b': 2, 'c': 3 },
       *   { 'a': 4, 'b': 5, 'c': 6 }
       * ];
       *
       * _.find(objects, _.matchesProperty('a', 4));
       * // => { 'a': 4, 'b': 5, 'c': 6 }
       *
       * // Checking for several possible values
       * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));
       * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
       */
      function matchesProperty(path, srcValue) {
        return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
      }

      /*
       * Creates a function that invokes the method at `path` of a given object.
       * Any additional arguments are provided to the invoked method.
       *
       * @static
       * @memberOf _
       * @since 3.7.0
       *  Util
       * @param {Array|string} path The path of the method to invoke.
       * @param {...*} [args] The arguments to invoke the method with.
       * @returns {Function} Returns the new invoker function.
       * @example
       *
       * var objects = [
       *   { 'a': { 'b': _.constant(2) } },
       *   { 'a': { 'b': _.constant(1) } }
       * ];
       *
       * _.map(objects, _.method('a.b'));
       * // => [2, 1]
       *
       * _.map(objects, _.method(['a', 'b']));
       * // => [2, 1]
       */
      var method = baseRest(function (path, args) {
        return function (object) {
          return baseInvoke(object, path, args);
        };
      });

      /*
       * The opposite of `_.method`; this method creates a function that invokes
       * the method at a given path of `object`. Any additional arguments are
       * provided to the invoked method.
       *
       * @static
       * @memberOf _
       * @since 3.7.0
       *  Util
       * @param {Object} object The object to query.
       * @param {...*} [args] The arguments to invoke the method with.
       * @returns {Function} Returns the new invoker function.
       * @example
       *
       * var array = _.times(3, _.constant),
       *     object = { 'a': array, 'b': array, 'c': array };
       *
       * _.map(['a[2]', 'c[0]'], _.methodOf(object));
       * // => [2, 0]
       *
       * _.map([['a', '2'], ['c', '0']], _.methodOf(object));
       * // => [2, 0]
       */
      var methodOf = baseRest(function (object, args) {
        return function (path) {
          return baseInvoke(object, path, args);
        };
      });

      /*
       * Adds all own enumerable string keyed function properties of a source
       * object to the destination object. If `object` is a function, then methods
       * are added to its prototype as well.
       *
       * **Note:** Use `_.runInContext` to create a pristine `lodash` function to
       * avoid conflicts caused by modifying the original.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Util
       * @param {Function|Object} [object=lodash] The destination object.
       * @param {Object} source The object of functions to add.
       * @param {Object} [options={}] The options object.
       * @param {boolean} [options.chain=true] Specify whether mixins are chainable.
       * @returns {Function|Object} Returns `object`.
       * @example
       *
       * function vowels(string) {
       *   return _.filter(string, function(v) {
       *     return /[aeiou]/i.test(v);
       *   });
       * }
       *
       * _.mixin({ 'vowels': vowels });
       * _.vowels('fred');
       * // => ['e']
       *
       * _('fred').vowels().value();
       * // => ['e']
       *
       * _.mixin({ 'vowels': vowels }, { 'chain': false });
       * _('fred').vowels();
       * // => ['e']
       */
      function mixin(object, source, options) {
        var props = keys(source),
          methodNames = baseFunctions(source, props);

        if (options == null &&
          !(isObject(source) && (methodNames.length || !props.length))) {
          options = source;
          source = object;
          object = this;
          methodNames = baseFunctions(source, keys(source));
        }
        var chain = !(isObject(options) && 'chain' in options) || !!options.chain,
          isFunc = isFunction(object);

        arrayEach(methodNames, function (methodName) {
          var func = source[methodName];
          object[methodName] = func;
          if (isFunc) {
            object.prototype[methodName] = function () {
              var chainAll = this.__chain__;
              if (chain || chainAll) {
                var result = object(this.__wrapped__),
                  actions = result.__actions__ = copyArray(this.__actions__);

                actions.push({ 'func': func, 'args': arguments, 'thisArg': object });
                result.__chain__ = chainAll;
                return result;
              }
              return func.apply(object, arrayPush([this.value()], arguments));
            };
          }
        });

        return object;
      }

      /*
       * Reverts the `_` variable to its previous value and returns a reference to
       * the `lodash` function.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Util
       * @returns {Function} Returns the `lodash` function.
       * @example
       *
       * var lodash = _.noConflict();
       */
      function noConflict() {
        if (root._ === this) {
          root._ = oldDash;
        }
        return this;
      }

      /*
       * This method returns `undefined`.
       *
       * @static
       * @memberOf _
       * @since 2.3.0
       *  Util
       * @example
       *
       * _.times(2, _.noop);
       * // => [undefined, undefined]
       */
      function noop() {
        // No operation performed.
      }

      /*
       * Creates a function that gets the argument at index `n`. If `n` is negative,
       * the nth argument from the end is returned.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Util
       * @param {number} [n=0] The index of the argument to return.
       * @returns {Function} Returns the new pass-thru function.
       * @example
       *
       * var func = _.nthArg(1);
       * func('a', 'b', 'c', 'd');
       * // => 'b'
       *
       * var func = _.nthArg(-2);
       * func('a', 'b', 'c', 'd');
       * // => 'c'
       */
      function nthArg(n) {
        n = toInteger(n);
        return baseRest(function (args) {
          return baseNth(args, n);
        });
      }

      /*
       * Creates a function that invokes `iteratees` with the arguments it receives
       * and returns their results.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Util
       * @param {...(Function|Function[])} [iteratees=[_.identity]]
       *  The iteratees to invoke.
       * @returns {Function} Returns the new function.
       * @example
       *
       * var func = _.over([Math.max, Math.min]);
       *
       * func(1, 2, 3, 4);
       * // => [4, 1]
       */
      var over = createOver(arrayMap);

      /*
       * Creates a function that checks if **all** of the `predicates` return
       * truthy when invoked with the arguments it receives.
       *
       * Following shorthands are possible for providing predicates.
       * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
       * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Util
       * @param {...(Function|Function[])} [predicates=[_.identity]]
       *  The predicates to check.
       * @returns {Function} Returns the new function.
       * @example
       *
       * var func = _.overEvery([Boolean, isFinite]);
       *
       * func('1');
       * // => true
       *
       * func(null);
       * // => false
       *
       * func(NaN);
       * // => false
       */
      var overEvery = createOver(arrayEvery);

      /*
       * Creates a function that checks if **any** of the `predicates` return
       * truthy when invoked with the arguments it receives.
       *
       * Following shorthands are possible for providing predicates.
       * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
       * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Util
       * @param {...(Function|Function[])} [predicates=[_.identity]]
       *  The predicates to check.
       * @returns {Function} Returns the new function.
       * @example
       *
       * var func = _.overSome([Boolean, isFinite]);
       *
       * func('1');
       * // => true
       *
       * func(null);
       * // => true
       *
       * func(NaN);
       * // => false
       *
       * var matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])
       * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])
       */
      var overSome = createOver(arraySome);

      /*
       * Creates a function that returns the value at `path` of a given object.
       *
       * @static
       * @memberOf _
       * @since 2.4.0
       *  Util
       * @param {Array|string} path The path of the property to get.
       * @returns {Function} Returns the new accessor function.
       * @example
       *
       * var objects = [
       *   { 'a': { 'b': 2 } },
       *   { 'a': { 'b': 1 } }
       * ];
       *
       * _.map(objects, _.property('a.b'));
       * // => [2, 1]
       *
       * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
       * // => [1, 2]
       */
      function property(path) {
        return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
      }

      /*
       * The opposite of `_.property`; this method creates a function that returns
       * the value at a given path of `object`.
       *
       * @static
       * @memberOf _
       * @since 3.0.0
       *  Util
       * @param {Object} object The object to query.
       * @returns {Function} Returns the new accessor function.
       * @example
       *
       * var array = [0, 1, 2],
       *     object = { 'a': array, 'b': array, 'c': array };
       *
       * _.map(['a[2]', 'c[0]'], _.propertyOf(object));
       * // => [2, 0]
       *
       * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
       * // => [2, 0]
       */
      function propertyOf(object) {
        return function (path) {
          return object == null ? undefined$1 : baseGet(object, path);
        };
      }

      /*
       * Creates an array of numbers (positive and/or negative) progressing from
       * `start` up to, but not including, `end`. A step of `-1` is used if a negative
       * `start` is specified without an `end` or `step`. If `end` is not specified,
       * it's set to `start` with `start` then set to `0`.
       *
       * **Note:** JavaScript follows the IEEE-754 standard for resolving
       * floating-point values which can produce unexpected results.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Util
       * @param {number} [start=0] The start of the range.
       * @param {number} end The end of the range.
       * @param {number} [step=1] The value to increment or decrement by.
       * @returns {Array} Returns the range of numbers.
       * @see _.inRange, _.rangeRight
       * @example
       *
       * _.range(4);
       * // => [0, 1, 2, 3]
       *
       * _.range(-4);
       * // => [0, -1, -2, -3]
       *
       * _.range(1, 5);
       * // => [1, 2, 3, 4]
       *
       * _.range(0, 20, 5);
       * // => [0, 5, 10, 15]
       *
       * _.range(0, -4, -1);
       * // => [0, -1, -2, -3]
       *
       * _.range(1, 4, 0);
       * // => [1, 1, 1]
       *
       * _.range(0);
       * // => []
       */
      var range = createRange();

      /*
       * This method is like `_.range` except that it populates values in
       * descending order.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Util
       * @param {number} [start=0] The start of the range.
       * @param {number} end The end of the range.
       * @param {number} [step=1] The value to increment or decrement by.
       * @returns {Array} Returns the range of numbers.
       * @see _.inRange, _.range
       * @example
       *
       * _.rangeRight(4);
       * // => [3, 2, 1, 0]
       *
       * _.rangeRight(-4);
       * // => [-3, -2, -1, 0]
       *
       * _.rangeRight(1, 5);
       * // => [4, 3, 2, 1]
       *
       * _.rangeRight(0, 20, 5);
       * // => [15, 10, 5, 0]
       *
       * _.rangeRight(0, -4, -1);
       * // => [-3, -2, -1, 0]
       *
       * _.rangeRight(1, 4, 0);
       * // => [1, 1, 1]
       *
       * _.rangeRight(0);
       * // => []
       */
      var rangeRight = createRange(true);

      /*
       * This method returns a new empty array.
       *
       * @static
       * @memberOf _
       * @since 4.13.0
       *  Util
       * @returns {Array} Returns the new empty array.
       * @example
       *
       * var arrays = _.times(2, _.stubArray);
       *
       * console.log(arrays);
       * // => [[], []]
       *
       * console.log(arrays[0] === arrays[1]);
       * // => false
       */
      function stubArray() {
        return [];
      }

      /*
       * This method returns `false`.
       *
       * @static
       * @memberOf _
       * @since 4.13.0
       *  Util
       * @returns {boolean} Returns `false`.
       * @example
       *
       * _.times(2, _.stubFalse);
       * // => [false, false]
       */
      function stubFalse() {
        return false;
      }

      /*
       * This method returns a new empty object.
       *
       * @static
       * @memberOf _
       * @since 4.13.0
       *  Util
       * @returns {Object} Returns the new empty object.
       * @example
       *
       * var objects = _.times(2, _.stubObject);
       *
       * console.log(objects);
       * // => [{}, {}]
       *
       * console.log(objects[0] === objects[1]);
       * // => false
       */
      function stubObject() {
        return {};
      }

      /*
       * This method returns an empty string.
       *
       * @static
       * @memberOf _
       * @since 4.13.0
       *  Util
       * @returns {string} Returns the empty string.
       * @example
       *
       * _.times(2, _.stubString);
       * // => ['', '']
       */
      function stubString() {
        return '';
      }

      /*
       * This method returns `true`.
       *
       * @static
       * @memberOf _
       * @since 4.13.0
       *  Util
       * @returns {boolean} Returns `true`.
       * @example
       *
       * _.times(2, _.stubTrue);
       * // => [true, true]
       */
      function stubTrue() {
        return true;
      }

      /*
       * Invokes the iteratee `n` times, returning an array of the results of
       * each invocation. The iteratee is invoked with one argument; (index).
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Util
       * @param {number} n The number of times to invoke `iteratee`.
       * @param {Function} [iteratee=_.identity] The function invoked per iteration.
       * @returns {Array} Returns the array of results.
       * @example
       *
       * _.times(3, String);
       * // => ['0', '1', '2']
       *
       *  _.times(4, _.constant(0));
       * // => [0, 0, 0, 0]
       */
      function times(n, iteratee) {
        n = toInteger(n);
        if (n < 1 || n > MAX_SAFE_INTEGER) {
          return [];
        }
        var index = MAX_ARRAY_LENGTH,
          length = nativeMin(n, MAX_ARRAY_LENGTH);

        iteratee = getIteratee(iteratee);
        n -= MAX_ARRAY_LENGTH;

        var result = baseTimes(length, iteratee);
        while (++index < n) {
          iteratee(index);
        }
        return result;
      }

      /*
       * Converts `value` to a property path array.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Util
       * @param {*} value The value to convert.
       * @returns {Array} Returns the new property path array.
       * @example
       *
       * _.toPath('a.b.c');
       * // => ['a', 'b', 'c']
       *
       * _.toPath('a[0].b.c');
       * // => ['a', '0', 'b', 'c']
       */
      function toPath(value) {
        if (isArray(value)) {
          return arrayMap(value, toKey);
        }
        return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
      }

      /*
       * Generates a unique ID. If `prefix` is given, the ID is appended to it.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Util
       * @param {string} [prefix=''] The value to prefix the ID with.
       * @returns {string} Returns the unique ID.
       * @example
       *
       * _.uniqueId('contact_');
       * // => 'contact_104'
       *
       * _.uniqueId();
       * // => '105'
       */
      function uniqueId(prefix) {
        var id = ++idCounter;
        return toString(prefix) + id;
      }

      /*------------------------------------------------------------------------*/

      /*
       * Adds two numbers.
       *
       * @static
       * @memberOf _
       * @since 3.4.0
       *  Math
       * @param {number} augend The first number in an addition.
       * @param {number} addend The second number in an addition.
       * @returns {number} Returns the total.
       * @example
       *
       * _.add(6, 4);
       * // => 10
       */
      var add = createMathOperation(function (augend, addend) {
        return augend + addend;
      }, 0);

      /*
       * Computes `number` rounded up to `precision`.
       *
       * @static
       * @memberOf _
       * @since 3.10.0
       *  Math
       * @param {number} number The number to round up.
       * @param {number} [precision=0] The precision to round up to.
       * @returns {number} Returns the rounded up number.
       * @example
       *
       * _.ceil(4.006);
       * // => 5
       *
       * _.ceil(6.004, 2);
       * // => 6.01
       *
       * _.ceil(6040, -2);
       * // => 6100
       */
      var ceil = createRound('ceil');

      /*
       * Divide two numbers.
       *
       * @static
       * @memberOf _
       * @since 4.7.0
       *  Math
       * @param {number} dividend The first number in a division.
       * @param {number} divisor The second number in a division.
       * @returns {number} Returns the quotient.
       * @example
       *
       * _.divide(6, 4);
       * // => 1.5
       */
      var divide = createMathOperation(function (dividend, divisor) {
        return dividend / divisor;
      }, 1);

      /*
       * Computes `number` rounded down to `precision`.
       *
       * @static
       * @memberOf _
       * @since 3.10.0
       *  Math
       * @param {number} number The number to round down.
       * @param {number} [precision=0] The precision to round down to.
       * @returns {number} Returns the rounded down number.
       * @example
       *
       * _.floor(4.006);
       * // => 4
       *
       * _.floor(0.046, 2);
       * // => 0.04
       *
       * _.floor(4060, -2);
       * // => 4000
       */
      var floor = createRound('floor');

      /*
       * Computes the maximum value of `array`. If `array` is empty or falsey,
       * `undefined` is returned.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Math
       * @param {Array} array The array to iterate over.
       * @returns {*} Returns the maximum value.
       * @example
       *
       * _.max([4, 2, 8, 6]);
       * // => 8
       *
       * _.max([]);
       * // => undefined
       */
      function max(array) {
        return (array && array.length)
          ? baseExtremum(array, identity, baseGt)
          : undefined$1;
      }

      /*
       * This method is like `_.max` except that it accepts `iteratee` which is
       * invoked for each element in `array` to generate the criterion by which
       * the value is ranked. The iteratee is invoked with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Math
       * @param {Array} array The array to iterate over.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {*} Returns the maximum value.
       * @example
       *
       * var objects = [{ 'n': 1 }, { 'n': 2 }];
       *
       * _.maxBy(objects, function(o) { return o.n; });
       * // => { 'n': 2 }
       *
       * // The `_.property` iteratee shorthand.
       * _.maxBy(objects, 'n');
       * // => { 'n': 2 }
       */
      function maxBy(array, iteratee) {
        return (array && array.length)
          ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)
          : undefined$1;
      }

      /*
       * Computes the mean of the values in `array`.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Math
       * @param {Array} array The array to iterate over.
       * @returns {number} Returns the mean.
       * @example
       *
       * _.mean([4, 2, 8, 6]);
       * // => 5
       */
      function mean(array) {
        return baseMean(array, identity);
      }

      /*
       * This method is like `_.mean` except that it accepts `iteratee` which is
       * invoked for each element in `array` to generate the value to be averaged.
       * The iteratee is invoked with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 4.7.0
       *  Math
       * @param {Array} array The array to iterate over.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {number} Returns the mean.
       * @example
       *
       * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
       *
       * _.meanBy(objects, function(o) { return o.n; });
       * // => 5
       *
       * // The `_.property` iteratee shorthand.
       * _.meanBy(objects, 'n');
       * // => 5
       */
      function meanBy(array, iteratee) {
        return baseMean(array, getIteratee(iteratee, 2));
      }

      /*
       * Computes the minimum value of `array`. If `array` is empty or falsey,
       * `undefined` is returned.
       *
       * @static
       * @since 0.1.0
       * @memberOf _
       *  Math
       * @param {Array} array The array to iterate over.
       * @returns {*} Returns the minimum value.
       * @example
       *
       * _.min([4, 2, 8, 6]);
       * // => 2
       *
       * _.min([]);
       * // => undefined
       */
      function min(array) {
        return (array && array.length)
          ? baseExtremum(array, identity, baseLt)
          : undefined$1;
      }

      /*
       * This method is like `_.min` except that it accepts `iteratee` which is
       * invoked for each element in `array` to generate the criterion by which
       * the value is ranked. The iteratee is invoked with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Math
       * @param {Array} array The array to iterate over.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {*} Returns the minimum value.
       * @example
       *
       * var objects = [{ 'n': 1 }, { 'n': 2 }];
       *
       * _.minBy(objects, function(o) { return o.n; });
       * // => { 'n': 1 }
       *
       * // The `_.property` iteratee shorthand.
       * _.minBy(objects, 'n');
       * // => { 'n': 1 }
       */
      function minBy(array, iteratee) {
        return (array && array.length)
          ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)
          : undefined$1;
      }

      /*
       * Multiply two numbers.
       *
       * @static
       * @memberOf _
       * @since 4.7.0
       *  Math
       * @param {number} multiplier The first number in a multiplication.
       * @param {number} multiplicand The second number in a multiplication.
       * @returns {number} Returns the product.
       * @example
       *
       * _.multiply(6, 4);
       * // => 24
       */
      var multiply = createMathOperation(function (multiplier, multiplicand) {
        return multiplier * multiplicand;
      }, 1);

      /*
       * Computes `number` rounded to `precision`.
       *
       * @static
       * @memberOf _
       * @since 3.10.0
       *  Math
       * @param {number} number The number to round.
       * @param {number} [precision=0] The precision to round to.
       * @returns {number} Returns the rounded number.
       * @example
       *
       * _.round(4.006);
       * // => 4
       *
       * _.round(4.006, 2);
       * // => 4.01
       *
       * _.round(4060, -2);
       * // => 4100
       */
      var round = createRound('round');

      /*
       * Subtract two numbers.
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Math
       * @param {number} minuend The first number in a subtraction.
       * @param {number} subtrahend The second number in a subtraction.
       * @returns {number} Returns the difference.
       * @example
       *
       * _.subtract(6, 4);
       * // => 2
       */
      var subtract = createMathOperation(function (minuend, subtrahend) {
        return minuend - subtrahend;
      }, 0);

      /*
       * Computes the sum of the values in `array`.
       *
       * @static
       * @memberOf _
       * @since 3.4.0
       *  Math
       * @param {Array} array The array to iterate over.
       * @returns {number} Returns the sum.
       * @example
       *
       * _.sum([4, 2, 8, 6]);
       * // => 20
       */
      function sum(array) {
        return (array && array.length)
          ? baseSum(array, identity)
          : 0;
      }

      /*
       * This method is like `_.sum` except that it accepts `iteratee` which is
       * invoked for each element in `array` to generate the value to be summed.
       * The iteratee is invoked with one argument: (value).
       *
       * @static
       * @memberOf _
       * @since 4.0.0
       *  Math
       * @param {Array} array The array to iterate over.
       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
       * @returns {number} Returns the sum.
       * @example
       *
       * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
       *
       * _.sumBy(objects, function(o) { return o.n; });
       * // => 20
       *
       * // The `_.property` iteratee shorthand.
       * _.sumBy(objects, 'n');
       * // => 20
       */
      function sumBy(array, iteratee) {
        return (array && array.length)
          ? baseSum(array, getIteratee(iteratee, 2))
          : 0;
      }

      /*------------------------------------------------------------------------*/

      // Add methods that return wrapped values in chain sequences.
      lodash.after = after;
      lodash.ary = ary;
      lodash.assign = assign;
      lodash.assignIn = assignIn;
      lodash.assignInWith = assignInWith;
      lodash.assignWith = assignWith;
      lodash.at = at;
      lodash.before = before;
      lodash.bind = bind;
      lodash.bindAll = bindAll;
      lodash.bindKey = bindKey;
      lodash.castArray = castArray;
      lodash.chain = chain;
      lodash.chunk = chunk;
      lodash.compact = compact;
      lodash.concat = concat;
      lodash.cond = cond;
      lodash.conforms = conforms;
      lodash.constant = constant;
      lodash.countBy = countBy;
      lodash.create = create;
      lodash.curry = curry;
      lodash.curryRight = curryRight;
      lodash.debounce = debounce;
      lodash.defaults = defaults;
      lodash.defaultsDeep = defaultsDeep;
      lodash.defer = defer;
      lodash.delay = delay;
      lodash.difference = difference;
      lodash.differenceBy = differenceBy;
      lodash.differenceWith = differenceWith;
      lodash.drop = drop;
      lodash.dropRight = dropRight;
      lodash.dropRightWhile = dropRightWhile;
      lodash.dropWhile = dropWhile;
      lodash.fill = fill;
      lodash.filter = filter;
      lodash.flatMap = flatMap;
      lodash.flatMapDeep = flatMapDeep;
      lodash.flatMapDepth = flatMapDepth;
      lodash.flatten = flatten;
      lodash.flattenDeep = flattenDeep;
      lodash.flattenDepth = flattenDepth;
      lodash.flip = flip;
      lodash.flow = flow;
      lodash.flowRight = flowRight;
      lodash.fromPairs = fromPairs;
      lodash.functions = functions;
      lodash.functionsIn = functionsIn;
      lodash.groupBy = groupBy;
      lodash.initial = initial;
      lodash.intersection = intersection;
      lodash.intersectionBy = intersectionBy;
      lodash.intersectionWith = intersectionWith;
      lodash.invert = invert;
      lodash.invertBy = invertBy;
      lodash.invokeMap = invokeMap;
      lodash.iteratee = iteratee;
      lodash.keyBy = keyBy;
      lodash.keys = keys;
      lodash.keysIn = keysIn;
      lodash.map = map;
      lodash.mapKeys = mapKeys;
      lodash.mapValues = mapValues;
      lodash.matches = matches;
      lodash.matchesProperty = matchesProperty;
      lodash.memoize = memoize;
      lodash.merge = merge;
      lodash.mergeWith = mergeWith;
      lodash.method = method;
      lodash.methodOf = methodOf;
      lodash.mixin = mixin;
      lodash.negate = negate;
      lodash.nthArg = nthArg;
      lodash.omit = omit;
      lodash.omitBy = omitBy;
      lodash.once = once;
      lodash.orderBy = orderBy;
      lodash.over = over;
      lodash.overArgs = overArgs;
      lodash.overEvery = overEvery;
      lodash.overSome = overSome;
      lodash.partial = partial;
      lodash.partialRight = partialRight;
      lodash.partition = partition;
      lodash.pick = pick;
      lodash.pickBy = pickBy;
      lodash.property = property;
      lodash.propertyOf = propertyOf;
      lodash.pull = pull;
      lodash.pullAll = pullAll;
      lodash.pullAllBy = pullAllBy;
      lodash.pullAllWith = pullAllWith;
      lodash.pullAt = pullAt;
      lodash.range = range;
      lodash.rangeRight = rangeRight;
      lodash.rearg = rearg;
      lodash.reject = reject;
      lodash.remove = remove;
      lodash.rest = rest;
      lodash.reverse = reverse;
      lodash.sampleSize = sampleSize;
      lodash.set = set;
      lodash.setWith = setWith;
      lodash.shuffle = shuffle;
      lodash.slice = slice;
      lodash.sortBy = sortBy;
      lodash.sortedUniq = sortedUniq;
      lodash.sortedUniqBy = sortedUniqBy;
      lodash.split = split;
      lodash.spread = spread;
      lodash.tail = tail;
      lodash.take = take;
      lodash.takeRight = takeRight;
      lodash.takeRightWhile = takeRightWhile;
      lodash.takeWhile = takeWhile;
      lodash.tap = tap;
      lodash.throttle = throttle;
      lodash.thru = thru;
      lodash.toArray = toArray;
      lodash.toPairs = toPairs;
      lodash.toPairsIn = toPairsIn;
      lodash.toPath = toPath;
      lodash.toPlainObject = toPlainObject;
      lodash.transform = transform;
      lodash.unary = unary;
      lodash.union = union;
      lodash.unionBy = unionBy;
      lodash.unionWith = unionWith;
      lodash.uniq = uniq;
      lodash.uniqBy = uniqBy;
      lodash.uniqWith = uniqWith;
      lodash.unset = unset;
      lodash.unzip = unzip;
      lodash.unzipWith = unzipWith;
      lodash.update = update;
      lodash.updateWith = updateWith;
      lodash.values = values;
      lodash.valuesIn = valuesIn;
      lodash.without = without;
      lodash.words = words;
      lodash.wrap = wrap;
      lodash.xor = xor;
      lodash.xorBy = xorBy;
      lodash.xorWith = xorWith;
      lodash.zip = zip;
      lodash.zipObject = zipObject;
      lodash.zipObjectDeep = zipObjectDeep;
      lodash.zipWith = zipWith;

      // Add aliases.
      lodash.entries = toPairs;
      lodash.entriesIn = toPairsIn;
      lodash.extend = assignIn;
      lodash.extendWith = assignInWith;

      // Add methods to `lodash.prototype`.
      mixin(lodash, lodash);

      /*------------------------------------------------------------------------*/

      // Add methods that return unwrapped values in chain sequences.
      lodash.add = add;
      lodash.attempt = attempt;
      lodash.camelCase = camelCase;
      lodash.capitalize = capitalize;
      lodash.ceil = ceil;
      lodash.clamp = clamp;
      lodash.clone = clone;
      lodash.cloneDeep = cloneDeep;
      lodash.cloneDeepWith = cloneDeepWith;
      lodash.cloneWith = cloneWith;
      lodash.conformsTo = conformsTo;
      lodash.deburr = deburr;
      lodash.defaultTo = defaultTo;
      lodash.divide = divide;
      lodash.endsWith = endsWith;
      lodash.eq = eq;
      lodash.escape = escape;
      lodash.escapeRegExp = escapeRegExp;
      lodash.every = every;
      lodash.find = find;
      lodash.findIndex = findIndex;
      lodash.findKey = findKey;
      lodash.findLast = findLast;
      lodash.findLastIndex = findLastIndex;
      lodash.findLastKey = findLastKey;
      lodash.floor = floor;
      lodash.forEach = forEach;
      lodash.forEachRight = forEachRight;
      lodash.forIn = forIn;
      lodash.forInRight = forInRight;
      lodash.forOwn = forOwn;
      lodash.forOwnRight = forOwnRight;
      lodash.get = get;
      lodash.gt = gt;
      lodash.gte = gte;
      lodash.has = has;
      lodash.hasIn = hasIn;
      lodash.head = head;
      lodash.identity = identity;
      lodash.includes = includes;
      lodash.indexOf = indexOf;
      lodash.inRange = inRange;
      lodash.invoke = invoke;
      lodash.isArguments = isArguments;
      lodash.isArray = isArray;
      lodash.isArrayBuffer = isArrayBuffer;
      lodash.isArrayLike = isArrayLike;
      lodash.isArrayLikeObject = isArrayLikeObject;
      lodash.isBoolean = isBoolean;
      lodash.isBuffer = isBuffer;
      lodash.isDate = isDate;
      lodash.isElement = isElement;
      lodash.isEmpty = isEmpty;
      lodash.isEqual = isEqual;
      lodash.isEqualWith = isEqualWith;
      lodash.isError = isError;
      lodash.isFinite = isFinite;
      lodash.isFunction = isFunction;
      lodash.isInteger = isInteger;
      lodash.isLength = isLength;
      lodash.isMap = isMap;
      lodash.isMatch = isMatch;
      lodash.isMatchWith = isMatchWith;
      lodash.isNaN = isNaN;
      lodash.isNative = isNative;
      lodash.isNil = isNil;
      lodash.isNull = isNull;
      lodash.isNumber = isNumber;
      lodash.isObject = isObject;
      lodash.isObjectLike = isObjectLike;
      lodash.isPlainObject = isPlainObject;
      lodash.isRegExp = isRegExp;
      lodash.isSafeInteger = isSafeInteger;
      lodash.isSet = isSet;
      lodash.isString = isString;
      lodash.isSymbol = isSymbol;
      lodash.isTypedArray = isTypedArray;
      lodash.isUndefined = isUndefined;
      lodash.isWeakMap = isWeakMap;
      lodash.isWeakSet = isWeakSet;
      lodash.join = join;
      lodash.kebabCase = kebabCase;
      lodash.last = last;
      lodash.lastIndexOf = lastIndexOf;
      lodash.lowerCase = lowerCase;
      lodash.lowerFirst = lowerFirst;
      lodash.lt = lt;
      lodash.lte = lte;
      lodash.max = max;
      lodash.maxBy = maxBy;
      lodash.mean = mean;
      lodash.meanBy = meanBy;
      lodash.min = min;
      lodash.minBy = minBy;
      lodash.stubArray = stubArray;
      lodash.stubFalse = stubFalse;
      lodash.stubObject = stubObject;
      lodash.stubString = stubString;
      lodash.stubTrue = stubTrue;
      lodash.multiply = multiply;
      lodash.nth = nth;
      lodash.noConflict = noConflict;
      lodash.noop = noop;
      lodash.now = now;
      lodash.pad = pad;
      lodash.padEnd = padEnd;
      lodash.padStart = padStart;
      lodash.parseInt = parseInt;
      lodash.random = random;
      lodash.reduce = reduce;
      lodash.reduceRight = reduceRight;
      lodash.repeat = repeat;
      lodash.replace = replace;
      lodash.result = result;
      lodash.round = round;
      lodash.runInContext = runInContext;
      lodash.sample = sample;
      lodash.size = size;
      lodash.snakeCase = snakeCase;
      lodash.some = some;
      lodash.sortedIndex = sortedIndex;
      lodash.sortedIndexBy = sortedIndexBy;
      lodash.sortedIndexOf = sortedIndexOf;
      lodash.sortedLastIndex = sortedLastIndex;
      lodash.sortedLastIndexBy = sortedLastIndexBy;
      lodash.sortedLastIndexOf = sortedLastIndexOf;
      lodash.startCase = startCase;
      lodash.startsWith = startsWith;
      lodash.subtract = subtract;
      lodash.sum = sum;
      lodash.sumBy = sumBy;
      lodash.template = template;
      lodash.times = times;
      lodash.toFinite = toFinite;
      lodash.toInteger = toInteger;
      lodash.toLength = toLength;
      lodash.toLower = toLower;
      lodash.toNumber = toNumber;
      lodash.toSafeInteger = toSafeInteger;
      lodash.toString = toString;
      lodash.toUpper = toUpper;
      lodash.trim = trim;
      lodash.trimEnd = trimEnd;
      lodash.trimStart = trimStart;
      lodash.truncate = truncate;
      lodash.unescape = unescape;
      lodash.uniqueId = uniqueId;
      lodash.upperCase = upperCase;
      lodash.upperFirst = upperFirst;

      // Add aliases.
      lodash.each = forEach;
      lodash.eachRight = forEachRight;
      lodash.first = head;

      mixin(lodash, (function () {
        var source = {};
        baseForOwn(lodash, function (func, methodName) {
          if (!hasOwnProperty.call(lodash.prototype, methodName)) {
            source[methodName] = func;
          }
        });
        return source;
      }()), { 'chain': false });

      /*------------------------------------------------------------------------*/

      /*
       * The semantic version number.
       *
       * @static
       * @memberOf _
       * @type {string}
       */
      lodash.VERSION = VERSION$1;

      // Assign default placeholders.
      arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function (methodName) {
        lodash[methodName].placeholder = lodash;
      });

      // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
      arrayEach(['drop', 'take'], function (methodName, index) {
        LazyWrapper.prototype[methodName] = function (n) {
          n = n === undefined$1 ? 1 : nativeMax(toInteger(n), 0);

          var result = (this.__filtered__ && !index)
            ? new LazyWrapper(this)
            : this.clone();

          if (result.__filtered__) {
            result.__takeCount__ = nativeMin(n, result.__takeCount__);
          } else {
            result.__views__.push({
              'size': nativeMin(n, MAX_ARRAY_LENGTH),
              'type': methodName + (result.__dir__ < 0 ? 'Right' : '')
            });
          }
          return result;
        };

        LazyWrapper.prototype[methodName + 'Right'] = function (n) {
          return this.reverse()[methodName](n).reverse();
        };
      });

      // Add `LazyWrapper` methods that accept an `iteratee` value.
      arrayEach(['filter', 'map', 'takeWhile'], function (methodName, index) {
        var type = index + 1,
          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;

        LazyWrapper.prototype[methodName] = function (iteratee) {
          var result = this.clone();
          result.__iteratees__.push({
            'iteratee': getIteratee(iteratee, 3),
            'type': type
          });
          result.__filtered__ = result.__filtered__ || isFilter;
          return result;
        };
      });

      // Add `LazyWrapper` methods for `_.head` and `_.last`.
      arrayEach(['head', 'last'], function (methodName, index) {
        var takeName = 'take' + (index ? 'Right' : '');

        LazyWrapper.prototype[methodName] = function () {
          return this[takeName](1).value()[0];
        };
      });

      // Add `LazyWrapper` methods for `_.initial` and `_.tail`.
      arrayEach(['initial', 'tail'], function (methodName, index) {
        var dropName = 'drop' + (index ? '' : 'Right');

        LazyWrapper.prototype[methodName] = function () {
          return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
        };
      });

      LazyWrapper.prototype.compact = function () {
        return this.filter(identity);
      };

      LazyWrapper.prototype.find = function (predicate) {
        return this.filter(predicate).head();
      };

      LazyWrapper.prototype.findLast = function (predicate) {
        return this.reverse().find(predicate);
      };

      LazyWrapper.prototype.invokeMap = baseRest(function (path, args) {
        if (typeof path == 'function') {
          return new LazyWrapper(this);
        }
        return this.map(function (value) {
          return baseInvoke(value, path, args);
        });
      });

      LazyWrapper.prototype.reject = function (predicate) {
        return this.filter(negate(getIteratee(predicate)));
      };

      LazyWrapper.prototype.slice = function (start, end) {
        start = toInteger(start);

        var result = this;
        if (result.__filtered__ && (start > 0 || end < 0)) {
          return new LazyWrapper(result);
        }
        if (start < 0) {
          result = result.takeRight(-start);
        } else if (start) {
          result = result.drop(start);
        }
        if (end !== undefined$1) {
          end = toInteger(end);
          result = end < 0 ? result.dropRight(-end) : result.take(end - start);
        }
        return result;
      };

      LazyWrapper.prototype.takeRightWhile = function (predicate) {
        return this.reverse().takeWhile(predicate).reverse();
      };

      LazyWrapper.prototype.toArray = function () {
        return this.take(MAX_ARRAY_LENGTH);
      };

      // Add `LazyWrapper` methods to `lodash.prototype`.
      baseForOwn(LazyWrapper.prototype, function (func, methodName) {
        var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),
          isTaker = /^(?:head|last)$/.test(methodName),
          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],
          retUnwrapped = isTaker || /^find/.test(methodName);

        if (!lodashFunc) {
          return;
        }
        lodash.prototype[methodName] = function () {
          var value = this.__wrapped__,
            args = isTaker ? [1] : arguments,
            isLazy = value instanceof LazyWrapper,
            iteratee = args[0],
            useLazy = isLazy || isArray(value);

          var interceptor = function (value) {
            var result = lodashFunc.apply(lodash, arrayPush([value], args));
            return (isTaker && chainAll) ? result[0] : result;
          };

          if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {
            // Avoid lazy use if the iteratee has a "length" value other than `1`.
            isLazy = useLazy = false;
          }
          var chainAll = this.__chain__,
            isHybrid = !!this.__actions__.length,
            isUnwrapped = retUnwrapped && !chainAll,
            onlyLazy = isLazy && !isHybrid;

          if (!retUnwrapped && useLazy) {
            value = onlyLazy ? value : new LazyWrapper(this);
            var result = func.apply(value, args);
            result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined$1 });
            return new LodashWrapper(result, chainAll);
          }
          if (isUnwrapped && onlyLazy) {
            return func.apply(this, args);
          }
          result = this.thru(interceptor);
          return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;
        };
      });

      // Add `Array` methods to `lodash.prototype`.
      arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function (methodName) {
        var func = arrayProto[methodName],
          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',
          retUnwrapped = /^(?:pop|shift)$/.test(methodName);

        lodash.prototype[methodName] = function () {
          var args = arguments;
          if (retUnwrapped && !this.__chain__) {
            var value = this.value();
            return func.apply(isArray(value) ? value : [], args);
          }
          return this[chainName](function (value) {
            return func.apply(isArray(value) ? value : [], args);
          });
        };
      });

      // Map minified method names to their real names.
      baseForOwn(LazyWrapper.prototype, function (func, methodName) {
        var lodashFunc = lodash[methodName];
        if (lodashFunc) {
          var key = lodashFunc.name + '';
          if (!hasOwnProperty.call(realNames, key)) {
            realNames[key] = [];
          }
          realNames[key].push({ 'name': methodName, 'func': lodashFunc });
        }
      });

      realNames[createHybrid(undefined$1, WRAP_BIND_KEY_FLAG).name] = [{
        'name': 'wrapper',
        'func': undefined$1
      }];

      // Add methods to `LazyWrapper`.
      LazyWrapper.prototype.clone = lazyClone;
      LazyWrapper.prototype.reverse = lazyReverse;
      LazyWrapper.prototype.value = lazyValue;

      // Add chain sequence methods to the `lodash` wrapper.
      lodash.prototype.at = wrapperAt;
      lodash.prototype.chain = wrapperChain;
      lodash.prototype.commit = wrapperCommit;
      lodash.prototype.next = wrapperNext;
      lodash.prototype.plant = wrapperPlant;
      lodash.prototype.reverse = wrapperReverse;
      lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;

      // Add lazy aliases.
      lodash.prototype.first = lodash.prototype.head;

      if (symIterator) {
        lodash.prototype[symIterator] = wrapperToIterator;
      }
      return lodash;
    });

    /*--------------------------------------------------------------------------*/

    // Export lodash.
    var lodash = runInContext();

    var tree = {};
    /** 实际数据源
     *
     */

    tree.Source = [];
    /**临时数据源 用来前端使用 item：null
     *
     * */
    tree.TempSource = [];

    /**可编辑点,线,面数据存储
     *
     * */
    tree.entity = [];
    tree.lastSelectEntity = null;
    /**可编辑军事标绘数据存储
    *
    * */
    tree.pointsId = [];
    tree.states = 0;
    /**
     *  点选图层元素时保存点选的对象*/
    tree.PointSelectSource = [];
    tree.currentObj = null;
    /**
     *当前选中的组组  */
    tree.selectedItem = null;
    /**
     * 设置数据源
     */
    tree.setSource = function (Source) {
        this.Source = Source;
    };
    /**
     * 设置临时数据源 */
    tree.setTempSource = function (Source) {
        this.TempSource = Source;
    };
    /**
     * 点选数据源
     */
    tree.setPointSelectSource = function (Source) {
        this.PointSelectSource = Source;
    };
    /**
     * 获取数据源
     */
    tree.getSource = function () {
        return this.Source;
    };
    /**
     * 获取临时数据源
     */
    tree.getTempSource = function () {
        return this.TempSource;
    };
    /**
     * 获取点选数据源
     */
    tree.getPointSelectSource = function () {
        return this.PointSelectSource;
    };
    /**
     * 添加数据源
     */
    tree.push = function (obj) {
        this.Source.push(obj);
    };
    /**
     * 添加临时数据源
     */
    tree.pusTemSource = function (obj) {
        this.TempSource.push(obj);
    };
    /**
     * 添加点选数据源
     */
    tree.pusPointSelectSource = function (obj) {
        this.PointSelectSource.push(obj);
    };
    /**
     * 添加数据源
     */
    tree.insertGroupId = function (obj, groupId) {
        if (obj.checked != undefined && obj.checked != "true" && obj.checked != null) ; else {
            obj.checked = true;
        }
        // if(obj.type=='group')
        // {
        //     obj.isParent=true;
        // }
        // if (obj.item && obj.item.item && obj.item.item.show) {
        //     obj.checked = true;
        // } else {
        //     obj.checked = false;
        // }
        try {
            if (obj.item.item.show == false) {
                obj.checked = false;
            }
        } catch (ex) {
        }
        var child = this.getSourceById(tree.Source, groupId);
        if (child) {
            //图层未展开时绘制操作工程树增加数并正常显示勾选状态 2019 0822 caoyong
            for (var i = 0, l = this.TempSource.length; i < l; i++) {
                if (this.TempSource[i].id == groupId) {
                    if (obj.checked && !this.TempSource[i].checked) {
                        this.TempSource[i].checked = true;
                    }
                    break;
                }
            }
            if (!child.children) {
                child.children = [];
            }
            child.children.push(obj);
        } else {
            this.push(obj);
        }
        var tempObj = lodash.clone(obj);
        tempObj.item = null;
        tree.currentObj = tempObj;
        this.pusTemSource(tempObj);
        return obj.id;
    };

    /**
     * 获取数据源中的数据 通过组编号
     */
    tree.getSourceById = function (Source, groupId) {
        if (Source) {
            for (var i = 0; i < Source.length; i++) {
                if (Source[i].id == groupId) {
                    return Source[i];
                }
                if (Source[i] && Source[i].children && Source[i].children.length > 0) {
                    var vv = this.getSourceById(Source[i].children, groupId);
                    if (vv != undefined) {
                        return vv;
                    }
                }
            }
        }
    };
    /**
     * 是否存在组
     */
    tree.exitsGroup = function (groupId, name) {
        if (groupId) {
            var Source = tree.Source;
            for (var i = 0; i < Source.length; i++) {
                if (Source[i].id == groupId) {
                    if (Source[i].type == 'group') {
                        for (var j = 0; j < Source[i].children.length; j++) {
                            var SourceChildrenItem = Source[i].children[j];
                            if (SourceChildrenItem.name == name) {
                                return true;
                            }
                        }
                    }
                    return false;
                }
                if (Source[i] && Source[i].children && Source[i].children.length > 0) {
                    this.getSourceById(Source[i].children, groupId);
                }

            }
        }
    };
    /**
     * 获取临时数据源中的数据 通过编号
     */
    tree.getTempSourceById = function (id) {
        for (var i = 0; i < this.TempSource.length; i++) {
            if (this.TempSource[i].id == id) {
                return this.TempSource[i];
            }
        }
    };
    /**
     * 获取点选数据源中的数据 通过编号
     */
    tree.getPointSelectSourceById = function (id) {
        for (var i = 0; i < this.PointSelectSource.length; i++) {
            if (this.PointSelectSource[i].id == id) {
                return this.PointSelectSource[i];
            }
        }
    };

    /**
     * 获取数据源中的数据 通过名称
     */
    tree.getSourceByName = function (Source, name) {
        return lodash.find(Source, function (o) {
            return o.name == name;
        });
    };
    /**
     * 删除数据源中的数据
     */
    tree.delete = function (id, viewer, cesium) {
        var vv = this.getSourceById(tree.Source, id);
        if (vv && vv.children && vv.children.length > 0) {
            for (var i = 0; i < vv.children.length;) {
                this.delete(vv.children[i].id);
            }
            if (vv && vv.type == "group") {
                if (vv.pId == 0 || vv.pId == "") {
                    var index = this.getIndex(tree.Source, vv);
                    tree.Source.splice(index, 1);
                    this.delete1(vv.id);
                } else {
                    var vvp = this.getSourceById(tree.Source, vv.pId);
                    var index = this.getIndex(vvp.children, vv);
                    vvp.children.splice(index, 1);
                    this.delete1(vv.id);
                }
            } else {
                ///从cesium中删除数据
                if (vv.item)
                    vv.item.deleteObject(id);
                else {
                    try {
                        viewer.entities.removeById(vv.id);
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.dataSources.get(vv.id);
                        if (o)
                            viewer.dataSources.remove(o);
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.imageryLayers.get(vv.id);
                        if (o)
                            viewer.imageryLayers.remove(o);
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.scene.primitives.get(vv.id);
                        viewer.scene.primitives.remove(o);
                    } catch (ex) {
                        //throw ex;
                    }
                }
                var vvp = this.getSourceById(tree.Source, vv.pId);
                var index = this.getIndex(vvp.children, vv);
                vvp.children.splice(index, 1);
                this.delete1(vv.id);
            }
        } else {
            if (vv && vv.type == "group") {
                if (vv.pId == 0 || vv.pId == "") {
                    var index = this.getIndex(tree.Source, vv);
                    tree.Source.splice(index, 1);
                    this.delete1(vv.id);
                } else {
                    var vvp = this.getSourceById(tree.Source, vv.pId);
                    var index = this.getIndex(vvp.children, vv);
                    vvp.children.splice(index, 1);
                    this.delete1(vv.id);
                }
            } else if (vv) {
                ///从cesium删除数据
                if (vv.item && vv.item.deleteObject)
                    vv.item.deleteObject(id);
                else {
                    try {
                        viewer.entities.removeById(vv.id);
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.dataSources.get(vv.id);
                        if (o)
                            viewer.dataSources.remove(o);
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.imageryLayers.get(vv.id);
                        if (o)
                            viewer.imageryLayers.remove(o);
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.scene.primitives.get(vv.id);
                        viewer.scene.primitives.remove(o);
                    } catch (ex) {
                        //throw ex;
                    }
                }
                this.delete1(vv.id);
                var vvp = this.getSourceById(tree.Source, vv.pId);
                if (vvp) {
                    var index = this.getIndex(vvp.children, vv);
                    vvp.children.splice(index, 1);
                }
            }
        }
    };
    //临时数据
    tree.temporaryItem = { obj: [], state: "start", operation: "" };
    //临时数据结束
    tree.endtemporaryItem = function () {
        tree.temporaryItem.obj = [];
        tree.temporaryItem.state = "end";
        tree.temporaryItem.operation = "";
    };
    //临时数据开始
    tree.starttemporaryItem = function (viewer) {
        var tooltip = null;
        try {
            tooltip = document.getElementById('toolTip');
        } catch (ex) {
        }
        if (tooltip != null) {
            tooltip.style.display = "none";
        }
        if (tree.handler != null) {
            tree.handler.destroy();
            tree.handler = null;
        }
        if (tree.temporaryItem.obj.length > 0 && tree.temporaryItem.state == "start") {
            for (var i = 0; i < tree.temporaryItem.obj.length; i++) {
                try {
                    tree.temporaryItem.obj[i].destroy();
                } catch (ex) {
                }
                try {
                    viewer.entities.remove(tree.temporaryItem.obj[i]);
                } catch (e) {
                }
            }
        }
        tree.temporaryItem.obj = [];
        tree.temporaryItem.state = "start";
        return tree.temporaryItem.operation;
    };

    /**
     * 删除临时数据源中的数据 通过编号删除
     */
    tree.delete1 = function (id) {
        for (var i = 0; i < this.TempSource.length; i++) {
            if (this.TempSource[i].id == id) {
                this.TempSource.splice(i, 1);
            }
        }
    };
    /**
     * 获取数据源中的序号 通过对象
     */
    tree.getIndex = function (Source, obj) {
        for (var i = 0; i < Source.length; i++) {
            if (Source[i].id == obj.id) {
                return i;
            }
        }
        return -1;
    };
    /**
     * 设置数据的显示隐藏
     */
    tree.setVisibilityTemp = function (itemId, b) {
        var item = lodash.filter(this.TempSource, function (o) {
            return o.id == itemId;
        });
        if (item && item.length) {
            item[0].checked = b;
        }
    };
    tree.setVisibility = function (itemId, b, viewer, cesium) {
        this.setVisibilityTemp(itemId, b);
        var vv = this.getSourceById(tree.Source, itemId);
        if (!vv) {
            return;
        }
        if (vv.children && vv.children.length > 0) {
            for (var i = 0; i < vv.children.length; i++) {
                this.setVisibility(vv.children[i].id, b);
            }

            if (vv.type == "group") ; else {
                if (vv.item && vv.item.setVisibility)
                    vv.item.setVisibility(b, itemId);
                else {
                    try {
                        var o = viewer.entities.getById(vv.id);
                        if (o)
                            o.show = b;
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.dataSources.get(vv.id);
                        if (o)
                            o.show = b;
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.imageryLayers.get(vv.id);
                        if (o)
                            o.show = b;
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.scene.primitives.get(vv.id);
                        if (o)
                            o.show = b;
                    } catch (ex) {
                        //throw ex;
                    }
                }
            }
        } else {
            if (vv.type == "group") ; else {
                if (vv.item && vv.item.setVisibility)
                    vv.item.setVisibility(b, itemId);
                else {
                    try {
                        var o = viewer.entities.getById(vv.id);
                        if (o)
                            o.show = b;
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.dataSources.get(vv.id);
                        if (o)
                            o.show = b;
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.imageryLayers.get(vv.id);
                        if (o)
                            o.show = b;
                    } catch (ex) {
                        //throw ex;
                    }
                    try {
                        var o = viewer.scene.primitives.get(vv.id);
                        if (o)
                            o.show = b;
                    } catch (ex) {
                        //throw ex;
                    }
                }
            }
        }
    };
    /**
     * 数据源中移除数据
     */
    tree.removeItem = function (Source) {
        if (Source) {
            for (var i = 0; i < Source.length; i++) {
                Source[i].item = null;
                if (Source[i].children) {
                    this.removeItem(Source[i].children);
                }
            }
        }
        return Source;
    };
    /**
     * 修改组顺序
     */
    tree.changeGroup = function (ItemID, GroupID) {
        ///数据源修改
        var vv = this.getSourceById(this.Source, ItemID);
        var targetVV = this.getSourceById(this.Source, GroupID);
        if (vv && targetVV && targetVV.children) {
            if (vv.id == 0 || vv.id == null || vv.id == undefined) {
                var index = this.getIndex(this.Source, vv);
                this.Source.splice(index, 1);
                vv.pId = GroupID;
                targetVV.children.push(vv);
            } else {
                var vvp = this.getSourceById(this.Source, vv.pId);
                var index = this.getIndex(vvp.children, vv);
                vvp.children.splice(index, 1);
                vv.pId = GroupID;
                targetVV.children.push(vv);
            }
        }
        ///临时数据源修改
        var vv = this.getTempSourceById(ItemID);
        if (vv) {
            vv.pId = GroupID;
        }
    };
    /**
     * 移除鼠标绑定事件
     */
    tree.handler = null;
    tree.removeHandler = function () {
        if (tree.handler) {
            tree.handler.destroy();
            tree.handler = null;
        }
    };

    var Cesium$1;
    var DeltaRadian = 0.00001 * Math.PI / 180.0; //Cesium.Math.RADIANS_PER_DEGREE
    var terrainLevel = 11; //数据等级14

    /**
     *
     * 通视分析。
     *
     * @alias lineOfSight
     * @constructor
     *
     */
    function lineOfSight(viewer, cesium) {
        viewer = viewer;
        Cesium$1 = cesium;
        this._cesium = cesium;
        this._viewer = viewer;
        this._core = new Core();
        this._polylines = [];
        this._points = [];
        this._tree = tree;
        this._interval = 20;
    }

    lineOfSight.prototype.createlineOfSight = function (parameter, methond) {
        var _this = this;
        this._tree.starttemporaryItem(this._viewer);
        var zub = [];
        var ent = [];
        var Distance = {
            polyline: []
        };
        this._tree.removeHandler();
        var tooltip = this._core.CreateTooltip();
        _this.objectsToExclude = null;
        var firtP = undefined;
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        var PolyLinePrimitive = (function () {
            function execute(positionsp) {
                this.options = {
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.YELLOW,
                        width: 3,
                        clampToGround: false
                    }
                };
                this.positionsp = positionsp;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positionsp;
                };
                //实时更新polyline.positions
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                this.polyline = _this._viewer.entities.add(this.options);
                _this.item = this.polyline;
                _this._tree.temporaryItem.obj.push(this.polyline);
                ent.push(this.polyline);
            };
            return execute;
        })();
        this._tree.handler = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        ///存储点的数组 至多有两个点
        var positionsp = [];
        var poly = undefined;
        //删除所有通视结果
        if (this._points.length > 0) {
            for (var i = 0; i < this._points.length; i++) {
                this._viewer.entities.remove(this._points[i]);
            }
        }
        //鼠标左键单击画点
        var zubd = [];
        this._tree.handler.setInputAction(function (movement) {
            var cartesian;
            var ray = _this._viewer.camera.getPickRay(movement.position);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);

            var feature = _this._viewer.scene.pick(movement.position);
            if (feature) {
                var _cartesian = _this._viewer.scene.pickPosition(movement.position);
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            }
            if (!cartesian) {
                return;
            }
            if (positionsp.length === 0) {
                ///两个点画一条线
                positionsp.push(cartesian.clone(), cartesian.clone());
                ///存储第一个点
                var left = {
                    leftX: movement.position.x,
                    leftY: movement.position.y
                };
                zubd.push(left);
                firtP = cartesian.clone();
            } else {
                var left = {
                    rightX: movement.position.x,
                    rightY: movement.position.y
                };
                zubd.push(left);
                var zubj = { "postion": positionsp, "entity": ent, "cartesian": zubd };
                zub.push(zubj);
                zubd = [];
                ///画一条线结束
                poly = undefined;
                ///清空存储点数组
                positionsp = [];
                //用第一个点的数组再次画线
                var cartographics = firtP.clone();
                if (parameter.height != undefined) {
                    var cartographic = ellipsoid.cartesianToCartographic(firtP.clone());
                    var lat = Cesium$1.Math.toDegrees(cartograhphic.latitude);
                    var lng = Cesium$1.Math.toDegrees(cartograhpinc.longitude);
                    var alt = parameter.height;
                    var cartographic = Cesium$1.Cartographic.fromDegrees(lng, lat, alt);
                    var cartesian3 = ellipsoid.cartographicToCartesian(cartographic);
                    cartographics = cartesian3;
                }
                positionsp.push(cartographics);
                positionsp.push(cartographics);
                ///再画一条线
                poly = new PolyLinePrimitive(positionsp);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        this._tree.handler.setInputAction(function (movement) {
            var cartesian;
            var ray = _this._viewer.camera.getPickRay(movement.endPosition);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);

            var feature = _this._viewer.scene.pick(movement.endPosition);
            if (feature) {
                var _cartesian = _this._viewer.scene.pickPosition(movement.endPosition);
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            }
            if (!cartesian) {
                return;
            }

            if (positionsp.length === 0) {
                tooltip.showAt(movement.endPosition, '点击添加视点');
            } else {
                tooltip.showAt(movement.endPosition, '点击添加目标视点，右键结束');
            }
            if (positionsp.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive(positionsp);
                } else {
                    if (cartesian != undefined) {
                        positionsp.pop();
                        //cartesian.y += (1 + Math.random());
                        positionsp.push(cartesian);
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        var leftX = 0.0;
        var leftY = 0.0;
        //单击鼠标右键结束画线
        this._tree.handler.setInputAction(function (movement) {
            _this.end && _this.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        this.end = (type) => {
            tooltip.show(false);
            this.end = undefined;

            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0);
            _this._tree.endtemporaryItem();
            _this._tree.handler.destroy();

            if (type === 'cancel') {
                for (var u = 0; u < ent.length; u++) {
                    _this._viewer.entities.remove(ent[u]);
                }
                return;
            }
            var gu = true;
            for (var s = 0; s < zub.length; s++) {
                if (s == 0) {
                    leftX = zub[s].cartesian[0].leftX;
                    leftY = zub[s].cartesian[0].leftY;
                    gu = _this.tsjx(zub[s].postion, leftX, leftY, zub[s].cartesian[1].rightX, zub[s].cartesian[1].rightY, 50, ent, _this._cesium, _this._viewer);
                } else {
                    gu = _this.tsjx(zub[s].postion, leftX, leftY, zub[s].cartesian[0].rightX, zub[s].cartesian[0].rightY, 50, ent, _this._cesium, _this._viewer);
                }
                //var gu = _this.tsjx(zub[s].postion, leftX, leftY, zub[s].cartesian[1].rightX, zub[s].cartesian[1].rightY, 20, _this._cesium, _this._viewer);
                if (gu) {
                    var pl = _this._viewer.entities.add({
                        name: 'polyline1',
                        polyline: {
                            positions: zub[s].postion,
                            width: 3,
                            material: _this._cesium.Color.GREEN
                        }
                    });
                    Distance.polyline.push(pl);
                } else {
                    var pl = _this._viewer.entities.add({
                        name: 'polyline1',
                        polyline: {
                            positions: zub[s].postion,
                            width: 3,
                            material: _this._cesium.Color.RED
                        }
                    });
                    Distance.polyline.push(pl);
                }
            }
            positionsp.pop();
            _this._polylines = Distance.polyline;
            _this._tree.handler.destroy();
            for (var u = 0; u < ent.length; u++) {
                _this._viewer.entities.remove(ent[u]);
            }
            if (methond != "" && methond != null) {
                if (typeof methond == 'function')
                    methond(Distance);
            }
        };
        return this;
    };
    /**
     * 通视分析解析
     */
    lineOfSight.prototype.tsjx = function (_positions, leftX, leftY, rightX, rightY, pointSum1, objectsToExclude, cesium, viewer) {
        //测量距离
        var julifr = this._core.getSpaceDistancem(_positions, cesium);
        if (julifr <= 100 && julifr >= 10) {
            pointSum1 = parseInt(julifr / 2);
        } else if (julifr < 10 && julifr > 0) {
            pointSum1 = parseInt(julifr / 1);
        } else if (julifr > 100) {
            pointSum1 = parseInt(julifr / 10);
        }
        var startPoint = _positions[0];
        var endPoint = _positions[_positions.length - 1];
        var scartographic = cesium.Cartographic.fromCartesian(startPoint);
        var slongitude = cesium.Math.toDegrees(scartographic.longitude);
        var slatitude = cesium.Math.toDegrees(scartographic.latitude);
        scartographic.height;
        //线本身高度 初始
        var slasheight = scartographic.height;

        var ecartographic = cesium.Cartographic.fromCartesian(endPoint);
        var elongitude = cesium.Math.toDegrees(ecartographic.longitude);
        var elatitude = cesium.Math.toDegrees(ecartographic.latitude);
        ecartographic.height;
        //线本身高度 结束
        var slaeheight = ecartographic.height;


        //var pointSum = pointSum1;  //取样点个数
        var pointSum = pointSum1; //取样点个数
        var addXTT = cesium.Math.lerp(slongitude, elongitude, 1.0 / pointSum) - slongitude;
        var addYTT = cesium.Math.lerp(slatitude, elatitude, 1.0 / pointSum) - slatitude;
        var addHTT = cesium.Math.lerp(slasheight, slaeheight, 1.0 / pointSum) - slasheight;


        cesium.Math.lerp(leftX, rightX, 1.0 / pointSum) - leftX;
        cesium.Math.lerp(leftY, rightY, 1.0 / pointSum) - leftY;
        var ts = true;
        var _cartesian, _cartographic;
        //var dp1, dp2;
        for (var i = 0; i < pointSum - 2; i++) {

            var longitude = slongitude + (i + 1) * addXTT;
            var latitude = slatitude + (i + 1) * addYTT;
            var he = slasheight + (i + 1) * addHTT;

            _cartesian = cesium.Cartesian3.fromDegrees(longitude, latitude, he);
            _cartographic = cesium.Cartographic.fromCartesian(_cartesian);
            //本身高度

            // if (i == 0) {
            //     dp1 = new cesium.Cartesian3(longitude, latitude, 0);
            // } else if (i == 1) {
            //     dp2 = new cesium.Cartesian3(longitude, latitude, 0);
            // }
            // var x = leftX + (i + 1) * addX;
            // var y = leftY + (i + 1) * addY;
            // var eventPosition = {x: x, y: y};
            //var height = 0;
            // var ray = viewer.scene.camera.getPickRay(eventPosition);
            // var position = viewer.scene.globe.pick(ray, viewer.scene);
            // var cartographic1 = cesium.Ellipsoid.WGS84.cartesianToCartographic(position);
            // var feature = viewer.scene.pick(eventPosition);
            // if (feature == undefined) {
            //     height = cartographic1.height;
            // } else if (feature) {
            //     var cartesian = viewer.scene.pickPosition(eventPosition);
            //     if (cesium.defined(cartesian)) {
            //         var cartographic = cesium.Cartographic.fromCartesian(cartesian);
            //         height = cartographic1.height + cartographic.height;//模型高度 } }
            //         //--------------------------------------------------------------
            //     }
            // } else if (feature.id != null && feature.id.polygon != undefined && feature.id.polygon != null) {
            //     //面拉伸高度
            //     height = feature.id.polygon.extrudedHeight._value;
            //     height = cartographic1.height + parseFloat(height);
            // } else {
            //     height = cartographic1.height;
            // }
            var height = viewer.scene.globe.getHeight(_cartographic);
            var _height = viewer.scene.sampleHeight(_cartographic, objectsToExclude);
            if (_height) {
                height = _height;
            }
            height = parseFloat(height.toFixed(1));
            he = parseFloat(he.toFixed(1));
            if (height > he) {
                ts = false;
                return ts;
            }
        }
        return ts;
    };
    /**
     * 通视分析
     */
    lineOfSight.prototype.deleteObject = function () {
        if (this._points.length > 0) {
            this.objectsToExclude = null;
            for (var i = 0; i < this._points.length; i++) {
                this._viewer.entities.remove(this._points[i]);
            }
        }
    };
    /*
    线段插值
    经纬度坐标插值
    Cartographic start.longitude start.latitude 单位:弧度
    return [Cartographic,...]
    */
    lineOfSight.prototype.InterpolateLineCartographic = function (start, end, _Delta) {
        if (start && end) ; else {
            return null;
        }
        if (start.longitude && start.latitude && end.longitude && end.latitude) ; else {
            return null;
        }
        var result = [];
        //开始点
        result.push(new Cesium$1.Cartographic(start.longitude, start.latitude));
        var interval = Math.sqrt(Math.pow((end.longitude - start.longitude), 2) + Math.pow((end.latitude - start.latitude), 2));
        var delta = _Delta && (typeof _Delta === 'number') ? _Delta : DeltaRadian;
        if (interval <= delta) {
            //小于最小间隔
            result.push(new Cesium$1.Cartographic(end.longitude, end.latitude));
            return result;
        } else {
            var num = interval / delta;
            var stepLon = (end.longitude - start.longitude) / num;
            var stepLat = (end.latitude - start.latitude) / num;
            for (var i = 0; i < num; i++) {
                var lon = start.longitude + (i + 1) * stepLon;
                var lat = start.latitude + (i + 1) * stepLat;
                result.push(new Cesium$1.Cartographic(lon, lat)); //与最后一个点有偏差
            }
            result.push(new Cesium$1.Cartographic(end.longitude, end.latitude, end.height));
        }
        return result;
    };
    /*
    线段插值薛鹏修改
    经纬度坐标插值线段高度插值
    Cartographic start.longitude start.latitude 单位:弧度
    return [Cartographic,...]
    */
    lineOfSight.prototype.InterpolateLineCartographicxp = function (start, end, _Delta) {
        if (start && end) ; else {
            return null;
        }
        if (start.longitude && start.latitude && end.longitude && end.latitude) ; else {
            return null;
        }
        var result = [];
        //开始点
        result.push(new Cesium$1.Cartographic(start.longitude, start.latitude));
        var interval = Math.sqrt(Math.pow((end.longitude - start.longitude), 2) + Math.pow((end.latitude - start.latitude), 2));
        var delta = _Delta && (typeof _Delta === 'number') ? _Delta : DeltaRadian;
        if (interval <= delta) {
            //小于最小间隔
            result.push(new Cesium$1.Cartographic(end.longitude, end.latitude));
            return result;
        } else {
            var num = interval / delta;
            var stepLon = (end.longitude - start.longitude) / num;
            var stepLat = (end.latitude - start.latitude) / num;
            var stepheight = (end.height - start.height) / num;
            //if(start.height >= end.height){
            //    stepheight = (start.height - end.height) / num;
            //} else {
            //    stepheight = (end.height - start.height) / num;
            //    fs = false;
            //}
            for (var i = 0; i < num; i++) {
                var lon = start.longitude + (i + 1) * stepLon;
                var lat = start.latitude + (i + 1) * stepLat;
                var height = start.height + stepheight * (i + 1);
                //var height = start.height - (start.height - end.height) * 0.01 * (i + 1);
                result.push(new Cesium$1.Cartographic(lon, lat, height)); //与最后一个点有偏差
            }
            result.push(new Cesium$1.Cartographic(end.longitude, end.latitude, end.height));
        }
        return result;
    };
    /*
    线段插值
    经纬度高程插值
    Cartographic start.longitude start.latitude 单位:弧度 start.height 高程单位m
    return [Cartographic,...]
    */
    lineOfSight.prototype.InterpolateLineHeightCartographic = function (start, end) {
        if (start && end) ; else {
            return null;
        }
        if (start.longitude && start.latitude && end.longitude && end.latitude) ; else {
            return null;
        }
        var result = [];
        result.push(new Cesium$1.Cartographic(start.longitude, start.latitude, start.height));
        var interval = Math.sqrt(Math.pow((end.longitude - start.longitude), 2) + Math.pow((end.latitude - start.latitude), 2));
        if (interval <= DeltaRadian) {
            //小于最小间隔
            result.push(new Cesium$1.Cartographic(end.longitude, end.latitude, end.height));
            return result;
        } else {
            var num = interval / DeltaRadian;
            var stepLon = (end.longitude - start.longitude) / num;
            var stepLat = (end.latitude - start.latitude) / num;
            var stepHeight = (end.height - start.height) / num;
            for (var i = 0; i < num; i++) {
                var lon = start.longitude + (i + 1) * stepLon;
                var lat = start.latitude + (i + 1) * stepLat;
                var hieght = start.height + (i + 1) * stepHeight;
                result.push(new Cesium$1.Cartographic(lon, lat, hieght));
            }
            result.push(new Cesium$1.Cartographic(end.longitude, end.latitude, end.height));
        }
        return result;
    };
    /*
    线段插值 指定第index值
    经纬度高程插值
    Cartographic start.longitude start.latitude 单位:弧度 start.height 高程单位m
    num:分总段数  传入数组长度-1
    index:获取第index个插值点  0点是开始点
    return Cartographic
    */
    lineOfSight.prototype.InterpolateIndexLineHeightCartographic = function (start, end, num, index) {
        if (start && end) ; else {
            return null;
        }
        if (start.longitude && start.latitude && end.longitude && end.latitude) ; else {
            return null;
        }
        //var delta = _Delta && (typeof _Delta === 'number') ? _Delta : DeltaRadian;    
        var stepLon = (end.longitude - start.longitude) / num;
        var stepLat = (end.latitude - start.latitude) / num;
        var stepHeight = (end.height - start.height) / num;
        var lon = start.longitude + index * stepLon;
        var lat = start.latitude + index * stepLat;
        var hieght = start.height + index * stepHeight;
        var result = new Cesium$1.Cartographic(lon, lat, hieght);
        return result;
    };
    /*
    线段插值 指定第index值
    经纬度高程插值
    Cartographic start.longitude start.latitude 单位:弧度 start.height 高程单位m
    num:分总段数  传入数组长度-1
    index:获取第index个插值点  0点是开始点
    return Cartographic
    */
    lineOfSight.prototype.InterpolateIndexLineHeightCartographicxp = function (start, end, num, index) {
        if (start && end) ; else {
            return null;
        }
        if (start.longitude && start.latitude && end.longitude && end.latitude) ; else {
            return null;
        }
        //var delta = _Delta && (typeof _Delta === 'number') ? _Delta : DeltaRadian;    
        var stepLon = (end.longitude - start.longitude) / num;
        var stepLat = (end.latitude - start.latitude) / num;
        var stepHeight = (end.height - start.height) / num;
        var lon = start.longitude + index * stepLon;
        var lat = start.latitude + index * stepLat;
        var hieght = start.height + index * stepHeight;
        var result = new Cesium$1.Cartographic(lon, lat, hieght);
        return result;
    };
    /*
    线段插值
    经纬度高程插值
    Cartographic start.longitude start.latitude 单位:弧度 start.height 高程单位m
    num:分总段数  传入数组长度-1
    index:获取到第index点的所有插值 0点是开始点
    return [Cartographic,...]
    */
    lineOfSight.prototype.Interpolate2IndexLineHeightCartographic = function (start, end, num, curIndex) {
        if (start && end) ; else {
            return null;
        }
        if (start.longitude && start.latitude && end.longitude && end.latitude) ; else {
            return null;
        }
        var result = [];
        result.push(new Cesium$1.Cartographic(start.longitude, start.latitude, start.height));
        var stepLon = (end.longitude - start.longitude) / num;
        var stepLat = (end.latitude - start.latitude) / num;
        var stepHeight = (end.height - start.height) / num;
        for (var i = 0; i < curIndex; i++) {
            var lon = start.longitude + (i + 1) * stepLon;
            var lat = start.latitude + (i + 1) * stepLat;
            var hieght = start.height + (i + 1) * stepHeight;
            result.push(new Cesium$1.Cartographic(lon, lat, hieght));
        }
        //result.push(new Cesium.Cartographic(end.longitude, end.latitude, end.height));
        return result;
    };
    //传入Cartographic类型数组 弧度制经纬度
    lineOfSight.prototype.CartographicPointsTerrainData = function (Cartographics, callback) {
        if (Cartographics.length && Cartographics.length > 0) ; else {
            return;
        }
        var promise = Cesium$1.sampleTerrain(this._viewer.terrainProvider, terrainLevel, Cartographics); //pointArrInput
        Cesium$1.when(promise, function (updatedPositions) {
            callback(updatedPositions);
        });
    };
    //显示隐藏
    lineOfSight.prototype.setVisibility = function (b) {
        if (this._polylines.length > 0) {
            for (var i = 0; i < this._polylines.length; i++) {
                this._polylines[i].show = b;
            }
        }
    };
    //显示隐藏
    lineOfSight.prototype.deleteObject = function () {
        if (this._polylines.length > 0) {
            for (var i = 0; i < this._polylines.length; i++) {
                this._viewer.entities.remove(this._polylines[i]);
            }
        }
    };
    Object.defineProperties(lineOfSight.prototype, {
        /**
         * 获取或设置墙
         */
        sight: {
            get: function () {
                return this.item.sight;
            },
            set: function (wall) {
                this.item.sight = sight;
            }
        }
    });

    /**
     * ModelEdit
     *
     * @alias ModelEdit
     * @constructor
     *
     * @param {Viewer} viewer 地图视图。
     * 
     * @example
     * modelEdit = new SmartEarth.ModelEdit(Viewer);
     * modelEdit.start(model)
     */
    function ModelEdit(viewer) {
        this._viewer = viewer;

        this._core = new Core();
        this.tooltip = this._core.CreateTooltip({
            id: 'ModelEdit'
        });
    }

    /**
     * 开始编辑
     * @param {Entity} model 模型
     * @param {Object} [option] 参数
     * @param {Number} [option.minimumPixelSize=0] 最小显示尺寸
     * @returns {ModelEdit}
     */
    ModelEdit.prototype.start = function (model, option = {}) {
        this.end();

        if (!model) return
        let modelIndex = this._viewer.scene.primitives._primitives.findIndex(primitive => {
            return primitive.id && primitive.id.id === model.id
        });
        if (modelIndex < 0) return

        let model_primitive = this._viewer.scene.primitives.get(modelIndex);
        let boundingSphere = model_primitive.boundingSphere;

        // 所编辑模型的边界半径
        let radius = boundingSphere.radius;
        // 编辑坐标轴的边界半径
        let axisRadius = 3.63;
        // 编辑坐标轴的比例
        let axisScale = 2 * radius / axisRadius;

        let modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(model.position.getValue());

        this.model = model;
        !model.heading && (model.heading = 0);
        !model.pitch && (model.pitch = 0);
        !model.roll && (model.roll = 0);

        this.axis = this._viewer.scene.primitives.add(Cesium.Model.fromGltf({
            id: 'modeEditAxis',
            modelMatrix: modelMatrix,
            url: window.SmartEarthRootUrl + configData$1.modelAxis,
            scale: axisScale,
            minimumPixelSize: option.minimumPixelSize
        }));
        this.initEvent();

        return this
    };

    /*
     * 初始化模型编辑响应事件
     */
    ModelEdit.prototype.initEvent = function () {
        this.editHandler && this.editHandler.destroy();
        this.editHandler = new Cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);

        let editType, startP;
        this.editHandler.setInputAction(event => {
            if (editType) {
                startP = event.position;

                this.originPosition = this.model.position.getValue();
                this.originHeading = this.model.heading || 0;
                this.originPitch = this.model.pitch || 0;
                this.originRoll = this.model.roll || 0;

                this.startPosition = this._viewer.scene.pickPosition(startP);
                this.defaultEvent(false);
                this.setMouseStyle('edit');
            } else {
                startP = undefined;
            }
        }, Cesium.ScreenSpaceEventType.LEFT_DOWN);
        this.editHandler.setInputAction(event => {
            startP = undefined;
            this.defaultEvent(true);
            this.setMouseStyle('default');
        }, Cesium.ScreenSpaceEventType.LEFT_UP);

        this.editHandler.setInputAction(event => {
            if (startP) {
                this.mouseTooltip(editType, event);
                this.edit(editType, startP, event.endPosition);
                return
            }
            let pick = this._viewer.scene.pick(event.endPosition);
            if (pick && pick.id === 'modeEditAxis') {
                if (pick.mesh.name === 'XArrow_1') {
                    editType = 'y';
                } else if (pick.mesh.name === 'YArrow_1') {
                    editType = 'x';
                } else if (pick.mesh.name === 'ZArrow_1') {
                    editType = 'z';
                } else if (pick.mesh.name === 'ZAxis_1') {
                    editType = 'heading';
                } else if (pick.mesh.name === 'XAxis_1') {
                    editType = 'pitch';
                } else if (pick.mesh.name === 'YAxis_1') {
                    editType = 'roll';
                } else {
                    editType = undefined;
                }
            } else {
                editType = undefined;
            }
            this.mouseTooltip(editType, event);
        }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
    };

    /*
     * 默认鼠标事件
     */
    ModelEdit.prototype.defaultEvent = function (isOpen) {
        let scene = this._viewer.scene;
        scene.screenSpaceCameraController.enableRotate = isOpen;
        scene.screenSpaceCameraController.enableTranslate = isOpen;
        scene.screenSpaceCameraController.enableZoom = isOpen;
        scene.screenSpaceCameraController.enableTilt = isOpen;
        scene.screenSpaceCameraController.enableLook = isOpen;
    };

    /*
     * 设置鼠标样式
     */
    ModelEdit.prototype.setMouseStyle = function (type) {
        if (type === 'edit') {
            this.defaultMouseStyle = this._viewer.container.style.cursor;
            this._viewer.container.style.cursor = "crosshair";
        } else if (type === 'default') {
            this._viewer.container.style.cursor = this.defaultMouseStyle || "default";
        }
    };

    /*
     * 编辑模型
     */
    ModelEdit.prototype.edit = function (editType, start, end) {
        if (editType) {
            let centerPosition = this.originPosition;
            let startPosition = this.startPosition;
            let centerDegrees = this._core.toDegrees(centerPosition);
            let startDegrees = this._core.toDegrees(startPosition);

            let c_winPosition = this._viewer.scene.cartesianToCanvasCoordinates(centerPosition);

            let _x = end.x - start.x;
            let _y = end.y - start.y;

            let newPosition;
            if (editType === 'x') {
                let originLon = startDegrees.lon - centerDegrees.lon;

                //移动后经度变化
                let _lon = _x * originLon / (start.x - c_winPosition.x);

                centerDegrees.lon += _lon;
                newPosition = Cesium.Cartesian3.fromDegrees(centerDegrees.lon, centerDegrees.lat, centerDegrees.height);
                this.model.position = newPosition;
                this.axis.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(newPosition);
            } else if (editType === 'y') {
                let originLat = startDegrees.lat - centerDegrees.lat;

                //移动后纬度变化
                let _lat = _x * originLat / (start.x - c_winPosition.x);

                centerDegrees.lat += _lat;
                newPosition = Cesium.Cartesian3.fromDegrees(centerDegrees.lon, centerDegrees.lat, centerDegrees.height);
                this.model.position = newPosition;
                this.axis.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(newPosition);
            } else if (editType === 'z') {
                let originHeight = startDegrees.height - centerDegrees.height;

                //移动后高度变化
                let _height = _y * Math.abs(originHeight / (start.y - c_winPosition.y));

                centerDegrees.height -= _height;
                newPosition = Cesium.Cartesian3.fromDegrees(centerDegrees.lon, centerDegrees.lat, centerDegrees.height);
                this.model.position = newPosition;
                this.axis.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(newPosition);

                if (window.SmartEarthPopupData && window.SmartEarthPopupData.window) {
                    SmartEarthPopupData.window.document.querySelector('.model input[name="height"]') && (SmartEarthPopupData.window.document.querySelector('.model input[name="height"]').value = centerDegrees.height.toFixed(2));
                }
            } else if (editType === 'heading') {
                let heading = this.originHeading;
                let angle = this._core.arge(c_winPosition, start, end, '+-', true);
                heading -= angle;
                this.setRotate('heading', heading);

                if (window.SmartEarthPopupData && window.SmartEarthPopupData.window) {
                    SmartEarthPopupData.window.document.querySelector('.model input[name="heading"]') && (SmartEarthPopupData.window.document.querySelector('.model input[name="heading"]').value = heading);
                }
            } else if (editType === 'pitch') {
                let originLon = startDegrees.lon - centerDegrees.lon;
                //移动后经度变化
                let _lon = originLon / (start.x - c_winPosition.x);

                let pitch = this.originPitch;
                let angle = this._core.arge(c_winPosition, start, end, '+-', true);
                if (_lon > 0) {
                    pitch += angle;

                } else {
                    pitch -= angle;
                }
                this.setRotate('pitch', pitch);

                if (window.SmartEarthPopupData && window.SmartEarthPopupData.window) {
                    SmartEarthPopupData.window.document.querySelector('.model input[name="pitch"]') && (SmartEarthPopupData.window.document.querySelector('.model input[name="pitch"]').value = pitch);
                }
            } else if (editType === 'roll') {
                let originLat = startDegrees.lat - centerDegrees.lat;
                //移动后纬度变化
                let _lat = originLat / (start.x - c_winPosition.x);

                let roll = this.originRoll;
                let angle = this._core.arge(c_winPosition, start, end, '+-', true);
                if (_lat < 0) {
                    roll -= angle;
                } else {
                    roll += angle;
                }
                this.setRotate('roll', roll);

                if (window.SmartEarthPopupData && window.SmartEarthPopupData.window) {
                    SmartEarthPopupData.window.document.querySelector('.model input[name="roll"]') && (SmartEarthPopupData.window.document.querySelector('.model input[name="roll"]').value = roll);
                }
            }
        }
    };

    /**
     * 设置模型旋转角
     * @param {String} type 旋转类型【heading | pitch | roll】
     * @param {Number} value 旋转角
     */
    ModelEdit.prototype.setRotate = function (type, value) {
        if (this.model) {
            let heading = this.model.heading;
            let pitch = this.model.pitch;
            let roll = this.model.roll;
            if (type === 'heading') {
                this.model.heading = heading = value;
            } else if (type === 'pitch') {
                this.model.pitch = pitch = value;
            } else if (type === 'roll') {
                this.model.roll = roll = value;
            }
            this.model.orientation = Cesium.Transforms.headingPitchRollQuaternion(
                this.model.position.getValue(),
                new Cesium.HeadingPitchRoll(
                    Cesium.Math.toRadians(heading),
                    Cesium.Math.toRadians(pitch),
                    Cesium.Math.toRadians(roll)
                )
            );
        }
    };

    /*
     * 鼠标提示
     */
    ModelEdit.prototype.mouseTooltip = function (editType, event) {
        if (editType) {
            let position = event.endPosition || event.position;
            if (editType === 'x') {
                this.tooltip.showAt(position, "X方向平移");
            } else if (editType === 'y') {
                this.tooltip.showAt(position, "Y方向平移");
            } else if (editType === 'z') {
                this.tooltip.showAt(position, "Z方向平移");
            } else if (editType === 'heading') {
                this.tooltip.showAt(position, "绕Z轴旋转");
            } else if (editType === 'pitch') {
                this.tooltip.showAt(position, "绕Y轴旋转");
            } else if (editType === 'roll') {
                this.tooltip.showAt(position, "绕X轴旋转");
            } else {
                this.tooltip.show(false);
            }
        } else {
            this.tooltip.show(false);
        }
    };

    /**
     * 结束编辑
     *
     */
    ModelEdit.prototype.end = function () {
        this.axis && this._viewer.scene.primitives.remove(this.axis);
        this.axis = undefined;

        this.editHandler && this.editHandler.destroy();
        this.editHandler = undefined;

        this.model && (this.model.ModelEdit = undefined);
        this.model = undefined;

        this.tooltip && this.tooltip.show(false);
    };

    /**
     *
     * 创建点。
     *
     * @alias DivPoint
     * @constructor
     *
     */
    function DivPoint(viewer) {
        this._viewer = viewer;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 向三维场景中添加一个div点。
     * @param {String} [name] 名称。
     * @param {Object} [degrees] 经纬度
     * @param {Object} [option] 参数
     * @param {String} [option.id] id
     * @param {String} [option.GroupID] GroupID
     * @param {String} [option.type="default"] 类型【default | custom】
     * @param {String|Array} [option.offset="l"] 对齐方式【左: l | 中: c | 右: r | [左|中|右, 20]】
     * @param {String} [option.description] 内容
     * @param {Number} [option.near=0] 最小可视距离
     * @param {Number} [option.far=Infinity] 最大可视距离
     * @param {Function} [option.onclick] 点击事件
     * @param {Function} [option.update] 更新事件
     * @returns {DivPoint} 返回DivPoint对象
     *
     */
    DivPoint.prototype.createDivPoint = function (name, position, option = {}) {
        var Cartesian3;
        var id = option.id || 'DivPoint' + this._core.getuid();
        if (Array.isArray(position)) {
            if (position.length === 2) {
                Cartesian3 = Cesium.Cartesian3.fromDegrees(position[0], position[1]);
            } else if (position.length === 3) {
                Cartesian3 = Cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]);
            }
        } else if (position.x && position.y) {
            if (position instanceof Cesium.Cartesian3) {
                Cartesian3 = position;
            } else {
                Cartesian3 = Cesium.Cartesian3.fromDegrees(position.x, position.y, position.z);
            }
        } else if (position.lon && position.lat) {
            Cartesian3 = Cesium.Cartesian3.fromDegrees(position.lon, position.lat, position.height);
        }

        this.item = {
            id: id,
            show: true,
            name: name,
            type: 'default',
            offset: 'l',
            position: Cartesian3,
        };
        Object.assign(this.item, option);

        this._viewer.clock.onTick.addEventListener(this.updateDivPointEvent, this);


        var obj = {
            id: this.item.id,
            name: name,
            pId: option.GroupID || 0,
            type: 'DivPoint',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, obj.pId);
        return this;
    };

    /**
     * div点实时更新函数
     */
    DivPoint.prototype.updateDivPointEvent = function () {
        if (this.item) {
            let point = this.item;
            let divPoint = document.getElementById(point.id);
            let show = false;
            if (point.show) {
                if (point.near !== undefined || point.far !== undefined) {
                    let distance = this._core.getPointToCameraDistance(this._viewer, point.position);
                    let near = point.near || 0;
                    let far = point.far || Infinity;
                    if (distance >= near && distance <= far) {
                        divPoint && (divPoint.style.display = 'block');
                        show = true;
                    } else {
                        divPoint && (divPoint.style.display = 'none');
                    }
                } else {
                    divPoint && (divPoint.style.display = 'block');
                    show = true;
                }
            } else {
                divPoint && (divPoint.style.display = 'none');
            }
            if (show) {
                let CanvasCoordinates = this._viewer.scene.cartesianToCanvasCoordinates(point.position);
                if (!CanvasCoordinates) return;
                !point.name && (point.name = 'SmartEarth');
                if (!divPoint) {
                    let divPointHtml;
                    if (point.type === 'default') {
                        if (point.description) {
                            let list = '';
                            if (Array.isArray(point.description)) {
                                point.description.forEach(text => {
                                    list += '<div class="divpoint-data-li" style="padding: 4px 45px 4px 0;font-size: 14px;">' + text + '</div>';
                                });
                            } else {
                                list = '<div class="divpoint-data-li" style="padding: 4px 45px 4px 0;font-size: 14px;">' + point.description + '</div>';
                            }
                            divPointHtml =
                                `<div id="${point.id}" style="${point.onclick ? 'cursor: pointer;' : 'pointer-events: none;'}position: absolute; left: 0px; top: 0px; transform: matrix(1, 0, 0, 1, 246.52, 299.197); transform-origin: left bottom 0px;">
                                <div class="divpoint">
                                    <div class="divpoint-wrap" style="position: relative;padding: 30px;overflow: hidden;">
                                        <div class="divpoint-area" style="background-image:linear-gradient(135deg,transparent 30px,#28bbf06c 30px,#28bbf06c 50%,transparent 50%),linear-gradient(-45deg,transparent 30px,#28bbf06c 30px,#28bbf06c 50.1%,transparent 50%);position: relative;min-width: 180px;">
                                            <div class="divpoint-arrow-lt"></div>
                                            <div class="divpoint-b-t" style="background-color: #29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;top: 0;left: 44px;right: 0;height: 1px;z-index: 10;"></div>
                                            <div class="divpoint-b-r" style="background-color: #29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;top: 0;right: 0;bottom: 44px;width: 1px;z-index: 10;"></div>
                                            <div class="divpoint-b-b" style="background-color: #29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;left: 0;right: 44px;bottom: 0;height: 1px;z-index: 10;"></div>
                                            <div class="divpoint-b-l" style="background-color: #29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;top: 44px;left: 0;bottom: 0;width: 1px;z-index: 10;"></div>
                                            <div class="divpoint-arrow-rb"></div>
                                            <div class="divpoint-label-wrap" style="padding-left: 12px;color:#fff;font-size: 16px;white-space: nowrap;overflow: hidden;">
                                                <div class="divpoint-title" style="background-image: linear-gradient(135deg,transparent 25px,#29baf1 25px);    margin-top: 20px;padding: 0 12px 0 30px;height: 36px;line-height: 36px;position: relative;">${point.name}</div>
                                                <div class="divpoint-label-content" style="padding: 15px 0;margin-top: 3px;border-top: 2px solid #29baf1;">
                                                    ${list}
                                                </div>
                                            </div>
                                        </div>
                                        <div class="divpoint-b-t-l" style="background-color:#29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;top: 0;left: 0;width: 1px;height: 62px;transform: rotate(45deg) translate(52px,-22px);z-index: 10;"></div>
                                        <div class="divpoint-b-b-r" style="background-color: #29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;bottom: 0;right: 0;width: 1px;height: 62px;transform: rotate(45deg) translate(-52px,22px);z-index: 10;"></div>
                                    </div>
                                    <div class="divpoint-arrow" style="background-color: #28bbf0;position: absolute;bottom: 0;left: 0;width: 45px;height: 2px;transform: rotate(-45deg) translate(5px,-15px);"></div>
                                </div>
                            </div>`;
                            $(this._viewer.container).append(divPointHtml);
                            divPoint = document.getElementById(point.id);
                            point.onclick && (divPoint.onclick = () => {
                                point.onclick(point);
                            });
                        } else {
                            divPointHtml =
                                `<div id="${point.id}"  style="${point.onclick ? 'cursor: pointer;' : 'pointer-events: none;'}position: absolute; left: 0px; top: 0px; transform: matrix(1, 0, 0, 1, 246.52, 299.197); transform-origin: left bottom 0px;">
                                <div class="divpoint">
                                    <div class="divpoint-wrap" style="position: relative;padding: 30px;overflow: hidden;">
                                        <div class="divpoint-area" style="background-image:linear-gradient(135deg,transparent 30px,#28bbf06c 30px,#28bbf06c 50%,transparent 50%),linear-gradient(-45deg,transparent 30px,#28bbf06c 30px,#28bbf06c 50.1%,transparent 50%);position: relative;min-width: 180px;">
                                            <div class="divpoint-arrow-lt"></div>
                                            <div class="divpoint-b-t" style="background-color: #29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;top: 0;left: 44px;right: 0;height: 1px;z-index: 10;"></div>
                                            <div class="divpoint-b-r" style="background-color: #29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;top: 0;right: 0;bottom: 44px;width: 1px;z-index: 10;"></div>
                                            <div class="divpoint-b-b" style="background-color: #29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;left: 0;right: 44px;bottom: 0;height: 1px;z-index: 10;"></div>
                                            <div class="divpoint-b-l" style="background-color: #29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;top: 44px;left: 0;bottom: 0;width: 1px;z-index: 10;"></div>
                                            <div class="divpoint-arrow-rb"></div>
                                            <div class="divpoint-label-wrap" style="padding-left: 12px;color:#fff;font-size: 16px;white-space: nowrap;overflow: hidden;">
                                                <div class="divpoint-title" style="background-image: linear-gradient(135deg,transparent 25px,#28bbf0 25px,#28bbf0 50%,transparent 50%),linear-gradient(-45deg,transparent 32px,#28bbf0 32px,#28bbf0 50%,transparent 50%);margin-top: 10px;margin-bottom: 10px;padding: 0 12px 0 30px;height: 36px;line-height: 36px;position: relative;">${point.name}</div>
                                            </div>
                                        </div>
                                        <div class="divpoint-b-t-l" style="background-color:#29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;top: 0;left: 0;width: 1px;height: 62px;transform: rotate(45deg) translate(52px,-22px);z-index: 10;"></div>
                                        <div class="divpoint-b-b-r" style="background-color: #29baf1;box-shadow: 0 0 10px 2px #29baf1;position: absolute;bottom: 0;right: 0;width: 1px;height: 62px;transform: rotate(45deg) translate(-52px,22px);z-index: 10;"></div>
                                    </div>
                                    <div class="divpoint-arrow" style="background-color: #28bbf0;position: absolute;bottom: 0;left: 0;width: 45px;height: 2px;transform: rotate(-45deg) translate(5px,-15px);"></div>
                                </div>
                            </div>`;
                            $(this._viewer.container).append(divPointHtml);
                            divPoint = document.getElementById(point.id);
                            point.onclick && (divPoint.onclick = () => {
                                point.onclick(point);
                            });
                        }
                    } else {
                        divPointHtml =
                            `<div id="${point.id}"  style="${point.onclick ? 'cursor: pointer;' : 'pointer-events: none;'}position: absolute; left: 0px; top: 0px; transform: matrix(1, 0, 0, 1, 0, 0); transform-origin: left bottom 0px;">
                            <div class="divpoint">
                                ${point.description}
                            </div>
                        </div>`;
                        $(this._viewer.container).append(divPointHtml);
                        divPoint = document.getElementById(point.id);
                        point.onclick && (divPoint.onclick = () => {
                            point.onclick(point);
                        });
                    }
                }
                let x = CanvasCoordinates.x;
                let y = CanvasCoordinates.y - divPoint.offsetHeight;
                if (point.offset === 'c') {
                    x -= divPoint.offsetWidth / 2;
                } else if (point.offset === 'r') {
                    x -= divPoint.offsetWidth;
                } else if (Array.isArray(point.offset)) {
                    if (point.offset[0] === 'c') {
                        x -= divPoint.offsetWidth / 2;
                    } else if (point.offset[0] === 'r') {
                        x -= divPoint.offsetWidth;
                    } else if (typeof point.offset[0] === 'number') {
                        x -= point.offset[0];
                    }
                    if (typeof point.offset[1] === 'number') {
                        y -= point.offset[1];
                    }
                }
                divPoint.style.transform = `matrix(1, 0, 0, 1, ${x}, ${y})`;
            }
            // 更新函数
            point.update && point.update();
        }
    };

    /**
     * 更新div点参数
     * @param {String} name 名称
     * @param {Object} option 描述
     */
    DivPoint.prototype.updateDivPoint = function (name, option = {}) {
        if (this.item) {
            Object.assign(this.item, option);
            this.item.name = name;
            let p = document.getElementById(this.item.id);
            p && p.remove();
        }
    };

    /**
     * 删除DivPoint
     */
    DivPoint.prototype.deleteObject = function () {
        this._viewer.clock.onTick.removeEventListener(this.updateDivPointEvent, this);
        let divPoint = document.getElementById(this.item.id);
        divPoint && divPoint.remove();
    };
    /**
     * 设置DivPoint的显示隐藏
     * @param {Boolean} [show] true|false
     */
    DivPoint.prototype.setVisibility = function (show) {
        this.item && (this.item.show = show);
    };

    /**
     * 获取Point的显示隐藏
     */
    DivPoint.prototype.getVisibility = function () {
        return this.item && this.item.show;
    };

    // 工程树添加
    DivPoint.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    /**
     *
     * 获取位置。
     *
     * @alias getPosition
     * @constructor
     *
     */

    function getPosition(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    getPosition.prototype.getPosition = function () {
        return this._viewer.camera.position;
    };

    getPosition.prototype.getDegrees = function () {
        var cartographic = this._viewer.camera.positionCartographic;
        var Degrees = {
            lon: this._cesium.Math.toDegrees(cartographic.longitude),
            lat: this._cesium.Math.toDegrees(cartographic.latitude),
            height: cartographic.height
        };

        return Degrees;
    };
    /**
     * 获取鼠标当前世界坐标
     * @param {object} [movement] 鼠标屏幕位置
     * @param {Array/Object} [objectsToExclude] 排除的实体对象
     * @param {number} [type] 类型（0为模型优先，1为地形优先）,默认模型优先
     * @param {boolean} [isAdsorption] true|false 是否吸附，默认否
     * @param {number} [distance] 吸附半径，默认30
     **/
    getPosition.prototype.getMousePosition = function (movement, objectsToExclude, type, isAdsorption, distance) {
        var mousePosition = movement.endPosition || movement.position || movement;
        type === undefined && (type = 0);
        isAdsorption = this._cesium.defaultValue(isAdsorption, false);
        this.defaultDepthTest === undefined && (this.defaultDepthTest = !!this._viewer.scene.globe.depthTestAgainstTerrain);

        var ray, cartesian, _cartesian, feature;
        //this.isObjectsToExcludeShow(objectsToExclude, false);
        var width = isAdsorption ? (distance ? distance : 30) : 1;
        if (type !== 0) {
            //地形优先
            //开启深度检测
            this._viewer.scene.globe.depthTestAgainstTerrain = true;
            ray = this._viewer.camera.getPickRay(mousePosition);
            ray && (cartesian = this._viewer.scene.globe.pick(ray, this._viewer.scene));
            //isAdsorption && (mousePosition = this.getAdsorptionPosition(mousePosition, objectsToExclude));

            if (!objectsToExclude || objectsToExclude.length === 0) {
                feature = this._viewer.scene.pick(mousePosition);
                if (feature && feature.id && !this.id3DGraphic(feature.id)) {
                    feature = undefined;
                }
            } else {
                feature = this._viewer.scene.drillPick(mousePosition, objectsToExclude.length, width, width);
                feature = this.getNotExcludedObj(feature, objectsToExclude);
            }

            if (feature && !isAdsorption) {
                this._viewer.scene.pick(mousePosition);
                _cartesian = this._viewer.scene.pickPosition(mousePosition);
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            } else {
                cartesian && isAdsorption && (_cartesian = this._getAdsorptionPosition(mousePosition, feature, distance));//吸附
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            }
        } else {
            //模型优先
            if (!objectsToExclude || objectsToExclude.length === 0) {
                feature = this._viewer.scene.pick(mousePosition);
                if (feature && feature.id && !this.id3DGraphic(feature.id)) {
                    feature = undefined;
                }
            } else {
                feature = this._viewer.scene.drillPick(mousePosition, (objectsToExclude && objectsToExclude.length && objectsToExclude.length + 1) || 1, width, width);
                feature = this.getNotExcludedObj(feature, objectsToExclude);
            }
            if (feature && !isAdsorption) {
                this._viewer.scene.pick(mousePosition);
                cartesian = this._viewer.scene.pickPosition(mousePosition);
            } else if (feature && isAdsorption) {
                this._viewer.scene.pick(mousePosition);
                cartesian = this._viewer.scene.pickPosition(mousePosition);
                _cartesian = this._getAdsorptionPosition(mousePosition, feature, distance); //吸附
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            } else {
                //开启深度检测
                this._viewer.scene.globe.depthTestAgainstTerrain = true;
                ray = this._viewer.camera.getPickRay(mousePosition);
                ray && (cartesian = this._viewer.scene.globe.pick(ray, this._viewer.scene));
            }
        }
        this._viewer.scene.globe.depthTestAgainstTerrain = !!this.defaultDepthTest;
        this.defaultDepthTest = undefined;

        if (!cartesian) {
            console.log('未拾取到坐标！');
            return;
        }

        return cartesian;
    };
    /**
     * 获取鼠标当前经纬度
     * @param {object} [movement] 鼠标屏幕位置
     * @param {Array/Object} [objectsToExclude] 排除的实体对象
     * @param {number} [type] 类型（0为模型优先，1为地形优先）,默认模型优先
     * @param {boolean} [isAdsorption] true|false 是否吸附，默认否
     * @param {number} [distance] 吸附半径，默认30
     */
    getPosition.prototype.getMouseDegrees = function (movement, objectsToExclude, type, isAdsorption, distance) {
        var mousePosition = movement.endPosition || movement.position || movement;
        type === undefined && (type = 0);
        isAdsorption = this._cesium.defaultValue(isAdsorption, false);
        this.defaultDepthTest === undefined && (this.defaultDepthTest = !!this._viewer.scene.globe.depthTestAgainstTerrain);

        var ray, cartesian, _cartesian, feature;
        //this.isObjectsToExcludeShow(objectsToExclude, false);
        var width = isAdsorption ? (distance ? distance : 30) : 1;
        if (type !== 0) {
            //地形优先
            //开启深度检测
            this._viewer.scene.globe.depthTestAgainstTerrain = true;
            ray = this._viewer.camera.getPickRay(mousePosition);
            ray && (cartesian = this._viewer.scene.globe.pick(ray, this._viewer.scene));
            //isAdsorption && (mousePosition = this.getAdsorptionPosition(mousePosition, objectsToExclude));

            if (!objectsToExclude || objectsToExclude.length === 0) {
                feature = this._viewer.scene.pick(mousePosition);
                if (feature && feature.id && !this.id3DGraphic(feature.id)) {
                    feature = undefined;
                }
            } else {
                feature = this._viewer.scene.drillPick(mousePosition, (objectsToExclude && objectsToExclude.length && objectsToExclude.length + 1) || 1, width, width);
                feature = this.getNotExcludedObj(feature, objectsToExclude);
            }
            if (feature && !isAdsorption) {
                this._viewer.scene.pick(mousePosition);
                _cartesian = this._viewer.scene.pickPosition(mousePosition);
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            } else {
                cartesian && isAdsorption && (_cartesian = this._getAdsorptionPosition(mousePosition, feature, distance));//吸附
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            }
        } else {
            //模型优先
            if (!objectsToExclude || objectsToExclude.length === 0) {
                feature = this._viewer.scene.pick(mousePosition);
                if (feature && feature.id && !this.id3DGraphic(feature.id)) {
                    feature = undefined;
                }
            } else {
                feature = this._viewer.scene.drillPick(mousePosition, (objectsToExclude && objectsToExclude.length && objectsToExclude.length + 1) || 1, width, width);
                feature = this.getNotExcludedObj(feature, objectsToExclude);
            }
            if (feature && !isAdsorption) {
                this._viewer.scene.pick(mousePosition);
                cartesian = this._viewer.scene.pickPosition(mousePosition);
            } else if (feature && isAdsorption) {
                this._viewer.scene.pick(mousePosition);
                cartesian = this._viewer.scene.pickPosition(mousePosition);
                _cartesian = this._getAdsorptionPosition(mousePosition, feature, distance); //吸附
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            } else {
                //开启深度检测
                this._viewer.scene.globe.depthTestAgainstTerrain = true;
                ray = this._viewer.camera.getPickRay(mousePosition);
                ray && (cartesian = this._viewer.scene.globe.pick(ray, this._viewer.scene));
            }
        }
        this._viewer.scene.globe.depthTestAgainstTerrain = !!this.defaultDepthTest;
        this.defaultDepthTest = undefined;

        if (!cartesian) {
            console.log('未拾取到坐标！');
            return;
        }

        var cartographic = this._cesium.Cartographic.fromCartesian(cartesian);
        return {
            lon: this._cesium.Math.toDegrees(cartographic.longitude),
            lat: this._cesium.Math.toDegrees(cartographic.latitude),
            height: cartographic.height
        };
    };

    //判断是否是三维图形
    getPosition.prototype.id3DGraphic = function (graphic) {
        let threeD = true;
        if (graphic.polyline || graphic.point || graphic.label || graphic.billboard) {
            threeD = false;
        } else if (graphic.polygon && graphic.polygon.extrudedHeight == undefined) {
            threeD = false;
        } else if (graphic.rectangle && graphic.rectangle.extrudedHeight == undefined) {
            threeD = false;
        } else if (graphic.ellipse && graphic.ellipse.extrudedHeight == undefined) {
            threeD = false;
        } else if (graphic.corridor && graphic.corridor.extrudedHeight == undefined) {
            threeD = false;
        }
        return threeD;
    };

    //吸附坐标-屏幕坐标
    getPosition.prototype.getAdsorptionPosition = function (mousePosition, objectsToExclude) {
        var dis = 5;   //吸附半径
        var ave = 3;   //采样数
        var object = this._viewer.scene.drillPick(mousePosition, (objectsToExclude && objectsToExclude.length && objectsToExclude.length + 1) || 3, dis + 3, dis + 3);  //3为默认拾取范围
        var need = false;
        for (var i = 0; i < object.length; i++) {
            if (object[i] && !this.isExcluded(object[i], objectsToExclude)) {
                need = true;
                break;
            }
        }

        if (need) {
            object = this._viewer.scene.pick(mousePosition, 1, 1);
            if (object && !this.isExcluded(object, objectsToExclude)) {
                return mousePosition;
            }
            for (var i = dis / ave; i <= dis; i += dis / ave) {
                object = this._viewer.scene.pick({ x: mousePosition.x + i, y: mousePosition.y }, 1, 1);
                if (object && !this.isExcluded(object, objectsToExclude)) {
                    return { x: mousePosition.x + i, y: mousePosition.y };
                }
            }
            for (var i = dis / ave; i <= dis; i += dis / ave) {
                object = this._viewer.scene.pick({ x: mousePosition.x + i, y: mousePosition.y + i }, 1, 1);
                if (object && !this.isExcluded(object, objectsToExclude)) {
                    return { x: mousePosition.x + i, y: mousePosition.y + i };
                }
            }
            for (var i = dis / ave; i <= dis; i += dis / ave) {
                object = this._viewer.scene.pick({ x: mousePosition.x, y: mousePosition.y + i }, 1, 1);
                if (object && !this.isExcluded(object, objectsToExclude)) {
                    return { x: mousePosition.x, y: mousePosition.y + i };
                }
            }
            for (var i = dis / ave; i <= dis; i += dis / ave) {
                object = this._viewer.scene.pick({ x: mousePosition.x - i, y: mousePosition.y + i }, 1, 1);
                if (object && !this.isExcluded(object, objectsToExclude)) {
                    return { x: mousePosition.x - i, y: mousePosition.y + i };
                }
            }
            for (var i = dis / ave; i <= dis; i += dis / ave) {
                object = this._viewer.scene.pick({ x: mousePosition.x - i, y: mousePosition.y }, 1, 1);
                if (object && !this.isExcluded(object, objectsToExclude)) {
                    return { x: mousePosition.x - i, y: mousePosition.y };
                }
            }
            for (var i = dis / ave; i <= dis; i += dis / ave) {
                object = this._viewer.scene.pick({ x: mousePosition.x - i, y: mousePosition.y - i }, 1, 1);
                if (object && !this.isExcluded(object, objectsToExclude)) {
                    return { x: mousePosition.x - i, y: mousePosition.y - i };
                }
            }
            for (var i = dis / ave; i <= dis; i += dis / ave) {
                object = this._viewer.scene.pick({ x: mousePosition.x, y: mousePosition.y - i }, 1, 1);
                if (object && !this.isExcluded(object, objectsToExclude)) {
                    return { x: mousePosition.x, y: mousePosition.y - i };
                }
            }
            for (var i = dis / ave; i <= dis; i += dis / ave) {
                object = this._viewer.scene.pick({ x: mousePosition.x + i, y: mousePosition.y - i }, 1, 1);
                if (object && !this.isExcluded(object, objectsToExclude)) {
                    return { x: mousePosition.x + i, y: mousePosition.y - i };
                }
            }
        }
        return mousePosition;
    };

    //吸附坐标
    getPosition.prototype._getAdsorptionPosition = function (mousePosition, feature, distance) {
        var dis = distance ? distance : 30;   //吸附半径

        if (feature) {
            feature = this.getFeature(feature);
            var _PosArr = [];
            var CanvasCoordinates;
            for (var i = 0; i < feature.position.length; i++) {
                CanvasCoordinates = this._viewer.scene.cartesianToCanvasCoordinates(feature.position[i]);
                if (CanvasCoordinates) {
                    CanvasCoordinates.index = i;
                    _PosArr.push(CanvasCoordinates);
                }
            }
            var compare = function (obj1, obj2) {
                var val1 = obj1.x;
                var val2 = obj2.x;
                if (val1 < val2) {
                    return -1;
                } else if (val1 > val2) {
                    return 1;
                } else {
                    return 0;
                }
            };
            _PosArr = _PosArr.sort(compare);
            if (_PosArr && _PosArr.length > 1) {
                //二分法算最接近下标
                var n = Math.log(_PosArr.length) / Math.log(2);
                var m = 0;
                var maxn = _PosArr.length;
                var minn = 0;
                var zd = -1;

                for (var i = 0; i < n; i++) {
                    m = Math.floor((maxn + minn) / 2);
                    if (mousePosition.x - _PosArr[m].x > dis) {
                        minn = m;
                    } else if (mousePosition.x - _PosArr[m].x < -dis) {
                        maxn = m;
                    } else if (Math.abs(mousePosition.x - _PosArr[m].x) < dis) {
                        zd = m;
                        break;
                    }
                }
                if (zd !== -1) {
                    for (var i = m; i < maxn; i++) {
                        if (Math.abs(mousePosition.x - _PosArr[i].x) > dis) {
                            maxn = i;
                            break;
                        }
                    }
                    for (var i = m; i > minn; i--) {
                        if (Math.abs(mousePosition.x - _PosArr[i].x) > dis) {
                            minn = i + 1;
                            break;
                        }
                    }
                    for (var i = minn; i < maxn; i++) {
                        if (Math.abs(mousePosition.y - _PosArr[i].y) < dis) {
                            return feature.position[_PosArr[i].index];
                        }
                    }
                }
            }
            if (_PosArr && _PosArr.length === 1) {
                if (Math.abs(mousePosition.x - _PosArr[0].x) < dis && Math.abs(mousePosition.y - _PosArr[0].y) < dis) {
                    return feature.position[0];
                }
            }
        }
    };

    getPosition.prototype.getFeature = function (obj) {
        var position;
        var data = {
            position: [],
            object: []
        };
        if (obj && obj.id) {
            if (obj.id instanceof this._cesium.Entity) {
                var entity = obj.id;
                if (entity.billboard) {
                    position = entity.position.getValue(this._viewer.clock.currentTime);
                    data.position.push(position);
                    data.object.push({
                        type: 'billboard',
                        feature: entity.billboard
                    });
                }
                if (entity.box) {
                    position = entity.position.getValue(this._viewer.clock.currentTime);
                    data.position.push(position);
                    data.object.push({
                        type: 'box',
                        feature: entity.box
                    });
                }
                if (entity.corridor) {
                    position = entity.position.getValue(this._viewer.clock.currentTime);
                    data.position.push(position);
                    data.object.push({
                        type: 'corridor',
                        feature: entity.corridor
                    });
                }
                if (entity.cylinder) {
                    position = entity.position.getValue(this._viewer.clock.currentTime);
                    data.position.push(position);
                    data.object.push({
                        type: 'cylinder',
                        feature: entity.cylinder
                    });
                }
                if (entity.ellipse) {
                    position = entity.position.getValue(this._viewer.clock.currentTime);
                    data.position.push(position);
                    data.object.push({
                        type: 'ellipse',
                        feature: entity.ellipse
                    });
                }
                if (entity.ellipsoid) {
                    position = entity.position.getValue(this._viewer.clock.currentTime);
                    data.position.push(position);
                    data.object.push({
                        type: 'ellipsoid',
                        feature: entity.ellipsoid
                    });
                }
                if (entity.label) {
                    position = entity.position.getValue(this._viewer.clock.currentTime);
                    data.position.push(position);
                    data.object.push({
                        type: 'label',
                        feature: entity.label
                    });
                }
                if (entity.model) {
                    position = entity.position.getValue(this._viewer.clock.currentTime);
                    data.position.push(position);
                    data.object.push({
                        type: 'model',
                        feature: entity.model
                    });
                }
                if (entity.path) {
                    position = entity.position.getValue(this._viewer.clock.currentTime);
                    data.position.push(position);
                    data.object.push({
                        type: 'path',
                        feature: entity.path
                    });
                }
                if (entity.plane) {
                    position = entity.position.getValue(this._viewer.clock.currentTime);
                    data.position.push(position);
                    data.object.push({
                        type: 'plane',
                        feature: entity.plane
                    });
                }
                if (entity.point) {
                    position = entity.position.getValue(this._viewer.clock.currentTime);
                    data.position.push(position);
                    data.object.push({
                        type: 'point',
                        feature: entity.point
                    });
                }
                if (entity.polygon) {
                    position = entity.polygon.hierarchy.getValue(this._viewer.clock.currentTime);
                    data.position = data.position.concat(position.positions);
                    data.object.push({
                        type: 'polygon',
                        feature: entity.polygon
                    });
                }
                if (entity.polyline) {
                    position = entity.polyline.positions.getValue(this._viewer.clock.currentTime);
                    data.position = data.position.concat(position);
                    data.object.push({
                        type: 'polyline',
                        feature: entity.polyline
                    });
                }
                if (entity.polylineVolume) {
                    position = entity.polylineVolume.positions.getValue(this._viewer.clock.currentTime);
                    data.position = data.position.concat(position);
                    data.object.push({
                        type: 'polylineVolume',
                        feature: entity.polylineVolume
                    });
                }
                if (entity.rectangle) {
                    position = entity.rectangle.coordinates.getValue(this._viewer.clock.currentTime);
                    data.position = data.position.concat(position);
                    data.object.push({
                        type: 'rectangle',
                        feature: entity.rectangle
                    });
                }
                if (entity.wall) {
                    position = entity.wall.positions.getValue(this._viewer.clock.currentTime);
                    data.position = data.position.concat(position);
                    data.object.push({
                        type: 'wall',
                        feature: entity.wall
                    });
                }
            }
        }
        if (obj && obj.primitive) {
            if (obj.primitive instanceof this._cesium.Model) {
                position = obj.primitive.positionObj;
                data.position.push(position);
                data.object.push({
                    type: 'model',
                    feature: obj.primitive
                });
            }
        }
        return data;
    };

    //是否包含对象
    getPosition.prototype.isExcluded = function (object, objectsToExclude) {
        if (!this._cesium.defined(object) || !this._cesium.defined(objectsToExclude) || objectsToExclude.length === 0) {
            return false;
        }
        return (objectsToExclude.indexOf(object) > -1) ||
            (objectsToExclude.indexOf(object.primitive) > -1) ||
            (objectsToExclude.indexOf(object.id) > -1);
    };

    //获取不包含的对象
    getPosition.prototype.getNotExcludedObj = function (objectOrArr, objectsToExclude) {
        if (objectOrArr.length === 0) {
            return false;
        } else if (!this._cesium.defined(objectsToExclude) || objectsToExclude.length === 0) {
            return objectOrArr;
        }
        for (var i = 0; i < objectOrArr.length; i++) {
            if (objectOrArr[i] && !this.isExcluded(objectOrArr[i], objectsToExclude)) {
                return objectOrArr[i];
            }
        }
        return false;
    };

    //控制对象显隐
    getPosition.prototype.isObjectsToExcludeShow = function (objectsToExclude, isShow) {
        if (!this._cesium.defined(objectsToExclude) || objectsToExclude.length === 0) {
            return;
        }
        if (objectsToExclude instanceof Array) {
            objectsToExclude.forEach(function (item) {
                item.show = isShow;
            });
        } else {
            objectsToExclude.show = isShow;
        }
    };

    /**
     *
     * 弹框
     *
     * @alias PopupMessage
     * @constructor
     *
     */
    function PopupMessage(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 创建弹框
     * createPopupMessage
     * @param {string} [name] 名称
     * @param {object} [options] 名称
     */
    PopupMessage.prototype.createPopupMessage = function (name) {
        var div1 = document.createElement("div");
        div1.className = "kz";
        div1.id = "kzmb";
        div1.style.position = "absolute";
        div1.style.width = "200px";
        div1.style.height = "500px";
        div1.style.padding = "15px";
        div1.style.background = "rgba(0, 0, 0, 0.5)";
        div1.style.color = "#fff";
        div1.style.top = "0px";
        div1.style.right = "0px";
        div1.style.border = "solid 2px #358ABA";
        //div1.style.borderWidth="10px";
        //div1.style.borderColor="#358ABA"
        document.body.appendChild(div1);
        //标题
        var divbt = document.createElement('div');
        div1.id = "bt";
        divbt.style.overflow = "hidden";
        divbt.style.height = "45px";
        divbt.style.height = "100%";
        divbt.className = 'layui-form-item';
        divbt.style.borderBottom = "solid 2px #358ABA";
        var span = document.createElement('span');
        span.textContent = name;
        divbt.appendChild(span);
        div1.appendChild(divbt);
        //拖动
        this.getElement("bt", "kzmb");
    };
    /**
    * 创建标绘面板
    * createPlotting
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    PopupMessage.prototype.createPlotting = function (name, method) {
        var div1 = document.createElement("main");
        div1.id = "kzmb";
        div1.style.position = "absolute";
        div1.style.cursor = "auto";
        div1.style.left = "0px";
        div1.style.top = "0px;";
        //div1.style.height = "500px";
        div1.className = "mainView";
        document.body.appendChild(div1);
        //关闭按钮
        var button = document.createElement("button");
        button.id = "closeScene";
        button.setAttribute("aria-label", "Close");
        button.innerHTML = "<span aria-hidden='true'>×</span>";
        button.onclick = closeScene;
        button.className = "myModal-close";
        div1.appendChild(button);
        //选择样式
        var input1 = document.createElement("input");
        input1.id = "objectTab1";
        input1.type = "radio";
        input1.setAttribute("checked", "");
        input1.name = "objectTab";
        var lable1 = document.createElement("label");
        //lable1.for = "objectTab1";
        lable1.setAttribute("for", "objectTab1");
        lable1.id = "objectLabel1";
        lable1.className = "function-module-caption";
        lable1.innerHTML = "二维";
        div1.appendChild(input1);
        div1.appendChild(lable1);
        //
        var input2 = document.createElement("input");
        input2.id = "objectTab2";
        input2.type = "radio";
        input2.name = "objectTab";
        var lable2 = document.createElement("label");
        //lable2.for = "objectTab2";
        lable2.setAttribute("for", "objectTab2");
        lable2.id = "objectLabel2";
        lable2.className = "function-module-caption";
        lable2.innerHTML = "三维";
        div1.appendChild(input2);
        div1.appendChild(lable2);
        //
        //var input3 = document.createElement("input");
        //input3.id = "objectTab3";
        //input3.type = "radio";
        //input3.name = "objectTab";
        //var lable3 = document.createElement("label");
        //lable3.for = "objectTab3";
        //lable3.id = "objectLabel3"
        //lable3.className = "function-module-caption";
        //lable3.innerHTML = "三维";
        //div1.appendChild(input3);
        //div1.appendChild(lable3);
        //符号库二维
        var section1 = document.createElement("section");
        section1.id = "objectContent1";
        div1.appendChild(section1);
        var str2 = [{ title: "点", src: "../../static/image/point/points.png", onclick: "labelDraw()" }, { title: "线", src: "../../static/image/point/polyline.png", onclick: "polylineDraw()" }
            , { title: "多边形", src: "../../static/image/point/polygon_clampToGround.png", onclick: "polygonDraw()" }, { title: "矩形", src: "../../static/image/point/rectangle.png", onclick: "rectangleDraw()" }
            , { title: "圆", src: "../../static/image/point/Cricle.png", onclick: "circleDraw()" }];
        this.getBh(section1, str2);
        //符号库三维
        var section2 = document.createElement("section");
        section2.id = "objectContent2";
        div1.appendChild(section2);
        var str3 = [{ title: "立方体", src: "../../static/image/point/extrudedRectangle.png", onclick: "boxDraw()" }, { title: "圆柱体", src: "../../static/image/point/extrudedCircle.png", onclick: "cylinderDraw()" }
            , { title: "圆锥体", src: "../../static/image/point/Cone.png", onclick: "coneDraw()" }, { title: "球体", src: "../../static/image/point/ellipsoid.png", onclick: "circleDraw()" }
            , { title: "多边体", src: "../../static/image/point/Multilateral.png", onclick: "multilateralDraw()" }];
        this.getBh(section2, str3);
        //拖动
        this.getElement("kzmb", "kzmb");
    };
    //标绘
    PopupMessage.prototype.getBh = function (section, str) {
        var html = "";
        html = "<div class='function-module-content' style(height:'500px')><div class='function-module-sub-section'> <label class='function-module-sub-section-caption'>符号库</label><div id='icons' class='mark-list'>";
        for (var i = 0; i < str.length; i++) {
            html = html + "<div class='mark-list-item'><img title=" + str[i].title + " src=" + str[i].src + " id=" + str[i].title + " onclick=" + str[i].onclick + "></div>";
        }
        html = html + "</div></div></div>";
        section.innerHTML = html;
    };
    /**
    * 创建图上量算
    * createMeasurement
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    PopupMessage.prototype.createMeasurement = function (name, method) {
        var div1 = document.createElement("div");
        div1.className = "kz";
        div1.id = "kzmb";
        div1.style.position = "absolute";
        div1.style.width = "330px";
        div1.style.height = "500px";
        div1.style.padding = "15px";
        div1.style.background = "rgba(0, 0, 0, 0.5)";
        div1.style.color = "#fff";
        div1.style.top = "0px";
        div1.style.right = "0px";
        div1.style.border = "solid 2px #358ABA";
        //div1.style.borderWidth="10px";
        //div1.style.borderColor="#358ABA"
        document.body.appendChild(div1);
        //标题
        var divbt = document.createElement('div');
        divbt.id = "bt";
        divbt.style.height = "100%";
        divbt.style.overflow = "hidden";
        divbt.style.height = "25px";
        divbt.className = 'layui-form-item';
        divbt.style.borderBottom = "solid 2px #358ABA";
        var span = document.createElement('span');
        span.textContent = name;
        divbt.appendChild(span);
        div1.appendChild(divbt);
        //内容
        var divbn1 = document.createElement('div');
        divbn1.className = 'layui-tab-content';
        div1.appendChild(divbn1);

        var divbn2 = document.createElement('div');
        divbn2.className = 'layui-tab-item layui-show';
        divbn1.appendChild(divbn2);

        var divbn3 = document.createElement('div');
        divbn3.className = 'kind';
        divbn2.appendChild(divbn3);
        var ul = document.createElement('ul');
        divbn3.appendChild(ul);
        //创建功能
        var str = [{ img: "../../img/bh/labels.png", text: "垂直高度", onclick: MeasurementVd }, { img: "../../img/bh/labels.png", text: "海拔高度", onclick: MeasurementAltitude }
            , { img: "../../img/bh/labels.png", text: "空间距离", onclick: MeasurementSpaceD }, { img: "../../img/bh/labels.png", text: "水平距离", onclick: MeasurementHD }
            , { img: "../../img/bh/labels.png", text: "三维面积", onclick: MeasurementThreeDSurfaceArea }, { img: "../../img/bh/labels.png", text: "平面面积", onclick: MeasurementPlaneArea }
            , { img: "../../img/bh/labels.png", text: "角度测量", onclick: MeasurementAngle }];
        this.getLi(ul, str);
        if (typeof method == 'function') {
            method();
        }
        //拖动
        this.getElement("bt", "kzmb");
    };

    //测量遍历
    PopupMessage.prototype.getLi = function (ol, str) {
        for (var i = 0; i < str.length; i++) {
            var oLi = document.createElement("li");
            oLi.innerHTML = `<img src="${str[i].img}" /><p>${str[i].text}</p>`;
            oLi.onclick = str[i].onclick;
            ol.appendChild(oLi);
        }
    };
    //拖动控制
    PopupMessage.prototype.getElement = function (id, parentid) {
        // 限定拖动区域的id
        var x = 0;
        var y = 0;
        var limitarea = document.getElementById(id);
        limitarea.style.cursor = "move";
        // 要拖动的id
        var dragarea = document.getElementById(parentid);
        var isDrop = false; //移动状态的判断鼠标按下才能移动
        // 鼠标按下事件
        limitarea.onmousedown = function (e) {
            var e = e || window.event; //要用event这个对象来获取鼠标的位置
            x = e.clientX - dragarea.offsetLeft;
            y = e.clientY - dragarea.offsetTop;
            isDrop = true; //设为true表示可以移动
        };
        // 为了防止鼠标移动过快时间短无法正确处理,所以事件绑定到document上
        document.onmousemove = function (e) {
            //是否为可移动状态                　　　　　　　　　　　 　　　　　　　
            if (isDrop) {
                var e = e || window.event;
                var moveX = e.clientX - x; //得到距离左边移动距离                    　　
                var moveY = e.clientY - y; //得到距离上边移动距离
                //可移动最大距离
                var maxX = document.documentElement.clientWidth - dragarea.offsetWidth;
                var maxY = document.documentElement.clientHeight - dragarea.offsetHeight;

                //范围限定  当移动的距离最小时取最大  移动的距离最大时取最小
                if (moveX < 0) {
                    moveX = 0;
                } else if (moveX > maxX) {
                    moveX = maxX;
                }

                if (moveY < 0) {
                    moveY = 0;
                } else if (moveY > maxY) {
                    moveY = maxY;
                }

                dragarea.style.left = moveX + "px";
                dragarea.style.top = moveY + "px";
            } else {
                return;
            }

        };
        document.onmouseup = function () {
            isDrop = false; //设置为false不可移动
        };
    };
    /**
    * 创建entity属性弹窗
    * @param {string} [name] 名称
    * @param {object} [options] 参数。{
        width:宽度
        height:高度
        type:类型（GroundPolygon/ExtrudedPolygon）
        fn:回调函数对象。{
            cancel:关闭
            success:成功
            end:销毁
        }
    * }
    */
    PopupMessage.prototype.createPopupProp = function (name, options) {
        layuiLayer.close(SmartEarthPopupData.layerProp);

        var width = options.width;
        var height = options.height;
        var fn = options.fn || {};
        SmartEarthPopupData.propType = options.type;

        //获取相关回调事件
        var cancelFn = null;
        var successFn = null;
        var endFn = null;
        for (var key in fn) {
            cancelFn = (key == 'cancel') ? fn[key] : cancelFn;
            successFn = (key == 'success') ? fn[key] : successFn;
            endFn = (key == 'end') ? fn[key] : endFn;
        }

        SmartEarthPopupData.layerProp = layuiLayer.open({
            title: name,
            type: 2, //0（信息框，默认）1（页面层）2（iframe层）3（加载层）4（tips层）
            skin: 'other-class',
            shade: options.shade || 0,
            shadeClose: true,
            offset: options.offset || 'r',
            resize: false,
            area: [typeof width === 'number' ? width + 'px' : width, typeof height === 'number' ? height + 'px' : height],
            content: SmartEarthRootUrl + options.url,
            success: function (layero, index) {
                if (successFn && typeof successFn === 'function') {
                    successFn(layero, index);
                }
            },
            cancel: function () {
                if (cancelFn && typeof cancelFn === 'function') {
                    cancelFn();
                }
            },
            end: function () {
                if (endFn && typeof endFn === 'function') {
                    endFn();
                }
            }
        });
    };
    /**
    * 创建模型库弹窗
    * @param {object} [options] 参数。{
        width:宽度
        height:高度
        fn:回调函数对象。{
            cancel:关闭
            success:成功
            end:销毁
        }
    * }
    */
    PopupMessage.prototype.createModelLibrary = function (options) {
        layuiLayer.close(SmartEarthPopupData.ModelLibraryLayer);
        !options && (options = {});
        var width = options.width || 342;
        var height = options.height || '90%';
        var offset = options.offset || 'r';
        var fn = options.fn || {};

        //获取相关回调事件
        var cancelFn = null;
        var successFn = null;
        var endFn = null;
        for (var key in fn) {
            cancelFn = (key == 'cancel') ? fn[key] : cancelFn;
            successFn = (key == 'success') ? fn[key] : successFn;
            endFn = (key == 'end') ? fn[key] : endFn;
        }

        SmartEarthPopupData.ModelLibraryLayer = layuiLayer.open({
            title: '模型库',
            type: 2, //0（信息框，默认）1（页面层）2（iframe层）3（加载层）4（tips层）
            skin: 'other-class',
            shade: 0,
            shadeClose: true,
            offset: offset,
            resize: false,
            area: [width + 'px', typeof height === 'number' ? height + 'px' : height],
            content: SmartEarthRootUrl + 'Workers/Model/ModelLibrary.html',
            success: function (layero, index) {
                if (successFn && typeof successFn === 'function') {
                    successFn(layero, index);
                }
            },
            cancel: function () {
                if (cancelFn && typeof cancelFn === 'function') {
                    cancelFn();
                }
            },
            end: function () {
                if (endFn && typeof endFn === 'function') {
                    endFn();
                }
            }
        });
    };

    /**
     *
     * 向工程树添加组。
     *
     * @alias createGroup 
     * @constructor
     *
     */
    function createGroup(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
        this._core = new Core();
    }
    /**
     * 向工程树添加组
     * @param {String} [GroupName] 创建组的名称。
     * @param {int} [ParentGroupID] 组的ID，组在该组中被创建。如果GroupID设置为零，则对象在根节点下创建。
     * @returns {Promise.<Array>} 返回一个数组。
     * 
     */
    createGroup.prototype.createGroup = function (GroupName, checked, ParentGroupID) {
        //if (ParentGroupID == null || ParentGroupID == undefined || ParentGroupID == "" || ParentGroupID == 0) {
        if (ParentGroupID == 0) ; else if (ParentGroupID == null || ParentGroupID == undefined || ParentGroupID == "") {
            ParentGroupID = this._core.isnull(tree.selectedItem) ? 0 : tree.selectedItem.id;
            var vv = tree.getSourceByName(this._tree, GroupName);
            if (vv) {
                return vv.id;
            }
        }

        var group = tree.getSourceById(this._tree, ParentGroupID);
        if (group) {
            var vv = tree.getSourceByName(group.children, GroupName);
            if (vv) {
                return vv.id;
            } else {
                var treeObj = {
                    id: this._core.getuid(),
                    name: GroupName,
                    pId: ParentGroupID,
                    checked: checked,
                    type: 'group',
                    item: this
                };
                this.item = treeObj;
                return tree.insertGroupId(treeObj, ParentGroupID)
            }
        } else {
            var treeObj = {
                id: this._core.getuid(),
                name: GroupName,
                pId: ParentGroupID,
                type: 'group',
                checked: checked,
                item: this
            };
            this.item = treeObj;
            return tree.insertGroupId(treeObj, ParentGroupID)
        }
    };
    createGroup.prototype.changeGroup = function (ItemID, GroupID) {
        tree.changeGroup(ItemID, GroupID);
    };
    //临时数据初始化
    createGroup.prototype.starttemporaryItem = function () {
        return tree.starttemporaryItem(this._viewer);
    };
    //临时数据添加
    createGroup.prototype.pushtemporaryItem = function (obj) {
        tree.temporaryItem.obj.push(obj);
    };
    //临时状态添加
    createGroup.prototype.pushStateItem = function (obj) {
        tree.temporaryItem.operation = obj;
    };
    //临时数据结束
    createGroup.prototype.endtemporaryItem = function () {
        tree.endtemporaryItem();
    };
    /**
     * 导出组
     */
    createGroup.prototype.export = function () {
        return {
            type: 'group',
            style: {
                name: this.item.name,
                pId: this.item.pId,
                id: this.item.id
            }
        }
    };

    var _slicedToArray$2 = function () {
        function sliceIterator(arr, i) {
            var _arr = [];
            var _n = true;
            var _d = false;
            var _e = undefined;
            try {
                for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"]) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        return function (arr, i) {
            if (Array.isArray(arr)) {
                return arr;
            } else if (Symbol.iterator in Object(arr)) {
                return sliceIterator(arr, i);
            } else {
                throw new TypeError("Invalid attempt to destructure non-iterable instance");
            }
        };
    }();

    var _typeof$6 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
        return typeof obj;
    } : function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };

    function _toConsumableArray$3(arr) {
        if (Array.isArray(arr)) {
            for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
                arr2[i] = arr[i];
            }
            return arr2;
        } else {
            return Array.from(arr);
        }
    }

    function GeoJSONVectorTileProvider(viewer, cesium, options) {
        this._viewer = viewer;
        this._cesium = cesium;

        // Cesium.Viewer 实例
        // this._viewer = null;

        // Cesium 对象
        this._Cesium = options.Cesium;

        // 矢量切片服务接口
        this._url = options.url;

        // 矢量切片服务接口请求参数
        this._urlParams = options.urlParams;

        // 矢量切片服务 URL 模板
        this._urlTemplate = this._url + '?' + this._serialize(this._urlParams);

        // 矢量切片服务数据范围
        this._rectangle = options.rectangle;

        // 最大视图等级
        this._maximumLevel = options.maximumLevel || 19;

        // 最小视图等级
        this._minimumLevel = options.minimumLevel || 1;

        // Cesium.TilingScheme 实例
        this._tilingScheme = options.tilingScheme || new this._Cesium.GeographicTilingScheme();

        // 瓦片范围，以 level 索引
        this._tileRangeByLevel = {};

        // 摄像机 moveEnd 事件时间戳
        this._moveEndTimestamp = null;

        // provider 是否已销毁
        this._isRemoved = false;

        // 摄像机是否正在移动
        this._isCameraMoving = false;

        // 将被过滤的属性和值
        this._propertyToBeFiltered = null;
        this._valuesToBeFiltered = null;

        // 瓦片 primitive，以 tile key 索引
        this._primitiveByTile = {};

        // 最新视角下的瓦片标识列表
        this._tileKeys = [];

        // 瓦片层级限制
        this._lowerLevelLimit = options.lowerLevelLimit || 1;
        this._upperLevelLimit = options.upperLevelLimit || null;

        this._cameraMoveEndHandler = this._cameraMoveEndHandler.bind(this);
        this._cameraMoveStartHandler = this._cameraMoveStartHandler.bind(this);

        // 高度属性，以 id 索引
        this.heightById = {};

        // 计算瓦片范围
        var west = this._radianToDegree(this._rectangle.west);
        var south = this._radianToDegree(this._rectangle.south);
        var east = this._radianToDegree(this._rectangle.east);
        var north = this._radianToDegree(this._rectangle.north);

        for (var z = this._minimumLevel; z <= this._maximumLevel; z++) {
            var bottomLeftTile = this._lonLatToTileInWGS84([west, south], z);
            var topRightTile = this._lonLatToTileInWGS84([east, north], z);
            var minRow = Math.min(bottomLeftTile[0], topRightTile[0]);
            var maxRow = Math.max(bottomLeftTile[0], topRightTile[0]);
            var minCol = Math.min(bottomLeftTile[1], topRightTile[1]);
            var maxCol = Math.max(bottomLeftTile[1], topRightTile[1]);

            this._tileRangeByLevel[z] = {
                minCol: minCol,
                maxCol: maxCol,
                minRow: minRow,
                maxRow: maxRow
            };
        }

        this._tileRangeByLevel[0] = {
            minCol: 0,
            maxCol: 0,
            minRow: 0,
            maxRow: 0
        };

        this._primitiveCollection = new this._Cesium.PrimitiveCollection();

        this._stop = false;

        this._core = new Core();
        this.tooltip = this._core.CreateTooltip();
        this._getPosition = new getPosition(this._viewer, this._cesium);
    }
    /**
     * 序列化参数对象
     *
     * @param {Object} params 参数对象
     * @returns {String} 序列化字符串
     */
    GeoJSONVectorTileProvider.prototype._serialize = function (params) {
        var queryArray = [];
        var encode = window.encodeURIComponent;

        for (var key in params) {
            var value = params[key];

            if ((typeof value === 'undefined' ? 'undefined' : _typeof$6(value)) === 'object') {
                queryArray.push(encode(key) + '=' + encode(JSON.stringify(value)));
            } else {
                queryArray.push(encode(key) + '=' + encode(params[key]));
            }
        }

        return queryArray.join('&');
    };

    /**
     * 模拟 fetch 接口
     *
     * @param {String} url 请求 URL
     * @param {Object} [options] 选项
     * @returns {Promise} 处理请求结果的 Promise
     *
     */
    GeoJSONVectorTileProvider.prototype._fetch = function (url) {
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        var promise = new Promise(function (resolve, reject) {
            var xhr = new XMLHttpRequest();

            xhr.open(options.method || 'GET', url);

            if (options.headers) {
                for (var key in options.headers) {
                    xhr.setRequestHeader(key, options.headers[key]);
                }
            }

            xhr.onload = function () {
                if (xhr.readyState === 4 && xhr.status === 200) {
                    try {
                        var json = JSON.parse(xhr.responseText);

                        resolve(json);
                    } catch (e) {
                        reject(new Error('INVALID RESPONSE'));
                    }
                }
            };

            xhr.onerror = function (e) {
                reject(e);
            };

            xhr.onloadend = function (e) {
                if (e.target.status !== 200) {
                    reject(new Error('[' + e.target.status + ']request failed: ' + url));
                }
            };

            xhr.send(options.body || null);
        });

        return promise;
    };

    /**
     * 通过经纬度获取瓦片 X、Y 值 (WGS84)
     *
     * @param {Number[]} lonLat 经纬度
     * @param {Number} level 地图缩放等级
     * @returns {Number[]} 瓦片的 X、Y 值
     */
    GeoJSONVectorTileProvider.prototype._lonLatToTileInWGS84 = function (lonLat, level) {
        var _lonLat = _slicedToArray$2(lonLat, 2),
            lon = _lonLat[0],
            lat = _lonLat[1];

        var tileX = Math.floor(Math.pow(2, level) * (90 - lat) / 180);
        var tileY = Math.floor(Math.pow(2, level) * (180 + lon) / 180);

        return [tileX, tileY];
    };

    /**
     * 弧度转角度
     *
     * @param {Number} radian 弧度值
     * @returns {Number} 角度值
     */
    GeoJSONVectorTileProvider.prototype._radianToDegree = function (radian) {
        return radian / Math.PI * 180;
    };

    /**
     * 判断目标瓦片是否在数据范围内
     *
     * @param {QuadtreeTile} tile 瓦片对象
     * @returns {Boolean} 瓦片是否在数据范围内
     */
    GeoJSONVectorTileProvider.prototype._isTileInRange = function (tile) {
        try {
            var _tileRangeByLevel$til = this._tileRangeByLevel[tile.level],
                minCol = _tileRangeByLevel$til.minCol,
                maxCol = _tileRangeByLevel$til.maxCol,
                minRow = _tileRangeByLevel$til.minRow,
                maxRow = _tileRangeByLevel$til.maxRow;

            return tile.x >= minCol && tile.x <= maxCol && tile.y >= minRow && tile.y <= maxRow;
        } catch (e) {
            return false;
        }
    };

    /**
     * 摄像机 moveStart 事件处理程序
     */
    GeoJSONVectorTileProvider.prototype._cameraMoveStartHandler = function () {
        this._isCameraMoving = true;
    };

    /**
     * 处理数据请求回来的数据 创建不同的geometry
     */
    GeoJSONVectorTileProvider.prototype._loadTile = function (json) {
        var geomInstances = [];
        var color = new this._Cesium.ColorGeometryInstanceAttribute(0.75, 0.75, 0.75, 1);
        var _this = this;
        json.features.forEach(function (feature) {
            if (_this._propertyToBeFiltered) {
                if (Array.isArray(_this._valuesToBeFiltered)) {
                    var value = feature.properties[_this._propertyToBeFiltered];

                    if (_this._valuesToBeFiltered.includes(value)) return;
                }
            }

            var geometryType = feature.geometry.type;

            if (geometryType === 'Polygon' || geometryType === 'MultiPolygon') {
                var coordinates = [];

                _this.heightById[feature.properties.house_id] = feature.properties.height;
                feature.geometry.coordinates.forEach(function (coords, index) {
                    coordinates.push([]);
                    coords.forEach(function (coordinate) {
                        if (coordinate.length > 2) {
                            coordinate.forEach(function (coord) {
                                if (coord.length >= 2) {
                                    var _coordinates$index;

                                    (_coordinates$index = coordinates[index]).push.apply(_coordinates$index, _toConsumableArray$3(coord));
                                }
                            });
                        } else {
                            var _coordinates$index2;

                            (_coordinates$index2 = coordinates[index]).push.apply(_coordinates$index2, _toConsumableArray$3(coordinate));
                        }
                    });
                    var polygonHierarchy = new _this._Cesium.PolygonHierarchy(_this._Cesium.Cartesian3.fromDegreesArray(coordinates[index]));
                    var center = _this._Cesium.BoundingSphere.fromPoints(polygonHierarchy.positions).center;
                    var height = _this._viewer.scene.globe.getHeight(_this._Cesium.Cartographic.fromCartesian(center)) || 0;
                    var geometry = new _this._Cesium.PolygonGeometry({
                        polygonHierarchy: polygonHierarchy,
                        height: height,
                        vertexFormat: _this._Cesium.PerInstanceColorAppearance.VERTEX_FORMAT,
                        //extrudedHeight: feature.properties.height + height
                        extrudedHeight: 1000
                    });
                    var geomInstance = new _this._Cesium.GeometryInstance({
                        geometry: geometry,
                        attributes: {
                            color: color
                        }
                    });

                    geomInstances.push(geomInstance);
                });
            } else {
                console.warn('GeoJSONVectorTileProvider: geometry type "' + feature.geometry.type + '" detected, but is not going to be rendered');
            }
        });
        var primitive = new this._Cesium.Primitive({
            allowPicking: false,
            appearance: new this._Cesium.PerInstanceColorAppearance({
                translucent: false
            }),
            geometryInstances: geomInstances
        });
        return primitive;
    };

    /**
     * 摄像机 moveEnd 事件处理程序
     */
    GeoJSONVectorTileProvider.prototype._cameraMoveEndHandler = function () {
        if (this._stop) return;
        var _this = this;
        var timestamp = Date.now();
        var tilesToRender = this._viewer.scene.globe._surface._tilesToRender;
        var levels = tilesToRender.map(function (tile) {
            return tile.level;
        });
        var minLevel = Math.min.apply(Math, _toConsumableArray$3(levels));
        var maxLevel = Math.max.apply(Math, _toConsumableArray$3(levels));
        if (maxLevel < this._lowerLevelLimit) {
            _this._tileKeys = [];
            _this._removeObsoletePrimitives(_this._primitiveByTile, []);
            tilesToRender = [];
            return;
        }
        if (this._upperLevelLimit && minLevel > this._upperLevelLimit) {
            _this._tileKeys = [];
            _this._removeObsoletePrimitives(_this._primitiveByTile, []);
            tilesToRender = [];
            return;
        }

        if (maxLevel - minLevel > 2) {
            tilesToRender = tilesToRender.filter(function (tile) {
                return tile.level >= maxLevel - 2;
            });
        }

        tilesToRender.sort(function (val1, val2) {
            return -(val1.level - val2.level);
        });
        tilesToRender = tilesToRender.filter(function (tile) {
            return _this._isTileInRange(tile);
        });

        if (this._upperLevelLimit) {
            tilesToRender = this._refineTiles(tilesToRender, this._upperLevelLimit);
        }

        this._isCameraMoving = false;
        this._moveEndTimestamp = timestamp;
        //this._tileKeys = [];
        //var 
        var newTileKeys = [];
        var tilesLength = 0;
        //tilesToRender.length;
        var returnCount = 0;
        tilesToRender.forEach(function (tile) {
            var tileKey = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
            newTileKeys.push(tileKey);
            _this._tileKeys.push(tileKey);

            if (_this._primitiveByTile[tileKey]) {
                //tilesLength--;
                return;
            }

            var tileUrl = _this._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
            tilesLength++;
            _this._fetch(tileUrl).then(function (json) {
                if (_this._isRemoved) throw new Error('DISCARD');
                if (_this._isCameraMoving) throw new Error('DISCARD');
                if (timestamp !== _this._moveEndTimestamp) throw new Error('DISCARD');

                var primitive = _this._loadTile(json, tile);
                _this._primitiveCollection.add(primitive);
                //_this._viewer.scene.primitives.add(primitive);
                _this._primitiveByTile[tileKey] = primitive;
                returnCount++;

                if (returnCount >= tilesLength) {
                    _this._tileKeys = newTileKeys;
                    _this._removeObsoletePrimitives(_this._primitiveByTile, newTileKeys);

                }

            }).catch(function (ex) {
                returnCount++;
                if (returnCount >= tilesLength) {
                    _this._tileKeys = newTileKeys;
                    _this._removeObsoletePrimitives(_this._primitiveByTile, newTileKeys);

                }
                if (ex.message !== 'DISCARD') ;
            });
        });



        /**
         *  删除之前加载的数据
         *
         */
    };

    /**
     * 通过拆分、合并优化瓦片下载与渲染
     *
     * @param {Object[]} tiles 待处理的瓦片列表
     * @param {Number} targetLevel 目标优化层级
     * @returns {Object[]} 优化后的瓦片列表
     */
    GeoJSONVectorTileProvider.prototype._refineTiles = function (tiles, targetLevel) {
        var newTiles = [];
        var tileKeys = [];

        tiles.forEach(function (tile) {
            var tileKey = 'Z' + tile.level + 'X' + tile.x + 'Y' + tile.y;

            if (tile.level < targetLevel - 1) {
                if (!tileKeys.includes(tileKey)) {
                    newTiles.push(tile);
                    tileKeys.push(tileKey);
                }
            } else if (tile.level === targetLevel - 1) {
                for (var i = 0; i < 2; i++) {
                    for (var j = 0; j < 2; j++) {
                        var _tileKey = 'Z' + (tile.level + 1) + 'X' + (tile.x * 2 + i) + 'Y' + (tile.y * 2 + j);

                        if (!tileKeys.includes(_tileKey)) {
                            newTiles.push({
                                x: tile.x * 2 + i,
                                y: tile.y * 2 + j,
                                level: tile.level + 1
                            });
                            tileKeys.push(_tileKey);
                        }
                    }
                }
            } else {
                var levelDiff = tile.level - targetLevel;

                if (levelDiff === 0) {
                    if (!tileKeys.includes(tileKey)) {
                        newTiles.push(tile);
                        tileKeys.push(tileKey);
                    }
                } else {
                    var factor = levelDiff * 2;
                    var targetX = Math.floor(tile.x / factor);
                    var targetY = Math.floor(tile.y / factor);
                    var _tileKey2 = 'Z' + targetLevel + 'X' + targetX + 'Y' + targetY;

                    if (!tileKeys.includes(_tileKey2)) {
                        newTiles.push({
                            x: targetX,
                            y: targetY,
                            level: targetLevel
                        });
                        tileKeys.push(_tileKey2);
                    }
                }
            }
        });

        return newTiles;
    };

    /**
     * 移除过期的瓦片
     *
     * @param {Object} primitiveByTile 瓦片 primitive，以 tileKey 索引
     * @param {String[]} tileKeys 当前有效的瓦片 keys
     */
    GeoJSONVectorTileProvider.prototype._removeObsoletePrimitives = function (primitiveByTile, tileKeys) {
        var deleteTileKeys = [];
        if (tileKeys.length > 0) {
            // deleteTileKeys = tileKeys.slice(0, Math.ceil(tileKeys.length / 10));
            deleteTileKeys = tileKeys;
        }
        for (var tileKey in primitiveByTile) {
            if (!deleteTileKeys.includes(tileKey)) {
                //var removed = this._viewer.scene.primitives.remove(primitiveByTile[tileKey]);
                var removed = this._primitiveCollection.remove(primitiveByTile[tileKey]);
                if (removed) {
                    delete primitiveByTile[tileKey];
                }
            }
        }
    };

    /**
     * 将 provider 添加到指定 viewer
     *
     * @param {Cesium.Viewer} viewer 目标 viewer
     */
    GeoJSONVectorTileProvider.prototype.addTo = function (viewer) {
        this._viewer = viewer;
        this._viewer.scene.primitives.add(this._primitiveCollection, this.availability);
        this._isRemoved = false;
        //修改加载机制
        //new Cesium.CallbackProperty(this._cameraMoveEndHandler, false);
        //this._viewer.scene.preUpdate.addEventListener(this._cameraMoveEndHandler);
        //
        this._viewer.camera.moveEnd.addEventListener(this._cameraMoveEndHandler);
        this._viewer.camera.moveStart.addEventListener(this._cameraMoveStartHandler);
        this._cameraMoveEndHandler();
    };

    /**
     * 移除 provider
     */
    GeoJSONVectorTileProvider.prototype.remove = function () {
        if (this._viewer) {
            for (var tileKey in this._primitiveByTile) {
                this._viewer.scene.primitives.remove(this._primitiveByTile[tileKey]);
            }
            this._primitiveByTile = {};
            this._viewer.camera.moveEnd.removeEventListener(this._cameraMoveEndHandler);
            this._viewer.camera.moveStart.removeEventListener(this._cameraMoveStartHandler);
            this._viewer = null;
            this._isRemoved = true;
        }
    };

    /**
     * 停止 刷新
     */
    GeoJSONVectorTileProvider.prototype.setStatus = function (b) {
        this._stop = b;
        if (this._primitiveCollection._availability && b) {
            this._primitiveCollection._availability = undefined;
        } else if (this.availability && !b) {
            this._primitiveCollection._availability = this.availability;
        }
    };
    /**
     * provider 是否已移除
     */
    GeoJSONVectorTileProvider.prototype.isRemoved = function () {
        return this._isRemoved;
    };

    /**
     * 添加属性过滤
     *
     * @param {string} property 要过滤的属性名称
     * @param {any[]} values 要过滤的属性值
     * @param {Cesium.Rectangle} [rectangle] 要过滤的数据范围
     */
    GeoJSONVectorTileProvider.prototype.filterBy = function (property, values, rectangle) {
        this._propertyToBeFiltered = property;
        this._valuesToBeFiltered = values;
    };

    /**
     * 移除属性过滤
     */
    GeoJSONVectorTileProvider.prototype.removeFilter = function () {
        this._propertyToBeFiltered = null;
        this._valuesToBeFiltered = null;
    };

    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    GeoJSONVectorTileProvider.prototype.edit = function (open, option) {
        let that = this;
        let viewer = this._viewer;
        !option && (option = {});

        if (this.editHandler) {
            this.editHandler.destroy();
            this.editHandler = undefined;
        }
        open === undefined && (open = true);
        if (!open) {
            endThisEdit();
            return;
        }

        // 创建监听的handler
        this.editHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        //当前编辑的实体对象、当前的编辑点、当前的编辑点位置和当前编辑类型
        var geo, currentPoint, currentPointpos, type;
        // 判断是否处于编辑状态
        this.isEditting = false;
        //移动点（拖拽可移动当前图形）和选中编辑点的类型
        let pointType;

        // 对鼠标按下事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            // 获取屏幕坐标
            let windowPosition = event.position;
            // 通过屏幕坐标获取当前位置的实体
            let pickedObject = viewer.scene.pick(windowPosition);
            if (pickedObject && pickedObject.id && pickedObject.id.treeID !== that.treeID) {
                return;
            }
            if (pickedObject && pickedObject.id && (pickedObject.id instanceof Cesium.Entity || pickedObject.id.VectorType)) {
                // 获取当前点的实体
                let entity = pickedObject.id;
                if (!that.isEditting && tree.states == 0) {
                    option.callBack && option.callBack.start && option.callBack.start(entity);
                    type = entity.VectorType;
                    geo = that.createEditEntity(type, entity.VectorStyle);
                    geo.feature = entity;
                    geo.treeID = that.treeID;

                    //获取简单图形数据
                    that.getSimpleGraphicData(type, geo);

                    if (type === 'point' || type === 'billboard' || type === 'label' || type === 'model') {
                        // 设置编辑状态为true 
                        that.isEditting = true;
                        that.tooltip.showAt(event.position, '拖拽修改位置');
                    } else {
                        // 设置编辑状态为true 
                        that.isEditting = true;
                        SmartEarthPopupData.editGraphic.updataEditPoint();
                        SmartEarthPopupData.editGraphic.setTreeID(that.treeID);
                    }
                    that.setStatus(true);
                    tree.editVector = true;
                    that._primitiveCollection.show = false;
                } else if ((entity == geo && (entity.VectorType === 'point' || entity.VectorType === 'billboard' || entity.VectorType === 'label' || entity.VectorType === 'model')) ||
                    entity.name == "_height_point" || entity.name == "_edit_point" || entity.name == "_move_point" || entity.name == "_add_point" || entity.name == "_size_point") {
                    viewer.container.style.cursor = 'crosshair';
                    // 禁止地球旋转和缩放，地球的旋转会对鼠标移动监听有影响，所以需要禁止
                    that.defaultEvent(false);
                    if (entity.name == "_height_point") {
                        //获取当前高度点位置
                        currentPointpos = {
                            windowPosition: windowPosition,
                            originHeight: that._cesium.Cartographic.fromCartesian(entity.position.getValue()).height
                        };
                        pointType = "_height_point";
                    } else if (entity.name == "_move_point") {
                        pointType = "_move_point";
                    } else if (entity.VectorType === 'point' || entity.VectorType === 'billboard' || entity.VectorType === 'label' || entity.VectorType === 'model') {
                        that.tooltip.showAt(event.position, '释放后完成修改');
                        pointType = "_move_point";
                        //隐藏模型
                        if (entity.VectorType === 'model') {
                            entity.show = false;
                        }
                    } else if (entity.name == "_edit_point") {
                        pointType = "_edit_point";
                    } else if (entity.name == "_add_point") {
                        pointType = "_add_point";
                    } else if (entity.name == "_size_point") {
                        pointType = "_size_point";
                    }
                    // 如果实体为编辑点，那么设置当前编辑点为该点
                    currentPoint = entity;
                } else ;
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);

        //// 对鼠标移动事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            let pickedObject = viewer.scene.pick(event.endPosition);
            if (pickedObject && pickedObject.id && pickedObject.id.treeID !== that.treeID) {
                return;
            }
            if (that._cesium.defined(pickedObject)) {
                if (that.isEditting && !currentPoint) {
                    if ((type === 'point' || type === 'billboard' || type === 'label' || type === 'model') && pickedObject.id == geo) {
                        //点类
                        that.tooltip.showAt(event.endPosition, '拖拽修改位置，右键删除');
                    } else if (pickedObject.id && pickedObject.id.name === "_edit_point" && geo.pottingPoint) {
                        //编辑节点
                        if ((type === 'polyline' || type === 'wall') && geo.pottingPoint.length > 2) {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置，右键删除点');
                        } else if (type === 'polygon' && geo.pottingPoint.length > 3) {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置，右键删除点');
                        } else {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置');
                        }
                    } else if (pickedObject.id && (pickedObject.id.name === "_move_point" || pickedObject.id.name === "_size_point")) {
                        that.tooltip.showAt(event.endPosition, '拖拽修改位置');
                    } else if (pickedObject.id && pickedObject.id.name === "_add_point") {
                        that.tooltip.showAt(event.endPosition, '拖拽增加节点');
                    } else if (pickedObject.id && pickedObject.id.name === "_height_point") {
                        that.tooltip.showAt(event.endPosition, '拖拽修改高度');
                    } else if (pickedObject.id == geo) {
                        that.tooltip.show(false);
                    }
                } else if (!that.isEditting && tree.states === 0) {
                    if (pickedObject.id && pickedObject.id.VectorType) {
                        // that.tooltip.showAt(event.endPosition, '点击激活编辑，右键删除');
                        that.tooltip.showAt(event.endPosition, '点击激活编辑');
                    } else {
                        that.tooltip.show(false);
                    }
                }
            } else if (tree.states == 0 && !currentPoint) {
                that.tooltip.show(false);
            }

            // 如果处于编辑状态且编辑点已定义，那么开始拖拽编辑
            if (that.isEditting && currentPoint) {
                that.tooltip.showAt(event.endPosition, '释放后完成修改');
                let cartesian = that._getPosition.getMousePosition(event);
                //拉伸节点不需要获取当前位置坐标
                if (!cartesian && pointType !== "_height_point") {
                    return;
                }            ///地面上点
                if (pointType === "_edit_point") {
                    // 更新编辑点的位置
                    currentPoint.position = cartesian;
                    let pointIndex = tree.editPointID.edit.indexOf(currentPoint.id);

                    //修改对应坐标数据
                    if (geo[type].height !== undefined) {
                        let degrees = that.toDegrees(cartesian);
                        geo.pottingPoint[pointIndex] = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, geo[type].height.getValue());
                        currentPoint.position = geo.pottingPoint[pointIndex];
                    } else {
                        geo.pottingPoint[pointIndex] = cartesian;
                    }

                    //修改对应的拉伸节点
                    // if (tree.editPointID.height.length > 0) {
                    //     let thisHeightPoint = viewer.entities.getById(tree.editPointID.height[pointIndex]);
                    //     if (thisHeightPoint) {
                    //         let degrees = that.toDegrees(cartesian);
                    //         //修改拉伸节点位置
                    //         let expiontcart = that._cesium.Cartographic.fromCartesian(thisHeightPoint.position.getValue());
                    //         thisHeightPoint.position = that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, expiontcart.height);
                    //     }
                    // }

                    //修改边上的新增节点
                    if (tree.editPointID.add.length > 0) {
                        //上一个新增节点
                        if (pointIndex > 0) {
                            let thisAddPoint1 = viewer.entities.getById(tree.editPointID.add[pointIndex - 1]);
                            if (thisAddPoint1) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[pointIndex - 1]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                                thisAddPoint1.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                        //下一个新增节点
                        if (pointIndex < geo.pottingPoint.length - 1) {
                            let thisAddPoint2 = viewer.entities.getById(tree.editPointID.add[pointIndex]);
                            if (thisAddPoint2) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[pointIndex + 1]);
                                thisAddPoint2.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                        //面的起点和终点之间的节点
                        if (type === 'polygon' && (pointIndex === 0 || pointIndex === geo.pottingPoint.length - 1)) {
                            let thisAddPoint3 = viewer.entities.getById(tree.editPointID.add[tree.editPointID.add.length - 1]);
                            if (thisAddPoint3) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[0]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[geo.pottingPoint.length - 1]);
                                thisAddPoint3.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                    }

                    let positions = geo.pottingPoint.concat([]);
                    //修改移动节点位置
                    let _center = new that._cesium.Cartesian3();
                    let pointLength = positions.length;
                    positions.forEach(item => {
                        _center.x += item.x;
                        _center.y += item.y;
                        _center.z += item.z;
                    });
                    _center.x /= pointLength;
                    _center.y /= pointLength;
                    _center.z /= pointLength;
                    tree.editPointID.move && (tree.editPointID.move.position = _center);

                    //修改实体对象坐标
                    if (type === 'polyline' || type === 'wall' || type === 'polygon' || type === 'rectangle') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    }
                } else if (pointType === "_height_point") {////拉伸高度点
                    let pointIndex = tree.editPointID.height.indexOf(currentPoint.id);
                    let e_point = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                    if (type === 'ellipse' || type === 'cylinder' || type === 'box') {
                        //圆和圆柱、圆锥、立方体没有对应的编辑节点，对应移动节点
                        e_point = tree.editPointID.move;
                    }
                    let e_degrees = that.toDegrees(e_point.position.getValue());
                    let originHeight = currentPointpos.originHeight - e_degrees.height;
                    let e_winPosition = viewer.scene.cartesianToCanvasCoordinates(e_point.position.getValue());

                    //移动后高度变化
                    let _height = (currentPointpos.windowPosition.y - event.endPosition.y) * originHeight / Math.abs(e_winPosition.y - currentPointpos.windowPosition.y);

                    let h = Math.abs(originHeight + _height);
                    tree.editPointID.height.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            let e_p = e.position.getValue();
                            let e_d = that.toDegrees(e_p);
                            e.position = that._cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, h + e_degrees.height);
                        }
                    });

                    if (geo[type].extrudedHeight) {
                        geo[type].extrudedHeight = h + e_degrees.height;
                    } else if (type === 'box') {
                        SmartEarthPopupData.editGraphic.setValue('height', h);
                    } else if (type === 'cylinder') {
                        SmartEarthPopupData.editGraphic.setValue('length', h);
                    }
                } else if (pointType === "_add_point") {////新增节点
                    let addIndex = tree.editPointID.add.indexOf(currentPoint.id);
                    //移除旧新增节点
                    viewer.entities.remove(currentPoint);
                    //添加新的编辑节点
                    let new_edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: cartesian,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    tree.editPointID.edit.splice(addIndex + 1, 0, new_edit_point.id);
                    geo.pottingPoint.splice(addIndex + 1, 0, cartesian.clone());

                    //添加新的拉伸节点
                    // if (tree.editPointID.height.length > 0) {
                    //     //拉伸节点
                    //     let degrees = that.toDegrees(cartesian);
                    //     degrees.height = geo[type].extrudedHeight.getValue();

                    //     let new_heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: that._cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.splice(addIndex + 1, 0, new_heightpoint.id);
                    // }

                    //添加两个新的新增节点
                    let add_position1 = Cesium.Cartesian3.midpoint(geo.pottingPoint[addIndex], geo.pottingPoint[addIndex + 1], new Cesium.Cartesian3());
                    //添加节点1
                    let add_point1 = viewer.entities.add({
                        name: "_add_point",
                        position: add_position1,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    let add_position2 = Cesium.Cartesian3.midpoint(geo.pottingPoint[addIndex + 1], geo.pottingPoint[addIndex + 2 === geo.pottingPoint.length ? 0 : addIndex + 2], new Cesium.Cartesian3());
                    //添加节点2
                    let add_point2 = viewer.entities.add({
                        name: "_add_point",
                        position: add_position2,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    tree.editPointID.add.splice(addIndex, 1, add_point1.id, add_point2.id);

                    SmartEarthPopupData.editGraphic.setTreeID(that.treeID);

                    //转为编辑节点状态
                    currentPoint = new_edit_point;
                    pointType = '_edit_point';

                    //修改实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'polygon') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    } else if (type === 'wall') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                        let minimumHeights = SmartEarthPopupData.editGraphic.getValue('minimumHeights');
                        let maximumHeights = SmartEarthPopupData.editGraphic.getValue('maximumHeights');
                        minimumHeights.push(minimumHeights[0]);
                        maximumHeights.push(maximumHeights[0]);
                        SmartEarthPopupData.editGraphic.setValue('minimumHeights', minimumHeights);
                        SmartEarthPopupData.editGraphic.setValue('maximumHeights', maximumHeights);
                    }
                } else if (pointType === "_size_point") {    //大小节点
                    let center = tree.editPointID.move.position.getValue();
                    let distance = that._cesium.Cartesian3.distance(center, cartesian);

                    //修改实体对象坐标
                    if (type === 'ellipse' || type === 'cylinder' || (type === 'ellipsoid' && geo.isSphere)) {
                        SmartEarthPopupData.editGraphic.setValue('radius', distance);
                    } else if (type === 'box') {
                        let s = currentPoint.angle === 90 ? 'long' : 'width';
                        SmartEarthPopupData.editGraphic.setValue(s, distance * 2);
                    }
                } else {
                    //点类移动
                    if (type === 'point' || type === 'billboard' || type === 'label' || type === 'model') {
                        currentPoint.position = cartesian;
                        return;
                    }

                    ///移动后变化
                    let degrees1 = that.toDegrees(cartesian);
                    ///移动前经纬度
                    currentPointpos = currentPoint.position.getValue();
                    let degrees2 = that.toDegrees(currentPointpos);
                    //计算差值
                    let _x = degrees1.lon - degrees2.lon, _y = degrees1.lat - degrees2.lat, _z = degrees1.height - degrees2.height;

                    //修改移动节点位置
                    currentPoint.position = cartesian;
                    if (geo[type].height) {
                        let height = that.toDegrees(cartesian).height;
                        geo[type].height = height;
                        geo.thisHeight = height;
                    }

                    //修改所有节点位置
                    geo.pottingPoint.forEach((item, index) => {
                        let oldPosition, newPosition;

                        //对应的编辑节点
                        let _edit = viewer.entities.getById(tree.editPointID.edit[index]);
                        if (!_edit) {
                            //对应的大小节点
                            _edit = viewer.entities.getById(tree.editPointID.size[index]);
                        }

                        if (_edit) {
                            oldPosition = that.toDegrees(_edit.position.getValue());
                        } else {
                            oldPosition = that.toDegrees(item);
                        }

                        // if (geo[type].height) {
                        //     oldPosition.height = geo[type].height.getValue ? geo[type].height.getValue() : geo[type].height;
                        // }

                        newPosition = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                        item.x = newPosition.x;
                        item.y = newPosition.y;
                        item.z = newPosition.z;
                        //修改编辑节点坐标
                        _edit && (_edit.position = newPosition);

                        //修改拉伸节点坐标
                        // if (tree.editPointID.height.length > 0) {
                        //     let _heightPoint = viewer.entities.getById(tree.editPointID.height[index]);
                        //     if (_heightPoint) {
                        //         oldPosition = _heightPoint.position.getValue();
                        //         oldCartographic = that._cesium.Cartographic.fromCartesian(oldPosition);
                        //         oldPosition = {
                        //             lon: that._cesium.Math.toDegrees(oldCartographic.longitude),
                        //             lat: that._cesium.Math.toDegrees(oldCartographic.latitude),
                        //             height: oldCartographic.height
                        //         }
                        //         _heightPoint.position = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                        //     }
                        // }

                        //修改新增节点坐标
                        if (tree.editPointID.add.length > 0 && tree.editPointID.add[index]) {
                            let _addPoint = viewer.entities.getById(tree.editPointID.add[index]);
                            if (_addPoint) {
                                oldPosition = that.toDegrees(_addPoint.position.getValue());
                                // if (geo[type].height) {
                                //     oldPosition.height = geo[type].height.getValue ? geo[type].height.getValue() : geo[type].height;
                                // }
                                _addPoint.position = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                            }
                        }
                    });

                    //修改实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'wall' || type === 'polygon' || type === 'rectangle') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                        // if (tree.editPointID.height.length > 0) {
                        //     SmartEarthPopupData.editGraphic.setValue('extrudedHeight', SmartEarthPopupData.editGraphic.getValue('extrudedHeight') + _z);
                        // }
                    } else if (type === 'ellipse') {
                        geo.pottingPoint[1] = cartesian;
                        geo.position = cartesian.clone();
                    } else if (type === 'box') {
                        geo.pottingPoint[2] = cartesian;
                        let size = geo.box.dimensions.getValue();
                        let center = that.toDegrees(cartesian);
                        geo.position = Cesium.Cartesian3.fromDegrees(center.lon, center.lat, center.height + size.z / 2);
                    } else if (type === 'cylinder') {
                        geo.pottingPoint[1] = cartesian;
                        let length = geo.cylinder.length.getValue();
                        let degrees = that.toDegrees(geo.pottingPoint[1]);
                        geo.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + length / 2);
                    } else if (type === 'ellipsoid') {
                        geo.pottingPoint[geo.pottingPoint.length - 1] = cartesian;
                        geo.position = cartesian.clone();
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //// 对鼠标抬起事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            if (currentPoint && currentPoint.VectorType === 'model') {
                currentPoint.show = true;
            }
            if (currentPoint) {
                option.callBack && option.callBack.updata && option.callBack.updata(currentPoint.name, geo);
            }
            viewer.container.style.cursor = 'default';
            // 移除当前编辑点
            currentPoint = undefined;
            // 恢复地球的旋转和缩放
            that.defaultEvent(true);
        }, this._cesium.ScreenSpaceEventType.LEFT_UP);
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            // 通过屏幕坐标获取当前位置的实体信息
            let pickedObject = viewer.scene.pick(event.position);
            if (pickedObject && pickedObject.id && pickedObject.id.treeID !== that.treeID) {
                return;
            }
            // 如果实体信息存在则说明该位置存在实体
            if (that._cesium.defined(pickedObject) && tree.states == 0) {
                // 获取当前点的实体
                let entity = pickedObject.id;
                if (entity.VectorType) ; else if (tree.editPointID.edit.indexOf(entity.id) > -1 &&
                    (((type === 'polyline' || type === 'wall') && tree.editPointID.edit.length > 2) || (type === 'polygon' && tree.editPointID.edit.length > 3))) {
                    let thisPointIndex = tree.editPointID.edit.indexOf(entity.id);

                    //移除编辑节点
                    viewer.entities.removeById(entity.id);
                    tree.editPointID.edit.splice(thisPointIndex, 1);

                    //移除拉伸节点
                    // if (tree.editPointID.height.length > 0) {
                    //     viewer.entities.removeById(tree.editPointID.height[thisPointIndex]);
                    //     tree.editPointID.height.splice(thisPointIndex, 1);
                    // }

                    //移除实体对象节点
                    geo.pottingPoint.splice(thisPointIndex, 1);

                    //移除并更新新增节点
                    if (tree.editPointID.add.length > 0) {
                        //删除下一个新增节点
                        if (tree.editPointID.add[thisPointIndex]) {
                            viewer.entities.removeById(tree.editPointID.add[thisPointIndex]);
                            tree.editPointID.add.splice(thisPointIndex, 1);
                            //更新上一个新增节点
                            if (thisPointIndex - 1 >= 0) {
                                let updataAddPoint = viewer.entities.getById(tree.editPointID.add[thisPointIndex - 1]);
                                if (updataAddPoint) {
                                    //删除的是面的最后一个节点的话就计算第一个节点（索引0）和最后一个节点的中点
                                    updataAddPoint.position = Cesium.Cartesian3.midpoint(
                                        geo.pottingPoint[thisPointIndex - 1],
                                        geo.pottingPoint[thisPointIndex === geo.pottingPoint.length ? 0 : thisPointIndex],
                                        new Cesium.Cartesian3());
                                }
                            } else if (thisPointIndex - 1 === -1 && type === 'polygon') {
                                //删除的是面的第一个节点
                                let updataAddPoint = viewer.entities.getById(tree.editPointID.add[tree.editPointID.add.length - 1]);
                                if (updataAddPoint) {
                                    updataAddPoint.position = Cesium.Cartesian3.midpoint(geo.pottingPoint[0], geo.pottingPoint[geo.pottingPoint.length - 1], new Cesium.Cartesian3());
                                }
                            }
                        } else {
                            //直接移除上一个新增节点
                            viewer.entities.removeById(tree.editPointID.add[thisPointIndex - 1]);
                            tree.editPointID.add.pop();
                        }
                    }

                    //修改移动节点位置
                    let _center = new that._cesium.Cartesian3();
                    let pointLength = geo.pottingPoint.length;
                    geo.pottingPoint.forEach(item => {
                        _center.x += item.x;
                        _center.y += item.y;
                        _center.z += item.z;
                    });
                    _center.x /= pointLength;
                    _center.y /= pointLength;
                    _center.z /= pointLength;
                    tree.editPointID.move && (tree.editPointID.move.position = _center);

                    //更新实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'polygon') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    } else if (type === 'wall') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                        let minimumHeights = SmartEarthPopupData.editGraphic.getValue('minimumHeights');
                        let maximumHeights = SmartEarthPopupData.editGraphic.getValue('maximumHeights');
                        minimumHeights.pop();
                        maximumHeights.pop();
                        SmartEarthPopupData.editGraphic.setValue('minimumHeights', minimumHeights);
                        SmartEarthPopupData.editGraphic.setValue('maximumHeights', maximumHeights);
                    }
                    that.tooltip.show(false);
                    option.callBack && option.callBack.updata && option.callBack.updata(currentPoint && currentPoint.name, geo);
                }
            }
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        endThisEdit();

        function endThisEdit() {
            // 恢复地球的旋转和缩放
            that.defaultEvent(true);

            // 移除编辑点，清空编辑点数组
            tree.editPointID.edit.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.edit = [];

            tree.editPointID.height.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.height = [];

            tree.editPointID.add.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.add = [];

            tree.editPointID.size.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.size = [];

            tree.editPointID.move && viewer.entities.remove(tree.editPointID.move);
            tree.editPointID.move = undefined;

            geo && viewer.entities.remove(geo);
            geo = undefined;
            type = undefined;

            SmartEarthPopupData.editGraphic = {};

            that.isEditting = false;
            that.setStatus(false);
            tree.editVector = false;

            that._primitiveCollection.show = true;
            that.delButton(false);
        }

        return {
            endThisEdit: endThisEdit,
            getEditData: function () {
                return {
                    entity: geo
                }
            }
        }
    };

    //创建历史编辑图形
    GeoJSONVectorTileProvider.prototype.createEditEntity = function (type, option) {
        let entity;
        let that = this;
        let viewer = this._viewer;
        if (type === 'polygon') {
            let positions = option.positions;
            let height = that._core.defaultValue(option.height, undefined);
            let hierarchy;
            if (option.hierarchy) {
                hierarchy = option.hierarchy;
            } else {
                positions = option.haveZ ?
                    that._cesium.Cartesian3.fromDegreesArrayHeights(positions) :
                    that._cesium.Cartesian3.fromDegreesArray(positions)
                    ;
                hierarchy = new that._cesium.PolygonHierarchy(positions);
            }
            entity = viewer.entities.add({
                polygon: {
                    hierarchy: new that._cesium.CallbackProperty(function () {
                        return hierarchy;
                    }, false),
                    extrudedHeight: that._core.defaultValue(option.extrudedHeight, undefined),
                    height: height,
                    material: new that._cesium.ImageMaterialProperty({
                        image: that._core.defaultValue(option.image, null),
                        repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                        color: option.material
                    }),
                    shadows: that._cesium.ShadowMode.ENABLED,
                    fill: true
                }
            });
            entity.VectorType = 'polygon';
        } else if (type === 'polyline') {
            let positions = option.positions;
            positions = option.haveZ ?
                that._cesium.Cartesian3.fromDegreesArrayHeights(positions) :
                that._cesium.Cartesian3.fromDegreesArray(positions)
                ;
            entity = viewer.entities.add({
                polyline: {
                    positions: new that._cesium.CallbackProperty(function () {
                        return positions
                    }, false),
                    clampToGround: that._core.defaultValue(option.clampToGround, false),
                    material: new Cesium.PolylineOutlineMaterialProperty({
                        color: option.material,
                        outlineWidth: that._core.defaultValue(option.outlineWidth, 0),
                        outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                    }),
                    width: that._core.defaultValue(option.width, 3)
                }
            });
            entity.VectorType = 'polyline';
        } else if (type === 'wall') {
            let positions = option.positions;
            positions = option.haveZ ?
                that._cesium.Cartesian3.fromDegreesArrayHeights(positions) :
                that._cesium.Cartesian3.fromDegreesArray(positions)
                ;
            entity = viewer.entities.add({
                wall: {
                    positions: new that._cesium.CallbackProperty(function () {
                        return positions
                    }, false),
                    minimumHeights: option.minimumHeights,
                    maximumHeights: option.maximumHeights,
                    material: option.material,
                    outline: true,
                    outlineWidth: that._core.defaultValue(option.outlineWidth, 0),
                    outlineColor: option.outlineColor
                }
            });
            entity.VectorType = 'wall';
        } else if (type === 'label') {
            entity = viewer.entities.add({
                position: option.position,
                label: {
                    text: option.text, //文本
                    font: option.font,
                    scale: option.scale,
                    style: option.style,
                    fillColor: option.fillColor,
                    outlineColor: option.outlineColor,
                    outlineWidth: option.outlineWidth,
                    showBackground: option.showBackground,
                    backgroundColor: option.backgroundColor,
                    heightReference: option.heightReference,
                    horizontalOrigin: option.horizontalOrigin,
                    verticalOrigin: option.verticalOrigin,
                    scaleByDistance: option.scaleByDistance,
                    distanceDisplayCondition: option.distanceDisplayCondition
                }
            });
            entity.VectorType = 'label';
        } else if (type === 'billboard') {
            entity = viewer.entities.add({
                position: option.position,
                billboard: {
                    rotation: option.rotation,
                    width: option.width,
                    height: option.height,
                    image: option.image,
                    color: option.color,
                    scale: option.scale,
                    heightReference: option.heightReference,
                    horizontalOrigin: option.horizontalOrigin,
                    verticalOrigin: option.verticalOrigin,
                    scaleByDistance: option.scaleByDistance,
                    distanceDisplayCondition: option.distanceDisplayCondition
                }
            });
            entity.VectorType = 'billboard';
        }
        return entity;
    };
    //删除按钮
    GeoJSONVectorTileProvider.prototype.delButton = function (show, position, even) {
        if (show) {
            let del = document.getElementById('DeleteMilitaryStandardDelete');
            if (!del) {
                del = document.createElement('button');
                del.id = 'DeleteMilitaryStandardDelete';
                del.innerText = '删除对象';
                del.style.cssText = `height: 38px;
                    line-height: 38px;
                    padding: 0 18px;
                    background-color: #052355;
                    color: #fff;
                    white-space: nowrap;
                    text-align: center;
                    font-size: 14px;
                    border: none;
                    border-radius: 2px;
                    cursor: pointer;
                    position: absolute;`;
                this._viewer.container.appendChild(del);
            }
            del.style.display = 'block';
            del.style.top = position.y + 'px';
            del.style.left = position.x + 'px';
            del.onclick = even;
        } else {
            let del = document.getElementById('DeleteMilitaryStandardDelete');
            if (del) {
                del.style.display = 'none';
                del.onclick = null;
            }

        }
    };

    //默认鼠标事件
    GeoJSONVectorTileProvider.prototype.defaultEvent = function (isOpen) {
        let scene = this._viewer.scene;
        scene.screenSpaceCameraController.enableRotate = isOpen;
        scene.screenSpaceCameraController.enableTranslate = isOpen;
        scene.screenSpaceCameraController.enableZoom = isOpen;
        scene.screenSpaceCameraController.enableTilt = isOpen;
        scene.screenSpaceCameraController.enableLook = isOpen;
    };

    //获取entity对象的类型和关联的对象
    GeoJSONVectorTileProvider.prototype.getEntityTypeAndObject = function (entity) {
        let data = {
            type: '',
            object: null
        };
        if (entity) {
            if (entity.billboard) {
                data.type = 'billboard';
                data.object = entity.billboard;
            } else if (entity.box) {
                data.type = 'box';
                data.object = entity.box;
            } else if (entity.corridor) {
                data.type = 'corridor';
                data.object = entity.corridor;
            } else if (entity.cylinder) {
                data.type = 'cylinder';
                data.object = entity.cylinder;
            } else if (entity.ellipse) {
                data.type = 'ellipse';
                data.object = entity.ellipse;
            } else if (entity.ellipsoid) {
                data.type = 'ellipsoid';
                data.object = entity.ellipsoid;
            } else if (entity.label) {
                data.type = 'label';
                data.object = entity.label;
            } else if (entity.model) {
                data.type = 'model';
                data.object = entity.model;
            } else if (entity.path) {
                data.type = 'path';
                data.object = entity.path;
            } else if (entity.plane) {
                data.type = 'plane';
                data.object = entity.plane;
            } else if (entity.point) {
                data.type = 'point';
                data.object = entity.point;
            } else if (entity.polygon) {
                data.type = 'polygon';
                data.object = entity.polygon;
            } else if (entity.polyline) {
                data.type = 'polyline';
                data.object = entity.polyline;
            } else if (entity.polylineVolume) {
                data.type = 'polylineVolume';
                data.object = entity.polylineVolume;
            } else if (entity.rectangle) {
                data.type = 'rectangle';
                data.object = entity.rectangle;
            } else if (entity.wall) {
                data.type = 'wall';
                data.object = entity.wall;
            }
        }
        return data;
    };


    /**
    * 
    * 世界坐标转经纬度
    * 
    */
    GeoJSONVectorTileProvider.prototype.toDegrees = function (cartesian) {
        let cartographic = this._cesium.Cartographic.fromCartesian(cartesian);
        return {
            lon: this._cesium.Math.toDegrees(cartographic.longitude),
            lat: this._cesium.Math.toDegrees(cartographic.latitude),
            height: cartographic.height
        };
    };

    GeoJSONVectorTileProvider.prototype.getSimpleGraphicData = function (type, geo) {
        let that = this;
        let viewer = this._viewer;
        SmartEarthPopupData.editGraphic = {
            entity: geo,
            type: type,
            graphic: geo[type],
            getValue: function (attr) {
                if (attr === 'position' || attr === 'name' || attr === 'id') {
                    return this.entity[attr] && (this.entity[attr].getValue ? this.entity[attr].getValue() : this.entity[attr]);
                } else if (attr === 'radius') {
                    if (this.type === 'ellipse') {
                        return this.graphic.semiMajorAxis.getValue();
                    } else if (this.type === 'ellipsoid') {
                        return this.graphic.radii.getValue().x;
                    } else if (this.type === 'cylinder') {
                        return this.graphic.bottomRadius.getValue();
                    }
                } else if (attr === 'pHeight') {
                    if (this.getValue('position')) {
                        let position = this.getValue('position');
                        let Cartographic = Cesium.Cartographic.fromCartesian(position);
                        return Cartographic.height;
                    }
                } else if (attr === 'repeat') {
                    return this.graphic.material[attr] && (this.graphic.material[attr].getValue ? this.graphic.material[attr].getValue() : this.graphic.material[attr]);
                } else {
                    return this.graphic[attr] && (this.graphic[attr].getValue ? this.graphic[attr].getValue() : this.graphic[attr]);
                }
            },
            changeHeightPoint: function (height) {
                if (tree.editPointID.height.length > 0) {
                    tree.editPointID.height.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            let e_p = e.position.getValue();
                            let e_d = that.toDegrees(e_p);
                            e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                        }
                    });
                }
            },
            changeEditPoint: function (height) {
                if (tree.editPointID.edit.length > 0) {
                    tree.editPointID.edit.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                if (tree.editPointID.size.length > 0) {
                    tree.editPointID.size.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                if (tree.editPointID.add.length > 0) {
                    tree.editPointID.add.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                let e = tree.editPointID.move;
                if (e) {
                    if (height === 'clampToGround') {
                        e.point.heightReference = 1;
                    } else {
                        e.point.heightReference = 0;
                        let e_p = e.position.getValue();
                        let e_d = that.toDegrees(e_p);
                        e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                    }
                }
            },
            clearAllEditPoint: function () {
                // 移除编辑点，清空编辑点数组
                tree.editPointID.edit.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.edit = [];

                tree.editPointID.height.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.height = [];

                tree.editPointID.add.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.add = [];

                tree.editPointID.size.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.size = [];

                tree.editPointID.move && viewer.entities.remove(tree.editPointID.move);
                tree.editPointID.move = undefined;
            },
            setTreeID: function (id) {
                // 移除编辑点，清空编辑点数组
                tree.editPointID.edit.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.height.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.add.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.size.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.move && (tree.editPointID.move.treeID = id);
            }
        };
        if (type === 'billboard' || type === 'point' || type === 'label' || type === 'model') {
            //获取颜色值
            let color = SmartEarthPopupData.editGraphic.getValue('color') || SmartEarthPopupData.editGraphic.getValue('fillColor');
            if (color) {
                getFillColor(color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            if (type === 'label') {
                let backgroundColor = SmartEarthPopupData.editGraphic.getValue('backgroundColor');
                if (backgroundColor) {
                    getBackgroundColor(backgroundColor);
                } else {
                    SmartEarthPopupData.editGraphic.backgroundColor = '#000000';
                    SmartEarthPopupData.editGraphic.backgroundAlpha = 80;
                }
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'position' || attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor' || attr === 'backgroundColor' || attr === 'fillColor') {
                        value = Cesium.Color.fromCssColorString(value);
                    } else if (attr === 'fontSize') {
                        let font = this.getValue('font');
                        font = font.split(' ');
                        font[0] = value;
                        value = font.join(' ');
                    } else if (attr === 'alpha') {
                        if (this.type === 'label') {
                            this.graphic.fillColor._value.alpha = value;
                        } else {
                            this.graphic.color._value.alpha = value;
                        }
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'backgroundAlpha') {
                        this.graphic.backgroundColor._value.alpha = value;
                        return;
                    } else if (attr === 'pHeight') {
                        if (this.getValue('position')) {
                            let position = this.getValue('position');
                            let Cartographic = Cesium.Cartographic.fromCartesian(position);
                            Cartographic.height = value;
                            this.entity.position = Cesium.Cartographic.toCartesian(Cartographic);
                            return;
                        }
                    }
                    this.graphic[attr] = value;
                }
            };
        } else if (type === 'polyline') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            if (material.outlineColor) {
                getOutlineColor(material.outlineColor);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'outlineWidth') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.material.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic[attr] = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let pottingPoint = this.getValue('positions');
                this.entity.pottingPoint = pottingPoint;
                return pottingPoint;
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    // if (this.getValue('extrudedHeight') !== undefined) {
                    //     let cartographic = Cesium.Cartographic.fromCartesian(item);
                    //     let degrees = {
                    //         lon: Cesium.Math.toDegrees(cartographic.longitude),
                    //         lat: Cesium.Math.toDegrees(cartographic.latitude),
                    //         height: this.getValue('extrudedHeight')
                    //     }

                    //     if (this.getValue('height')) {
                    //         let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                    //         item.x = e_p.x;
                    //         item.y = e_p.y;
                    //         item.z = e_p.z;
                    //         edit_point.position = e_p;
                    //         this.entity.pottingPoint[index] = e_p.clone();
                    //     }

                    //     let heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: Cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.push(heightpoint.id);
                    // }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });

                for (let i = 0; i < points.length - 1; i++) {
                    let add_position = Cesium.Cartesian3.midpoint(points[i], points[i + 1], new Cesium.Cartesian3());
                    //添加节点
                    let add_point = viewer.entities.add({
                        name: "_add_point",
                        position: add_position,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.add.push(add_point.id);
                }
            };
        } else if (type === 'polygon') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic.hierarchy = new Cesium.CallbackProperty(function () {
                            return new Cesium.PolygonHierarchy(value);
                        }, false);
                        return;
                    } else if (attr === 'hierarchy') {
                        this.graphic.hierarchy = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'clampToGround') {
                        if (this.graphic.hierarchy instanceof Cesium.CallbackProperty) {
                            this.graphic.hierarchy = this.graphic.hierarchy.getValue();
                            setTimeout(() => {
                                changeGround(this.graphic, this.entity.pottingPoint, value);
                            }, 100);
                        } else {
                            changeGround(this.graphic, this.entity.pottingPoint, value);
                        }
                        //更新新增节点贴地状态
                        if (tree.editPointID.add.length > 0) {
                            tree.editPointID.add.forEach(item => {
                                let updataAddPoint = viewer.entities.getById(item);
                                if (updataAddPoint) {
                                    if (value) {
                                        updataAddPoint.point.heightReference = 1;
                                    } else {
                                        updataAddPoint.point.heightReference = 0;
                                    }
                                }
                            });
                        }

                        function changeGround(graphic, points, checked) {
                            if (checked) {
                                graphic.perPositionHeight = false;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.perPositionHeight = true;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            //更新节点高度
                            if (tree.editPointID.edit.length > 0 && !checked) {
                                points.forEach((item, index) => {
                                    let _editPoint = viewer.entities.getById(tree.editPointID.edit[index]);
                                    if (_editPoint) {
                                        let p = _editPoint.position.getValue();
                                        item.x = p.x;
                                        item.y = p.y;
                                        item.z = p.z;
                                    }
                                });
                            }
                            graphic.hierarchy = new Cesium.CallbackProperty(function () {
                                return new Cesium.PolygonHierarchy(points);
                            }, false);
                        }
                        return;
                    } else if (attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (attr === 'height') {
                        this.changeEditPoint(value);
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let hierarchy = this.getValue('hierarchy');
                let positions = hierarchy.positions.concat([]);
                if (this.getValue('height') !== undefined) {
                    let height = this.getValue('height');
                    positions.forEach(item => {
                        let degree = that.toDegrees(item);
                        let cartesian = Cesium.Cartesian3.fromDegrees(degree.lon, degree.lat, height);
                        item.x = cartesian.x;
                        item.y = cartesian.y;
                        item.z = cartesian.z;
                    });
                }
                this.entity.pottingPoint = positions;
                return positions;
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    // if (this.getValue('extrudedHeight') !== undefined) {
                    //     let cartographic = Cesium.Cartographic.fromCartesian(item);
                    //     let degrees = {
                    //         lon: Cesium.Math.toDegrees(cartographic.longitude),
                    //         lat: Cesium.Math.toDegrees(cartographic.latitude),
                    //         height: this.getValue('extrudedHeight')
                    //     }

                    //     if (this.getValue('height')) {
                    //         let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                    //         item.x = e_p.x;
                    //         item.y = e_p.y;
                    //         item.z = e_p.z;
                    //         edit_point.position = e_p;
                    //         this.entity.pottingPoint[index] = e_p.clone();
                    //     }

                    //     let heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: Cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.push(heightpoint.id);
                    // }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                //移动节点
                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });

                for (let i = 0; i < points.length - 1; i++) {
                    let add_position = Cesium.Cartesian3.midpoint(points[i], points[i + 1], new Cesium.Cartesian3());
                    //添加节点
                    let add_point = viewer.entities.add({
                        name: "_add_point",
                        position: add_position,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.add.push(add_point.id);
                }

                //首尾间的添加节点
                let add_position = Cesium.Cartesian3.midpoint(points[0], points[points.length - 1], new Cesium.Cartesian3());
                let add_point = viewer.entities.add({
                    name: "_add_point",
                    position: add_position,
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
                tree.editPointID.add.push(add_point.id);
            };
        } else if (type === 'ellipse' || type === 'cylinder' || geo.isSphere) {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'semiMajorAxis') {
                        this.graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'semiMinorAxis') {
                        this.graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'radii') {
                        this.graphic.radii = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'topRadius') {
                        this.graphic.topRadius = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'bottomRadius') {
                        this.graphic.bottomRadius = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'radius') {
                        if (this.type === 'ellipse') {
                            this.graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                            this.graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                        } else if (this.type === 'ellipsoid') {
                            if (this.graphic.material.image.getValue() !== null) {
                                this.graphic.radii = new Cesium.Cartesian3(value, value, value);
                            } else {
                                this.graphic.radii = new Cesium.CallbackProperty(function () {
                                    return new Cesium.Cartesian3(value, value, value);
                                }, false);
                            }
                        } else if (this.type === 'cylinder') {
                            this.graphic.bottomRadius = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                            if (this.entity.changeTop) {
                                this.graphic.topRadius = new Cesium.CallbackProperty(function () {
                                    return value;
                                }, false);
                            }
                        }
                        let center = tree.editPointID.move.position.getValue();
                        let newPosition = that.GetPositionFromA_D(center, value, 90);

                        // 更新编辑点的位置
                        let _sizePoint = viewer.entities.getById(tree.editPointID.size[0]);
                        _sizePoint.position = newPosition;
                        geo.pottingPoint[0] = newPosition;
                        geo.pottingPoint[geo.pottingPoint.length - 1] = center;

                        //修改对应的拉伸节点
                        let thisHeightPoint = viewer.entities.getById(tree.editPointID.height[0]);
                        if (thisHeightPoint) {
                            let degrees = that.toDegrees(newPosition);
                            //修改拉伸节点位置
                            let expiontcart = that._cesium.Cartographic.fromCartesian(thisHeightPoint.position.getValue());
                            thisHeightPoint.position = that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, expiontcart.height);
                        }
                        return;
                    } else if (this.type === 'cylinder' && attr === 'length') {
                        this.graphic.length = value;
                        let degrees = that.toDegrees(this.entity.pottingPoint[1]);
                        this.entity.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + value / 2);
                        this.changeHeightPoint(degrees.height + value);
                        return;
                    } else if (this.type === 'ellipse' && attr === 'clampToGround') {
                        if (this.graphic.semiMinorAxis instanceof Cesium.CallbackProperty) {
                            this.graphic.semiMinorAxis = this.graphic.semiMinorAxis.getValue();
                            this.graphic.semiMajorAxis = this.graphic.semiMajorAxis.getValue();
                            setTimeout(() => {
                                changeGround(this.entity, this.graphic, value);
                            }, 100);
                        } else {
                            changeGround(this.entity, this.graphic, value);
                        }

                        if (!value) {
                            this.changeEditPoint(this.entity.thisHeight);
                        } else {
                            this.changeEditPoint('clampToGround');
                        }

                        function changeGround(entity, graphic, checked) {
                            if (checked) {
                                if (entity.thisHeight === undefined) {
                                    entity.thisHeight = graphic.height && graphic.height.getValue();
                                }
                                graphic.height = undefined;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.height = entity.thisHeight;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            let radius = graphic.semiMinorAxis.getValue();
                            graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                                return radius;
                            }, false);
                            graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                                return radius;
                            }, false);
                        }
                        return;
                    } else if (this.type === 'ellipse' && attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (this.type === 'ellipse' && attr === 'height') {
                        this.changeEditPoint(value);
                        this.entity.thisHeight = value;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let radius = this.getValue('radius');
                let position = this.getValue('position');
                if (this.type === 'ellipse' || this.entity.isSphere) {
                    if (this.type === 'ellipse' && this.getValue('height') !== undefined) {
                        let height = this.getValue('height');
                        let degree = that.toDegrees(position);
                        position = Cesium.Cartesian3.fromDegrees(degree.lon, degree.lat, height);
                    }
                    let position0 = that.GetPositionFromA_D(position, radius, 90);
                    this.entity.pottingPoint = [position0, position];
                    return [position0, position];
                } else {
                    let degrees = that.toDegrees(position);
                    //求cylinder底部点位置
                    position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height - this.getValue('length') / 2);
                    let position0 = that.GetPositionFromA_D(position, radius, 90);
                    this.entity.pottingPoint = [position0, position];
                    return [position0, position];
                }
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;
                //大小节点
                let size_point = viewer.entities.add({
                    name: "_size_point",
                    position: points[0],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
                size_point.angle = 90;
                tree.editPointID.size.push(size_point.id);

                //拉伸节点
                // if (this.getValue('extrudedHeight') !== undefined) {
                //     let degrees = that.toDegrees(points[1]);
                //     degrees.height = this.getValue('extrudedHeight');

                //     let heightpoint = viewer.entities.add({
                //         name: "_height_point",
                //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                //         point: {
                //             color: Cesium.Color.YELLOW,
                //             pixelSize: 12,
                //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                //             outlineWidth: 2,
                //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                //         }
                //     });
                //     tree.editPointID.height.push(heightpoint.id);
                // } else if (type === 'cylinder') {
                //     let degrees = that.toDegrees(points[1]);
                //     let length = this.getValue('length');
                //     let heightpoint = viewer.entities.add({
                //         name: "_height_point",
                //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + length),
                //         point: {
                //             color: Cesium.Color.YELLOW,
                //             pixelSize: 12,
                //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                //             outlineWidth: 2,
                //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                //         }
                //     });
                //     tree.editPointID.height.push(undefined, heightpoint.id);
                // }

                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: points[1],
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'rectangle') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic.coordinates = new Cesium.CallbackProperty(function () {
                            return Cesium.Rectangle.fromCartesianArray(value);
                        }, false);
                        return;
                    } else if (attr === 'coordinates') {
                        this.graphic.coordinates = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'clampToGround') {
                        if (this.graphic.coordinates instanceof Cesium.CallbackProperty) {
                            this.graphic.coordinates = this.graphic.coordinates.getValue();
                            setTimeout(() => {
                                changeGround(this.entity, this.graphic, value);
                            }, 100);
                        } else {
                            changeGround(this.entity, this.graphic, value);
                        }

                        if (!value) {
                            this.changeEditPoint(this.entity.thisHeight);
                        } else {
                            this.changeEditPoint('clampToGround');
                        }

                        function changeGround(entity, graphic, checked) {
                            if (checked) {
                                if (entity.thisHeight === undefined) {
                                    entity.thisHeight = graphic.height && graphic.height.getValue();
                                }
                                graphic.height = undefined;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.height = entity.thisHeight;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            let coordinates = graphic.coordinates.getValue();
                            graphic.coordinates = new Cesium.CallbackProperty(function () {
                                return coordinates;
                            }, false);
                        }
                        return;
                    } else if (attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (attr === 'height') {
                        this.changeEditPoint(value);
                        this.entity.thisHeight = value;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let coordinates = this.getValue('coordinates');
                let position0, position1;
                let height = this.getValue('height');
                if (height !== undefined) {
                    position0 = Cesium.Cartesian3.fromRadians(coordinates.west, coordinates.north, height);
                    position1 = Cesium.Cartesian3.fromRadians(coordinates.east, coordinates.south, height);
                } else {
                    height = viewer.scene.sampleHeight(new Cesium.Cartographic(coordinates.west, coordinates.north, 0), [this.entity]);
                    position0 = Cesium.Cartesian3.fromRadians(coordinates.west, coordinates.north, height);
                    height = viewer.scene.sampleHeight(new Cesium.Cartographic(coordinates.east, coordinates.south, 0), [this.entity]);
                    position1 = Cesium.Cartesian3.fromRadians(coordinates.east, coordinates.south, height);
                }
                this.entity.pottingPoint = [position0, position1];
                return [position0, position1];
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    // if (this.getValue('extrudedHeight') !== undefined) {
                    //     let cartographic = Cesium.Cartographic.fromCartesian(item);
                    //     let degrees = {
                    //         lon: Cesium.Math.toDegrees(cartographic.longitude),
                    //         lat: Cesium.Math.toDegrees(cartographic.latitude),
                    //         height: this.getValue('extrudedHeight')
                    //     }

                    //     if (this.getValue('height')) {
                    //         let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                    //         item.x = e_p.x;
                    //         item.y = e_p.y;
                    //         item.z = e_p.z;
                    //         edit_point.position = e_p;
                    //         this.entity.pottingPoint[index] = e_p.clone();
                    //     }

                    //     let heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: Cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.push(heightpoint.id);
                    // }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                //移动节点
                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'box') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'long' || attr === 'width' || attr === 'height') {
                        let dimensions = this.getValue('dimensions');
                        if (attr === 'long') {
                            dimensions.x = value;
                        } else if (attr === 'width') {
                            dimensions.y = value;
                        } else {
                            dimensions.z = value;
                        }
                        this.graphic.dimensions = new Cesium.CallbackProperty(function () {
                            return dimensions;
                        }, false);

                        if (attr === 'long' || attr === 'width') {
                            let angle = attr === 'long' ? 90 : 180;
                            let pointIndex = attr === 'long' ? 0 : 1;
                            let center = tree.editPointID.move.position.getValue();
                            let newPosition = that.GetPositionFromA_D(center, value / 2, angle);

                            // 更新编辑点的位置
                            let _sizePoint = viewer.entities.getById(tree.editPointID.size[pointIndex]);
                            _sizePoint.position = newPosition;
                            this.entity.pottingPoint[pointIndex] = newPosition;
                            this.entity.pottingPoint[this.entity.pottingPoint.length - 1] = center;
                        } else {
                            let degrees = that.toDegrees(tree.editPointID.move.position.getValue());
                            this.entity.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + value / 2);
                            this.changeHeightPoint(degrees.height + value);
                        }
                        return;
                    } else if (attr === 'dimensions') {
                        this.graphic.dimensions = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let dimensions = this.getValue('dimensions');
                let position = this.getValue('position');
                let degrees = that.toDegrees(position);
                //求box底部点位置
                position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height - dimensions.z / 2);
                let position0 = that.GetPositionFromA_D(position, dimensions.x / 2, 90);
                let position1 = that.GetPositionFromA_D(position, dimensions.y / 2, 180);
                this.entity.pottingPoint = [position0, position1, position];
                return [position0, position1, position];
            };

            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;
                //大小节点
                let size_point1 = viewer.entities.add({
                    name: "_size_point",
                    position: points[0],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY
                    }
                });
                size_point1.angle = 90;

                let size_point2 = viewer.entities.add({
                    name: "_size_point",
                    position: points[1],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY
                    }
                });
                size_point2.angle = 180;
                tree.editPointID.size.push(size_point1.id);
                tree.editPointID.size.push(size_point2.id);

                //拉伸节点
                // let degrees = that.toDegrees(points[2]);
                // let dimensions = this.getValue('dimensions');
                // let heightpoint = viewer.entities.add({
                //     name: "_height_point",
                //     position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + dimensions.z),
                //     point: {
                //         color: Cesium.Color.YELLOW,
                //         pixelSize: 12,
                //         outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                //         outlineWidth: 2,
                //         disableDepthTestDistance: Number.POSITIVE_INFINITY,
                //     }
                // });
                // tree.editPointID.height.push(undefined, undefined, heightpoint.id);

                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: points[2],
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'corridor') ; else if (type === 'ellipsoid' && !geo.isSphere) ; else if (type === 'path') ; else if (type === 'plane') ; else if (type === 'polylineVolume') ; else if (type === 'wall') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color') {
                        value = Cesium.Color.fromCssColorString(value);
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic[attr] = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let pottingPoint = this.getValue('positions');
                this.entity.pottingPoint = pottingPoint;
                return pottingPoint;
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                let minimumHeights = this.getValue('minimumHeights');
                points.forEach((item, index) => {
                    let Cartographic = Cesium.Cartographic.fromCartesian(item);
                    let position_ = Cesium.Cartesian3.fromRadians(Cartographic.longitude, Cartographic.latitude, minimumHeights[index]);
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: position_,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    // if (this.getValue('extrudedHeight') !== undefined) {
                    //     let cartographic = Cesium.Cartographic.fromCartesian(item);
                    //     let degrees = {
                    //         lon: Cesium.Math.toDegrees(cartographic.longitude),
                    //         lat: Cesium.Math.toDegrees(cartographic.latitude),
                    //         height: this.getValue('extrudedHeight')
                    //     }

                    //     if (this.getValue('height')) {
                    //         let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                    //         item.x = e_p.x;
                    //         item.y = e_p.y;
                    //         item.z = e_p.z;
                    //         edit_point.position = e_p;
                    //         this.entity.pottingPoint[index] = e_p.clone();
                    //     }

                    //     let heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: Cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.push(heightpoint.id);
                    // }

                    centerPoint.x += position_.x;
                    centerPoint.y += position_.y;
                    centerPoint.z += position_.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });

                for (let i = 0; i < points.length - 1; i++) {
                    let add_position = Cesium.Cartesian3.midpoint(points[i], points[i + 1], new Cesium.Cartesian3());
                    //添加节点
                    let add_point = viewer.entities.add({
                        name: "_add_point",
                        position: add_position,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.add.push(add_point.id);
                }
            };
        }

        function getFillColor(rgba) {
            SmartEarthPopupData.editGraphic.fillColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.alpha = rgba.alpha * 100;
        }

        function getOutlineColor(rgba) {
            SmartEarthPopupData.editGraphic.outlineColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.outlineAlpha = rgba.alpha * 100;
        }

        function getBackgroundColor(rgba) {
            SmartEarthPopupData.editGraphic.backgroundColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.backgroundAlpha = rgba.alpha * 100;
        }

        function colorHex(rgb) {
            let _this = rgb;
            let reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;
            if (/^(rgb|RGB)/.test(_this)) {
                let str = _this.replace(/(rgb|RGB)*/g, "");
                str = str.replace("(", "").replace(")", "");
                let aColor = str.split(",");
                let strHex = "#";
                for (let i = 0; i < aColor.length; i++) {
                    let hex = Number(aColor[i]).toString(16);
                    hex = hex.length === 1 ? 0 + '' + hex : hex;// 保证每个rgb的值为2位
                    if (hex === "0") {
                        hex += hex;
                    }
                    strHex += hex;
                }
                if (strHex.length !== 7) {
                    strHex = _this;
                }
                return strHex;
            } else if (reg.test(_this)) {
                let aNum = _this.replace(/#/, "").split("");
                if (aNum.length === 6) {
                    return _this;
                } else if (aNum.length === 3) {
                    let numHex = "#";
                    for (let i = 0; i < aNum.length; i += 1) {
                        numHex += (aNum[i] + aNum[i]);
                    }
                    return numHex;
                }
            } else {
                return _this;
            }
        }
    };

    /**
     *
     * 创建图片标签Geojson要素图层。
     *
     * @alias billboardGeoJsonFeatureLayer
     * @constructor
     *
     */
    function billboardGeoJsonFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this._Provider = undefined;
        /**
         * 是否强制清楚缓存
         */
        this._cache = false;
        this._forceRefreshPrvimitive = null;
    }

    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *            show: true,
                position: this._cesium.Cartesian3.ZERO,
                pixelOffset: Cesium.Cartesian2.ZERO,
                eyeOffset: Cesium.Cartesian3.ZERO,
                heightReference: Cesium.HeightReference.NONE,
                horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
                verticalOrigin: Cesium.VerticalOrigin.CENTER,
                scale: 1.0,
                image: '',
                imageSubRegion: undefined,
                color: Cesium.Color.WHITE,
                id: undefined,
                rotation: 0.0,
                alignedAxis: Cesium.Cartesian3.ZERO,
                width: undefined,
                height: undefined,
                scaleByDistance: undefined,
                translucencyByDistance: undefined,
                pixelOffsetScaleByDistance: undefined,
                sizeInMeters: false,
                distanceDisplayCondition: undefined
       }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    billboardGeoJsonFeatureLayer.prototype.createBillboardPointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        //this._viewer.dataSources.add(dataSource);
        var that = this;
        dataSource.then(function (dataSource) {
            var defaultOptions = {
                show: true,
                position: that._cesium.Cartesian3.ZERO,
                pixelOffset: that._cesium.Cartesian2.ZERO,
                eyeOffset: that._cesium.Cartesian3.ZERO,
                heightReference: that._cesium.HeightReference.NONE,
                horizontalOrigin: that._cesium.HorizontalOrigin.CENTER,
                verticalOrigin: that._cesium.VerticalOrigin.CENTER,
                scale: 1.0,
                image: '',
                imageSubRegion: undefined,
                color: that._cesium.Color.WHITE,
                id: undefined,
                rotation: 0.0,
                alignedAxis: that._cesium.Cartesian3.ZERO,
                width: undefined,
                height: undefined,
                scaleByDistance: undefined,
                translucencyByDistance: undefined,
                pixelOffsetScaleByDistance: undefined,
                sizeInMeters: false,
                distanceDisplayCondition: undefined
            };
            //填充颜色设置
            if (!that._core.isnull(option) && !that._core.isnull(option.color)) {
                if (/^\[/.test(option.color) && option.color.charAt(0) == "[" && option.color.charAt(option.color.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(option.color)) {
                        option.color = that._color.colorFromHtmlColor(option.color);
                    } else {
                        if (/^rgb/.test(option.color)) {
                            option.color = that._color.rgbaStringToRgbaObj(option.color);
                        }
                        if (option.color.r > 1) {
                            option.color.r = option.color.r / 255;
                        }
                        if (option.color.g > 1) {
                            option.color.g = option.color.g / 255;
                        }
                        if (option.color.b > 1) {
                            option.color.b = option.color.b / 255;
                        }
                        if (option.color.a > 1) {
                            option.color.a = option.color.a / 255;
                        }
                        option.color = that._color.createColor(option.color.r, option.color.g, option.color.b, option.color.a);
                    }
                }
            }

            var options = that._core.extend(defaultOptions, option, true);
            if (that._core.isnull(option.near)) {
                option.near = 0;
            }
            if (that._core.isnull(option.far)) {
                option.far = 999999999;
            }
            var min = parseFloat(option.near);
            var max = parseFloat(option.far);
            new that._cesium.DistanceDisplayCondition(min, max);
            //options.distanceDisplayCondition = distance;

            var billboardCollections = new that._cesium.BillboardCollection();

            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                options.position = entity.position._value;
                billboardCollections.add(options);
            }
            var ps = that._viewer.scene.primitives.add(billboardCollections);
            // if (checked == "false") {
            //     that.setVisibility(false);
            // }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        // if (this._core.isnull(options.id)) {
        //     options.id = this._core.getuid();
        // }
        var guid = this._core.getuid();
        if (this._core.isnull(name)) {
            name = "新建图层" + guid;
        }
        //导出工程树
        var obj = {
            id: guid,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'billboardLayer',
            item: this,
            url: geojsonOrurl,
            style: options
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *        Name: "",
            text: "",
            font_size: '30px',
            font_family:'sans-serif'
            stylet: this._cesium.LabelStyle.FILL,
            fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
            outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
            show: true,//	optional A boolean Property specifying the visibility of the label.
            showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
            backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
            near: 0,
            far: 5000
       }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    billboardGeoJsonFeatureLayer.prototype.createBillboardGeoJsonFeatureLayerProvider = function (name, geoOptions, option, GroupID, checked, disFnc) {
        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        var that = this;
        geoJSONVectorTileProvider._loadTile = function (json) {
            var defaultOptions = {
                show: true,
                position: that._cesium.Cartesian3.ZERO,
                pixelOffset: that._cesium.Cartesian2.ZERO,
                eyeOffset: that._cesium.Cartesian3.ZERO,
                heightReference: that._cesium.HeightReference.NONE,
                horizontalOrigin: that._cesium.HorizontalOrigin.CENTER,
                verticalOrigin: that._cesium.VerticalOrigin.CENTER,
                scale: 1.0,
                image: '',
                imageSubRegion: undefined,
                color: that._cesium.Color.WHITE,
                id: undefined,
                rotation: 0.0,
                alignedAxis: that._cesium.Cartesian3.ZERO,
                width: undefined,
                height: undefined,
                scaleByDistance: undefined,
                translucencyByDistance: undefined,
                pixelOffsetScaleByDistance: undefined,
                sizeInMeters: false,
                distanceDisplayCondition: undefined
            };
            //填充颜色设置
            if (!that._core.isnull(option) && !that._core.isnull(option.color)) {
                if (/^\[/.test(option.color) && option.color.charAt(0) == "[" && option.color.charAt(option.color.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(option.color)) {
                        option.color = that._color.colorFromHtmlColor(option.color);
                    } else {
                        if (/^rgb/.test(option.color)) {
                            option.color = that._color.rgbaStringToRgbaObj(option.color);
                        }
                        if (option.color.r > 1) {
                            option.color.r = option.color.r / 255;
                        }
                        if (option.color.g > 1) {
                            option.color.g = option.color.g / 255;
                        }
                        if (option.color.b > 1) {
                            option.color.b = option.color.b / 255;
                        }
                        if (option.color.a > 1) {
                            option.color.a = option.color.a / 255;
                        }
                        option.color = that._color.createColor(option.color.r, option.color.g, option.color.b, option.color.a);
                    }
                }
            }
            var options = that._core.extend(defaultOptions, option, true);
            if (that._core.isnull(option.near)) {
                option.near = 0;
            }
            if (that._core.isnull(option.far)) {
                option.far = 999999999;
            }
            var min = parseFloat(option.near);
            var max = parseFloat(option.far);
            new that._cesium.DistanceDisplayCondition(min, max);
            //options.distanceDisplayCondition = distance;

            var billboardCollections = new that._cesium.BillboardCollection();

            json.features.forEach(function (feature) {
                options.id = feature;
                var height;
                if (/^\[/.test(options.pointHeight) && /\]$/.test(options.pointHeight)) {
                    var heightStr = options.pointHeight.replace(/\[/, '').replace(/\]/, '');
                    height = parseFloat(feature.properties[heightStr]);
                    feature.geometry.coordinates.push(height);
                    options.position = that._cesium.Cartesian3.fromDegreesArrayHeights(feature.geometry.coordinates)[0];
                } else if (options.pointHeight) {
                    height = parseFloat(options.pointHeight);
                    feature.geometry.coordinates.push(height);
                    options.position = that._cesium.Cartesian3.fromDegreesArrayHeights(feature.geometry.coordinates)[0];
                } else {
                    options.position = that._cesium.Cartesian3.fromDegreesArray(feature.geometry.coordinates)[0];
                }

                //样式属性
                options.id.treeID = option.id;
                options.id.VectorType = 'billboard';
                options.id.VectorStyle = {
                    position: options.position,
                    pointHeight: height,
                    rotation: options.rotation,
                    width: options.width,
                    height: options.height,
                    image: options.image,
                    color: options.color,
                    scale: options.scale,
                    heightReference: options.heightReference,
                    horizontalOrigin: options.horizontalOrigin,
                    verticalOrigin: options.verticalOrigin,
                    scaleByDistance: options.scaleByDistance,
                    distanceDisplayCondition: options.distanceDisplayCondition
                };

                billboardCollections.add(options);
            });

            return billboardCollections;
        };

        //添加时间段
        if (option && option.time) {
            geoJSONVectorTileProvider.availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(option.id)) {
            option.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + option.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: option.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'imageLayer',
            item: this,
            url: defaultGeoOptions.url,
            style: option
        };
        this._Provider.treeID = option.id;
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        if (typeof disFnc == 'function')
            disFnc(this.item);
        return this;
    };
    /**
     * 导出工程数据
     */
    billboardGeoJsonFeatureLayer.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url
            }
        };
    };
    /**
     * 设置数据是否刷新
     */
    billboardGeoJsonFeatureLayer.prototype.setRefresh = function (b) {
        try {
            if (this._Provider) {
                this._Provider.setStatus(b);
            }
        } catch (ex) {
        }
    };
    /**
     * 设置数据显示隐藏
     */
    billboardGeoJsonFeatureLayer.prototype.setVisibility = function (b) {
        this.item.show = b;
        if (this._Provider) {
            this._Provider.setStatus(!b);
        }
        !b && this.item.removeAll();
    };

    /**
     * 删除数据
     */
    billboardGeoJsonFeatureLayer.prototype.deleteObject = function () {
        if (this._Provider != undefined) {
            this._Provider.setStatus(false);
        }
        if (this.items != undefined && this.items != null && this.items.length > 0) {
            for (var i = 0; i < this.items.length; i++) {
                this._viewer.scene.primitives.remove(this.items[i]);
            }
        } else {
            this._viewer.scene.primitives.remove(this.item);
        }
        try {
            this._Provider.remove();
        } catch (ex) {
        }
    };
    //工程树添加
    billboardGeoJsonFeatureLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    billboardGeoJsonFeatureLayer.prototype.edit = function (open, option) {
        this.isEditting = open;
        this.editoption = option;
        return this._Provider && this._Provider.edit && this._Provider.edit(open, option);
    };
    /**
    * 设置数据是否刷新
    */
    billboardGeoJsonFeatureLayer.prototype.forceRefresh = function () {
        try {
            // this._cache = true;
            // if (!this._forceRefreshPrvimitive)
            //     this._forceRefreshPrvimitive = loadsh.cloneDeep(this._primitive)
            // var temp = loadsh.cloneDeep(this._forceRefreshPrvimitive)
            // this._viewer.scene.primitives.remove(this._primitive);
            // this._viewer.scene.primitives.add(temp);
            // this._viewer.scene.primitivesQuadTrees.push(temp);
            // // this.edit(this.isEditting, this.editoption);
            //     // temp._tileProvider.edit(this.isEditting, this.editoption);

            for (var i = 0; i < this._Provider.quadtree._levelZeroTiles.length; i++) {
                this._Provider.quadtree._levelZeroTiles[i].freeResources();
            }
        } catch (ex) {
        }
    };

    /**
     *
     * 这个方法用于创建一个Geojson要素图层。
     *
     * @alias GeoJsonFeatureLayer
     * @constructor
     *
     */
    function GeoJsonFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._getPosition = new getPosition(this._viewer, this._cesium);
        this._tree = tree;
        this._popupmessage = new PopupMessage(this._viewer, this._cesium);
        //图例
        this.Legend = [];
        this.tooltip = this._core.CreateTooltip();
        this.enty = null;
        //数据加载
        //this.labelCollections = new sgworld._cesium.LabelCollection();
    }

    /**
    * 创建Geojson数据加载(全部加载)优化
    *
    * @param {String} [name] 图层名称。
    * @param {object|String} [geojsonOrurl] geojosn对象或者地址
    * @param {object} [option] 参数对象{
           color: this._cesium.Color.WHITE,//	optional A Property specifying the Color of the point.
           pixelSize: 1,//optional A numeric Property specifying the size in pixels.
           outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the Color of the outline.
           outlineWidth: 0,//	optional A numeric Property specifying the the outline width in pixels.
           show: true,//	optional A boolean Property specifying the visibility of the point.
           near: 0,
           far: 5000
       }
    * @param {Function} [disFnc] 回调函数
    * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
    */
    GeoJsonFeatureLayer.prototype.createGeojsonFeatureLayer = function (name, geojson, option, GroupID, checked, disFnc) {
        var geojsonOrurl = geojson.url;
        var maxLevel = geojson.maxLevel;
        var minLevel = geojson.minLevel;
        var options = this._core.StyleContrastGeoJson(option, this._cesium);
        //this._core.extendgl(options,extendgl);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');

        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        this._viewer.dataSources.add(dataSource);
        var that = this;
        if (!this.setNearAndFar && maxLevel && minLevel) {
            this.setNearAndFar = true;
            this.Level = 0;
            this._viewer.scene.preRender.addEventListener(function () {
                if (that.isShow && that.item) {
                    that.Level = that.getLevel();

                    if (that.Level >= minLevel && that.Level <= maxLevel && !that.item.show) {
                        that.item.show = true;
                    } else if (that.Level < minLevel || that.Level > maxLevel) {
                        that.item.show = false;
                    }
                }
            });
        }
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //加载数据
                //point
                if (options.point != undefined) {
                    var point = options.point;
                    point.color = that._color.VectorColorTransformation(point.color, entity);
                    point.outlineColor = that._color.VectorColorTransformation(point.outlineColor, entity);
                    if (point.pointHeight != undefined) {
                        entity.position._value = that._core.setheight(entity.position._value, point.pointHeight, that._cesium, that._viewer);
                        delete point.pointHeight;
                    }
                    entity.point = new that._cesium.PointGraphics(point);
                }
                //label
                if (options.label != undefined) {
                    var label = options.label;
                    label.fillColor = that._color.VectorColorTransformation(label.fillColor, entity);
                    label.outlineColor = that._color.VectorColorTransformation(label.outlineColor, entity);
                    if (label.pointHeight != undefined) {
                        entity.position._value = that._core.setheight(entity.position._value, label.pointHeight, that._cesium, that._viewer);
                        delete label.pointHeight;
                    }
                    entity.label = new that._cesium.LabelGraphics(label);
                }
                //billboard
                if (options.billboard != undefined) {
                    var billboard = options.billboard;
                    billboard.color = that._color.VectorColorTransformation(billboard.color, entity);
                    if (billboard.pointHeight != undefined) {
                        entity.position._value = that._core.setheight(entity.position._value, billboard.pointHeight, that._cesium, that._viewer);
                        delete billboard.pointHeight;
                    }
                    entity.billboard = new that._cesium.BillboardGraphics(billboard);
                }
                //polyline
                if (options.polyline != undefined) {
                    var polyline = options.polyline;
                    polyline.material = that._color.VectorColorTransformation(polyline.material, entity);
                    polyline.positions = entity.polyline.positions;
                    if (polyline.pointHeight != undefined) {
                        entity.position._value = that._core.setpolylineheight(entity.position._value, polyline.pointHeight, that._cesium, that._viewer);
                        delete polyline.pointHeight;
                    }
                    entity.polyline = new that._cesium.PolylineGraphics(polyline);
                }
                //polygon
                if (options.polygon != undefined) {
                    var polygon = options.polygon;
                    polygon.hierarchy = entity.polygon.hierarchy;
                    polygon.material = that._color.VectorColorTransformation(polygon.material, entity);
                    polygon.outlineColor = that._color.VectorColorTransformation(polygon.outlineColor, entity);
                    polygon.outlineColor && (polygon.outline = true);
                    entity.polygon = new that._cesium.PolygonGraphics(polygon);
                }
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        if (checked) {
            that.isShow = true;
        } else {
            that.setVisibility(false);
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'datasource',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojson, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);

        return this;
    };
    //加载kml
    GeoJsonFeatureLayer.prototype.createGeojsonKmlFeatureLayer = function (name, geojson, GroupID, checked, disFnc) {
        var geojsonOrurl = geojson;
        var options = {
            camera: this._viewer.scene.camera,
            canvas: this._viewer.scene.canvas
        };
        this._viewer.dataSources.add(this._cesium.KmlDataSource.load(geojson, options));
        var that = this;
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        if (checked) ; else {
            that.setVisibility(false);
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'datasource',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojson, "styleOption": "", "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);

        return this;
    };
    /**
     * 创建geofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
            "layertype": "",                     //图层类型
            "text": "",                      //显示的文本
            "font": "16px",                     //字体
            "fillColor": this._cesium.ALICEBLUE,//字体填充颜色
            "outlineColor": this._cesium.BLACK, //边框颜色
            "outlineWidth": "1.0",              //边框宽度
            "scale": "1.0",                     //缩放
            "maxDistanceDisplay": 55555555,     //最大可视化距离
            "minDistanceDisplay": 5000,         //最小可视化距离
            "icon": ""                       //显示的图标
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createGeoJsonFeatureLayerAlawys = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var defaultOptions = {
            "id": this._core.getuid(),
            "layertype": "", //图层类型
            "text": "", //显示的文本
            "font": "16px", //字体
            "fillColor": this._cesium.WHITE, //字体填充颜色
            "outlineColor": this._cesium.BLACK, //边框颜色
            "outlineWidth": "1.0", //边框宽度
            "scale": "1.0", //缩放
            "maxDistanceDisplay": 99999999, //最大可视化距离
            "minDistanceDisplay": 0, //最小可视化距离
            "far": 99999999, //最大可视化距离
            "near": 0, //最小可视化距离
            "icon": "" //显示的图标
        };
        //字体填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.fillColor)) {
            if (option.fillColor.toString().charAt(0) == "[" && option.fillColor.toString().charAt(option.fillColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.fillColor)) {
                    option.fillColor = this._color.colorFromHtmlColor(option.fillColor);
                } else {
                    option.fillColor = this._color.createColor(option.fillColor.r, option.fillColor.g, option.fillColor.b, option.fillColor.a);
                }
            }
        }
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (option.outlineColor.toString().charAt(0) == "[" && option.outlineColor.toString().charAt(option.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.outlineColor)) {
                    option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
                } else {
                    option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        this._viewer.dataSources.add(dataSource);
        var that = this;
        var time;
        //添加时间段
        if (option && option.time) {
            time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.id = that._core.extendgl(entity, option.id, options.id);
                options.text = that._core.extendgl(entity, option.text, options.text);
                options.font = that._core.extendgl(entity, option.font, options.font);
                options.fillColor = that._core.extendgl(entity, option.fillColor, options.fillColor);
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseInt(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.scale = parseFloat(that._core.extendgl(entity, option.scale, options.scale));
                //options.distanceDisplayCondition= that._core.scale(entity,option.distanceDisplayCondition);
                options.image = that._core.extendgl(entity, option.image, options.image);
                options.icon = that._core.extendgl(entity, option.icon, options.icon);

                var min = parseFloat(that._core.extendgl(entity, options.minDistanceDisplay || options.near));
                var max = parseFloat(that._core.extendgl(entity, options.maxDistanceDisplay || options.far));
                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                //获取数据结束
                if (entity.billboard) {
                    ///有图标和文字
                    if (options) {
                        if ((that._core.isUrl(entity.properties[options.icon]) || that._core.isUrl(options.icon)) && (!that._core.isnull(entity.properties[options.text])) || !that._core.isnull(options.text)) {
                            var col = "fillColor:" + options.fillColor.red * 255 + "," + options.fillColor.green * 255 + "," + options.fillColor.blue * 255 +
                                ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                            that.Legend.push(col);
                            entity.label = {
                                id: 'my label',
                                text: that._core.isnull(entity.properties[options.text]) ? options.text : entity.properties[options.text] + "",
                                font: options.font + " sans-serif",
                                fillColor: options.fillColor,
                                outlineColor: options.outlineColor,
                                outlineWidth: options.outlineWidth,
                                scale: parseFloat(options.scale),
                                distanceDisplayCondition: distance
                            };
                            entity.billboard = {
                                image: that._core.isUrl(entity.properties[options.icon]) ? entity.properties[options.icon] : options.icon,
                                distanceDisplayCondition: distance
                            };
                        }
                        ///是否有图标
                        else if (!that._core.isnull(options.icon)) {
                            entity.billboard = {
                                image: that._core.isUrl(entity.properties[options.icon]) ? entity.properties[options.icon] : options.icon,
                                distanceDisplayCondition: distance
                            };
                        }
                        ///是否有文字
                        else if ((!that._core.isnull(entity.properties[options.text])) || !that._core.isnull(options.text)) {
                            entity.billboard = undefined;
                            var col = "fillColor:" + options.fillColor.red * 255 + "," + options.fillColor.green * 255 + "," + options.fillColor.blue * 255 +
                                ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                            that.Legend.push(col);
                            entity.label = {
                                id: 'my label',
                                text: that._core.isnull(entity.properties[options.text]) ? options.text : entity.properties[options.text] + "",
                                font: options.font + " sans-serif",
                                fillColor: options.fillColor,
                                outlineColor: options.outlineColor,
                                outlineWidth: options.outlineWidth,
                                scale: parseFloat(options.scale),
                                distanceDisplayCondition: distance
                            };
                        }

                        ///是否包含文字和图片
                        else {
                            var col = "color:" + options.fillColor.red * 255 + "," + options.fillColor.green * 255 + "," + options.fillColor.blue * 255;
                            that.Legend.push(col);
                            entity.billboard = undefined;
                            entity.point = new that._cesium.PointGraphics({
                                color: that._cesium.Color.RED,
                                pixelSize: 10,
                                distanceDisplayCondition: distance
                            });
                        }

                    } else if (entity.polygon) {
                        entity.polygon.distanceDisplayCondition = distance;
                    } else if (entity.polyline) {
                        entity.polyline.distanceDisplayCondition = distance;
                    }
                    time && (entity.availability = time);
                }
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树数据
        var obj = {
            id: options.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'pointLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": true, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建geofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
              "layertype": "",                     //图层类型
              "text": "",                      //显示的文本
              "font": "16px",                     //字体
              "fillColor": this._cesium.ALICEBLUE,//字体填充颜色
              "outlineColor": this._cesium.BLACK, //边框颜色
              "outlineWidth": "1.0",              //边框宽度
              "scale": "1.0",                     //缩放
              "maxDistanceDisplay": 55555555,     //最大可视化距离
              "minDistanceDisplay": 5000,         //最小可视化距离
              "icon": ""                       //显示的图标
          }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createGeoJsonFeatureLayer = function (name, geojsonOrurl, options, GroupID, checked, disFnc) {

        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        var that = this;
        dataSource.then(function (dataSourceTemp) {
            var dataSourceItem0 = dataSourceTemp.entities.values[0];
            if (/^point.fid/.test(dataSourceItem0._id) || dataSourceItem0.point != undefined) {
                that.createPointGeojsonFeatureLayer(name, dataSource, options, GroupID, checked, disFnc);
            } else if (/^polygon.fid/.test(dataSourceItem0._id) || dataSourceItem0.polygon != undefined) {
                that.createPolygonGeoJsonFeatureLayer(name, dataSource, options, GroupID, checked, disFnc);
            } else if (/^line.fid/.test(dataSourceItem0._id) || dataSourceItem0.polyline != undefined) {
                that.createPolylineGeoJsonFeatureLayer(name, dataSource, options, GroupID, checked, disFnc);
            } else {
                that.createGeoJsonFeatureLayerAlawys(name, dataSource, options, GroupID, disFnc);
            }
        });
        return this;
    };

    /**
     * 创建pointGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
            color: this._cesium.Color.WHITE,//	optional A Property specifying the Color of the point.
            pixelSize: 1,//optional A numeric Property specifying the size in pixels.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the Color of the outline.
            outlineWidth: 0,//	optional A numeric Property specifying the the outline width in pixels.
            show: true,//	optional A boolean Property specifying the visibility of the point.
            near: 0,
            far: 5000
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createPointGeojsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            color: this._cesium.Color.WHITE, //	optional A Property specifying the Color of the point.
            pixelSize: 1, //optional A numeric Property specifying the size in pixels.
            outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the Color of the outline.
            outlineWidth: 0, //	optional A numeric Property specifying the the outline width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the point.
            scaleByDistance: new this._cesium.NearFarScalar(0, 0, 1, 1),
            height: 0,
            pointHeight: 0,
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
        };
        //字体填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.color)) {
            if (option.color.toString().charAt(0) == "[" && option.color.toString().charAt(option.color.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.color)) {
                    option.color = this._color.colorFromHtmlColor(option.color);
                } else {
                    if (/^rgb/.test(option.color)) {
                        option.color = this._color.rgbaStringToRgbaObj(option.color);
                    }
                    if (option.color.r > 1) {
                        option.color.r = option.color.r / 255;
                    }
                    if (option.color.g > 1) {
                        option.color.g = option.color.g / 255;
                    }
                    if (option.color.b > 1) {
                        option.color.b = option.color.b / 255;
                    }
                    if (option.color.a > 1) {
                        option.color.a = option.color.a / 255;
                    }
                    option.color = this._color.createColor(option.color.r, option.color.g, option.color.b, option.color.a);
                }
            }
        }
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (option.outlineColor.toString().charAt(0) == "[" && option.outlineColor.toString().charAt(option.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.outlineColor)) {
                    option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
                } else {
                    if (/^rgb/.test(option.outlineColor)) {
                        option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                    }
                    if (option.outlineColor.r > 1) {
                        option.outlineColor.r = option.outlineColor.r / 255;
                    }
                    if (option.outlineColor.g > 1) {
                        option.outlineColor.g = option.outlineColor.g / 255;
                    }
                    if (option.outlineColor.b > 1) {
                        option.outlineColor.b = option.outlineColor.b / 255;
                    }
                    if (option.outlineColor.a > 1) {
                        option.outlineColor.a = option.outlineColor.a / 255;
                    }
                    option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        //this._core.extendgl(options,extendgl);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');

        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        this._viewer.dataSources.add(dataSource);
        var that = this;

        var time;
        //添加时间段
        if (option && option.time) {
            time = new this._cesium.TimeIntervalCollection([new this._cesium.TimeInterval({
                start: option.time.start ? this._cesium.JulianDate.fromDate(new Date(option.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? this._cesium.JulianDate.fromDate(new Date(option.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            // var min = parseFloat(options.near);
            // var max = parseFloat(options.far);
            // var distance = new that._cesium.DistanceDisplayCondition(min, max);
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.color = that._core.extendgl(entity, option.color, options.color);
                options.pixelSize = parseInt(that._core.extendgl(entity, option.pixelSize, options.pixelSize));
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.height = parseFloat(that._core.extendgl(entity, option.height, options.height));
                options.scaleByDistance = that._core.extendgl(entity, option.scaleByDistance, options.scaleByDistance);
                var min = parseFloat(that._core.extendgl(entity, options.minDistanceDisplay || options.near));
                var max = parseFloat(that._core.extendgl(entity, options.maxDistanceDisplay || options.far));
                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                //获取数据结束
                //entity.billboard = undefined;
                //图例
                var col = "color:" + options.color.red * 255 + "," + options.color.green * 255 + "," + options.color.blue * 255 +
                    ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                that.Legend.push(col);
                options.distanceDisplayCondition = distance;
                options.pointHeight = that._core.extendgl(entity, option.pointHeight, options.pointHeight);
                options.pointHeight = parseFloat(options.pointHeight);
                //坐标转化
                that._viewer.scene.globe.ellipsoid;
                var scartographic = that._cesium.Cartographic.fromCartesian(entity.position._value);
                var slongitude = that._cesium.Math.toDegrees(scartographic.longitude);
                var slatitude = that._cesium.Math.toDegrees(scartographic.latitude);
                var sheight = scartographic.height + options.pointHeight; //

                var posit = new that._cesium.Cartesian3.fromDegrees(slongitude, slatitude, sheight);
                entity.position._value = posit;
                entity.point = new that._cesium.PointGraphics(options);
                entity.billboard = undefined;
                //数据修改i
                var id = {
                    positions: posit
                };
                entity.description = id;
                time && (entity.availability = time);
                //entity.position._value.z += options.height == null ? 0 : options.height;
            }
            if (checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'pointLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);

        return this;
    };

    /**
     * 创建pointGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象
     * @param {Function} [disFnc] 回调函数
     */
    GeoJsonFeatureLayer.prototype.createModelGeojsonFeatureLayer = function (name, geojsonOrurl, option = {}, GroupID, checked, disFnc) {
        var defaultOptions = {
            color: Cesium.Color.fromCssColorString(option.color || "#ffffff"),
            url: window.SmartEarthRootUrl + configData$1.testModel,
            scale: 1,
            minimumPixelSize: 0,
            height: 0,
            far: 5000, //最大可视化距离
            near: 0, //最小可视化距离
        };

        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined) {
            console.log('geojson is required');
        }

        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        this._viewer.dataSources.add(dataSource);

        var time;
        //添加时间段
        if (option && option.time) {
            time = new this._cesium.TimeIntervalCollection([new this._cesium.TimeInterval({
                start: option.time.start ? this._cesium.JulianDate.fromDate(new Date(option.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? this._cesium.JulianDate.fromDate(new Date(option.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        var min = parseFloat(options.near);
        var max = parseFloat(options.far);
        var distance = new Cesium.DistanceDisplayCondition(min, max);
        dataSource.then((dataSource) => {
            this.item = dataSource;
            var entities = dataSource.entities.values;

            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];

                //坐标转化
                var degrees = this._core.toDegrees(entity.position.getValue());
                if (options.height) {
                    degrees.height = options.height;
                }

                var position = new Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height);
                entity.position = position;
                entity.model = new Cesium.ModelGraphics({
                    uri: options.url,
                    distanceDisplayCondition: distance,
                    ...options
                });
                entity.billboard = undefined;
                entity.point = undefined;
                time && (entity.availability = time);
            }
            if (!checked) {
                this.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'pointLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);

        return this;
    };

    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *       radius:1,
            height: 0,
            heightReference: this._cesium.HeightReference.NONE,
            extrudedHeight: 0,
            extrudedHeightReference: this._cesium.HeightReference.NONE,
            show: true,
            fill: true,
            material: this._cesium.Color.WHITE,
            outline: false,
            outlineColor: this._cesium.Color.BLACK,
            outlineWidth: 1,
            near: 0,
            far: 5000
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createCirclePointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var defaultOptions = {
            semiMajorAxis: 1,
            semiMinorAxis: 1,
            height: 0,
            heightReference: this._cesium.HeightReference.NONE,
            extrudedHeight: 0,
            extrudedHeightReference: this._cesium.HeightReference.NONE,
            show: true,
            fill: true,
            material: this._cesium.Color.WHITE,
            outline: false,
            outlineColor: this._cesium.Color.BLACK,
            outlineWidth: 1,
            scaleByDistance: new this._cesium.NearFarScalar(0, 0, 1, 1)
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (option.outlineColor.toString().charAt(0) == "[" && option.outlineColor.toString().charAt(option.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.outlineColor)) {
                    option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
                } else {
                    if (/^rgb/.test(option.outlineColor)) {
                        option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                    }
                    if (option.outlineColor.r > 1) {
                        option.outlineColor.r = option.outlineColor.r / 255;
                    }
                    if (option.outlineColor.g > 1) {
                        option.outlineColor.g = option.outlineColor.g / 255;
                    }
                    if (option.outlineColor.b > 1) {
                        option.outlineColor.b = option.outlineColor.b / 255;
                    }
                    if (option.outlineColor.a > 1) {
                        option.outlineColor.a = option.outlineColor.a / 255;
                    }
                    option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
                }
            }
        }
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else if (option.material.toString().charAt(0) == "(" && option.material.toString().charAt(option.material.length - 1) == ")") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        if (!this._core.isnull(option) && !this._core.isnull(option.radius)) {
            defaultOptions.semiMajorAxis = option.radius;
            defaultOptions.semiMinorAxis = option.radius;
        }

        if (that._core.isnull(option.near)) {
            option.near = 0;
        }
        if (that._core.isnull(option.far)) {
            option.far = 999999999;
        }
        var options = this._core.extend(defaultOptions, option, true);
        //this._core.extendgl(options,extendgl);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        this._viewer.dataSources.add(dataSource);
        var that = this;
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            // var min = parseFloat(option.near);
            // var max = parseFloat(option.far);
            // var distance = new that._cesium.DistanceDisplayCondition(min, max);
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.semiMajorAxis = parseFloat(that._core.extendgl(entity, option.semiMajorAxis, options.semiMajorAxis));
                options.semiMinorAxis = parseFloat(that._core.extendgl(entity, option.semiMinorAxis, options.semiMinorAxis));
                options.height = parseFloat(that._core.extendgl(entity, option.height, options.height));
                options.heightReference = that._core.extendgl(entity, option.heightReference, options.heightReference);
                options.extrudedHeight = parseFloat(that._core.extendgl(entity, option.extrudedHeight, options.extrudedHeight));
                options.extrudedHeightReference = that._core.extendgl(entity, option.extrudedHeightReference, options.extrudedHeightReference);
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.fill = that._core.extendgl(entity, option.fill, options.fill);
                options.material = that._core.extendgl(entity, option.material, options.material);
                options.outline = that._core.extendgl(entity, option.outline, options.outline);
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.scaleByDistance = that._core.extendgl(entity, option.scaleByDistance, options.scaleByDistance);

                //图例
                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255 +
                    ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                that.Legend.push(col);
                var min = parseFloat(that._core.extendgl(entity, options.near));
                var max = parseFloat(that._core.extendgl(entity, options.far));

                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                options.distanceDisplayCondition = distance;
                //获取数据结束
                entity.billboard = undefined;
                entity.ellipse = new that._cesium.EllipseGraphics(options);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'layer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": true, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *         uri: "glb/gltf",
        show: true,//	optional A boolean Property specifying the visibility of the model.
        scale: 1.0,	//optional A numeric Property specifying a uniform linear scale.
        minimumPixelSize: 0.0,//	optional A numeric Property specifying the approximate minimum pixel size of the model regardless of zoom.
        incrementallyLoadTextures: true,//optional Determine if textures may continue to stream in after the model is loaded.
        runAnimations: true,//	optional A boolean Property specifying if glTF animations specified in the model should be started.
        clampAnimations: true,//	optional A boolean Property specifying if glTF animations should hold the last pose for time durations with no keyframes.
        shadows: this._cesium.ShadowMode.ENABLED,//	optional An enum Property specifying whether the model casts or receives shadows from each light source.
        heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.

        color: this._cesium.Color.WHITE,//	optional A Property specifying the Color that blends with the model's rendered color.
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createModelPointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            uri: "",
            show: true, //	optional A boolean Property specifying the visibility of the model.
            scale: 1.0, //optional A numeric Property specifying a uniform linear scale.
            //minimumPixelSize: 128, //	optional A numeric Property specifying the approximate minimum pixel size of the model regardless of zoom.
            //maximumScale: 20000,
            incrementallyLoadTextures: true, //optional Determine if textures may continue to stream in after the model is loaded.
            runAnimations: true, //	optional A boolean Property specifying if glTF animations specified in the model should be started.
            clampAnimations: true, //	optional A boolean Property specifying if glTF animations should hold the last pose for time durations with no keyframes.
            shadows: this._cesium.ShadowMode.ENABLED, //	optional An enum Property specifying whether the model casts or receives shadows from each light source.
            heightReference: this._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
            lightColor: undefined,
            scaleByDistance: new this._cesium.NearFarScalar(0, 0, 1, 1),
            color: this._cesium.Color.WHITE, //	optional A Property specifying the Color that blends with the model's rendered color.
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
        };
        var that = this;
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.color)) {
            if (this._core.isHtmlColor(option.color)) {
                option.color = this._color.colorFromHtmlColor(option.color);
            } else {
                if (/^rgb/.test(option.color)) {
                    option.color = this._color.rgbaStringToRgbaObj(option.color);
                }
                if (option.color.r > 1) {
                    option.color.r = option.color.r / 255;
                }
                if (option.color.g > 1) {
                    option.color.g = option.color.g / 255;
                }
                if (option.color.b > 1) {
                    option.color.b = option.color.b / 255;
                }
                if (option.color.a > 1) {
                    option.color.a = option.color.a / 255;
                }
                option.color = this._color.createColor(option.color.r, option.color.g, option.color.b, option.color.a);
            }
        }

        if (that._core.isnull(option.near)) {
            option.near = 0;
        }
        if (that._core.isnull(option.far)) {
            option.far = 999999999;
        }

        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        this._viewer.dataSources.add(dataSource);

        var time;
        //添加时间段
        if (option && option.time) {
            time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            // var min = parseFloat(option.near);
            // var max = parseFloat(option.far);
            // var distance = new that._cesium.DistanceDisplayCondition(min, max);
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.uri = that._core.extendgl(entity, option.uri, options.uri);
                options.scale = parseFloat(that._core.extendgl(entity, option.scale, options.scale));
                //options.minimumPixelSize = parseInt(that._core.extendgl(entity, option.minimumPixelSize, options.minimumPixelSize));
                //options.maximumScale = parseInt(that._core.extendgl(entity, option.maximumScale, options.maximumScale));
                options.incrementallyLoadTextures = that._core.extendgl(entity, option.incrementallyLoadTextures, options.incrementallyLoadTextures);
                options.runAnimations = that._core.extendgl(entity, option.runAnimations, options.runAnimations);
                options.clampAnimations = that._core.extendgl(entity, option.clampAnimations, options.clampAnimations);
                options.shadows = that._core.extendgl(entity, option.shadows, options.shadows);
                options.heightReference = that._core.extendgl(entity, option.heightReference, options.heightReference);
                options.lightColor = that._core.extendgl(entity, option.lightColor, options.lightColor);
                options.scaleByDistance = that._core.extendgl(entity, option.scaleByDistance, options.scaleByDistance);
                options.color = that._core.extendgl(entity, option.color, options.color);
                if (options.height)
                    options.height = parseFloat(that._core.extendgl(entity, option.height, options.height));
                else
                    options.height = undefined;
                var min = parseFloat(that._core.extendgl(entity, option.near, options.near));
                var max = parseFloat(that._core.extendgl(entity, option.far, options.far));
                //图例
                var col = "color:" + options.color.red * 255 + "," + options.color.green * 255 + "," + options.color.blue * 255;
                that.Legend.push(col);
                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                options.distanceDisplayCondition = distance;
                //获取数据结束
                entity.billboard = undefined;
                entity.model = new that._cesium.ModelGraphics(options);
                //entity.position._value.z += options.height == null ? 0 : options.height;
                if (options.height) {
                    var cartographic = that._cesium.Cartographic.fromCartesian(entity.position._value);
                    var lon = that._cesium.Math.toDegrees(cartographic.longitude);
                    var lat = that._cesium.Math.toDegrees(cartographic.latitude);
                    entity.position = that._cesium.Cartesian3.fromDegrees(lon, lat, options.height);
                }
                time && (entity.availability = time);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
            if (checked) ; else {
                that.setVisibility(false);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'modelLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": true, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *        Name: "",
            text: "",
            font_size: '30px',
            font_family:'sans-serif'
            stylet: this._cesium.LabelStyle.FILL,
            fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
            outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
            show: true,//	optional A boolean Property specifying the visibility of the label.
            showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
            backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
            near: 0,
            far: 5000
       }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createLabelPointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            Name: "",
            text: "test",
            font: ' 30px sans-serif',
            style: this._cesium.LabelStyle.FILL_AND_OUTLINE,
            fillColor: this._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
            outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
            show: true, //	optional A boolean Property specifying the visibility of the label.
            showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
            backgroundPadding: new this._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.RELATIVE_TO_GROUND, //	optional A Property specifying what the height is relative to.
            scaleByDistance: new this._cesium.NearFarScalar(0, 0, 1, 1),
            pointHeight: 0,
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
        };
        var that = this;
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.fillColor)) {
            if (this._core.isHtmlColor(option.fillColor)) {
                option.fillColor = this._color.colorFromHtmlColor(option.fillColor);
            } else {
                if (/^rgb/.test(option.fillColor)) {
                    option.fillColor = this._color.rgbaStringToRgbaObj(option.fillColor);
                }
                if (option.fillColor.r > 1) {
                    option.fillColor.r = option.fillColor.r / 255;
                }
                if (option.fillColor.g > 1) {
                    option.fillColor.g = option.fillColor.g / 255;
                }
                if (option.fillColor.b > 1) {
                    option.fillColor.b = option.fillColor.b / 255;
                }
                if (option.fillColor.a > 1) {
                    option.fillColor.a = option.fillColor.a / 255;
                }
                option.fillColor = this._color.createColor(option.fillColor.r, option.fillColor.g, option.fillColor.b, option.fillColor.a);
            }
        }
        //边框颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (this._core.isHtmlColor(option.outlineColor)) {
                option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
            } else {
                if (/^rgb/.test(option.outlineColor)) {
                    option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                }
                if (option.outlineColor.r > 1) {
                    option.outlineColor.r = option.outlineColor.r / 255;
                }
                if (option.outlineColor.g > 1) {
                    option.outlineColor.g = option.outlineColor.g / 255;
                }
                if (option.outlineColor.b > 1) {
                    option.outlineColor.b = option.outlineColor.b / 255;
                }
                if (option.outlineColor.a > 1) {
                    option.outlineColor.a = option.outlineColor.a / 255;
                }
                option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
            }
        }
        //背景颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.backgroundColor)) {
            if (this._core.isHtmlColor(option.backgroundColor)) {
                option.backgroundColor = this._color.colorFromHtmlColor(option.backgroundColor);
            } else {
                if (/^rgb/.test(option.backgroundColor)) {
                    option.backgroundColor = this._color.rgbaStringToRgbaObj(option.backgroundColor);
                }
                if (option.backgroundColor.r > 1) {
                    option.backgroundColor.r = option.backgroundColor.r / 255;
                }
                if (option.backgroundColor.g > 1) {
                    option.backgroundColor.g = option.backgroundColor.g / 255;
                }
                if (option.backgroundColor.b > 1) {
                    option.backgroundColor.b = option.backgroundColor.b / 255;
                }
                if (option.backgroundColor.a > 1) {
                    option.backgroundColor.a = option.backgroundColor.a / 255;
                }
                option.backgroundColor = this._color.createColor(option.backgroundColor.r, option.backgroundColor.g, option.backgroundColor.b, option.backgroundColor.a);
            }
        }

        if (that._core.isnull(option.near)) {
            option.near = 0;
        }
        if (that._core.isnull(option.far)) {
            option.far = 999999999;
        }

        var time;
        //添加时间段
        if (option && option.time) {
            time = new this._cesium.TimeIntervalCollection([new this._cesium.TimeInterval({
                start: option.time.start ? this._cesium.JulianDate.fromDate(new Date(option.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? this._cesium.JulianDate.fromDate(new Date(option.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        this._viewer.dataSources.add(dataSource);
        var that = this;
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;

            // var min = parseFloat(options.near);
            // var max = parseFloat(options.far);
            // var distance = new that._cesium.DistanceDisplayCondition(min, max);
            // options.distanceDisplayCondition = distance;
            if (that._core.isnull(options.font_size)) {
                options.font_size = "30px";
            }
            if (that._core.isnull(options.font_family)) {
                options.font_family = " sans-serif";
            }
            //options.font = option.font_size + " " + option.font_family;
            if (options.font_size.toString().indexOf('px') == -1) {
                options.font = options.font_size + "px " + options.font_family;
            } else {
                options.font = options.font_size + " " + options.font_family;
            }
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.font = that._core.extendgl(entity, option.font, options.font);
                options.style = parseInt(that._core.extendgl(entity, options.style, options.style));
                options.fillColor = that._core.extendgl(entity, option.fillColor, options.fillColor);
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.showBackground = that._core.extendgl(entity, option.showBackground, options.showBackground);
                options.backgroundColor = that._core.extendgl(entity, option.backgroundColor, options.backgroundColor);
                options.backgroundPadding = that._core.extendgl(entity, option.backgroundPadding, options.backgroundPadding);
                options.scale = parseFloat(that._core.extendgl(entity, option.scale, options.scale));
                options.horizontalOrigin = that._core.extendgl(entity, option.horizontalOrigin, options.horizontalOrigin);
                options.pointHeight = parseFloat(that._core.extendgl(entity, option.pointHeight, options.pointHeight));
                options.text = that._core.extendgl(entity, option.text, options.text).toString();
                var min = parseFloat(that._core.extendgl(entity, options.near));
                var max = parseFloat(that._core.extendgl(entity, options.far));
                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                options.distanceDisplayCondition = distance;
                //获取数据结束
                //判断是否是公告栏
                if (options.image != undefined && options.image != null && options.image.length > 0) {
                    entity.billboard.image = options.image;
                    entity.billboard.scale = options.scale;
                    entity.billboard.color = options.fillColor;
                    entity.billboard.verticalOrigin = options.verticalOrigin;
                    entity.billboard.horizontalOrigin = options.horizontalOrigin;
                    entity.billboard.disableDepthTestDistance = options.disableDepthTestDistance;
                    entity.billboard.heightReference = options.heightReference;
                    //entity.billboard.heightReference = 2;
                    entity.billboard.distanceDisplayCondition = options.distanceDisplayCondition;
                } else if (options.layertype == "ellipsoidlayer") {
                    entity.billboard = undefined;
                    entity.name = name;
                    var ellipsoid = {
                        //name: option.name,
                        show: true,
                        radii: new that._cesium.Cartesian3(options.long_axis, options.short_axis, options.long_axis),
                        material: that._cesium.Color.fromRandom({
                            alpha: 1.0
                        })
                    };
                    entity.ellipsoid = new that._cesium.EllipsoidGraphics(ellipsoid);
                    entity.ellipsoid.heightReference = options.heightReference;
                    //entity.ellipsoid.radii= new that._cesium.Cartesian3(option.long_axis, option.short_axis, option.long_axis);
                    entity.ellipsoid.material = url;
                } else {
                    entity.billboard = undefined;
                    var labels = {
                        Name: options.Name,
                        text: options.text,
                        font: options.font,
                        style: options.stylet,
                        fillColor: options.fillColor,
                        outlineColor: options.outlineColor,
                        outlineWidth: options.outlineWidth,
                        show: options.show,
                        showBackground: options.showBackground,
                        backgroundColor: options.backgroundColor,
                        backgroundPadding: options.backgroundPadding,
                        scale: options.scale,
                        horizontalOrigin: options.horizontalOrigin,
                        verticalOrigin: options.verticalOrigin,
                        eyeOffset: options.eyeOffset,
                        pixelOffset: options.pixelOffset,
                        heightReference: options.heightReference,
                        distanceDisplayCondition: options.distanceDisplayCondition,
                        scaleByDistance: options.scaleByDistance
                    };
                    //图例
                    var col = "fillColor:" + options.fillColor.red * 255 + "," + options.fillColor.green * 255 + "," + options.fillColor.blue * 255 +
                        ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                    that.Legend.push(col);
                    entity.label = new that._cesium.LabelGraphics(labels);
                    //entity.label.text = entity.properties[options.text] == null ? options.text : entity.properties[options.text]._value;
                    //entity.position._value.z += options.pointHeight;
                    time && (entity.availability = time);
                }
                //坐标转化
                var ellipsoid = that._viewer.scene.globe.ellipsoid;
                var scartographic = that._cesium.Cartographic.fromCartesian(entity.position._value);
                var slongitude = that._cesium.Math.toDegrees(scartographic.longitude);
                var slatitude = that._cesium.Math.toDegrees(scartographic.latitude);
                var sheight = scartographic.height + options.pointHeight; //

                var posit = new that._cesium.Cartesian3.fromDegrees(slongitude, slatitude, sheight);
                //var cartographics = that._cesium.Cartographic.fromDegrees(that._cesium.Math.toDegrees(cartograhphic.latitude), that._cesium.Math.toDegrees(cartograhpinc.longitude), cartographic.height + options.pointHeight);
                //var posit = ellipsoid.cartographicToCartesian(cartographics);
                //var posit = that._cesium.Cartographic(cartograhphic.latitude, cartograhpinc.longitude, cartographic.height + options.pointHeight);

                entity.position._value = posit;

                //数据修改i
                var id = {
                    positions: posit
                };
                entity.description = id;
                //entity.position._value.z += options.pointHeight;
            }
            if (checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建街景" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'labelPointLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    GeoJsonFeatureLayer.prototype.createStreetscapeGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            positions: [],
            arcType: this._cesium.ArcType.GEODESIC, //	optional The type of line the polyline segments must follow.
            clampToGround: true, //optional A boolean Property specifying whether the Polyline should be clamped to the ground.
            width: 1.0, //optional A numeric Property specifying the width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the polyline.
            material: this._cesium.Color.RED, //	optional A Property specifying the material used to draw the polyline.
            height: 30,
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
        };
        var that = this;
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else if (option.material.toString().charAt(0) == "(" && option.material.toString().charAt(option.material.length - 1) == ")") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }

                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);

                }
                //设置虚线
                if (option.arcType == '1' || option.arcType == 1) {
                    option.material = new Cesium.PolylineDashMaterialProperty({
                        color: option.material
                    });
                } else {
                    option.material = option.material;
                }
            }
        }
        if (that._core.isnull(option.near)) {
            option.near = 0;
        }
        if (that._core.isnull(option.far)) {
            option.far = 999999999;
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        this._viewer.dataSources.add(dataSource, {
            camera: this._viewer.scene.camera,
            canvas: this._viewer.scene.canvas,
            clampToGround: true
        });

        var time;
        //添加时间段
        if (option && option.time) {
            time = new this._cesium.TimeIntervalCollection([new this._cesium.TimeInterval({
                start: option.time.start ? this._cesium.JulianDate.fromDate(new Date(option.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? this._cesium.JulianDate.fromDate(new Date(option.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.arcType = that._core.extendgl(entity, option.arcType, options.arcType);
                options.clampToGround = that._core.extendgl(entity, option.clampToGround, options.clampToGround);
                options.width = parseFloat(that._core.extendgl(entity, option.width, options.width));
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.material = that._core.extendgl(entity, option.material, options.material);
                options.height = parseFloat(that._core.extendgl(entity, option.height, options.height));

                var min = parseFloat(that._core.extendgl(entity, options.near));
                var max = parseFloat(that._core.extendgl(entity, options.far));

                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                options.distanceDisplayCondition = distance;
                //获取数据结束
                //获取点
                //var positions = [];
                //var heights = [];
                //var ps = entity.polyline.positions.getValue();
                //var ellipsoid = that._viewer.scene.globe.ellipsoid;
                //for (var i = 0; i < ps.length; i++) {
                //    var cartesian3 = new that._cesium.Cartesian3(ps[i].x, ps[i].y, ps[i].z);
                //    var cartographic = ellipsoid.cartesianToCartographic(cartesian3);
                //    var lat = that._cesium.Math.toDegrees(cartographic.latitude);
                //    var lng = that._cesium.Math.toDegrees(cartographic.longitude);
                //    positions.push(lng);
                //    positions.push(lat);
                //    heights.push(height);
                //}
                //var positionsrt = that._cesium.Cartesian3.fromDegreesArray(positions);
                //entity.billboard = undefined;
                entity.polyline.arcType = true;
                if (options.heightReference == 0) {
                    entity.polyline.arcType = 0;
                } else {
                    entity.polyline.arcType = 1;
                }
                //entity.polyline.arcType = options.arcType;
                entity.polyline.clampToGround = options.clampToGround;
                entity.polyline.width = options.width;
                entity.polyline.height = options.height;
                entity.polyline.show = options.show;
                entity.polyline.material = options.material;
                entity.polyline.distanceDisplayCondition = distance;
                var path = [];
                var cartographic, lon, lat;
                entity.polyline.positions._value.forEach(function (item) {
                    if (options.height) {
                        cartographic = that._cesium.Cartographic.fromCartesian(item);
                        lon = that._cesium.Math.toDegrees(cartographic.longitude);
                        lat = that._cesium.Math.toDegrees(cartographic.latitude);
                        path.push(that._cesium.Cartesian3.fromDegrees(lon, lat, options.height));
                    } else {
                        path.push(item);
                    }
                });
                entity.polyline.positions = path;

                time && (entity.availability = time);
                //图例
                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                that.Legend.push(col);
            }
            if (checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建街景" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'Streetscape',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建circleGeofeaturelayer街景
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *        Name: "",
            text: "",
            font_size: '30px',
            font_family:'sans-serif'
            stylet: this._cesium.LabelStyle.FILL,
            fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
            outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
            show: true,//	optional A boolean Property specifying the visibility of the label.
            showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
            backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
            near: 0,
            far: 5000
       }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createEllipsoidlayerPointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var defaultOptions = {
            Name: "",
            text: "",
            font: ' 30px sans-serif',
            style: this._cesium.LabelStyle.OUTLINE,
            fillColor: this._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
            outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
            show: true, //	optional A boolean Property specifying the visibility of the label.
            showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
            backgroundPadding: new this._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
            scaleByDistance: new this._cesium.NearFarScalar(0, 0, 1, 1)
        };

        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.fillColor)) {
            if (option.fillColor.toString().charAt(0) == "[" && option.fillColor.toString().charAt(option.fillColor.length - 1) == "]") ; else if (option.material.toString().charAt(0) == "(" && option.material.toString().charAt(option.material.length - 1) == ")") ; else {
                if (this._core.isHtmlColor(option.fillColor)) {
                    option.fillColor = this._color.colorFromHtmlColor(option.fillColor);
                } else {
                    if (/^rgb/.test(option.fillColor)) {
                        option.fillColor = this._color.rgbaStringToRgbaObj(option.fillColor);
                    }
                    if (option.fillColor.r > 1) {
                        option.fillColor.r = option.fillColor.r / 255;
                    }
                    if (option.fillColor.g > 1) {
                        option.fillColor.g = option.fillColor.g / 255;
                    }
                    if (option.fillColor.b > 1) {
                        option.fillColor.b = option.fillColor.b / 255;
                    }
                    if (option.fillColor.a > 1) {
                        option.fillColor.a = option.fillColor.a / 255;
                    }
                    option.fillColor = this._color.createColor(option.fillColor.r, option.fillColor.g, option.fillColor.b, option.fillColor.a);
                }
            }
        }
        //边框颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (option.outlineColor.toString().charAt(0) == "[" && option.outlineColor.toString().charAt(option.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.outlineColor)) {
                    option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
                } else {
                    if (/^rgb/.test(option.outlineColor)) {
                        option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                    }
                    if (option.outlineColor.r > 1) {
                        option.outlineColor.r = option.outlineColor.r / 255;
                    }
                    if (option.outlineColor.g > 1) {
                        option.outlineColor.g = option.outlineColor.g / 255;
                    }
                    if (option.outlineColor.b > 1) {
                        option.outlineColor.b = option.outlineColor.b / 255;
                    }
                    if (option.outlineColor.a > 1) {
                        option.outlineColor.a = option.outlineColor.a / 255;
                    }
                    option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
                }
            }
        }
        //背景颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.backgroundColor)) {
            if (option.backgroundColor.toString().charAt(0) == "[" && option.backgroundColor.toString().charAt(option.backgroundColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.backgroundColor)) {
                    option.backgroundColor = this._color.colorFromHtmlColor(option.backgroundColor);
                } else {
                    if (/^rgb/.test(option.backgroundColor)) {
                        option.backgroundColor = this._color.rgbaStringToRgbaObj(option.backgroundColor);
                    }
                    if (option.backgroundColor.r > 1) {
                        option.backgroundColor.r = option.backgroundColor.r / 255;
                    }
                    if (option.backgroundColor.g > 1) {
                        option.backgroundColor.g = option.backgroundColor.g / 255;
                    }
                    if (option.backgroundColor.b > 1) {
                        option.backgroundColor.b = option.backgroundColor.b / 255;
                    }
                    if (option.backgroundColor.a > 1) {
                        option.backgroundColor.a = option.backgroundColor.a / 255;
                    }
                    option.backgroundColor = this._color.createColor(option.backgroundColor.r, option.backgroundColor.g, option.backgroundColor.b, option.backgroundColor.a);
                }
            }
        }
        if (that._core.isnull(option.near)) {
            option.near = 0;
        }
        if (that._core.isnull(option.far)) {
            option.far = 999999999;
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        this._viewer.dataSources.add(dataSource);
        var that = this;
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;

            // var min = parseFloat(option.near);
            // var max = parseFloat(option.far);
            // var distance = new that._cesium.DistanceDisplayCondition(min, max);
            // options.distanceDisplayCondition = distance;
            if (that._core.isnull(option.font_size)) {
                option.font_size = "30px";
            }
            if (that._core.isnull(option.font_family)) {
                option.font_family = " sans-serif";
            }
            //options.font = option.font_size + " " + option.font_family;
            options.font = option.font_size + "px " + option.font_family;
            for (var i = 0; i < entities.length; i++) {
                //获取数据开始
                options.text = that._core.extendgl(entity, option.text, options.text);
                options.font = that._core.extendgl(entity, option.font, options.font);
                options.stylet = that._core.extendgl(entity, option.stylet, options.stylet);
                options.fillColor = that._core.extendgl(entity, option.fillColor, options.fillColor);
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.showBackground = that._core.extendgl(entity, option.showBackground, options.showBackground);
                options.backgroundColor = that._core.extendgl(entity, option.backgroundColor, options.backgroundColor);
                options.backgroundPadding = that._core.extendgl(entity, option.backgroundPadding, options.backgroundPadding);
                options.scale = parseFloat(that._core.extendgl(entity, option.scale, options.scale));
                options.horizontalOrigin = that._core.extendgl(entity, option.horizontalOrigin, options.horizontalOrigin);
                options.pointheight = parseFloat(that._core.extendgl(entity, option.pointheight, options.pointheight));
                var min = parseFloat(that._core.extendgl(entity, options.near));
                var max = parseFloat(that._core.extendgl(entity, options.far));
                //图例
                var col = "fillColor:" + options.fillColor.red * 255 + "," + options.fillColor.green * 255 + "," + options.fillColor.blue * 255 +
                    ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                that.Legend.push(col);
                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                options.distanceDisplayCondition = distance;
                //获取数据结束
                entity.ellipsoid.radii = new _this._cesium.Cartesian3(option.long_axis, option.short_axis, option.short_axis),
                    entity.label = new that._cesium.LabelGraphics(options);
                entity.label.text = entity.properties[option.text] == null ? option.text : entity.properties[option.text]._value;
                if (options.pointheight) {
                    var cartographic = that._cesium.Cartographic.fromCartesian(entity.position._value);
                    var lon = that._cesium.Math.toDegrees(cartographic.longitude);
                    var lat = that._cesium.Math.toDegrees(cartographic.latitude);
                    entity.position = that._cesium.Cartesian3.fromDegrees(lon, lat, options.pointheight);
                }
                //entity.position._value.z += option.pointheight == null ? 0 : option.pointheight;
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'pointLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": true, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *      image: "",//	Property		optional A Property specifying the Image, URI, or Canvas to use for the billboard.
           show: true,//	optional A boolean Property specifying the visibility of the billboard.
           scale: 1.0,//optional A numeric Property specifying the scale to apply to the image size.
           horizontalOrigin: this._cesium.HorizontalOrigin.CENTER,//	optional A Property specifying the HorizontalOrigin.
           verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
           eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
           pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
           rotation: 0,//	optional A numeric Property specifying the rotation about the alignedAxis.
           alignedAxis: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the unit vector axis of rotation.
           width: undefined,//		optional A numeric Property specifying the width of the billboard in pixels, overriding the native size.
           height: undefined,//		optional A numeric Property specifying the height of the billboard in pixels, overriding the native size.
           color: this._cesium.Color.WHITE,//	optional A Property specifying the tint Color of the image.
           heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
      }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createBillboardGeoJsonFeature = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            image: "", //	Property		optional A Property specifying the Image, URI, or Canvas to use for the billboard.
            show: true, //	optional A boolean Property specifying the visibility of the billboard.
            scale: 1.0, //optional A numeric Property specifying the scale to apply to the image size.
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //	optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
            rotation: 0, //	optional A numeric Property specifying the rotation about the alignedAxis.
            alignedAxis: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the unit vector axis of rotation.
            width: 2, //		optional A numeric Property specifying the width of the billboard in pixels, overriding the native size.
            height: undefined, //		optional A numeric Property specifying the height of the billboard in pixels, overriding the native size.
            color: this._cesium.Color.WHITE, //	optional A Property specifying the tint Color of the image.
            heightReference: this._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
            scaleByDistance: new this._cesium.NearFarScalar(0, 0, 1, 1)
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.color)) {
            if (option.color.toString().charAt(0) == "[" && option.color.toString().charAt(option.color.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.color)) {
                    option.color = this._color.colorFromHtmlColor(option.color);
                } else {
                    if (/^rgb/.test(option.color)) {
                        option.color = this._color.rgbaStringToRgbaObj(option.color);
                    }
                    if (option.color.r > 1) {
                        option.color.r = option.color.r / 255;
                    }
                    if (option.color.g > 1) {
                        option.color.g = option.color.g / 255;
                    }
                    if (option.color.b > 1) {
                        option.color.b = option.color.b / 255;
                    }
                    if (option.color.a > 1) {
                        option.color.a = option.color.a / 255;
                    }
                    option.color = this._color.createColor(option.color.r, option.color.g, option.color.b, option.color.a);
                }
            }
        }



        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        this._viewer.dataSources.add(dataSource);
        var that = this;
        if (that._core.isnull(option.near)) {
            option.near = 0;
        }
        if (that._core.isnull(option.far)) {
            option.far = 999999999;
        }

        var time;
        //添加时间段
        if (option && option.time) {
            time = new this._cesium.TimeIntervalCollection([new this._cesium.TimeInterval({
                start: option.time.start ? this._cesium.JulianDate.fromDate(new Date(option.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? this._cesium.JulianDate.fromDate(new Date(option.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            // var min = parseFloat(option.near);
            // var max = parseFloat(option.far);
            // var distance = new that._cesium.DistanceDisplayCondition(min, max);
            // options.distanceDisplayCondition = distance;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.image = that._core.extendgl(entity, option.image, options.image);
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.scale = parseFloat(that._core.extendgl(entity, option.scale, options.scale));
                options.horizontalOrigin = that._core.extendgl(entity, option.horizontalOrigin, options.horizontalOrigin);
                options.verticalOrigin = that._core.extendgl(entity, option.verticalOrigin, options.verticalOrigin);
                options.eyeOffset = that._core.extendgl(entity, option.eyeOffset, options.eyeOffset);
                options.pixelOffset = that._core.extendgl(entity, option.pixelOffset, options.pixelOffset);
                options.alignedAxis = that._core.extendgl(entity, option.alignedAxis, options.alignedAxis);
                options.rotation = that._core.extendgl(entity, option.rotation, options.rotation);
                if (options.width)
                    options.width = parseFloat(that._core.extendgl(entity, option.width, options.width));
                else
                    options.width = undefined;
                if (options.height)
                    options.height = parseFloat(that._core.extendgl(entity, option.height, options.height));
                else
                    options.height = undefined;
                options.color = that._core.extendgl(entity, option.color, options.color);
                //图例
                var col = "color:" + options.color.red * 255 + "," + options.color.green * 255 + "," + options.color.blue * 255 + ';image:' + options.image;
                that.Legend.push(col);
                var min = parseFloat(that._core.extendgl(entity, options.near));
                var max = parseFloat(that._core.extendgl(entity, options.far));

                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                options.distanceDisplayCondition = distance;
                //获取数据结束
                entity.billboard = undefined;
                entity.billboard = new that._cesium.BillboardGraphics(options);
                //数据修改i
                that._viewer.scene.globe.ellipsoid;
                var scartographic = that._cesium.Cartographic.fromCartesian(entity.position._value);
                var slongitude = that._cesium.Math.toDegrees(scartographic.longitude);
                var slatitude = that._cesium.Math.toDegrees(scartographic.latitude);
                if (option.pointHeight)
                    var sheight = option.pointHeight; //
                else var sheight = scartographic.height;
                var posit = new that._cesium.Cartesian3.fromDegrees(slongitude, slatitude, sheight);
                entity.position._value = posit;
                var id = {
                    positions: posit
                };
                entity.description = id;

                time && (entity.availability = time);
            }
            if (checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        var treeobj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'imageLayer',
            item: this,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(treeobj);
        this._tree.insertGroupId(treeobj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建PolylineGeoJsonFeatureLayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *     positions: [],
            arcType: this._cesium.ArcType.GEODESIC,//	optional The type of line the polyline segments must follow.
            clampToGround: false,//optional A boolean Property specifying whether the Polyline should be clamped to the ground.
            width: 1.0,//optional A numeric Property specifying the width in pixels.
            show: true,//	optional A boolean Property specifying the visibility of the polyline.
            material: this._cesium.Color.WHITE,//	optional A Property specifying the material used to draw the polyline.
            near: 0,
            far: 5000,
          }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createPolylineGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            positions: [],
            arcType: this._cesium.ArcType.GEODESIC, //	optional The type of line the polyline segments must follow.
            clampToGround: true, //optional A boolean Property specifying whether the Polyline should be clamped to the ground.
            width: 1.0, //optional A numeric Property specifying the width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the polyline.
            material: this._cesium.Color.WHITE, //	optional A Property specifying the material used to draw the polyline.
            height: 30,
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
        };
        var that = this;
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else if (option.material.toString().charAt(0) == "(" && option.material.toString().charAt(option.material.length - 1) == ")") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        if (that._core.isnull(option.near)) {
            option.near = 0;
        }
        if (that._core.isnull(option.far)) {
            option.far = 999999999;
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        this._viewer.dataSources.add(dataSource, {
            camera: this._viewer.scene.camera,
            canvas: this._viewer.scene.canvas,
            clampToGround: true
        });
        var time;
        //添加时间段
        if (option && option.time) {
            time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            // var min = parseFloat(option.near);
            // var max = parseFloat(option.far);
            // var distance = new that._cesium.DistanceDisplayCondition(min, max);
            // options.distanceDisplayCondition = distance;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.arcType = that._core.extendgl(entity, option.arcType, options.arcType);
                options.clampToGround = that._core.extendgl(entity, option.clampToGround, options.clampToGround);
                options.width = parseFloat(that._core.extendgl(entity, option.width, options.width));
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.material = that._core.extendgl(entity, option.material, options.material);
                options.height = parseFloat(that._core.extendgl(entity, option.height, options.height));

                var min = parseFloat(that._core.extendgl(entity, options.near));
                var max = parseFloat(that._core.extendgl(entity, options.far));

                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                options.distanceDisplayCondition = distance;
                that._viewer.scene.globe.ellipsoid;
                if (options.heightReference != 1) {
                    entity.polyline.arcType = false;
                } else {
                    entity.polyline.arcType = true;
                }
                // entity.polyline.clampToGround = options.clampToGround;
                entity.polyline.width = options.width;
                //entity.polyline.height = options.height;
                entity.polyline.show = options.show;
                entity.polyline.material = options.material;
                entity.polyline.distanceDisplayCondition = distance;
                time && (entity.availability = time);
                //图例
                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                that.Legend.push(col);
            }
            //if (checked == "false") {
            //    that.setVisibility(false);
            //}
            if (checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *     show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createpolylineVolumeGeojsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
            radius: 0.5, //半径
            radiusScale: 1, //半径比例
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else if (option.material.toString().charAt(0) == "(" && option.material.toString().charAt(option.material.length - 1) == ")") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        this._viewer.dataSources.add(dataSource);
        var that = this;
        options.shape = this.computeCircle(option.radius);
        var time;
        //添加时间段
        if (option && option.time) {
            time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            if (that._core.isnull(option.near)) {
                option.near = 0;
            }
            if (that._core.isnull(option.far)) {
                option.far = 999999999;
            }
            var min = parseFloat(option.near);
            var max = parseFloat(option.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            if (typeof options.radius === 'string' && options.radius.indexOf('[') > -1 && options.radius.indexOf(']') > -1) {
                let radius;
                options.radius = options.radius.replace('[', '');
                options.radius = options.radius.replace(']', '');
                if (entities[0] && entities[0].properties[options.radius]) {
                    radius = entities[0].properties[options.radius].getValue();
                    if (radius.indexOf && (radius.indexOf('*') > -1 || radius.indexOf('x') > -1 || radius.indexOf('X') > -1)) {
                        if (radius.indexOf('*') > -1) {
                            radius = radius.split('*');
                        } else if (radius.indexOf('X') > -1) {
                            radius = radius.split('X');
                        } else if (radius.indexOf('x') > -1) {
                            radius = radius.split('x');
                        }
                        var x = parseFloat(radius[0]) * options.radiusScale;
                        var y = parseFloat(radius[1]) * options.radiusScale;
                        options.shape = [new that._cesium.Cartesian2(-x, -y),
                        new that._cesium.Cartesian2(x, -y),
                        new that._cesium.Cartesian2(x, y),
                        new that._cesium.Cartesian2(-x, y)
                        ];
                    } else {
                        options.shape = that._core.computeCircle(radius * options.radiusScale);
                    }
                } else {
                    options.shape = that._core.computeCircle(0.5);
                }
            } else {
                if (options.slttype == "0" || options.slttype == 0) {
                    options.shape = that._core.computeCircle(options.radius);
                } else if (options.slttype == "1" || options.slttype == 1) {
                    options.shape = that._core.starPositions(options.number, options.exradius, options.inradius);
                } else if (options.slttype == "2" || options.slttype == 2) {
                    var x = options.orth_width / 2;
                    var y = options.orth_height / 2;
                    options.shape = [new that._cesium.Cartesian2(-x, -y),
                    new that._cesium.Cartesian2(x, -y),
                    new that._cesium.Cartesian2(x, y),
                    new that._cesium.Cartesian2(-x, y)
                    ];
                }
            }
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.shape = that._core.extendgl(entity, option.shape, options.shape);
                options.cornerType = that._core.extendgl(entity, option.cornerType, options.cornerType);
                options.granularity = that._core.extendgl(entity, option.granularity, options.granularity);
                options.fill = that._core.extendgl(entity, option.fill, options.fill);
                options.material = that._core.extendgl(entity, option.material, options.material);
                options.outline = that._core.extendgl(entity, option.outline, options.outline);
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.shadows = that._core.extendgl(entity, option.shadows, options.shadows);
                var path = [];
                var cartographic, lon, lat;
                entity.polyline.positions._value.forEach(function (item) {
                    if (options.height) {
                        cartographic = that._cesium.Cartographic.fromCartesian(item);
                        lon = that._cesium.Math.toDegrees(cartographic.longitude);
                        lat = that._cesium.Math.toDegrees(cartographic.latitude);
                        path.push(that._cesium.Cartesian3.fromDegrees(lon, lat, options.height));
                    } else {
                        path.push(item);
                    }
                });
                //获取数据结束
                entity.polylineVolume = new that._cesium.PolylineVolumeGraphics({
                    positions: path,
                    show: options.show,
                    shape: options.shape,
                    cornerType: options.cornerType,
                    fill: options.fill,
                    outline: options.outline,
                    outlineWidth: options.outlineWidth,
                    material: options.material,
                    distanceDisplayCondition: distance
                });
                //图例
                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                that.Legend.push(col);
                entity.polyline = undefined;
                time && (entity.availability = time);
            }
            //if (checked == "false") {
            //    that.setVisibility(false);
            //}
            if (checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建管状图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineVolumeLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建管线-primitive
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *     show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createpolylineVolumeGeojsonPrimitiveLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
            radius: 0.5, //半径
            height: 0,
            radiusScale: 1, //半径比例
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else if (option.material.toString().charAt(0) == "(" && option.material.toString().charAt(option.material.length - 1) == ")") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        var that = this;
        //添加时间段
        if (option && option.time) {
            new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        let collection = new Cesium.PrimitiveCollection();
        let geomeOption = {
            allowPicking: true,
            appearance: new that._cesium.PerInstanceColorAppearance({
                translucent: false,
                vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
            }),
            shadows: options.shadows,
            geometryInstances: undefined
        };
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            debugger
            var entities = dataSource.entities.values;
            if (that._core.isnull(option.near)) {
                option.near = 0;
            }
            if (that._core.isnull(option.far)) {
                option.far = 999999999;
            }
            var min = parseFloat(option.near);
            var max = parseFloat(option.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            if (typeof options.radius === 'string' && options.radius.indexOf('[') > -1 && options.radius.indexOf(']') > -1) {
                let radius;
                options.radius = options.radius.replace('[', '');
                options.radius = options.radius.replace(']', '');
                if (entities[0] && entities[0].properties[options.radius]) {
                    radius = entities[0].properties[options.radius].getValue();
                    if (radius.indexOf && (radius.indexOf('*') > -1 || radius.indexOf('x') > -1 || radius.indexOf('X') > -1)) {
                        if (radius.indexOf('*') > -1) {
                            radius = radius.split('*');
                        } else if (radius.indexOf('X') > -1) {
                            radius = radius.split('X');
                        } else if (radius.indexOf('x') > -1) {
                            radius = radius.split('x');
                        }
                        var x = parseFloat(radius[0]) * options.radiusScale;
                        var y = parseFloat(radius[1]) * options.radiusScale;
                        options.shape = [new that._cesium.Cartesian2(-x, -y),
                        new that._cesium.Cartesian2(x, -y),
                        new that._cesium.Cartesian2(x, y),
                        new that._cesium.Cartesian2(-x, y)
                        ];
                        options.radius = y;
                    } else {
                        options.shape = that._core.computeCircle(radius * options.radiusScale);
                        if (options.connect) {
                            options.connectRadius = radius * options.radiusScale * 1.1;
                            options.connectRadius2 = radius * options.radiusScale * 1.2;
                            options.connectShape1 = that._core.computeCircle(options.connectRadius);
                            options.connectShape2 = that._core.computeCircle(options.connectRadius2);
                        }
                        options.radius = radius * options.radiusScale;
                    }
                } else {
                    options.shape = that._core.computeCircle(0.5);
                    options.radius = 0.5;
                    if (options.connect) {
                        options.connectRadius = options.radius * 1.1;
                        options.connectRadius2 = options.radius * 1.2;
                        options.connectShape1 = that._core.computeCircle(options.connectRadius);
                        options.connectShape2 = that._core.computeCircle(options.connectRadius2);
                    }
                }
            } else {
                if (options.slttype == "0" || options.slttype == 0) {
                    options.shape = that._core.computeCircle(options.radius);
                    if (options.connect) {
                        options.connectRadius = options.radius * 1.1;
                        options.connectRadius2 = options.radius * 1.2;
                        options.connectShape1 = that._core.computeCircle(options.connectRadius);
                        options.connectShape2 = that._core.computeCircle(options.connectRadius2);
                    }
                } else if (options.slttype == "1" || options.slttype == 1) {
                    options.shape = that._core.starPositions(options.number, options.exradius, options.inradius);
                } else if (options.slttype == "2" || options.slttype == 2) {
                    var x = options.orth_width / 2;
                    var y = options.orth_height / 2;
                    options.shape = [new that._cesium.Cartesian2(-x, -y),
                    new that._cesium.Cartesian2(x, -y),
                    new that._cesium.Cartesian2(x, y),
                    new that._cesium.Cartesian2(-x, y)
                    ];
                    options.radius = y;
                }
            }

            //获取数据开始
            options.show = that._core.extendgl(entities[0], option.show, options.show);
            options.shape = that._core.extendgl(entities[0], option.shape, options.shape);
            options.cornerType = that._core.extendgl(entities[0], option.cornerType, options.cornerType);
            options.granularity = that._core.extendgl(entities[0], option.granularity, options.granularity);
            options.fill = that._core.extendgl(entities[0], option.fill, options.fill);
            options.material = that._core.extendgl(entities[0], option.material, options.material);
            options.outline = that._core.extendgl(entities[0], option.outline, options.outline);
            options.outlineColor = that._core.extendgl(entities[0], option.outlineColor, options.outlineColor);
            options.outlineWidth = parseFloat(that._core.extendgl(entities[0], option.outlineWidth, options.outlineWidth));
            options.shadows = that._core.extendgl(entities[0], option.shadows, options.shadows);

            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                addPolylineVolume(entity);
            }

            that._viewer.scene.primitives.add(collection);
            that.item = collection;

            if (checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(collection);
            }
        });

        async function addConnect(entity, path) {
            let connect = [];
            // let startConnectP1 = that._core.getPointFromTwoPointCenter([path[0], path[1]], options.connectRadius * 2, options.height - options.connectRadius);
            // let startConnectP2 = that._core.getPointFromTwoPointCenter([path[0], path[1]], options.connectRadius2 * 2, options.height - options.connectRadius2);
            // let endConnectP1 = that._core.getPointFromTwoPointCenter([path[path.length - 1], path[path.length - 2]], options.connectRadius * 2, options.height - options.connectRadius);
            // let endConnectP2 = that._core.getPointFromTwoPointCenter([path[path.length - 1], path[path.length - 2]], options.connectRadius2 * 2, options.height - options.connectRadius2);
            //宁波修改
            if (path.length <= 1) {
                return;
            }
            let height1 = options.height - options.connectRadius;
            let height2 = options.height - options.connectRadius2;
            let startConnectP1 = that._core.getPointFromTwoPointCenter([path[0], path[1]], options.connectRadius * 2, height1);
            let startConnectP2 = that._core.getPointFromTwoPointCenter([path[0], path[1]], options.connectRadius2 * 2, height2);
            let endConnectP1 = that._core.getPointFromTwoPointCenter([path[path.length - 1], path[path.length - 2]], options.connectRadius * 2, height1);
            let endConnectP2 = that._core.getPointFromTwoPointCenter([path[path.length - 1], path[path.length - 2]], options.connectRadius2 * 2, height2);

            if (path[0].x == path[1].x && path[2]) {
                startConnectP1 = that._core.getPointFromTwoPointCenter([path[0], path[2]], options.connectRadius * 2, height1);
                startConnectP2 = that._core.getPointFromTwoPointCenter([path[0], path[2]], options.connectRadius2 * 2, height2);
            }
            if (path[path.length - 1].x == path[path.length - 2].x && path[path.length - 3]) {
                endConnectP1 = that._core.getPointFromTwoPointCenter([path[path.length - 1], path[path.length - 3]], options.connectRadius * 2, height1);
                endConnectP2 = that._core.getPointFromTwoPointCenter([path[path.length - 1], path[path.length - 3]], options.connectRadius2 * 2, height2);
            }

            let startConnect1 = new that._cesium.PolylineVolumeGeometry({
                polylinePositions: [path[0], startConnectP1],
                shapePositions: options.connectShape1,
                cornerType: options.cornerType,
                VertexFormat: {
                    bitangent: true,
                    color: true,
                    position: true,
                    st: true,
                    normal: true,
                    tangent: true
                }
            });
            connect.push(startConnect1);
            let startConnect2 = new that._cesium.PolylineVolumeGeometry({
                polylinePositions: [startConnectP1, startConnectP2],
                shapePositions: options.connectShape2,
                cornerType: options.cornerType,
                VertexFormat: {
                    bitangent: true,
                    color: true,
                    position: true,
                    st: true,
                    normal: true,
                    tangent: true
                }
            });
            connect.push(startConnect2);

            let endConnect1 = new that._cesium.PolylineVolumeGeometry({
                polylinePositions: [path[path.length - 1], endConnectP1],
                shapePositions: options.connectShape1,
                cornerType: options.cornerType,
                VertexFormat: {
                    bitangent: true,
                    color: true,
                    position: true,
                    st: true,
                    normal: true,
                    tangent: true
                }
            });
            connect.push(endConnect1);
            let endConnect2 = new that._cesium.PolylineVolumeGeometry({
                polylinePositions: [endConnectP1, endConnectP2],
                shapePositions: options.connectShape2,
                cornerType: options.cornerType,
                VertexFormat: {
                    bitangent: true,
                    color: true,
                    position: true,
                    st: true,
                    normal: true,
                    tangent: true
                }
            });
            connect.push(endConnect2);

            let connectGeometryInstance = [];
            connect.forEach(item => {
                let _geome = new that._cesium.GeometryInstance({
                    id: entity,
                    geometry: item,
                    attributes: {
                        color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                    }
                });
                connectGeometryInstance.push(_geome);
            });

            let q = new Cesium.EllipsoidGeometry({
                vertexFormat: {
                    bitangent: true,
                    color: true,
                    position: true,
                    st: true,
                    normal: true,
                    tangent: true
                },
                stackPartitions: 16,
                slicePartitions: 16,
                radii: new Cesium.Cartesian3(options.connectRadius, options.connectRadius, options.connectRadius)
            });
            let q1Instance = new Cesium.GeometryInstance({
                geometry: q,
                modelMatrix: Cesium.Matrix4.multiplyByTranslation(
                    Cesium.Transforms.eastNorthUpToFixedFrame(path[0]),
                    new Cesium.Cartesian3(0.0, 0.0, options.connectRadius),
                    new Cesium.Matrix4()
                ),
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(options.material)
                }
            });
            connectGeometryInstance.push(q1Instance);

            let q2Instance = new Cesium.GeometryInstance({
                geometry: q,
                modelMatrix: Cesium.Matrix4.multiplyByTranslation(
                    Cesium.Transforms.eastNorthUpToFixedFrame(path[path.length - 1]),
                    new Cesium.Cartesian3(0.0, 0.0, options.connectRadius),
                    new Cesium.Matrix4()
                ),
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(options.material)
                }
            });
            connectGeometryInstance.push(q2Instance);

            geomeOption.geometryInstances = connectGeometryInstance;
            collection.add(new that._cesium.Primitive(geomeOption));
        }

        async function addPolylineVolume(entity) {
            var path = [];
            var cartographic, lon, lat;
            entity.polyline && entity.polyline.positions._value.forEach(function (item) {
                if (options.height) {
                    cartographic = that._cesium.Cartographic.fromCartesian(item);
                    lon = that._cesium.Math.toDegrees(cartographic.longitude);
                    lat = that._cesium.Math.toDegrees(cartographic.latitude);
                    path.push(that._cesium.Cartesian3.fromDegrees(lon, lat, options.height - options.radius));
                } else {
                    path.push(item);
                }
            });
            entity.polyline = undefined;

            var dx = {
                polylinePositions: path,
                shapePositions: options.shape,
                cornerType: options.cornerType,
                VertexFormat: {
                    bitangent: true,
                    color: true,
                    position: true,
                    st: true,
                    normal: true,
                    tangent: true
                }
            };
            var volime = new that._cesium.PolylineVolumeGeometry(dx);

            var geome = new that._cesium.GeometryInstance({
                id: entity,
                geometry: volime,
                attributes: {
                    color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                }
            });
            geomeOption.geometryInstances = geome;
            collection.add(new that._cesium.Primitive(geomeOption));

            if (options.connect && path.length > 1) {
                addConnect(entity, path);
            }

            //图例
            var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
            that.Legend.push(col);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建管状图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineVolumeLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 生成管状数据
     * @param {Float} radians
     */
    GeoJsonFeatureLayer.prototype.computeCircle = function (radius) {
        if (this._core.isnull(radius)) {
            radius = 4;
        }
        var positions = [];
        for (var i = 0; i < 360; i++) {
            var radians = Cesium.Math.toRadians(i);
            positions.push(new this._cesium.Cartesian2(radius * Math.cos(radians), radius * Math.sin(radians)));
        }
        return positions;
    };
    /**
     * 创建墙图层 *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *       show: true, // optional A boolean Property specifying the visibility of the wall.
        positions: [], // optional A Property specifying the array of Cartesian3 positions which define the top of the wall.
        minimumHeights: [], // optional A Property specifying an array of heights to be used for the bottom of the wall instead of the globe surface.
        maximumHeights: [], // optional A Property specifying an array of heights to be used for the top of the wall instead of the height of each position.
        granularity: Cesium.Math.RADIANS_PER_DEGREE, // optional A numeric Property specifying the angular distance between each latitude and longitude point.
        fill: true, // optional A boolean Property specifying whether the wall is filled with the provided material.
        material: Color.WHITE, // optional A Property specifying the material used to fill the wall.
        outline: false, // optional A boolean Property specifying whether the wall is outlined.
        outlineColor: Color.BLACK, // optional A Property specifying the Color of the outline.
        outlineWidth: 1.0, // optional A numeric Property specifying the width of the outline.
        shadows: ShadowMode.DISABLED, // optional An enum Property specifying whether the wall casts or receives shadows from each light source.
    }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createWallGeoFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            // show: true, // optional A boolean Property specifying the visibility of the wall.
            positions: [], // optional A Property specifying the array of Cartesian3 positions which define the top of the wall.
            minimumHeights: [], // optional A Property specifying an array of heights to be used for the bottom of the wall instead of the globe surface.
            maximumHeights: [], // optional A Property specifying an array of heights to be used for the top of the wall instead of the height of each position.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, // optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, // optional A boolean Property specifying whether the wall is filled with the provided material.
            material: this._cesium.Color.WHITE, // optional A Property specifying the material used to fill the wall.
            outline: false, // optional A boolean Property specifying whether the wall is outlined.
            outlineColor: this._cesium.Color.BLACK, // optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, // optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, // optional An enum Property specifying whether the wall casts or receives shadows from each light source.
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (option.outlineColor.toString().charAt(0) == "[" && option.outlineColor.toString().charAt(option.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.outlineColor)) {
                    option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
                } else {
                    if (/^rgb/.test(option.outlineColor)) {
                        option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                    }
                    if (option.outlineColor.r > 1) {
                        option.outlineColor.r = option.outlineColor.r / 255;
                    }
                    if (option.outlineColor.g > 1) {
                        option.outlineColor.g = option.outlineColor.g / 255;
                    }
                    if (option.outlineColor.b > 1) {
                        option.outlineColor.b = option.outlineColor.b / 255;
                    }
                    if (option.outlineColor.a > 1) {
                        option.outlineColor.a = option.outlineColor.a / 255;
                    }
                    option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        this._viewer.dataSources.add(dataSource);
        var that = this;
        var time;
        //添加时间段
        if (option && option.time) {
            time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            if (that._core.isnull(option.near)) {
                option.near = 0;
            }
            if (that._core.isnull(option.far)) {
                option.far = 999999999;
            }
            var min = parseFloat(option.near);
            var max = parseFloat(option.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.granularity = that._core.extendgl(entity, option.granularity, options.granularity);
                options.fill = that._core.extendgl(entity, option.fill, options.fill);
                options.material = that._core.extendgl(entity, option.material, options.material);
                options.outline = that._core.extendgl(entity, option.outline, options.outline);
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.shadows = that._core.extendgl(entity, option.shadows, options.shadows);
                //获取数据结束
                var l = entity.polyline.positions._value.length;
                var minimumHeights = new Array(l);
                var maximumHeights = new Array(l);
                minimumHeights.fill(options.minimumHeights);
                maximumHeights.fill(options.maximumHeights);
                // options.minimumHeights = minimumHeights;
                // options.maximumHeights = maximumHeights;
                // options.positions = entity.polyline.positions._value
                entity.wall = new that._cesium.WallGraphics({
                    positions: entity.polyline.positions._value,
                    maximumHeights: maximumHeights,
                    minimumHeights: minimumHeights,
                    outline: options.outline,
                    fill: options.fill,
                    material: options.material,
                    outlineColor: options.outlineColor,
                    outlineWidth: options.outlineWidth,
                    shadows: options.shadows,
                    distanceDisplayCondition: distance
                });
                //图例
                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255 +
                    ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                that.Legend.push(col);
                entity.polyline = undefined;
                time && (entity.availability = time);
            }
            //if (checked == "false") {
            //    that.setVisibility(false);
            //}
            if (checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建墙图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineWallLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    //影像加载
    //GeoJsonFeatureLayer.prototype.createImageryProvider = function (name, type, option, GroupID, index, checked, disFnc) {
    //    var defaultOptions = {
    //        url: 'https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer',
    //    };
    //    var options = this._core.extend(defaultOptions, option, true);
    //    var de;
    //    if (type == "arcgis") {
    //        de = new this._cesium.ArcGisMapServerImageryProvider(options);
    //    } else if (type == "geoserver") {
    //        de = new this._cesium.WebMapServiceImageryProvider(options);
    //    } else if (type == "cesiumserver") {} else if (type == "skymap") {
    //        de = new this._cesium.WebMapTileServiceImageryProvider(options);
    //    } else if (type == "goglemap") {
    //        de = new this._cesium.UrlTemplateImageryProvider(options);
    //    }
    //    //de = new this._cesium.WebMapTileServiceImageryProvider(options);
    //    //this._viewer.imageryLayers.addImageryProvider(de);
    //    this.item = this._viewer.imageryLayers.addImageryProvider(de, index);
    //    if (checked == "false") {
    //        this.setVisibility(false);
    //    }
    //    if (typeof disFnc == 'function') {
    //        disFnc(dataSource);
    //    }
    //    if (this._core.isnull(options.id)) {
    //        options.id = this._core.getuid();
    //    }
    //    this._tree.insertGroupId({
    //        id: options.id,
    //        name: name,
    //        pId: this._core.isnull(GroupID) ? 0 : GroupID,
    //        type: 'ImageryProvider',
    //        //checked:false,
    //        item: this
    //    }, this._core.isnull(GroupID) ? 0 : GroupID);
    //    return this;
    //}
    //地形加载
    GeoJsonFeatureLayer.prototype.createterrainProvider = function (name, option, GroupID, disFnc) {
        var defaultOptions = {
            url: 'https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer',
        };
        var options = this._core.extend(defaultOptions, option, true);
        var terrainProvider = new this._cesium.CesiumTerrainProvider(options);
        //this._viewer.imageryLayers.addImageryProvider(de);
        this._viewer.terrainProvider = terrainProvider;
        this.item = terrainProvider;
        if (typeof disFnc == 'function') {
            disFnc(dataSource);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        this._tree.insertGroupId({
            id: options.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'terrainProvider',
            item: this
        }, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建PolylineGeoJsonFeatureLayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *     height: 0,//	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
            extrudedHeight: 0,//		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
            heightReference: this._cesium.HeightReference.NONE,//		optional A Property specifying what the extrudedHeight is relative to.
            show: true,//	optional A boolean Property specifying the visibility of the polygon.
            fill: true,//	optional A boolean Property specifying whether the polygon is filled with the provided material.
            material: this._cesium.Color.WHITE,//optional A Property specifying the material used to fill the polygon.
            outline: false,//optional A boolean Property specifying whether the polygon is outlined.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the Color of the outline.
            outlineWidth: 1.0,//optional A numeric Property specifying the width of the outline.
            stRotation: 0.0,//	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE,//	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            perPositionHeight: false,	//optional A boolean specifying whether or not the the height of each position is used.
            closeTop: true,	//optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true,//	optional When false, leaves off the bottom of an extruded polygon open.
            shadows: this._cesium.ShadowMode.DISABLED,//	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
            near: 0,
            far: 5000
          }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createPolygonGeoJsonFeatureLayers = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            height: 0, //	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
            extrudedHeight: 0, //		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
            heightReference: this._cesium.HeightReference.NONE, //		optional A Property specifying what the extrudedHeight is relative to.
            show: true, //	optional A boolean Property specifying the visibility of the polygon.
            fill: true, //	optional A boolean Property specifying whether the polygon is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional A Property specifying the material used to fill the polygon.
            outline: false, //optional A boolean Property specifying whether the polygon is outlined.
            outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            stRotation: 0.0, //	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            perPositionHeight: false, //optional A boolean specifying whether or not the the height of each position is used.
            closeTop: true, //optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //	optional When false, leaves off the bottom of an extruded polygon open.
            shadows: this._cesium.ShadowMode.ENABLED, //Cesium.ShadowMode.ENABLED	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
            clampToGround: true,
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else if (option.material.toString().charAt(0) == "(" && option.material.toString().charAt(option.material.length - 1) == ")") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (option.outlineColor.toString().charAt(0) == "[" && option.outlineColor.toString().charAt(option.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.outlineColor)) {
                    option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
                } else {
                    if (/^rgb/.test(option.outlineColor)) {
                        option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                    }
                    if (option.outlineColor.r > 1) {
                        option.outlineColor.r = option.outlineColor.r / 255;
                    }
                    if (option.outlineColor.g > 1) {
                        option.outlineColor.g = option.outlineColor.g / 255;
                    }
                    if (option.outlineColor.b > 1) {
                        option.outlineColor.b = option.outlineColor.b / 255;
                    }
                    if (option.outlineColor.a > 1) {
                        option.outlineColor.a = option.outlineColor.a / 255;
                    }
                    option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
                }
            }
        }
        option.checked = checked;
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        this._viewer.dataSources.add(dataSource);
        var that = this;
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            if (that._core.isnull(option.near)) {
                option.near = 0;
            }
            if (that._core.isnull(option.far)) {
                option.far = 999999999;
            }
            var min = parseFloat(option.near);
            var max = parseFloat(option.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.height = parseFloat(that._core.extendgl(entity, option.height, options.height));
                options.extrudedHeight = parseFloat(that._core.extendgl(entity, option.extrudedHeight, options.extrudedHeight));
                options.heightReference = that._core.extendgl(entity, option.heightReference, options.heightReference);
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.fill = that._core.extendgl(entity, option.fill, options.fill);
                options.material = that._core.extendgl(entity, option.material, options.material);
                options.outline = that._core.extendgl(entity, option.outline, options.outline);
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.stRotation = parseInt(that._core.extendgl(entity, option.stRotation, options.stRotation));
                options.granularity = that._core.extendgl(entity, option.granularity, options.granularity);

                options.shadows = that._core.extendgl(entity, option.shadows, options.shadows);
                //获取数据结束
                //entity.billboard = undefined;
                entity.polygon.height = options.height;
                entity.polygon.extrudedHeight = options.extrudedHeight;
                entity.polygon.heightReference = options.heightReference;
                entity.polygon.show = options.show;
                entity.polygon.fill = options.fill;
                entity.polygon.material = options.material;
                entity.polygon.outline = options.outline;
                entity.polygon.outlineColor = options.outlineColor;
                entity.polygon.outlineWidth = options.outlineWidth;
                entity.polygon.stRotation = options.stRotation;
                entity.polygon.granularity = options.granularity;
                entity.polygon.distanceDisplayCondition = distance;
                entity.polygon.perPositionHeight = options.perPositionHeight;
                entity.polygon.closeTop = options.closeTop;
                entity.polygon.closeBottom = options.closeBottom;
                entity.polygon.shadows = options.shadows;
                //图例
                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255 +
                    ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                that.Legend.push(col);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
            //if (option.checked == "false") {
            //    that.setVisibility(false);
            //}
            if (option.checked) ; else {
                that.setVisibility(false);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建PolylineGeoJsonFeatureLayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *     height: 0,//	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
        extrudedHeight: 0,//		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
        heightReference: this._cesium.HeightReference.NONE,//		optional A Property specifying what the extrudedHeight is relative to.
        show: true,//	optional A boolean Property specifying the visibility of the polygon.
        fill: true,//	optional A boolean Property specifying whether the polygon is filled with the provided material.
        material: this._cesium.Color.WHITE,//optional A Property specifying the material used to fill the polygon.
        outline: false,//optional A boolean Property specifying whether the polygon is outlined.
        outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the Color of the outline.
        outlineWidth: 1.0,//optional A numeric Property specifying the width of the outline.
        stRotation: 0.0,//	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
        granularity: this._cesium.Math.RADIANS_PER_DEGREE,//	optional A numeric Property specifying the angular distance between each latitude and longitude point.
        perPositionHeight: false,	//optional A boolean specifying whether or not the the height of each position is used.
        closeTop: true,	//optional When false, leaves off the top of an extruded polygon open.
        closeBottom: true,//	optional When false, leaves off the bottom of an extruded polygon open.
        shadows: this._cesium.ShadowMode.DISABLED,//	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
        near: 0,
        far: 5000
      }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createPolygonGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            height: 0, //	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
            //extrudedHeight: 0, //		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
            //heightReference: this._cesium.HeightReference.CLAMP_TO_GROUND, //		optional A Property specifying what the extrudedHeight is relative to.
            show: true, //	optional A boolean Property specifying the visibility of the polygon.
            fill: true, //	optional A boolean Property specifying whether the polygon is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional A Property specifying the material used to fill the polygon.
            outline: false, //optional A boolean Property specifying whether the polygon is outlined.
            outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            stRotation: 0.0, //	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
            // granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            // perPositionHeight: false, //optional A boolean specifying whether or not the the height of each position is used.
            // closeTop: true, //optional When false, leaves off the top of an extruded polygon open.
            // closeBottom: true, //	optional When false, leaves off the bottom of an extruded polygon open.
            shadows: this._cesium.ShadowMode.ENABLED, //	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
            clampToGround: true,
            classificationType: this._cesium.ClassificationType.BOTH,
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.indexOf("type") != -1) {
                if (option.material.type == "checker") {
                    option.material = new this._cesium.CheckerboardMaterialProperty({
                        evenColor: option.material.evenColor,
                        oddColor: option.material.oddColor,
                        repeat: option.material.repeat
                    });
                } else if (option.material.type == "stripe") {
                    option.material = new this._cesium.StripeMaterialProperty({
                        evenColor: option.material.evenColor,
                        oddColor: option.material.oddColor,
                        repeat: option.material.repeat,
                        offset: option.material.repeat,
                        orientation: option.material.repeat
                    });
                } else if (option.material.type == "grid") {
                    option.material = new this._cesium.GridMaterialProperty({
                        color: option.material.color,
                        cellAlpha: option.material.cellAlpha,
                        lineCount: option.material.lineCount,
                        lineThickness: option.material.lineThickness
                    });
                }
            } else if (this._core.isHtmlColor(option.material)) {
                option.material = this._color.colorFromHtmlColor(option.material);
            } else if (option.material.indexOf("[") != -1) ; else if (option.material.toString().charAt(0) == "(" && option.material.toString().charAt(option.material.length - 1) == ")") ; else {
                if (/^rgb/.test(option.material)) {
                    option.material = this._color.rgbaStringToRgbaObj(option.material);
                }
                if (option.material.r > 1) {
                    option.material.r = option.material.r / 255;
                }
                if (option.material.g > 1) {
                    option.material.g = option.material.g / 255;
                }
                if (option.material.b > 1) {
                    option.material.b = option.material.b / 255;
                }
                if (option.material.a > 1) {
                    option.material.a = option.material.a / 255;
                }
                option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
            }
        }
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (this._core.isHtmlColor(option.outlineColor)) {
                option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
            } else {
                if (/^rgb/.test(option.outlineColor)) {
                    option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                }
                if (option.outlineColor.r > 1) {
                    option.outlineColor.r = option.outlineColor.r / 255;
                }
                if (option.outlineColor.g > 1) {
                    option.outlineColor.g = option.outlineColor.g / 255;
                }
                if (option.outlineColor.b > 1) {
                    option.outlineColor.b = option.outlineColor.b / 255;
                }
                if (option.outlineColor.a > 1) {
                    option.outlineColor.a = option.outlineColor.a / 255;
                }
                option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        option.checked = checked;
        //修改
        //options.heightReference = this._cesium.HeightReference.CLAMP_TO_GROUND;
        var op = {
            clampToGround: true
        };
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl, op);
        }
        this._viewer.dataSources.add(dataSource);
        var that = this;
        var time;
        //添加时间段
        if (option && option.time) {
            time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            if (that._core.isnull(option.near)) {
                option.near = 0;
            }
            if (that._core.isnull(option.far)) {
                option.far = 999999999;
            }
            var min = parseFloat(option.near);
            var max = parseFloat(option.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            //options.classificationType = that._cesium.ClassificationType.BOTH;
            //var extrudedHeightReference = that._cesium.HeightReference.RELATIVE_TO_GROUND;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.height = parseFloat(that._core.extendgl(entity, option.height, options.height));
                options.height !== options.height && (options.height = undefined);
                options.extrudedHeight = that._core.extendgl(entity, option.extrudedHeight, options.extrudedHeight);
                options.heightReference = that._core.extendgl(entity, option.heightReference, options.heightReference);
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.fill = that._core.extendgl(entity, option.fill, options.fill);
                options.material = that._core.extendgl(entity, option.material, options.material);
                options.extrudedHeight !== undefined && (options.extrudedHeight = parseFloat(options.extrudedHeight));
                //填充颜色设置
                //if (that._core.isHtmlColor(options.material)) {
                //    options.material = that._color.colorFromHtmlColor(options.material);
                //} else {
                //    if (/^rgb/.test(options.material)) {
                //        options.material = that._color.rgbaStringToRgbaObj(options.material);
                //    }
                //    if (options.material.r > 1) {
                //        options.material.r = options.material.r / 255;
                //    }
                //    if (options.material.g > 1) {
                //        options.material.g = options.material.g / 255;
                //    }
                //    if (options.material.b > 1) {
                //        options.material.b = options.material.b / 255;
                //    }
                //    if (options.material.a > 1) {
                //        options.material.a = options.material.a / 255;
                //    }
                //    options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                //}
                options.outline = that._core.extendgl(entity, option.outline, options.outline);
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.stRotation = that._core.extendgl(entity, option.stRotation, options.stRotation);
                options.granularity = that._core.extendgl(entity, option.granularity, options.granularity);
                options.distanceDisplayCondition = that._core.extendgl(entity, option.distanceDisplayCondition, options.distanceDisplayCondition);
                options.perPositionHeight = that._core.extendgl(entity, option.perPositionHeight, options.perPositionHeight);
                options.closeTop = that._core.extendgl(entity, option.closeTop, options.closeTop);
                options.closeBottom = that._core.extendgl(entity, option.closeBottom, options.closeBottom);
                options.shadows = that._core.extendgl(entity, option.shadows, options.shadows);
                options.classificationType = that._core.extendgl(entity, option.classificationType, options.classificationType);
                //获取数据结束

                entity.polygon._hierarchy._value.positions;
                //entity.billboard = undefined;
                //entity.polygon.height = options.height;
                entity.polygon.extrudedHeightReference = options.extrudedHeightReference;
                //entity.polygon.extrudedHeightReference = that._cesium.HeightReference.RELATIVE_TO_GROUND;
                entity.polygon.heightReference = options.heightReference;
                if (options.heightReference != 1) {
                    entity.polygon.height = options.height;
                    options.height && (entity.polygon.perPositionHeight = false);
                }
                if (options.extrudedHeightReference != 1) {
                    entity.polygon.extrudedHeight = options.extrudedHeight;
                }
                entity.polygon.show = options.show;
                entity.polygon.fill = options.fill;
                entity.polygon.material = options.material;
                entity.polygon.outline = options.outline;
                entity.polygon.outlineColor = options.outlineColor;
                entity.polygon.outlineWidth = options.outlineWidth;
                entity.polygon.stRotation = options.stRotation;
                entity.polygon.granularity = options.granularity;
                entity.polygon.distanceDisplayCondition = distance;
                //entity.polygon.perPositionHeight = options.perPositionHeight;
                entity.polygon.closeTop = options.closeTop;
                entity.polygon.closeBottom = options.closeBottom;
                entity.polygon.shadows = options.shadows;
                entity.polygon.classificationType = options.classificationType;
                //图例
                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255 +
                    ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                that.Legend.push(col);
                // //数据修改i
                // var id = {
                //     positions: pos
                // };
                // entity.description = id;
                time && (entity.availability = time);
            }
            if (option.checked) {
                that.isShow = true;
            } else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建geofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    GeoJsonFeatureLayer.prototype.createGeoJsonDataSource = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl, option);
        this._viewer.dataSources.add(dataSource);
        var that = this;
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        this._tree.insertGroupId({
            id: this._core.getuid(),
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'layer',
            item: this
        }, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 删除geofeature图层
     */
    GeoJsonFeatureLayer.prototype.deleteObject = function () {
        this._viewer.dataSources.remove(this.item);
    };
    /**
     * 获取层级
     */
    GeoJsonFeatureLayer.prototype.getLevel = function () {
        var A = 40487.57;
        var B = 0.00007096758;
        var C = 91610.74;
        var D = -40467.74;

        var camera = this._viewer.camera,
            height, level;
        if (camera && camera.positionCartographic && camera.positionCartographic.height) {
            var groundHeightAtCameraPosition = this._viewer.scene.globe.getHeight(camera.positionCartographic);
            !groundHeightAtCameraPosition && (groundHeightAtCameraPosition = 0);
            height = camera.positionCartographic.height - groundHeightAtCameraPosition;
            level = Math.round(D + (A - D) / (1 + Math.pow(height / C, B)));
        } else {
            level = 0;
        }
        return level;
    };
    /**
     * 导出工程数据
     */
    GeoJsonFeatureLayer.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url
            },
            treeData: this.treeobj.treeData
        };
    };
    /**
     * 设置geo featurelayer的显示隐藏
     * @param {boolean} [b] true|false
     */
    GeoJsonFeatureLayer.prototype.setVisibility = function (b) {
        this.isShow = b;
        if (this.item != undefined) {
            this.item.show = b;
        }
    };
    /**
     * 获取geo featurelayer的显示隐藏状态
     * @param {Object} [label] label对象
     * @param {Float} [width] 透明度 0-1
     * @returns {Object} 返回一个Label对象。
     */
    GeoJsonFeatureLayer.prototype.getVisibility = function () {
        return this.item.show;
    };
    /**
     * 获取图层属性元素信息
     * @returns {Array} 返回‘["innerid", "stroke-height", "stroke-opacity", "id", "stroke-width", "fill", "stroke", "fill-opacity"]’
     */
    GeoJsonFeatureLayer.prototype.getProperties = function () {
        var props = [];
        if (this.item.entities.values) {
            var entity = this.item.entities.values[0];
            if (entity.properties) {
                for (var i = 0; i < entity.properties.propertyNames.length; i++) {
                    props.push({
                        value: "[" + entity.properties.propertyNames[i] + "]",
                        label: entity.properties.propertyNames[i]
                    });
                }
            }
        }
        return props;
    };
    /**
     * 获取当前的图层类型
     * @returns {Array} 返回‘[ { label: "文本标签", value: "labellayer" },
     { label: "图片标签", value: "billboardlayer" },
     { label: "点标签", value: "pointlayer" },
     { label: "模型", value: "modellayer" },
     { label: "圆", value: "circlelayer" }]’
     */
    GeoJsonFeatureLayer.prototype.getTypes = function () {
        if (this.item.entities.values) {
            var dataSourceItem0 = this.item.entities.values[0];
            if (/^point.fid/.test(dataSourceItem0._id) || dataSourceItem0.point != undefined) {
                return [{
                    label: "文本标签",
                    value: "labelLayer"
                },
                {
                    label: "图片标签",
                    value: "billboardLayer"
                },
                {
                    label: "点标签",
                    value: "pointLayer"
                },
                {
                    label: "模型",
                    value: "modelLayer"
                },
                {
                    label: "圆",
                    value: "circleLayer"
                }
                ];
            } else if (/^polygon.fid/.test(dataSourceItem0._id) || dataSourceItem0.polygon != undefined) {
                return [{
                    label: "面",
                    value: "polygonLayer"
                }];
            } else if (/^line.fid/.test(dataSourceItem0._id) || dataSourceItem0.polyline != undefined) {
                return [{
                    label: "线",
                    value: "polylineLayer"
                },];
            }
        }
    };
    /**
     * 当前图层加载类型
     *
     */
    GeoJsonFeatureLayer.prototype.getType = function () {
        if (this.item.entities.values) {
            var dataSourceItem0 = this.item.entities.values[0];
            //if (/^point.fid/.test(dataSourceItem0._id) || dataSourceItem0.point != undefined) {
            if (dataSourceItem0.label != undefined && dataSourceItem0.label.show) {
                return {
                    label: "文本标签",
                    value: "labelLayer"
                };
            } else if (dataSourceItem0.model != undefined && dataSourceItem0.model.show) {
                return {
                    label: "模型",
                    value: "modelLayer"
                };
            } else if (dataSourceItem0.billboard != undefined && dataSourceItem0.billboard.show) {
                return {
                    label: "图片标签",
                    value: "billboardLayer"
                };
            } else if (dataSourceItem0.ellipse != undefined && dataSourceItem0.ellipse.show) {

                return {
                    label: "圆",
                    value: "circleLayer"
                };
            } else if (/^polygon.fid/.test(dataSourceItem0._id) || dataSourceItem0.polygon != undefined) {
                return {
                    label: "面",
                    value: "polygonLayer"
                };
            } else if (/^line.fid/.test(dataSourceItem0._id) || dataSourceItem0.polyline != undefined) {
                return {
                    label: "线",
                    value: "polylineLayer"
                };
            } else if (dataSourceItem0.polylineVolume != undefined && dataSourceItem0.polylineVolume.show) {
                return {
                    label: "扫掠体",
                    value: "polylineVolume"
                };
            } else if (dataSourceItem0.wall != undefined && dataSourceItem0.wall != null) {
                return {
                    label: "墙",
                    value: "polylineWall"
                };
            }
            return {
                label: "点标签",
                value: "pointLayer"
            };
            //}
        }
    };
    ////图例
    //var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255
    //+ ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
    //that.Legend.push(col);

    /**
     * 返回图例
     * @returns {object}
     */
    GeoJsonFeatureLayer.prototype.getLegend = function () {
        var legend = [];
        if (this.Legend != null) {
            legend = this._core.unique(this.Legend);
        }
        return legend;
    };
    /**
     * 获取当前的图层数据集的第一条
     * @returns {object}
     */
    GeoJsonFeatureLayer.prototype.getFirstDataSourceItem = function () {
        if (this.item.entities.values) {
            var dataSourceItem0 = this.item.entities.values[0];
            return dataSourceItem0;
        }
        return undefined;
    };

    //工程树添加
    GeoJsonFeatureLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    GeoJsonFeatureLayer.prototype.setItem = function (item) {
        this.item = item;
    };

    Object.defineProperties(GeoJsonFeatureLayer.prototype, {
        /**
         * 设置geojson图层的显示文本
         * @memberof GeoJsonFeatureLayer.prototype
         *
         * @type {*}
         * @param {String}  text [text]
         */
        labelText: {
            set: lodash.debounce(function (text) {
                var text1 = text;
                if (this._core.isnull(text)) return;
                var entities = this.item.entities.values;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(text)) {
                            text1 = text.replace(/\[/, '').replace(/\]/, '');
                            text1 = entities[i].properties[text1]._value;
                        }
                        if (!entities[i].label) {
                            try {
                                entities[i].point.show = false;
                            } catch (ex) { }
                            entities[i].label = new this._cesium.LabelGraphics({
                                text: text1,
                                font: '30px sans-serif',
                                style: this._cesium.LabelStyle.FILL,
                                fillColor: this._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                                outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                                show: true, //	optional A boolean Property specifying the visibility of the label.
                                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                                backgroundColor: new this._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                                backgroundPadding: new this._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                heightReference: this._cesium.HeightReference.NONE //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            entities[i].label.text = text1;
                            try {
                                entities[i].point.show = false;
                            } catch (ex) { }
                        }
                    }
                }
            }, 500)
        },
        /**
         * 设置geojson图层显示文本的样式
         * @param {object} labelStyle
         */
        labelStyles: {
            set: lodash.debounce(function (labelStyle) {
                if (this._core.isnull(labelStyle)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.style = labelStyle;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return entities[0].label.style;
                }
            }
        },
        labelFont: {
            set: lodash.debounce(function (font_family) {
                if (this._core.isnull(font_family)) return;
                var entities = this.item.entities.values;
                font_family = font_family.toString().replace(/px/g, '');
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                var font = entities[0].label.font;
                var font_size = 16;
                if (font) {
                    font = font._value.trimLeft().trimRight();
                    font_size = font.split('px')[0];
                }
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.font = font_size + "px " + font_family;
                    }
                }
            }, 500)
        },

        /**
         * 设置geojson图层显示文本的样式
         * @param {Float} fontsize
         */
        labelFontSize1: {
            set: lodash.debounce(function (fontsize) {
                if (this._core.isnull(fontsize)) return;
                var entities = this.item.entities.values;
                fontsize = fontsize.toString().replace(/px/g, '');
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                var font = entities[0].label.font;
                var font_family = 'sans-serif';
                if (font) {
                    font = font._value.trimLeft().trimRight();
                    font_family = font.split('px')[1];
                }
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.font = fontsize + "px  " + font_family;
                    }
                }
            }, 500)
        },
        /**
         * 设置geojson图层显示文本的样式
         * @param {Float} fontsize
         */
        labelFontSize: {
            set: lodash.debounce(function (fontsize) {
                if (this._core.isnull(fontsize)) return;
                var entities = this.item.entities.values;
                fontsize = fontsize.toString().replace(/px/g, '');
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.font = fontsize + "px  sans-serif";
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return parseFloat(entities[0].label.font);
                }
            }
        },
        /**
         * 设置geojson图层显示文本的填充色
         * @param {object} color
         */
        labelFillColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.fillColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var color = entities[0].label.fillColor;
                    return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            }
        },
        /**
         * 设置geojson图层显示文本边框的填充色
         * @param {object} color
         */
        labelOutlineColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.outlineColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var color = entities[0].label.outlineColor;
                    try {
                        return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置geojson图层显示文本边框的宽度
         * @param {Float} width [width]
         */
        labelOutlineWidth: {
            set: lodash.debounce(function (width) {
                if (this._core.isnull(width)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(width)) {
                            width = width.replace(/\[/, '').replace(/\]/, '');
                            width = entities[i].properties[width];
                        }
                        entities[i].label.outlineWidth = width;
                    }
                }
            }, 200),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var width = entities[0].label.outlineWidth;
                    if (width) {
                        return width._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的背景色
         * @param {object} color
         */
        labelBackgroundColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.backgroundColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var color = entities[0].label.backgroundColor;
                    return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            }
        },
        /**
         * 设置geojson图层显示文本是否显示背景色
         * @param {boolean} b
         */
        labelBackground: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.showBackground = b;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return entities[0].label.background;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的大小
         * @param {Float} scale [scale]
         */
        labelScale: {
            set: lodash.debounce(function (scale) {
                if (this._core.isnull(scale)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(scale)) {
                            scale = scale.replace(/\[/, '').replace(/\]/, '');
                            scale = entities[i].properties[scale];
                        }
                        entities[i].label.scale = scale;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var scale = entities[0].label.scale;
                    if (scale) {
                        return scale._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的水平布局方式
         * @param {object} horizontalOrigin
         */
        labelHorizontalOrigin: {
            set: lodash.debounce(function (horizontalOrigin) {
                if (this._core.isnull(horizontalOrigin)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.horizontalOrigin = parseInt(horizontalOrigin);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var horizontalOrigin = entities[0].label.horizontalOrigin;
                    if (horizontalOrigin)
                        return horizontalOrigin._value;
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的水平布局方式
         * @param {object} verticalOrigin
         */
        labelVerticalOrigin: {
            set: lodash.debounce(function (verticalOrigin) {
                if (this._core.isnull(verticalOrigin)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.verticalOrigin = parseInt(verticalOrigin);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var verticalOrigin = entities[0].label.verticalOrigin;
                    if (verticalOrigin)
                        return verticalOrigin._value;
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的高度类型
         * @param {object} verticalOrigin
         */
        labelHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var heightReference = entities[0].label.heightReference;
                    if (heightReference)
                        return heightReference._value;
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的最大可视距离
         * @param {Float} far
         */
        labelDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var near = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, parseInt(far));
                        entities[i].label.scaleByDistance = new this._cesium.NearFarScalar(near, 1, parseInt(far), 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var far = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    return far;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的最小可视距离
         * @param {Float} near
         */
        labelDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var far = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(parseInt(near), far);
                        entities[i].label.scaleByDistance = new this._cesium.NearFarScalar(parseInt(near), 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var near = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         *
         *
         */
        labelHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude);
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude);
                // var height=this._cesium.Math.toDegrees( Cartographic.height);
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        },
        /**
         * 设置geojson图层的label显示隐藏
         *
         *
         */
        labelShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id)) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].label && b) {
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                            entities[i].label = new this._cesium.LabelGraphics({
                                text: "label",
                                font: '30px sans-serif',
                                style: this._cesium.LabelStyle.FILL,
                                fillColor: this._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                                outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                                show: true, //	optional A boolean Property specifying the visibility of the label.
                                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                                backgroundColor: new this._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                                backgroundPadding: new this._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                heightReference: this._cesium.HeightReference.NONE //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            if (entities[i].label)
                                entities[i].label.show = b;

                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return entities[0].label.show;
                }
            }
        },

        /**
         * 设置位置点的颜色
         * @param {object} color
         */
        pointColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.color = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var fillColor = entities[0].point.color;
                    try {
                        return this._color.toHtmlColor('rgb(' + fillColor._value.red * 255 + ',' + fillColor._value.green * 255 + ',' + fillColor._value.blue * 255 + ',' + fillColor._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置位置点的颜色
         * @param {boolean} b
         */
        pointShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id) ) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].point && b) {
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                            entities[i].point = new this._cesium.PointGraphics({
                                color: this._cesium.Color.WHITE, //	optional A Property specifying the Color of the point.
                                pixelSize: 1, //optional A numeric Property specifying the size in pixels.
                                outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the Color of the outline.
                                outlineWidth: 0, //	optional A numeric Property specifying the the outline width in pixels.
                                show: true //	optional A boolean Property specifying the visibility of the point.
                            });
                        } else {
                            if (entities[i].point)
                                entities[i].point.show = b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    return entities[0].point.show;
                }
            }
        },
        /**
         * 设置位置点的大小
         * @param {Float} pixelSize [pixelSize]
         */
        pointPixelSize: {
            set: lodash.debounce(function (pixelSize) {
                if (this._core.isnull(pixelSize)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(pixelSize)) {
                            pixelSize = pixelSize.replace(/\[/, '').replace(/\]/, '');
                            pixelSize = entities[i].properties[pixelSize];
                        }
                        entities[i].point.pixelSize = pixelSize;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var pixelSize = entities[0].point.pixelSize;
                    if (pixelSize) {
                        return pixelSize._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置点的边框颜色
         * @param {object} color
         */
        pointOutlineColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.outlineColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var outlineColor = entities[0].point.outlineColor;
                    try {
                        return this._color.toHtmlColor('rgb(' + outlineColor._value.red * 255 + ',' + outlineColor._value.green * 255 + ',' + outlineColor._value.blue * 255 + ',' + outlineColor._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置点的边框宽度
         * @param {Float} width [width]
         */
        pointOutlineWidth: {
            set: lodash.debounce(function (width) {
                if (this._core.isnull(width)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(width)) {
                            width = width.replace(/\[/, '').replace(/\]/, '');
                            width = entities[i].properties[width];
                        }
                        entities[i].point.outlineWidth = width;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var outlineWidth = entities[0].point.outlineWidth;
                    if (outlineWidth) {
                        return outlineWidth._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置点的高度类型
         * @param {object} heightReference
         */
        pointHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var heightReference = entities[0].point.heightReference;
                    if (heightReference) {
                        return heightReference._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层点的最大可视距离
         * @param {Float} far
         */
        pointDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var near = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                        entities[i].point.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var far = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    return far;
                }
            }
        },
        /**
         * 设置geojson图层点的最小可视距离
         * @param {Float} verticalOrigin
         */
        pointDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var far = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);

                        entities[i].point.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var near = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         */
        pointHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude)
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude)
                // var height=this._cesium.Math.toDegrees( Cartographic.height)
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        },

        /**
         * 模型图层的显示隐藏
         * @param {boolean} b
         */
        modelShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id)) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (entities[i].label) entities[i].label.show = !b;
                        if (entities[i].point) entities[i].point.show = !b;
                        if (entities[i].billboard) entities[i].billboard.show = !b;
                        if (!entities[i].model && b) {
                            entities[i].model = new this._cesium.ModelGraphics({
                                //uri: "glb/gltf",
                                show: true,
                                scale: 1.0,
                                minimumPixelSize: 0.0,
                                incrementallyLoadTextures: true,
                                runAnimations: true,
                                clampAnimations: true,
                                shadows: this._cesium.ShadowMode.ENABLED,
                                heightReference: this._cesium.HeightReference.NONE,
                                color: this._cesium.Color.WHITE
                            });
                        } else {
                            if (entities[i].model)
                                entities[i].model.show = b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    return entities[0].model.show;
                }
            }
        },
        /**
         * 模型图层的模型地址
         * @param {String} uri [uri]
         */
        modelUri: {
            set: lodash.debounce(function (uri) {
                if (this._core.isnull(uri)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].model) {
                            if (/^\[/.test(uri)) {
                                var uris = uri.split('[');
                                if (uris.length > 1) {
                                    uri = uris[0] + uris[1].replace(/\[/, '').replace(/\]/, '');
                                } else {
                                    uri = uri.replace(/\[/, '').replace(/\]/, '');
                                    uri = entities[i].properties[uri];
                                }
                            }
                            entities[i].model = new this._cesium.ModelGraphics({
                                uri: uri,
                                show: true,
                                scale: 1.0,
                                minimumPixelSize: 0.0,
                                incrementallyLoadTextures: true,
                                runAnimations: true,
                                clampAnimations: true,
                                shadows: this._cesium.ShadowMode.ENABLED,
                                heightReference: this._cesium.HeightReference.NONE,
                                color: this._cesium.Color.WHITE
                            });
                        } else {
                            entities[i].model.uri = uri;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var uri = entities[0].model.uri;
                    if (uri) {
                        return uri._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 模型图层的模型显示比例
         * @param {Float} scale [scale]
         */
        modelScale: {
            set: lodash.debounce(function (scale) {
                if (this._core.isnull(scale)) return;
                scale = parseFloat(scale);
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(scale)) {
                            scale = scale.replace(/\[/, '').replace(/\]/, '');
                            scale = entities[i].properties[scale];
                        }
                        entities[i].model.scale = scale;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var scale = entities[0].model.scale;
                    if (scale) {
                        return scale._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 模型图层的模型的阴影
         * @param {Float} shadows sgworld.ShadowMode.*
         */
        modelShadows: {
            set: lodash.debounce(function (shadows) {
                if (this._core.isnull(shadows)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.shadows = shadows;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    return entities[0].model.shadows;
                }
            }
        },
        /**
         * 模型图层的模型的高度类型
         * @param {object} heightReference sgworld.HeightReference.*
         */
        modelHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var heightReference = entities[0].model.heightReference;
                    if (heightReference) {
                        return heightReference._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层模型的最大可视距离
         * @param {Float} far
         */
        modelDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var near = entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                }
            }
        },
        /**
         * 设置geojson图层点模型最小可视距离
         * @param {Float} near
         */
        modelDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var far = entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var near = entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层模型颜色
         * @param {object} color
         */
        modelColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.color = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var color = entities[0].model.color;
                    try {
                        return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置geojson图层模型高亮颜色
         * @param {object} color
         */
        modelLightColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.lightColor = color;
                    }
                }
            }, 100),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var lightColor = entities[0].model.lightColor;
                    try {
                        return this._color.toHtmlColor('rgb(' + lightColor._value.red * 255 + ',' + lightColor._value.green * 255 + ',' + lightColor._value.blue * 255 + ',' + lightColor._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         */
        modelHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude)
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude)
                // var height=this._cesium.Math.toDegrees( Cartographic.height)
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        },


        /**
         * 控制billboard的显示隐藏
         * @param {boolean} b
         */
        billboardShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id)) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].billboard && b) {
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            entities[i].billboard = new this._cesium.BillboardGraphics({
                                //image: "",//	Property		optional A Property specifying the Image, URI, or Canvas to use for the billboard.
                                show: true, //	optional A boolean Property specifying the visibility of the billboard.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the image size.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //	optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                rotation: 0, //	optional A numeric Property specifying the rotation about the alignedAxis.
                                alignedAxis: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the unit vector axis of rotation.
                                width: undefined, //		optional A numeric Property specifying the width of the billboard in pixels, overriding the native size.
                                height: undefined, //		optional A numeric Property specifying the height of the billboard in pixels, overriding the native size.
                                color: this._cesium.Color.WHITE, //	optional A Property specifying the tint Color of the image.
                                heightReference: this._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            if (entities[i].billboard)
                                entities[i].billboard.show = b;
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    return entities[0].billboard.show;
                }
            }
        },
        /**
         * 控制billboard的图片
         * @param {string} image [image]
         */
        billboardImage: {
            set: lodash.debounce(function (image) {
                if (this._core.isnull(image)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(image)) {
                            var images = image.split('[');
                            if (images.length > 1) {
                                image = images[0] + images[1].replace(/\[/, '').replace(/\]/, '');
                            } else {
                                image = image.replace(/\[/, '').replace(/\]/, '');
                                image = entities[i].properties[image];
                            }
                        }
                        if (!entities[i].billboard) {
                            entities[i].billboard = new this._cesium.BillboardGraphics({
                                image: image, //	Property		optional A Property specifying the Image, URI, or Canvas to use for the billboard.
                                show: true, //	optional A boolean Property specifying the visibility of the billboard.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the image size.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //	optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                rotation: 0, //	optional A numeric Property specifying the rotation about the alignedAxis.
                                alignedAxis: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the unit vector axis of rotation.
                                width: undefined, //		optional A numeric Property specifying the width of the billboard in pixels, overriding the native size.
                                height: undefined, //		optional A numeric Property specifying the height of the billboard in pixels, overriding the native size.
                                color: this._cesium.Color.WHITE, //	optional A Property specifying the tint Color of the image.
                                heightReference: this._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            entities[i].billboard.image = image;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var image = entities[0].billboard.image;
                    if (image) {
                        return image._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 控制billboard的图片scale
         * @param {Float} scale
         */
        billboardScale: {
            set: lodash.debounce(function (scale) {
                if (this._core.isnull(scale)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.scale = scale;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var scale = entities[0].billboard.scale;
                    if (scale) {
                        return scale._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 控制billboard的图片horizontalOrigin
         * @param {Float} horizontalOrigin
         */
        billboardHorizontalOrigin: {
            set: lodash.debounce(function (horizontalOrigin) {
                if (this._core.isnull(horizontalOrigin)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.horizontalOrigin = horizontalOrigin;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    return entities[0].billboard.horizontalOrigin;
                }
            }
        },
        /**
         * 控制billboard的图片verticalOrigin
         * @param {Float} verticalOrigin
         */
        billboardVerticalOrigin: {
            set: lodash.debounce(function (verticalOrigin) {
                if (this._core.isnull(verticalOrigin)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.verticalOrigin = verticalOrigin;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    return entities[0].billboard.verticalOrigin;
                }
            }
        },
        /**
         * 控制billboard的图片width
         * @param {Float} width
         */
        billboardWidth: {
            set: lodash.debounce(function (width) {
                if (this._core.isnull(width)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.width = width;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var width = entities[0].billboard.width;
                    if (width) {
                        return width._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 控制billboard的图片height
         * @param {Float} height
         */
        billboardHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.height = height;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var height = entities[0].billboard.height;
                    if (height) {
                        return height._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 控制billboard的图片color
         * @param {object} color
         */
        billboardColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.color = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var color = entities[0].billboard.color;
                    try {
                        return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * billboard图层的高度类型
         * @param {object} heightReference sgworld.HeightReference.*
         */
        billboardHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var heightReference = entities[0].billboard.heightReference;
                    if (heightReference) {
                        return heightReference._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层模型的最大可视距离
         * @param {Float} far
         */
        billboardDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var near = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                        entities[i].billboard.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var far = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    return far;
                }
            }
        },
        /**
         * 设置geojson图层点模型最小可视距离
         * @param {Float} near
         */
        billboardDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var far = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                        entities[i].billboard.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var near = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         */
        billboardPHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude)
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude)
                // var height=this._cesium.Math.toDegrees( Cartographic.height)
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        },

        /**
         * 设置geojson图层线的显示隐藏
         * @param {boolean} b
         */
        polylineShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id)) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    for (var i = 0; i < entities.length; i++) {
                        if (entities[i].polyline)
                            entities[i].polyline.show = b;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id) && entities[0].polyline == undefined) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    return entities[0].polyline.b;
                }
            }
        },
        /**
         * 设置geojson图层线的宽度
         * @param {Float} width
         */
        polylineWidth: {
            set: lodash.debounce(function (width) {
                if (this._core.isnull(width)) return;
                width = parseFloat(width);
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id) && entities[0].polyline == undefined) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polyline.width = width;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id) && entities[0].polyline == undefined) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    var width = entities[0].polyline.width;
                    if (width) {
                        return width._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层线的材质
         * @param {object} material
         */
        polylinemMterial: {
            set: lodash.debounce(function (material) {
                if (this._core.isnull(material)) return;
                if (!this._core.isnull(material)) {
                    if (this._core.isHtmlColor(material)) {
                        material = this._color.colorFromHtmlColor(material);
                    } else {
                        if (/^rgb/.test(material)) {
                            material = this._color.rgbaStringToRgbaObj(material);
                        }
                        if (material.r > 1) {
                            material.r = material.r / 255;
                        }
                        if (material.g > 1) {
                            material.g = material.g / 255;
                        }
                        if (material.b > 1) {
                            material.b = material.b / 255;
                        }
                        if (material.a > 1) {
                            material.a = material.a / 255;
                        }
                        material = this._color.createColor(material.r, material.g, material.b, material.a);
                    }
                }
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id) && entities[0].polyline == undefined) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polyline.material = material;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id) && entities[0].polyline == undefined) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    var material = entities[0].polyline.material;
                    try {
                        return this._color.toHtmlColor('rgb(' + material._value.red * 255 + ',' + material._value.green * 255 + ',' + material._value.blue * 255 + ',' + material._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置geojson图层线的线型
         * @param {object} arcType
         */
        polylinemArcType: {
            set: lodash.debounce(function (arcType) {
                if (this._core.isnull(arcType)) return;
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id) && entities[0].polyline == undefined) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polyline.arcType = arcType;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id) && entities[0].polyline == undefined) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    var arcType = entities[0].polyline.arcType;
                    if (arcType) {
                        return arcType._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层线的最大可视距离
         * @param {Float} far
         */
        polylineDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id) && entities[0].polyline == undefined) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    var near = entities[0].polyline.distanceDisplayCondition ? entities[0].polyline.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polyline.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id) && entities[0].polyline == undefined) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    var far = entities[0].polyline.distanceDisplayCondition ? entities[0].polyline.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    return far;
                }
            }
        },
        /**
         * 设置geojson图层线最小可视距离
         * @param {Float} near
         */
        polylineDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id) && entities[0].polyline == undefined) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    var far = entities[0].polyline.distanceDisplayCondition ? entities[0].polyline.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polyline.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^line.fid/.test(entities[0]._id) && entities[0].polyline == undefined) return;
                if (entities && entities.length > 0 && entities[0].polyline) {
                    var near = entities[0].polyline.distanceDisplayCondition ? entities[0].polyline.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },


        /**
         * 设置geojson图层面的显示隐藏
         * @param {boolean} b
         */
        polygonShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id)) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    for (var i = 0; i < entities.length; i++) {
                        if (entities[i].polygon)
                            entities[i].polygon.show = b;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    return entities[0].polygon.b;
                }
            }
        },
        /**
         * 设置geojson图层面的显示高度
         * @param {Float} height [height]
         */
        polygonHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(height)) {
                            height = height.replace(/\[/, '').replace(/\]/, '');
                            height = entities[i].properties[height];
                        }
                        entities[i].polygon.height = height;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var height = entities[0].polygon.height;
                    if (height) {
                        return height._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层面的高度类型
         * @param {object} heightReference
         */
        polygonHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polygon.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var heightReference = entities[0].polygon.heightReference;
                    if (heightReference) {
                        return heightReference._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层面的拉伸高度ht
         * @param {Float} extrudedHeight [extrudedHeight]
         */
        polygonExtrudedHeight: {
            set: lodash.debounce(function (extrudedHeight) {
                if (this._core.isnull(extrudedHeight)) return;
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(extrudedHeight)) {
                            extrudedHeight = extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                            extrudedHeight = entities[i].properties[extrudedHeight];
                        }
                        entities[i].polygon.extrudedHeight = extrudedHeight;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var extrudedHeight = entities[0].polygon.extrudedHeight;
                    if (extrudedHeight) {
                        return extrudedHeight._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层面的拉伸高度ht
         * @param {Float} extrudedHeightReference
         */
        polygonExtrudedHeightReference: {
            set: lodash.debounce(function (extrudedHeightReference) {
                if (this._core.isnull(extrudedHeightReference)) return;
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polygon.extrudedHeightReference = extrudedHeightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var extrudedHeightReference = entities[0].polygon.extrudedHeightReference;
                    if (extrudedHeightReference) {
                        return extrudedHeightReference._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层面是否填充
         * @param {boolean} fill
         */
        polygonFill: {
            set: lodash.debounce(function (fill) {
                // if (this._core.isnull(fill)) return;
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polygon.fill = fill;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var fill = entities[0].polygon.fill;
                    if (fill) {
                        return fill._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层面材质
         * @param {object|string} color
         */
        polygonMaterial: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polygon.material = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var material = entities[0].polygon.material;
                    try {
                        return this._color.toHtmlColor('rgb(' + material._value.red * 255 + ',' + material._value.green * 255 + ',' + material._value.blue * 255 + ',' + material._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置geojson图层面是否显示边框
         * @param {boolean} outline
         */
        polygonOutline: {
            set: lodash.debounce(function (outline) {
                if (this._core.isnull(outline)) return;
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polygon.outline = outline;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var outline = entities[0].polygon.outline;
                    if (outline) {
                        return outline._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层面边框颜色
         * @param {object|string} color
         */
        polygonOutlineColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polygon.outlineColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var outlineColor = entities[0].polygon.outlineColor;
                    return this._color.toHtmlColor('rgb(' + outlineColor._value.red * 255 + ',' + outlineColor._value.green * 255 + ',' + outlineColor._value.blue * 255 + ',' + outlineColor._value.alpha * 255 + ')');
                }
            }
        },
        /**
         * 设置geojson图层面边框宽度
         * @param {Float} outlineWidth [outlineWidth]
         */
        polygonOutlineWidth: {
            set: lodash.debounce(function (outlineWidth) {
                if (this._core.isnull(outlineWidth)) return;
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(outlineWidth)) {
                            outlineWidth = outlineWidth.replace(/\[/, '').replace(/\]/, '');
                            outlineWidth = entities[i].properties[outlineWidth];
                        }
                        entities[i].polygon.outlineWidth = outlineWidth;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var outlineWidth = entities[0].polygon.outlineWidth;
                    if (outlineWidth) {
                        return outlineWidth._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层线的最大可视距离
         * @param {Float} far
         */
        polygonDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var near = entities[0].polygon.distanceDisplayCondition ? entities[0].polygon.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polygon.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var far = entities[0].polygon.distanceDisplayCondition ? entities[0].polygon.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    return far;
                }
            }
        },
        /**
         * 设置geojson图层线最小可视距离
         * @param {Float} near
         */
        polygonDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var far = entities[0].polygon.distanceDisplayCondition ? entities[0].polygon.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].polygon.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities.values;
                if (!/^polygon.fid/.test(entities[0]._id) && entities[0].polygon == undefined) return;
                if (entities && entities.length > 0 && entities[0].polygon) {
                    var near = entities[0].polygon.distanceDisplayCondition ? entities[0].polygon.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
    });

    function VectorTileProvider(viewer, cesium, tilingScheme) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._quadtree = undefined;
        this._tilingScheme = tilingScheme || new Cesium.GeographicTilingScheme();
        this._errorEvent = new Cesium.Event();
        this._reTilesKey = [];
        this._state = true;
        //前端点击显示隐藏控制字段
        this._client = true;

        this._reTiles = [];
        this._normalTile = 16;

        this._minimumHeight = 0.0;
        this._maximumHeight = 0.0;

        this._PrimitiveCollection = new Cesium.PrimitiveCollection();
        this._levelZeroMaximumError = Cesium.QuadtreeTileProvider.computeDefaultLevelZeroMaximumGeometricError(
            this._tilingScheme);
        this.cartographicLimitRectangle = Cesium.Rectangle.clone(Cesium.Rectangle.MAX_VALUE);
        if (!VectorTileProvider.prototype.ready)
            Object.defineProperties(VectorTileProvider.prototype, {
                quadtree: {
                    get: function () {
                        return this._quadtree;
                    },
                    set: function (value) {
                        this._quadtree = value;
                    }
                },
                ready: {
                    get: function () {
                        return true;
                    }
                },
                tilingScheme: {
                    get: function () {
                        return this._tilingScheme;
                    }
                },
                errorEvent: {
                    get: function () {
                        return this._errorEvent;
                    }
                }
            });

        this._core = new Core();
        this.tooltip = this._core.CreateTooltip();
        this._getPosition = new getPosition(this._viewer, this._cesium);
    }
    VectorTileProvider.prototype.update = function (frameState) {
        this._quadtree.beginFrame(frameState);
        // try {
        //     if (this.cs != undefined && this.cs == undefined) {
        //     } else {
        this._quadtree.render(frameState);
        //     }
        // } catch (ex) { };
        this._quadtree.endFrame(frameState);
    };
    VectorTileProvider.prototype.static = function (cs) {
        this.cs = cs;
    };
    VectorTileProvider.prototype.initialize = function (frameState) { };

    VectorTileProvider.prototype.beginUpdate = function (frameState) {
        //frameState.context._pickObjects = null;
        //for (var i = 0; i < this._reTiles.length; i++) {
        //    var tile = this._reTiles[i];
        //    if (this.computeTileVisibility(tile, frameState, null) == Cesium.Visibility.NONE) {
        //        for (var key in frameState.context._pickObjects) {
        //            var obj = frameState.context._pickObjects[key];
        //            if (obj.id.indexOf('z' + tile.level + 'x' + tile.x + 'y' + tile.y + 'n') == 0) {
        //                delete frameState.context._pickObjects[key];
        //            }
        //        }
        //    }
        //}
    };

    VectorTileProvider.prototype.endUpdate = function (frameState) {
        //frameState.context._pickObjects = [];


        //for (var key in frameState.context._pickObjects) {
        //    var obj = frameState.context._pickObjects[key];
        //    if ()
        //}
    };

    VectorTileProvider.prototype.getLevelMaximumGeometricError = function (level) {
        return this._levelZeroMaximumError / (1 << level);
    };

    VectorTileProvider.prototype.loadTile = function (frameState, tile) {

    };

    VectorTileProvider.prototype.computeTileVisibility = function (tile, frameState, occluders) {
        var distance = this.computeDistanceToTile(tile, frameState);
        tile._distance = distance;

        if (frameState.fog.enabled) {
            if (Cesium.Math.fog(distance, frameState.fog.density) >= 1.0) {
                // Tile is completely in fog so return that it is not visible.
                return Cesium.Visibility.NONE;
            }
        }

        var surfaceTile = tile.data;
        surfaceTile.tileBoundingRegion;

        if (surfaceTile.boundingVolumeSourceTile === undefined) {
            // We have no idea where this tile is, so let's just call it partially visible.
            return Cesium.Visibility.PARTIAL;
            //return Cesium.Visibility.NONE;
        }

        var cullingVolume = frameState.cullingVolume;
        var boundingVolume = surfaceTile.orientedBoundingBox;

        if (!boundingVolume && surfaceTile.renderedMesh) {
            boundingVolume = surfaceTile.renderedMesh.boundingSphere3D;
        }

        // Check if the tile is outside the limit area in cartographic space
        surfaceTile.clippedByBoundaries = false;

        function clipRectangleAntimeridian(tileRectangle, cartographicLimitRectangle) {
            if (cartographicLimitRectangle.west < cartographicLimitRectangle.east) {
                return cartographicLimitRectangle;
            }
            var splitRectangle = Rectangle.clone(cartographicLimitRectangle, splitCartographicLimitRectangleScratch);
            var tileCenter = Rectangle.center(tileRectangle, rectangleCenterScratch);
            if (tileCenter.longitude > 0.0) {
                splitRectangle.east = CesiumMath.PI;
            } else {
                splitRectangle.west = -CesiumMath.PI;
            }
            return splitRectangle;
        }
        var clippedCartographicLimitRectangle = clipRectangleAntimeridian(tile.rectangle, this
            .cartographicLimitRectangle);
        var rectangleIntersectionScratch = new Cesium.Rectangle();
        var areaLimitIntersection = Cesium.Rectangle.simpleIntersection(clippedCartographicLimitRectangle, tile
            .rectangle, rectangleIntersectionScratch);
        if (!areaLimitIntersection) {

            return Visibility.NONE;
        }
        if (!Cesium.Rectangle.equals(areaLimitIntersection, tile.rectangle)) {
            surfaceTile.clippedByBoundaries = true;
        }

        if (frameState.mode !== Cesium.SceneMode.SCENE3D) ;

        if (!boundingVolume) {
            return Cesium.Intersect.INTERSECTING;
        }

        var clippingPlanes = this._clippingPlanes;
        if (clippingPlanes && clippingPlanes.enabled) {
            var planeIntersection = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
            tile.isClipped = (planeIntersection !== Intersect.INSIDE);
            if (planeIntersection === Cesium.Intersect.OUTSIDE) {

                return Cesium.Visibility.NONE;
            }
        }

        var intersection = cullingVolume.computeVisibility(boundingVolume);
        if (intersection === Cesium.Intersect.OUTSIDE) {

            return Cesium.Visibility.NONE;
        }

        var ortho3D = frameState.mode === Cesium.SceneMode.SCENE3D && frameState.camera
            .frustum instanceof Cesium.OrthographicFrustum;
        if (frameState.mode === Cesium.SceneMode.SCENE3D && !ortho3D && occluders) {
            var occludeePointInScaledSpace = surfaceTile.occludeePointInScaledSpace;
            if (!occludeePointInScaledSpace) {
                return intersection;
            }

            if (occluders.ellipsoid.isScaledSpacePointVisible(occludeePointInScaledSpace)) {
                return intersection;
            }

            return Cesium.Visibility.NONE;
        }

        return intersection;
    };

    VectorTileProvider.prototype.canRefine = function (tile, frameState, occluders) {
        if (tile.level < this._normalTile)
            return true;
        return false;
    };

    VectorTileProvider.prototype.showTileThisFrame = function (tile, context, frameState, commandList) {
        // if (tile.data.geometryPrimitive && tile.data.geometryPrimitive._isModel) {
        //     for (var i = 0, l = tile.data.geometryPrimitive.length; i < l; i++)
        //         if (tile.data.geometryPrimitive[i] && tile.data.geometryPrimitive[i]._primitives)
        //             tile.data.geometryPrimitive[i]._primitives._isRender = 1;
        // }
        // else 
        if (this._availability) {
            this._state = this.isAvailable(context.time);
        }
        if (tile.data.geometryPrimitive && this._state && this._client && typeof tile.data.geometryPrimitive.update == 'function') {
            if (tile.data.geometryPrimitive instanceof Cesium.Cesium3DTileset) ; else {
                tile.data.geometryPrimitive.update(context, frameState, commandList);
                // tile.data.geometryPrimitive._isUpdateQuad = 1;
            }

        }
    };

    VectorTileProvider.prototype.computeDistanceToTile = function (tile, frameState) {
        function computeOccludeePoint(tileProvider, center, rectangle, height, result) {
            var ellipsoidalOccluder = tileProvider.quadtree._occluders.ellipsoid;
            var ellipsoid = ellipsoidalOccluder.ellipsoid;
            var cornerPositionsScratch = [new Cesium.Cartesian3(), new Cesium.Cartesian3(), new Cesium.Cartesian3(),
            new Cesium.Cartesian3()
            ];
            var cornerPositions = cornerPositionsScratch;
            Cesium.Cartesian3.fromRadians(rectangle.west, rectangle.south, height, ellipsoid, cornerPositions[0]);
            Cesium.Cartesian3.fromRadians(rectangle.east, rectangle.south, height, ellipsoid, cornerPositions[1]);
            Cesium.Cartesian3.fromRadians(rectangle.west, rectangle.north, height, ellipsoid, cornerPositions[2]);
            Cesium.Cartesian3.fromRadians(rectangle.east, rectangle.north, height, ellipsoid, cornerPositions[3]);

            return ellipsoidalOccluder.computeHorizonCullingPoint(center, cornerPositions, result);
        }

        function updateTileBoundingRegion(_maximumHeight, _minimumHeight, tile, terrainProvider, frameState) {
            var surfaceTile = tile.data;
            if (surfaceTile === undefined) {
                surfaceTile = tile.data = new Cesium.GlobeSurfaceTile();
            }
            if (tile._minimumHeight) {
                _minimumHeight = tile._minimumHeight;
            }
            if (tile._maximumHeight) {
                _maximumHeight = tile._maximumHeight;
            }
            if (surfaceTile.tileBoundingRegion === undefined) {
                surfaceTile.tileBoundingRegion = new Cesium.TileBoundingRegion({
                    computeBoundingVolumes: false,
                    rectangle: tile.rectangle,
                    ellipsoid: tile.tilingScheme.ellipsoid,
                    minimumHeight: _minimumHeight || 0.0,
                    maximumHeight: _maximumHeight || 0.0
                });
            }
            return tile;
        }
        var heightSource = updateTileBoundingRegion(this._maximumHeight, this._minimumHeight, tile, this.terrainProvider);
        var surfaceTile = tile.data;
        var tileBoundingRegion = surfaceTile.tileBoundingRegion;

        if (heightSource === undefined) {
            // Can't find any min/max heights anywhere? Ok, let's just say the
            // tile is really far away so we'll load and render it rather than
            // refining.
            return 9999999999.0;
        } else if (surfaceTile.boundingVolumeSourceTile !== heightSource) {
            // Heights are from a new source tile, so update the bounding volume.
            surfaceTile.boundingVolumeSourceTile = heightSource;

            var rectangle = tile.rectangle;
            if (rectangle && rectangle.width < Cesium.Math.PI_OVER_TWO + Cesium.Math.EPSILON5) {
                surfaceTile.orientedBoundingBox = Cesium.OrientedBoundingBox.fromRectangle(
                    tile.rectangle,
                    tileBoundingRegion.minimumHeight,
                    tileBoundingRegion.maximumHeight,
                    tile.tilingScheme.ellipsoid,
                    surfaceTile.orientedBoundingBox);

                surfaceTile.occludeePointInScaledSpace = computeOccludeePoint(this, surfaceTile
                    .orientedBoundingBox.center, tile.rectangle, tileBoundingRegion.maximumHeight,
                    surfaceTile.occludeePointInScaledSpace);
            }
        }

        var min = tileBoundingRegion.minimumHeight;
        var max = tileBoundingRegion.maximumHeight;

        if (surfaceTile.boundingVolumeSourceTile !== tile) {
            var cameraHeight = frameState.camera.positionCartographic.height;
            var distanceToMin = Math.abs(cameraHeight - min);
            var distanceToMax = Math.abs(cameraHeight - max);
            if (distanceToMin > distanceToMax) {
                tileBoundingRegion.minimumHeight = min;
                tileBoundingRegion.maximumHeight = min;
            } else {
                tileBoundingRegion.minimumHeight = max;
                tileBoundingRegion.maximumHeight = max;
            }
        }

        var result = tileBoundingRegion.distanceToCamera(frameState);

        tileBoundingRegion.minimumHeight = min;
        tileBoundingRegion.maximumHeight = max;

        return result;
    };

    VectorTileProvider.prototype.isDestroyed = function () {
        return false;
    };

    VectorTileProvider.prototype.destroy = function () {
        return Cesium.destroyObject(this);
    };

    VectorTileProvider.prototype.remove = function () {
        this.destroy();
    };
    VectorTileProvider.prototype.setStatus = function (state) {
        this._state = state;
        this._client = state;
    };

    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    VectorTileProvider.prototype.edit = function (open, option) {
        let that = this;
        let viewer = this._viewer;
        !option && (option = {});

        if (this.editHandler) {
            this.editHandler.destroy();
            this.editHandler = undefined;
        }
        open === undefined && (open = true);
        if (!open) {
            endThisEdit();
            return;
        }

        // 创建监听的handler
        this.editHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        //当前编辑的实体对象、当前的编辑点、当前的编辑点位置和当前编辑类型
        var geo, currentPoint, currentPointpos, type;
        // 判断是否处于编辑状态
        this.isEditting = false;
        //移动点（拖拽可移动当前图形）和选中编辑点的类型
        let pointType;

        // 对鼠标按下事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            // 获取屏幕坐标
            let windowPosition = event.position;
            // 通过屏幕坐标获取当前位置的实体
            let pickedObject = viewer.scene.pick(windowPosition);
            if (pickedObject) {
                if (pickedObject && pickedObject.id && pickedObject.id.treeID !== that.treeID) {
                    return;
                }
            }
            if (pickedObject && pickedObject.id && (pickedObject.id instanceof Cesium.Entity || pickedObject.id.VectorType)) {
                // 获取当前点的实体
                let entity = pickedObject.id;
                if (!that.isEditting && tree.states == 0) {
                    option.callBack && option.callBack.start && option.callBack.start(entity);
                    type = entity.VectorType;
                    geo = that.createEditEntity(type, entity.VectorStyle);
                    geo.feature = entity;
                    geo.treeID = that.treeID;

                    //获取简单图形数据
                    that.getSimpleGraphicData(type, geo);

                    if (type === 'point' || type === 'billboard' || type === 'label' || type === 'model') {
                        // 设置编辑状态为true 
                        that.isEditting = true;
                        that.tooltip.showAt(event.position, '拖拽修改位置');
                    } else {
                        // 设置编辑状态为true 
                        that.isEditting = true;
                        SmartEarthPopupData.editGraphic.updataEditPoint();
                        SmartEarthPopupData.editGraphic.setTreeID(that.treeID);
                    }
                    that.setStatus(false);
                    tree.editVector = true;
                } else if ((entity == geo && (entity.VectorType === 'point' || entity.VectorType === 'billboard' || entity.VectorType === 'label' || entity.VectorType === 'model')) ||
                    entity.name == "_height_point" || entity.name == "_edit_point" || entity.name == "_move_point" || entity.name == "_add_point" || entity.name == "_size_point") {
                    viewer.container.style.cursor = 'crosshair';
                    // 禁止地球旋转和缩放，地球的旋转会对鼠标移动监听有影响，所以需要禁止
                    that.defaultEvent(false);
                    if (entity.name == "_height_point") {
                        //获取当前高度点位置
                        currentPointpos = {
                            windowPosition: windowPosition,
                            originHeight: that._cesium.Cartographic.fromCartesian(entity.position.getValue()).height
                        };
                        pointType = "_height_point";
                    } else if (entity.name == "_move_point") {
                        pointType = "_move_point";
                    } else if (entity.VectorType === 'point' || entity.VectorType === 'billboard' || entity.VectorType === 'label' || entity.VectorType === 'model') {
                        that.tooltip.showAt(event.position, '释放后完成修改');
                        pointType = "_move_point";
                        //隐藏模型
                        if (entity.VectorType === 'model') {
                            entity.show = false;
                        }
                    } else if (entity.name == "_edit_point") {
                        pointType = "_edit_point";
                    } else if (entity.name == "_add_point") {
                        pointType = "_add_point";
                    } else if (entity.name == "_size_point") {
                        pointType = "_size_point";
                    }
                    // 如果实体为编辑点，那么设置当前编辑点为该点
                    currentPoint = entity;
                } else ;
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);

        //// 对鼠标移动事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            let pickedObject = viewer.scene.pick(event.endPosition);
            if (pickedObject) {
                if (pickedObject && pickedObject.id && pickedObject.id.treeID !== that.treeID) {
                    return;
                }
            }
            if (that._cesium.defined(pickedObject)) {
                if (that.isEditting && !currentPoint) {
                    if ((type === 'point' || type === 'billboard' || type === 'label' || type === 'model') && pickedObject.id == geo) {
                        //点类
                        that.tooltip.showAt(event.endPosition, '拖拽修改位置，右键删除');
                    } else if (pickedObject.id && pickedObject.id.name === "_edit_point" && geo.pottingPoint) {
                        //编辑节点
                        if (type === 'polyline' && geo.pottingPoint.length > 2) {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置，右键删除点');
                        } else if (type === 'polygon' && geo.pottingPoint.length > 3) {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置，右键删除点');
                        } else {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置');
                        }
                    } else if (pickedObject.id && (pickedObject.id.name === "_move_point" || pickedObject.id.name === "_size_point")) {
                        that.tooltip.showAt(event.endPosition, '拖拽修改位置');
                    } else if (pickedObject.id && pickedObject.id.name === "_add_point") {
                        that.tooltip.showAt(event.endPosition, '拖拽增加节点');
                    } else if (pickedObject.id && pickedObject.id.name === "_height_point") {
                        that.tooltip.showAt(event.endPosition, '拖拽修改高度');
                    } else if (pickedObject.id == geo) {
                        that.tooltip.show(false);
                    }
                } else if (!that.isEditting && tree.states === 0) {
                    if (pickedObject.id && pickedObject.id.VectorType) {
                        // that.tooltip.showAt(event.endPosition, '点击激活编辑，右键删除');
                        that.tooltip.showAt(event.endPosition, '点击激活编辑');
                    } else {
                        that.tooltip.show(false);
                    }
                }
            } else if (tree.states == 0 && !currentPoint) {
                that.tooltip.show(false);
            }

            // 如果处于编辑状态且编辑点已定义，那么开始拖拽编辑
            if (that.isEditting && currentPoint) {
                that.tooltip.showAt(event.endPosition, '释放后完成修改');
                let cartesian = that._getPosition.getMousePosition(event);
                //拉伸节点不需要获取当前位置坐标
                if (!cartesian && pointType !== "_height_point") {
                    return;
                }            ///地面上点
                if (pointType === "_edit_point") {
                    // 更新编辑点的位置
                    currentPoint.position = cartesian;
                    let pointIndex = tree.editPointID.edit.indexOf(currentPoint.id);

                    //修改对应坐标数据
                    if (geo[type].height !== undefined) {
                        let degrees = that.toDegrees(cartesian);
                        geo.pottingPoint[pointIndex] = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, geo[type].height.getValue());
                        currentPoint.position = geo.pottingPoint[pointIndex];
                    } else {
                        geo.pottingPoint[pointIndex] = cartesian;
                    }

                    //修改对应的拉伸节点
                    // if (tree.editPointID.height.length > 0) {
                    //     let thisHeightPoint = viewer.entities.getById(tree.editPointID.height[pointIndex]);
                    //     if (thisHeightPoint) {
                    //         let degrees = that.toDegrees(cartesian);
                    //         //修改拉伸节点位置
                    //         let expiontcart = that._cesium.Cartographic.fromCartesian(thisHeightPoint.position.getValue());
                    //         thisHeightPoint.position = that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, expiontcart.height);
                    //     }
                    // }

                    //修改边上的新增节点
                    if (tree.editPointID.add.length > 0) {
                        //上一个新增节点
                        if (pointIndex > 0) {
                            let thisAddPoint1 = viewer.entities.getById(tree.editPointID.add[pointIndex - 1]);
                            if (thisAddPoint1) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[pointIndex - 1]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                                thisAddPoint1.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                        //下一个新增节点
                        if (pointIndex < geo.pottingPoint.length - 1) {
                            let thisAddPoint2 = viewer.entities.getById(tree.editPointID.add[pointIndex]);
                            if (thisAddPoint2) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[pointIndex + 1]);
                                thisAddPoint2.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                        //面的起点和终点之间的节点
                        if (type === 'polygon' && (pointIndex === 0 || pointIndex === geo.pottingPoint.length - 1)) {
                            let thisAddPoint3 = viewer.entities.getById(tree.editPointID.add[tree.editPointID.add.length - 1]);
                            if (thisAddPoint3) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[0]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[geo.pottingPoint.length - 1]);
                                thisAddPoint3.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                    }

                    let positions = geo.pottingPoint.concat([]);
                    //修改移动节点位置
                    let _center = new that._cesium.Cartesian3();
                    let pointLength = positions.length;
                    positions.forEach(item => {
                        _center.x += item.x;
                        _center.y += item.y;
                        _center.z += item.z;
                    });
                    _center.x /= pointLength;
                    _center.y /= pointLength;
                    _center.z /= pointLength;
                    tree.editPointID.move && (tree.editPointID.move.position = _center);

                    //修改实体对象坐标
                    if (type === 'polyline' || type === 'polygon' || type === 'rectangle') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    }
                } else if (pointType === "_height_point") {////拉伸高度点
                    let pointIndex = tree.editPointID.height.indexOf(currentPoint.id);
                    let e_point = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                    if (type === 'ellipse' || type === 'cylinder' || type === 'box') {
                        //圆和圆柱、圆锥、立方体没有对应的编辑节点，对应移动节点
                        e_point = tree.editPointID.move;
                    }
                    let e_degrees = that.toDegrees(e_point.position.getValue());
                    let originHeight = currentPointpos.originHeight - e_degrees.height;
                    let e_winPosition = viewer.scene.cartesianToCanvasCoordinates(e_point.position.getValue());

                    //移动后高度变化
                    let _height = (currentPointpos.windowPosition.y - event.endPosition.y) * originHeight / Math.abs(e_winPosition.y - currentPointpos.windowPosition.y);

                    let h = Math.abs(originHeight + _height);
                    tree.editPointID.height.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            let e_p = e.position.getValue();
                            let e_d = that.toDegrees(e_p);
                            e.position = that._cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, h + e_degrees.height);
                        }
                    });

                    if (geo[type].extrudedHeight) {
                        geo[type].extrudedHeight = h + e_degrees.height;
                    } else if (type === 'box') {
                        SmartEarthPopupData.editGraphic.setValue('height', h);
                    } else if (type === 'cylinder') {
                        SmartEarthPopupData.editGraphic.setValue('length', h);
                    }
                } else if (pointType === "_add_point") {////新增节点
                    let addIndex = tree.editPointID.add.indexOf(currentPoint.id);
                    //移除旧新增节点
                    viewer.entities.remove(currentPoint);
                    //添加新的编辑节点
                    let new_edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: cartesian,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    tree.editPointID.edit.splice(addIndex + 1, 0, new_edit_point.id);
                    geo.pottingPoint.splice(addIndex + 1, 0, cartesian.clone());

                    //添加新的拉伸节点
                    // if (tree.editPointID.height.length > 0) {
                    //     //拉伸节点
                    //     let degrees = that.toDegrees(cartesian);
                    //     degrees.height = geo[type].extrudedHeight.getValue();

                    //     let new_heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: that._cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.splice(addIndex + 1, 0, new_heightpoint.id);
                    // }

                    //添加两个新的新增节点
                    let add_position1 = Cesium.Cartesian3.midpoint(geo.pottingPoint[addIndex], geo.pottingPoint[addIndex + 1], new Cesium.Cartesian3());
                    //添加节点1
                    let add_point1 = viewer.entities.add({
                        name: "_add_point",
                        position: add_position1,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    let add_position2 = Cesium.Cartesian3.midpoint(geo.pottingPoint[addIndex + 1], geo.pottingPoint[addIndex + 2 === geo.pottingPoint.length ? 0 : addIndex + 2], new Cesium.Cartesian3());
                    //添加节点2
                    let add_point2 = viewer.entities.add({
                        name: "_add_point",
                        position: add_position2,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    tree.editPointID.add.splice(addIndex, 1, add_point1.id, add_point2.id);

                    SmartEarthPopupData.editGraphic.setTreeID(that.treeID);

                    //转为编辑节点状态
                    currentPoint = new_edit_point;
                    pointType = '_edit_point';

                    //修改实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'polygon') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    }
                } else if (pointType === "_size_point") {    //大小节点
                    let center = tree.editPointID.move.position.getValue();
                    let distance = that._cesium.Cartesian3.distance(center, cartesian);

                    //修改实体对象坐标
                    if (type === 'ellipse' || type === 'cylinder' || (type === 'ellipsoid' && geo.isSphere)) {
                        SmartEarthPopupData.editGraphic.setValue('radius', distance);
                    } else if (type === 'box') {
                        let s = currentPoint.angle === 90 ? 'long' : 'width';
                        SmartEarthPopupData.editGraphic.setValue(s, distance * 2);
                    }
                } else {
                    //点类移动
                    if (type === 'point' || type === 'billboard' || type === 'label' || type === 'model') {
                        currentPoint.position = cartesian;
                        return;
                    }

                    ///移动后变化
                    let degrees1 = that.toDegrees(cartesian);
                    ///移动前经纬度
                    currentPointpos = currentPoint.position.getValue();
                    let degrees2 = that.toDegrees(currentPointpos);
                    //计算差值
                    let _x = degrees1.lon - degrees2.lon, _y = degrees1.lat - degrees2.lat, _z = degrees1.height - degrees2.height;

                    //修改移动节点位置
                    currentPoint.position = cartesian;
                    if (geo[type].height) {
                        let height = that.toDegrees(cartesian).height;
                        geo[type].height = height;
                        geo.thisHeight = height;
                    }

                    //修改所有节点位置
                    geo.pottingPoint.forEach((item, index) => {
                        let oldPosition, newPosition;

                        //对应的编辑节点
                        let _edit = viewer.entities.getById(tree.editPointID.edit[index]);
                        if (!_edit) {
                            //对应的大小节点
                            _edit = viewer.entities.getById(tree.editPointID.size[index]);
                        }

                        if (_edit) {
                            oldPosition = that.toDegrees(_edit.position.getValue());
                        } else {
                            oldPosition = that.toDegrees(item);
                        }

                        // if (geo[type].height) {
                        //     oldPosition.height = geo[type].height.getValue ? geo[type].height.getValue() : geo[type].height;
                        // }

                        newPosition = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                        item.x = newPosition.x;
                        item.y = newPosition.y;
                        item.z = newPosition.z;
                        //修改编辑节点坐标
                        _edit && (_edit.position = newPosition);

                        //修改拉伸节点坐标
                        // if (tree.editPointID.height.length > 0) {
                        //     let _heightPoint = viewer.entities.getById(tree.editPointID.height[index]);
                        //     if (_heightPoint) {
                        //         oldPosition = _heightPoint.position.getValue();
                        //         oldCartographic = that._cesium.Cartographic.fromCartesian(oldPosition);
                        //         oldPosition = {
                        //             lon: that._cesium.Math.toDegrees(oldCartographic.longitude),
                        //             lat: that._cesium.Math.toDegrees(oldCartographic.latitude),
                        //             height: oldCartographic.height
                        //         }
                        //         _heightPoint.position = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                        //     }
                        // }

                        //修改新增节点坐标
                        if (tree.editPointID.add.length > 0 && tree.editPointID.add[index]) {
                            let _addPoint = viewer.entities.getById(tree.editPointID.add[index]);
                            if (_addPoint) {
                                oldPosition = that.toDegrees(_addPoint.position.getValue());
                                // if (geo[type].height) {
                                //     oldPosition.height = geo[type].height.getValue ? geo[type].height.getValue() : geo[type].height;
                                // }
                                _addPoint.position = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                            }
                        }
                    });

                    //修改实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'polygon' || type === 'rectangle') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                        // if (tree.editPointID.height.length > 0) {
                        //     SmartEarthPopupData.editGraphic.setValue('extrudedHeight', SmartEarthPopupData.editGraphic.getValue('extrudedHeight') + _z);
                        // }
                    } else if (type === 'ellipse') {
                        geo.pottingPoint[1] = cartesian;
                        geo.position = cartesian.clone();
                    } else if (type === 'box') {
                        geo.pottingPoint[2] = cartesian;
                        let size = geo.box.dimensions.getValue();
                        let center = that.toDegrees(cartesian);
                        geo.position = Cesium.Cartesian3.fromDegrees(center.lon, center.lat, center.height + size.z / 2);
                    } else if (type === 'cylinder') {
                        geo.pottingPoint[1] = cartesian;
                        let length = geo.cylinder.length.getValue();
                        let degrees = that.toDegrees(geo.pottingPoint[1]);
                        geo.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + length / 2);
                    } else if (type === 'ellipsoid') {
                        geo.pottingPoint[geo.pottingPoint.length - 1] = cartesian;
                        geo.position = cartesian.clone();
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //// 对鼠标抬起事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            if (currentPoint && currentPoint.VectorType === 'model') {
                currentPoint.show = true;
            }
            if (currentPoint) {
                option.callBack && option.callBack.updata && option.callBack.updata(currentPoint.name, geo);
            }
            viewer.container.style.cursor = 'default';
            // 移除当前编辑点
            currentPoint = undefined;
            // 恢复地球的旋转和缩放
            that.defaultEvent(true);
        }, this._cesium.ScreenSpaceEventType.LEFT_UP);
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            // 通过屏幕坐标获取当前位置的实体信息
            let pickedObject = viewer.scene.pick(event.position);
            if (pickedObject && pickedObject.id && pickedObject.id.treeID !== that.treeID) {
                return;
            }
            // 如果实体信息存在则说明该位置存在实体
            if (that._cesium.defined(pickedObject) && tree.states == 0) {
                // 获取当前点的实体
                let entity = pickedObject.id;
                if (entity.VectorType) ; else if (tree.editPointID.edit.indexOf(entity.id) > -1 &&
                    ((type === 'polyline' && tree.editPointID.edit.length > 2) || (type === 'polygon' && tree.editPointID.edit.length > 3))) {
                    let thisPointIndex = tree.editPointID.edit.indexOf(entity.id);

                    //移除编辑节点
                    viewer.entities.removeById(entity.id);
                    tree.editPointID.edit.splice(thisPointIndex, 1);

                    //移除拉伸节点
                    // if (tree.editPointID.height.length > 0) {
                    //     viewer.entities.removeById(tree.editPointID.height[thisPointIndex]);
                    //     tree.editPointID.height.splice(thisPointIndex, 1);
                    // }

                    //移除实体对象节点
                    geo.pottingPoint.splice(thisPointIndex, 1);

                    //移除并更新新增节点
                    if (tree.editPointID.add.length > 0) {
                        //删除下一个新增节点
                        if (tree.editPointID.add[thisPointIndex]) {
                            viewer.entities.removeById(tree.editPointID.add[thisPointIndex]);
                            tree.editPointID.add.splice(thisPointIndex, 1);
                            //更新上一个新增节点
                            if (thisPointIndex - 1 >= 0) {
                                let updataAddPoint = viewer.entities.getById(tree.editPointID.add[thisPointIndex - 1]);
                                if (updataAddPoint) {
                                    //删除的是面的最后一个节点的话就计算第一个节点（索引0）和最后一个节点的中点
                                    updataAddPoint.position = Cesium.Cartesian3.midpoint(
                                        geo.pottingPoint[thisPointIndex - 1],
                                        geo.pottingPoint[thisPointIndex === geo.pottingPoint.length ? 0 : thisPointIndex],
                                        new Cesium.Cartesian3());
                                }
                            } else if (thisPointIndex - 1 === -1 && type === 'polygon') {
                                //删除的是面的第一个节点
                                let updataAddPoint = viewer.entities.getById(tree.editPointID.add[tree.editPointID.add.length - 1]);
                                if (updataAddPoint) {
                                    updataAddPoint.position = Cesium.Cartesian3.midpoint(geo.pottingPoint[0], geo.pottingPoint[geo.pottingPoint.length - 1], new Cesium.Cartesian3());
                                }
                            }
                        } else {
                            //直接移除上一个新增节点
                            viewer.entities.removeById(tree.editPointID.add[thisPointIndex - 1]);
                            tree.editPointID.add.pop();
                        }
                    }

                    //修改移动节点位置
                    let _center = new that._cesium.Cartesian3();
                    let pointLength = geo.pottingPoint.length;
                    geo.pottingPoint.forEach(item => {
                        _center.x += item.x;
                        _center.y += item.y;
                        _center.z += item.z;
                    });
                    _center.x /= pointLength;
                    _center.y /= pointLength;
                    _center.z /= pointLength;
                    tree.editPointID.move && (tree.editPointID.move.position = _center);

                    //更新实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'polygon') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    }
                    that.tooltip.show(false);
                    option.callBack && option.callBack.updata && option.callBack.updata(currentPoint && currentPoint.name, geo);
                }
            }
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        endThisEdit();

        function endThisEdit() {
            // 恢复地球的旋转和缩放
            that.defaultEvent(true);

            // 移除编辑点，清空编辑点数组
            tree.editPointID.edit.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.edit = [];

            tree.editPointID.height.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.height = [];

            tree.editPointID.add.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.add = [];

            tree.editPointID.size.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.size = [];

            tree.editPointID.move && viewer.entities.remove(tree.editPointID.move);
            tree.editPointID.move = undefined;

            geo && viewer.entities.remove(geo);
            geo = undefined;
            type = undefined;

            SmartEarthPopupData.editGraphic = {};

            that.isEditting = false;
            that.setStatus(true);
            tree.editVector = false;
            that.delButton(false);
        }
        return {
            endThisEdit: endThisEdit,
            getEditData: function () {
                return {
                    entity: geo
                }
            }
        }
    };

    //创建历史编辑图形
    VectorTileProvider.prototype.createEditEntity = function (type, option) {
        let entity;
        let that = this;
        let viewer = this._viewer;
        if (type === 'polygon') {
            let positions = option.positions;
            let height = that._core.defaultValue(option.height, undefined);
            let hierarchy;
            if (option.hierarchy) {
                hierarchy = option.hierarchy;
            } else {
                positions = option.haveZ ?
                    that._cesium.Cartesian3.fromDegreesArrayHeights(positions) :
                    that._cesium.Cartesian3.fromDegreesArray(positions)
                    ;
                hierarchy = new that._cesium.PolygonHierarchy(positions);
            }
            entity = viewer.entities.add({
                polygon: {
                    hierarchy: new that._cesium.CallbackProperty(function () {
                        return hierarchy;
                    }, false),
                    extrudedHeight: that._core.defaultValue(option.extrudedHeight, undefined),
                    height: height,
                    material: new that._cesium.ImageMaterialProperty({
                        image: that._core.defaultValue(option.image, null),
                        repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                        color: option.material
                    }),
                    shadows: that._cesium.ShadowMode.ENABLED,
                    fill: true
                }
            });
            entity.VectorType = 'polygon';
        } else if (type === 'polyline') {
            let positions = option.positions;
            positions = option.haveZ ?
                that._cesium.Cartesian3.fromDegreesArrayHeights(positions) :
                that._cesium.Cartesian3.fromDegreesArray(positions)
                ;
            entity = viewer.entities.add({
                polyline: {
                    positions: new that._cesium.CallbackProperty(function () {
                        return positions
                    }, false),
                    clampToGround: that._core.defaultValue(option.clampToGround, false),
                    material: new Cesium.PolylineOutlineMaterialProperty({
                        color: option.material,
                        outlineWidth: that._core.defaultValue(option.outlineWidth, 0),
                        outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                    }),
                    width: that._core.defaultValue(option.width, 3)
                }
            });
            entity.VectorType = 'polyline';
        } else if (type === 'wall') {
            let positions = option.positions;
            positions = option.haveZ ?
                that._cesium.Cartesian3.fromDegreesArrayHeights(positions) :
                that._cesium.Cartesian3.fromDegreesArray(positions)
                ;
            entity = viewer.entities.add({
                wall: {
                    positions: new that._cesium.CallbackProperty(function () {
                        return positions
                    }, false),
                    minimumHeights: option.minimumHeights,
                    maximumHeights: option.maximumHeights,
                    material: option.material,
                    outline: true,
                    outlineWidth: that._core.defaultValue(option.outlineWidth, 0),
                    outlineColor: option.outlineColor
                }
            });
            entity.VectorType = 'wall';
        } else if (type === 'label') {
            entity = viewer.entities.add({
                position: option.position,
                label: {
                    text: option.text, //文本
                    font: option.font,
                    scale: option.scale,
                    style: option.style,
                    fillColor: option.fillColor,
                    outlineColor: option.outlineColor,
                    outlineWidth: option.outlineWidth,
                    showBackground: option.showBackground,
                    backgroundColor: option.backgroundColor,
                    heightReference: option.heightReference,
                    horizontalOrigin: option.horizontalOrigin,
                    verticalOrigin: option.verticalOrigin,
                    scaleByDistance: option.scaleByDistance,
                    distanceDisplayCondition: option.distanceDisplayCondition
                }
            });
            entity.VectorType = 'label';
        } else if (type === 'billboard') {
            entity = viewer.entities.add({
                position: option.position,
                billboard: {
                    rotation: option.rotation,
                    width: option.width,
                    height: option.height,
                    image: option.image,
                    color: option.color,
                    scale: option.scale,
                    heightReference: option.heightReference,
                    horizontalOrigin: option.horizontalOrigin,
                    verticalOrigin: option.verticalOrigin,
                    scaleByDistance: option.scaleByDistance,
                    distanceDisplayCondition: option.distanceDisplayCondition
                }
            });
            entity.VectorType = 'billboard';
        } else if (type === 'point') {
            entity = viewer.entities.add({
                position: option.position,
                point: {
                    pixelSize: option.pixelSize,
                    color: option.color,
                    outlineWidth: option.outlineWidth,
                    outlineColor: option.outlineColor,
                    heightReference: option.heightReference,
                    scaleByDistance: option.scaleByDistance,
                    distanceDisplayCondition: option.distanceDisplayCondition
                }
            });
            entity.VectorType = 'point';
        }
        return entity;
    };

    //删除按钮
    VectorTileProvider.prototype.delButton = function (show, position, even) {
        if (show) {
            let del = document.getElementById('DeleteMilitaryStandardDelete');
            if (!del) {
                del = document.createElement('button');
                del.id = 'DeleteMilitaryStandardDelete';
                del.innerText = '删除对象';
                del.style.cssText = `height: 38px;
                        line-height: 38px;
                        padding: 0 18px;
                        background-color: #052355;
                        color: #fff;
                        white-space: nowrap;
                        text-align: center;
                        font-size: 14px;
                        border: none;
                        border-radius: 2px;
                        cursor: pointer;
                        position: absolute;`;
                this._viewer.container.appendChild(del);
            }
            del.style.display = 'block';
            del.style.top = position.y + 'px';
            del.style.left = position.x + 'px';
            del.onclick = even;
        } else {
            let del = document.getElementById('DeleteMilitaryStandardDelete');
            if (del) {
                del.style.display = 'none';
                del.onclick = null;
            }

        }
    };

    //默认鼠标事件
    VectorTileProvider.prototype.defaultEvent = function (isOpen) {
        let scene = this._viewer.scene;
        scene.screenSpaceCameraController.enableRotate = isOpen;
        scene.screenSpaceCameraController.enableTranslate = isOpen;
        scene.screenSpaceCameraController.enableZoom = isOpen;
        scene.screenSpaceCameraController.enableTilt = isOpen;
        scene.screenSpaceCameraController.enableLook = isOpen;
    };

    //获取entity对象的类型和关联的对象
    VectorTileProvider.prototype.getEntityTypeAndObject = function (entity) {
        let data = {
            type: '',
            object: null
        };
        if (entity) {
            if (entity.billboard) {
                data.type = 'billboard';
                data.object = entity.billboard;
            } else if (entity.box) {
                data.type = 'box';
                data.object = entity.box;
            } else if (entity.corridor) {
                data.type = 'corridor';
                data.object = entity.corridor;
            } else if (entity.cylinder) {
                data.type = 'cylinder';
                data.object = entity.cylinder;
            } else if (entity.ellipse) {
                data.type = 'ellipse';
                data.object = entity.ellipse;
            } else if (entity.ellipsoid) {
                data.type = 'ellipsoid';
                data.object = entity.ellipsoid;
            } else if (entity.label) {
                data.type = 'label';
                data.object = entity.label;
            } else if (entity.model) {
                data.type = 'model';
                data.object = entity.model;
            } else if (entity.path) {
                data.type = 'path';
                data.object = entity.path;
            } else if (entity.plane) {
                data.type = 'plane';
                data.object = entity.plane;
            } else if (entity.point) {
                data.type = 'point';
                data.object = entity.point;
            } else if (entity.polygon) {
                data.type = 'polygon';
                data.object = entity.polygon;
            } else if (entity.polyline) {
                data.type = 'polyline';
                data.object = entity.polyline;
            } else if (entity.polylineVolume) {
                data.type = 'polylineVolume';
                data.object = entity.polylineVolume;
            } else if (entity.rectangle) {
                data.type = 'rectangle';
                data.object = entity.rectangle;
            } else if (entity.wall) {
                data.type = 'wall';
                data.object = entity.wall;
            }
        }
        return data;
    };


    /**
    * 
    * 世界坐标转经纬度
    * 
    */
    VectorTileProvider.prototype.toDegrees = function (cartesian) {
        let cartographic = this._cesium.Cartographic.fromCartesian(cartesian);
        return {
            lon: this._cesium.Math.toDegrees(cartographic.longitude),
            lat: this._cesium.Math.toDegrees(cartographic.latitude),
            height: cartographic.height
        };
    };

    VectorTileProvider.prototype.getSimpleGraphicData = function (type, geo) {
        let that = this;
        let viewer = this._viewer;
        SmartEarthPopupData.editGraphic = {
            entity: geo,
            type: type,
            graphic: geo[type],
            getValue: function (attr) {
                if (attr === 'position' || attr === 'name' || attr === 'id') {
                    return this.entity[attr] && (this.entity[attr].getValue ? this.entity[attr].getValue() : this.entity[attr]);
                } else if (attr === 'radius') {
                    if (this.type === 'ellipse') {
                        return this.graphic.semiMajorAxis.getValue();
                    } else if (this.type === 'ellipsoid') {
                        return this.graphic.radii.getValue().x;
                    } else if (this.type === 'cylinder') {
                        return this.graphic.bottomRadius.getValue();
                    }
                } else if (attr === 'pHeight') {
                    if (this.getValue('position')) {
                        let position = this.getValue('position');
                        let Cartographic = Cesium.Cartographic.fromCartesian(position);
                        return Cartographic.height;
                    }
                } else if (attr === 'repeat') {
                    return this.graphic.material[attr] && (this.graphic.material[attr].getValue ? this.graphic.material[attr].getValue() : this.graphic.material[attr]);
                } else {
                    return this.graphic[attr] && (this.graphic[attr].getValue ? this.graphic[attr].getValue() : this.graphic[attr]);
                }
            },
            changeHeightPoint: function (height) {
                if (tree.editPointID.height.length > 0) {
                    tree.editPointID.height.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            let e_p = e.position.getValue();
                            let e_d = that.toDegrees(e_p);
                            e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                        }
                    });
                }
            },
            changeEditPoint: function (height) {
                if (tree.editPointID.edit.length > 0) {
                    tree.editPointID.edit.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                if (tree.editPointID.size.length > 0) {
                    tree.editPointID.size.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                if (tree.editPointID.add.length > 0) {
                    tree.editPointID.add.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                let e = tree.editPointID.move;
                if (e) {
                    if (height === 'clampToGround') {
                        e.point.heightReference = 1;
                    } else {
                        e.point.heightReference = 0;
                        let e_p = e.position.getValue();
                        let e_d = that.toDegrees(e_p);
                        e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                    }
                }
            },
            clearAllEditPoint: function () {
                // 移除编辑点，清空编辑点数组
                tree.editPointID.edit.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.edit = [];

                tree.editPointID.height.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.height = [];

                tree.editPointID.add.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.add = [];

                tree.editPointID.size.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.size = [];

                tree.editPointID.move && viewer.entities.remove(tree.editPointID.move);
                tree.editPointID.move = undefined;
            },
            setTreeID: function (id) {
                // 移除编辑点，清空编辑点数组
                tree.editPointID.edit.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.height.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.add.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.size.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.move && (tree.editPointID.move.treeID = id);
            }
        };
        if (type === 'billboard' || type === 'point' || type === 'label' || type === 'model') {
            //获取颜色值
            let color = SmartEarthPopupData.editGraphic.getValue('color') || SmartEarthPopupData.editGraphic.getValue('fillColor');
            if (color) {
                getFillColor(color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            if (type === 'label') {
                let backgroundColor = SmartEarthPopupData.editGraphic.getValue('backgroundColor');
                if (backgroundColor) {
                    getBackgroundColor(backgroundColor);
                } else {
                    SmartEarthPopupData.editGraphic.backgroundColor = '#000000';
                    SmartEarthPopupData.editGraphic.backgroundAlpha = 80;
                }
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'position' || attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor' || attr === 'backgroundColor' || attr === 'fillColor') {
                        value = Cesium.Color.fromCssColorString(value);
                    } else if (attr === 'fontSize') {
                        let font = this.getValue('font');
                        font = font.split(' ');
                        font[0] = value;
                        value = font.join(' ');
                    } else if (attr === 'alpha') {
                        if (this.type === 'label') {
                            this.graphic.fillColor._value.alpha = value;
                        } else {
                            this.graphic.color._value.alpha = value;
                        }
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'backgroundAlpha') {
                        this.graphic.backgroundColor._value.alpha = value;
                        return;
                    } else if (attr === 'pHeight') {
                        if (this.getValue('position')) {
                            let position = this.getValue('position');
                            let Cartographic = Cesium.Cartographic.fromCartesian(position);
                            Cartographic.height = value;
                            this.entity.position = Cesium.Cartographic.toCartesian(Cartographic);
                            return;
                        }
                    }
                    this.graphic[attr] = value;
                }
            };
        } else if (type === 'polyline') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            if (material.outlineColor) {
                getOutlineColor(material.outlineColor);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'outlineWidth') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.material.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic[attr] = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let pottingPoint = this.getValue('positions');
                this.entity.pottingPoint = pottingPoint;
                return pottingPoint;
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    // if (this.getValue('extrudedHeight') !== undefined) {
                    //     let cartographic = Cesium.Cartographic.fromCartesian(item);
                    //     let degrees = {
                    //         lon: Cesium.Math.toDegrees(cartographic.longitude),
                    //         lat: Cesium.Math.toDegrees(cartographic.latitude),
                    //         height: this.getValue('extrudedHeight')
                    //     }

                    //     if (this.getValue('height')) {
                    //         let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                    //         item.x = e_p.x;
                    //         item.y = e_p.y;
                    //         item.z = e_p.z;
                    //         edit_point.position = e_p;
                    //         this.entity.pottingPoint[index] = e_p.clone();
                    //     }

                    //     let heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: Cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.push(heightpoint.id);
                    // }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });

                for (let i = 0; i < points.length - 1; i++) {
                    let add_position = Cesium.Cartesian3.midpoint(points[i], points[i + 1], new Cesium.Cartesian3());
                    //添加节点
                    let add_point = viewer.entities.add({
                        name: "_add_point",
                        position: add_position,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.add.push(add_point.id);
                }
            };
        } else if (type === 'polygon') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic.hierarchy = new Cesium.CallbackProperty(function () {
                            return new Cesium.PolygonHierarchy(value);
                        }, false);
                        return;
                    } else if (attr === 'hierarchy') {
                        this.graphic.hierarchy = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'clampToGround') {
                        if (this.graphic.hierarchy instanceof Cesium.CallbackProperty) {
                            this.graphic.hierarchy = this.graphic.hierarchy.getValue();
                            setTimeout(() => {
                                changeGround(this.graphic, this.entity.pottingPoint, value);
                            }, 100);
                        } else {
                            changeGround(this.graphic, this.entity.pottingPoint, value);
                        }
                        //更新新增节点贴地状态
                        if (tree.editPointID.add.length > 0) {
                            tree.editPointID.add.forEach(item => {
                                let updataAddPoint = viewer.entities.getById(item);
                                if (updataAddPoint) {
                                    if (value) {
                                        updataAddPoint.point.heightReference = 1;
                                    } else {
                                        updataAddPoint.point.heightReference = 0;
                                    }
                                }
                            });
                        }

                        function changeGround(graphic, points, checked) {
                            if (checked) {
                                graphic.perPositionHeight = false;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.perPositionHeight = true;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            //更新节点高度
                            if (tree.editPointID.edit.length > 0 && !checked) {
                                points.forEach((item, index) => {
                                    let _editPoint = viewer.entities.getById(tree.editPointID.edit[index]);
                                    if (_editPoint) {
                                        let p = _editPoint.position.getValue();
                                        item.x = p.x;
                                        item.y = p.y;
                                        item.z = p.z;
                                    }
                                });
                            }
                            graphic.hierarchy = new Cesium.CallbackProperty(function () {
                                return new Cesium.PolygonHierarchy(points);
                            }, false);
                        }
                        return;
                    } else if (attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (attr === 'height') {
                        this.changeEditPoint(value);
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let hierarchy = this.getValue('hierarchy');
                let positions = hierarchy.positions.concat([]);
                if (this.getValue('height') !== undefined) {
                    let height = this.getValue('height');
                    positions.forEach(item => {
                        let degree = that.toDegrees(item);
                        let cartesian = Cesium.Cartesian3.fromDegrees(degree.lon, degree.lat, height);
                        item.x = cartesian.x;
                        item.y = cartesian.y;
                        item.z = cartesian.z;
                    });
                }
                this.entity.pottingPoint = positions;
                return positions;
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    // if (this.getValue('extrudedHeight') !== undefined) {
                    //     let cartographic = Cesium.Cartographic.fromCartesian(item);
                    //     let degrees = {
                    //         lon: Cesium.Math.toDegrees(cartographic.longitude),
                    //         lat: Cesium.Math.toDegrees(cartographic.latitude),
                    //         height: this.getValue('extrudedHeight')
                    //     }

                    //     if (this.getValue('height')) {
                    //         let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                    //         item.x = e_p.x;
                    //         item.y = e_p.y;
                    //         item.z = e_p.z;
                    //         edit_point.position = e_p;
                    //         this.entity.pottingPoint[index] = e_p.clone();
                    //     }

                    //     let heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: Cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.push(heightpoint.id);
                    // }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                //移动节点
                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });

                for (let i = 0; i < points.length - 1; i++) {
                    let add_position = Cesium.Cartesian3.midpoint(points[i], points[i + 1], new Cesium.Cartesian3());
                    //添加节点
                    let add_point = viewer.entities.add({
                        name: "_add_point",
                        position: add_position,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.add.push(add_point.id);
                }

                //首尾间的添加节点
                let add_position = Cesium.Cartesian3.midpoint(points[0], points[points.length - 1], new Cesium.Cartesian3());
                let add_point = viewer.entities.add({
                    name: "_add_point",
                    position: add_position,
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
                tree.editPointID.add.push(add_point.id);
            };
        } else if (type === 'ellipse' || type === 'cylinder' || geo.isSphere) {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'semiMajorAxis') {
                        this.graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'semiMinorAxis') {
                        this.graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'radii') {
                        this.graphic.radii = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'topRadius') {
                        this.graphic.topRadius = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'bottomRadius') {
                        this.graphic.bottomRadius = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'radius') {
                        if (this.type === 'ellipse') {
                            this.graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                            this.graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                        } else if (this.type === 'ellipsoid') {
                            if (this.graphic.material.image.getValue() !== null) {
                                this.graphic.radii = new Cesium.Cartesian3(value, value, value);
                            } else {
                                this.graphic.radii = new Cesium.CallbackProperty(function () {
                                    return new Cesium.Cartesian3(value, value, value);
                                }, false);
                            }
                        } else if (this.type === 'cylinder') {
                            this.graphic.bottomRadius = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                            if (this.entity.changeTop) {
                                this.graphic.topRadius = new Cesium.CallbackProperty(function () {
                                    return value;
                                }, false);
                            }
                        }
                        let center = tree.editPointID.move.position.getValue();
                        let newPosition = that.GetPositionFromA_D(center, value, 90);

                        // 更新编辑点的位置
                        let _sizePoint = viewer.entities.getById(tree.editPointID.size[0]);
                        _sizePoint.position = newPosition;
                        geo.pottingPoint[0] = newPosition;
                        geo.pottingPoint[geo.pottingPoint.length - 1] = center;

                        //修改对应的拉伸节点
                        let thisHeightPoint = viewer.entities.getById(tree.editPointID.height[0]);
                        if (thisHeightPoint) {
                            let degrees = that.toDegrees(newPosition);
                            //修改拉伸节点位置
                            let expiontcart = that._cesium.Cartographic.fromCartesian(thisHeightPoint.position.getValue());
                            thisHeightPoint.position = that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, expiontcart.height);
                        }
                        return;
                    } else if (this.type === 'cylinder' && attr === 'length') {
                        this.graphic.length = value;
                        let degrees = that.toDegrees(this.entity.pottingPoint[1]);
                        this.entity.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + value / 2);
                        this.changeHeightPoint(degrees.height + value);
                        return;
                    } else if (this.type === 'ellipse' && attr === 'clampToGround') {
                        if (this.graphic.semiMinorAxis instanceof Cesium.CallbackProperty) {
                            this.graphic.semiMinorAxis = this.graphic.semiMinorAxis.getValue();
                            this.graphic.semiMajorAxis = this.graphic.semiMajorAxis.getValue();
                            setTimeout(() => {
                                changeGround(this.entity, this.graphic, value);
                            }, 100);
                        } else {
                            changeGround(this.entity, this.graphic, value);
                        }

                        if (!value) {
                            this.changeEditPoint(this.entity.thisHeight);
                        } else {
                            this.changeEditPoint('clampToGround');
                        }

                        function changeGround(entity, graphic, checked) {
                            if (checked) {
                                if (entity.thisHeight === undefined) {
                                    entity.thisHeight = graphic.height && graphic.height.getValue();
                                }
                                graphic.height = undefined;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.height = entity.thisHeight;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            let radius = graphic.semiMinorAxis.getValue();
                            graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                                return radius;
                            }, false);
                            graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                                return radius;
                            }, false);
                        }
                        return;
                    } else if (this.type === 'ellipse' && attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (this.type === 'ellipse' && attr === 'height') {
                        this.changeEditPoint(value);
                        this.entity.thisHeight = value;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let radius = this.getValue('radius');
                let position = this.getValue('position');
                if (this.type === 'ellipse' || this.entity.isSphere) {
                    if (this.type === 'ellipse' && this.getValue('height') !== undefined) {
                        let height = this.getValue('height');
                        let degree = that.toDegrees(position);
                        position = Cesium.Cartesian3.fromDegrees(degree.lon, degree.lat, height);
                    }
                    let position0 = that.GetPositionFromA_D(position, radius, 90);
                    this.entity.pottingPoint = [position0, position];
                    return [position0, position];
                } else {
                    let degrees = that.toDegrees(position);
                    //求cylinder底部点位置
                    position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height - this.getValue('length') / 2);
                    let position0 = that.GetPositionFromA_D(position, radius, 90);
                    this.entity.pottingPoint = [position0, position];
                    return [position0, position];
                }
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;
                //大小节点
                let size_point = viewer.entities.add({
                    name: "_size_point",
                    position: points[0],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
                size_point.angle = 90;
                tree.editPointID.size.push(size_point.id);

                //拉伸节点
                // if (this.getValue('extrudedHeight') !== undefined) {
                //     let degrees = that.toDegrees(points[1]);
                //     degrees.height = this.getValue('extrudedHeight');

                //     let heightpoint = viewer.entities.add({
                //         name: "_height_point",
                //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                //         point: {
                //             color: Cesium.Color.YELLOW,
                //             pixelSize: 12,
                //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                //             outlineWidth: 2,
                //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                //         }
                //     });
                //     tree.editPointID.height.push(heightpoint.id);
                // } else if (type === 'cylinder') {
                //     let degrees = that.toDegrees(points[1]);
                //     let length = this.getValue('length');
                //     let heightpoint = viewer.entities.add({
                //         name: "_height_point",
                //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + length),
                //         point: {
                //             color: Cesium.Color.YELLOW,
                //             pixelSize: 12,
                //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                //             outlineWidth: 2,
                //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                //         }
                //     });
                //     tree.editPointID.height.push(undefined, heightpoint.id);
                // }

                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: points[1],
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'rectangle') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic.coordinates = new Cesium.CallbackProperty(function () {
                            return Cesium.Rectangle.fromCartesianArray(value);
                        }, false);
                        return;
                    } else if (attr === 'coordinates') {
                        this.graphic.coordinates = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'clampToGround') {
                        if (this.graphic.coordinates instanceof Cesium.CallbackProperty) {
                            this.graphic.coordinates = this.graphic.coordinates.getValue();
                            setTimeout(() => {
                                changeGround(this.entity, this.graphic, value);
                            }, 100);
                        } else {
                            changeGround(this.entity, this.graphic, value);
                        }

                        if (!value) {
                            this.changeEditPoint(this.entity.thisHeight);
                        } else {
                            this.changeEditPoint('clampToGround');
                        }

                        function changeGround(entity, graphic, checked) {
                            if (checked) {
                                if (entity.thisHeight === undefined) {
                                    entity.thisHeight = graphic.height && graphic.height.getValue();
                                }
                                graphic.height = undefined;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.height = entity.thisHeight;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            let coordinates = graphic.coordinates.getValue();
                            graphic.coordinates = new Cesium.CallbackProperty(function () {
                                return coordinates;
                            }, false);
                        }
                        return;
                    } else if (attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (attr === 'height') {
                        this.changeEditPoint(value);
                        this.entity.thisHeight = value;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let coordinates = this.getValue('coordinates');
                let position0, position1;
                let height = this.getValue('height');
                if (height !== undefined) {
                    position0 = Cesium.Cartesian3.fromRadians(coordinates.west, coordinates.north, height);
                    position1 = Cesium.Cartesian3.fromRadians(coordinates.east, coordinates.south, height);
                } else {
                    height = viewer.scene.sampleHeight(new Cesium.Cartographic(coordinates.west, coordinates.north, 0), [this.entity]);
                    position0 = Cesium.Cartesian3.fromRadians(coordinates.west, coordinates.north, height);
                    height = viewer.scene.sampleHeight(new Cesium.Cartographic(coordinates.east, coordinates.south, 0), [this.entity]);
                    position1 = Cesium.Cartesian3.fromRadians(coordinates.east, coordinates.south, height);
                }
                this.entity.pottingPoint = [position0, position1];
                return [position0, position1];
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    // if (this.getValue('extrudedHeight') !== undefined) {
                    //     let cartographic = Cesium.Cartographic.fromCartesian(item);
                    //     let degrees = {
                    //         lon: Cesium.Math.toDegrees(cartographic.longitude),
                    //         lat: Cesium.Math.toDegrees(cartographic.latitude),
                    //         height: this.getValue('extrudedHeight')
                    //     }

                    //     if (this.getValue('height')) {
                    //         let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                    //         item.x = e_p.x;
                    //         item.y = e_p.y;
                    //         item.z = e_p.z;
                    //         edit_point.position = e_p;
                    //         this.entity.pottingPoint[index] = e_p.clone();
                    //     }

                    //     let heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: Cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.push(heightpoint.id);
                    // }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                //移动节点
                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'box') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'long' || attr === 'width' || attr === 'height') {
                        let dimensions = this.getValue('dimensions');
                        if (attr === 'long') {
                            dimensions.x = value;
                        } else if (attr === 'width') {
                            dimensions.y = value;
                        } else {
                            dimensions.z = value;
                        }
                        this.graphic.dimensions = new Cesium.CallbackProperty(function () {
                            return dimensions;
                        }, false);

                        if (attr === 'long' || attr === 'width') {
                            let angle = attr === 'long' ? 90 : 180;
                            let pointIndex = attr === 'long' ? 0 : 1;
                            let center = tree.editPointID.move.position.getValue();
                            let newPosition = that.GetPositionFromA_D(center, value / 2, angle);

                            // 更新编辑点的位置
                            let _sizePoint = viewer.entities.getById(tree.editPointID.size[pointIndex]);
                            _sizePoint.position = newPosition;
                            this.entity.pottingPoint[pointIndex] = newPosition;
                            this.entity.pottingPoint[this.entity.pottingPoint.length - 1] = center;
                        } else {
                            let degrees = that.toDegrees(tree.editPointID.move.position.getValue());
                            this.entity.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + value / 2);
                            this.changeHeightPoint(degrees.height + value);
                        }
                        return;
                    } else if (attr === 'dimensions') {
                        this.graphic.dimensions = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let dimensions = this.getValue('dimensions');
                let position = this.getValue('position');
                let degrees = that.toDegrees(position);
                //求box底部点位置
                position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height - dimensions.z / 2);
                let position0 = that.GetPositionFromA_D(position, dimensions.x / 2, 90);
                let position1 = that.GetPositionFromA_D(position, dimensions.y / 2, 180);
                this.entity.pottingPoint = [position0, position1, position];
                return [position0, position1, position];
            };

            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;
                //大小节点
                let size_point1 = viewer.entities.add({
                    name: "_size_point",
                    position: points[0],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY
                    }
                });
                size_point1.angle = 90;

                let size_point2 = viewer.entities.add({
                    name: "_size_point",
                    position: points[1],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY
                    }
                });
                size_point2.angle = 180;
                tree.editPointID.size.push(size_point1.id);
                tree.editPointID.size.push(size_point2.id);

                //拉伸节点
                // let degrees = that.toDegrees(points[2]);
                // let dimensions = this.getValue('dimensions');
                // let heightpoint = viewer.entities.add({
                //     name: "_height_point",
                //     position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + dimensions.z),
                //     point: {
                //         color: Cesium.Color.YELLOW,
                //         pixelSize: 12,
                //         outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                //         outlineWidth: 2,
                //         disableDepthTestDistance: Number.POSITIVE_INFINITY,
                //     }
                // });
                // tree.editPointID.height.push(undefined, undefined, heightpoint.id);

                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: points[2],
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'corridor') ; else if (type === 'ellipsoid' && !geo.isSphere) ; else ;

        function getFillColor(rgba) {
            SmartEarthPopupData.editGraphic.fillColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.alpha = rgba.alpha * 100;
        }

        function getOutlineColor(rgba) {
            SmartEarthPopupData.editGraphic.outlineColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.outlineAlpha = rgba.alpha * 100;
        }

        function getBackgroundColor(rgba) {
            SmartEarthPopupData.editGraphic.backgroundColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.backgroundAlpha = rgba.alpha * 100;
        }

        function colorHex(rgb) {
            let _this = rgb;
            let reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;
            if (/^(rgb|RGB)/.test(_this)) {
                let str = _this.replace(/(rgb|RGB)*/g, "");
                str = str.replace("(", "").replace(")", "");
                let aColor = str.split(",");
                let strHex = "#";
                for (let i = 0; i < aColor.length; i++) {
                    let hex = Number(aColor[i]).toString(16);
                    hex = hex.length === 1 ? 0 + '' + hex : hex;// 保证每个rgb的值为2位
                    if (hex === "0") {
                        hex += hex;
                    }
                    strHex += hex;
                }
                if (strHex.length !== 7) {
                    strHex = _this;
                }
                return strHex;
            } else if (reg.test(_this)) {
                let aNum = _this.replace(/#/, "").split("");
                if (aNum.length === 6) {
                    return _this;
                } else if (aNum.length === 3) {
                    let numHex = "#";
                    for (let i = 0; i < aNum.length; i += 1) {
                        numHex += (aNum[i] + aNum[i]);
                    }
                    return numHex;
                }
            } else {
                return _this;
            }
        }
    };

    function VectorTileProviderEntity(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._quadtree = undefined;
        this._tilingScheme = new Cesium.GeographicTilingScheme();
        this._errorEvent = new Cesium.Event();
        this._reTilesKey = [];
        this._state = true;
        //前端点击显示隐藏控制字段
        this._client = true;

        this._reTiles = [];
        this._normalTile = 16;

        this._minimumHeight = 0.0;
        this._maximumHeight = 0.0;

        this._PrimitiveCollection = new Cesium.PrimitiveCollection();
        this._levelZeroMaximumError = Cesium.QuadtreeTileProvider.computeDefaultLevelZeroMaximumGeometricError(
            this._tilingScheme);
        this.cartographicLimitRectangle = Cesium.Rectangle.clone(Cesium.Rectangle.MAX_VALUE);
        if (!VectorTileProviderEntity.prototype.ready)
            Object.defineProperties(VectorTileProviderEntity.prototype, {
                quadtree: {
                    get: function () {
                        return this._quadtree;
                    },
                    set: function (value) {
                        this._quadtree = value;
                    }
                },
                ready: {
                    get: function () {
                        return true;
                    }
                },
                tilingScheme: {
                    get: function () {
                        return this._tilingScheme;
                    }
                },
                errorEvent: {
                    get: function () {
                        return this._errorEvent;
                    }
                }
            });

        this._core = new Core();
        this.tooltip = this._core.CreateTooltip();
        this._getPosition = new getPosition(this._viewer, this._cesium);
    }
    VectorTileProviderEntity.prototype.update = function (frameState) {
        this._quadtree.beginFrame(frameState);
        // try {
        //     if (this.cs != undefined && this.cs == undefined) {
        //     } else {
        this._quadtree.render(frameState);
        //     }
        // } catch (ex) { };
        this._quadtree.endFrame(frameState);
    };
    VectorTileProviderEntity.prototype.static = function (cs) {
        this.cs = cs;
    };
    VectorTileProviderEntity.prototype.initialize = function (frameState) { };

    VectorTileProviderEntity.prototype.beginUpdate = function (frameState) {
        //frameState.context._pickObjects = null;
        //for (var i = 0; i < this._reTiles.length; i++) {
        //    var tile = this._reTiles[i];
        //    if (this.computeTileVisibility(tile, frameState, null) == Cesium.Visibility.NONE) {
        //        for (var key in frameState.context._pickObjects) {
        //            var obj = frameState.context._pickObjects[key];
        //            if (obj.id.indexOf('z' + tile.level + 'x' + tile.x + 'y' + tile.y + 'n') == 0) {
        //                delete frameState.context._pickObjects[key];
        //            }
        //        }
        //    }
        //}
    };

    VectorTileProviderEntity.prototype.endUpdate = function (frameState) {
        //frameState.context._pickObjects = [];


        //for (var key in frameState.context._pickObjects) {
        //    var obj = frameState.context._pickObjects[key];
        //    if ()
        //}
    };

    VectorTileProviderEntity.prototype.getLevelMaximumGeometricError = function (level) {
        return this._levelZeroMaximumError / (1 << level);
    };

    VectorTileProviderEntity.prototype.loadTile = function (frameState, tile) {

    };

    VectorTileProviderEntity.prototype.computeTileVisibility = function (tile, frameState, occluders) {
        var distance = this.computeDistanceToTile(tile, frameState);
        tile._distance = distance;

        if (frameState.fog.enabled) {
            if (Cesium.Math.fog(distance, frameState.fog.density) >= 1.0) {
                // Tile is completely in fog so return that it is not visible.
                return Cesium.Visibility.NONE;
            }
        }

        var surfaceTile = tile.data;
        surfaceTile.tileBoundingRegion;

        if (surfaceTile.boundingVolumeSourceTile === undefined) {
            // We have no idea where this tile is, so let's just call it partially visible.
            return Cesium.Visibility.PARTIAL;
            //return Cesium.Visibility.NONE;
        }

        var cullingVolume = frameState.cullingVolume;
        var boundingVolume = surfaceTile.orientedBoundingBox;

        if (!boundingVolume && surfaceTile.renderedMesh) {
            boundingVolume = surfaceTile.renderedMesh.boundingSphere3D;
        }

        // Check if the tile is outside the limit area in cartographic space
        surfaceTile.clippedByBoundaries = false;

        function clipRectangleAntimeridian(tileRectangle, cartographicLimitRectangle) {
            if (cartographicLimitRectangle.west < cartographicLimitRectangle.east) {
                return cartographicLimitRectangle;
            }
            var splitRectangle = Rectangle.clone(cartographicLimitRectangle, splitCartographicLimitRectangleScratch);
            var tileCenter = Rectangle.center(tileRectangle, rectangleCenterScratch);
            if (tileCenter.longitude > 0.0) {
                splitRectangle.east = CesiumMath.PI;
            } else {
                splitRectangle.west = -CesiumMath.PI;
            }
            return splitRectangle;
        }
        var clippedCartographicLimitRectangle = clipRectangleAntimeridian(tile.rectangle, this
            .cartographicLimitRectangle);
        var rectangleIntersectionScratch = new Cesium.Rectangle();
        var areaLimitIntersection = Cesium.Rectangle.simpleIntersection(clippedCartographicLimitRectangle, tile
            .rectangle, rectangleIntersectionScratch);
        if (!areaLimitIntersection) {

            return Visibility.NONE;
        }
        if (!Cesium.Rectangle.equals(areaLimitIntersection, tile.rectangle)) {
            surfaceTile.clippedByBoundaries = true;
        }

        if (frameState.mode !== Cesium.SceneMode.SCENE3D) ;

        if (!boundingVolume) {
            return Cesium.Intersect.INTERSECTING;
        }

        var clippingPlanes = this._clippingPlanes;
        if (clippingPlanes && clippingPlanes.enabled) {
            var planeIntersection = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
            tile.isClipped = (planeIntersection !== Intersect.INSIDE);
            if (planeIntersection === Cesium.Intersect.OUTSIDE) {

                return Cesium.Visibility.NONE;
            }
        }

        var intersection = cullingVolume.computeVisibility(boundingVolume);
        if (intersection === Cesium.Intersect.OUTSIDE) {

            return Cesium.Visibility.NONE;
        }

        var ortho3D = frameState.mode === Cesium.SceneMode.SCENE3D && frameState.camera
            .frustum instanceof Cesium.OrthographicFrustum;
        if (frameState.mode === Cesium.SceneMode.SCENE3D && !ortho3D && occluders) {
            var occludeePointInScaledSpace = surfaceTile.occludeePointInScaledSpace;
            if (!occludeePointInScaledSpace) {
                return intersection;
            }

            if (occluders.ellipsoid.isScaledSpacePointVisible(occludeePointInScaledSpace)) {
                return intersection;
            }

            return Cesium.Visibility.NONE;
        }

        return intersection;
    };

    VectorTileProviderEntity.prototype.canRefine = function (tile, frameState, occluders) {
        if (tile.level < this._normalTile)
            return true;
        return false;
    };

    VectorTileProviderEntity.prototype.showTileThisFrame = function (tile, context, frameState, commandList) {
        // if (tile.data.geometryPrimitive && tile.data.geometryPrimitive._isModel) {
        //     for (var i = 0, l = tile.data.geometryPrimitive.length; i < l; i++)
        //         if (tile.data.geometryPrimitive[i] && tile.data.geometryPrimitive[i]._primitives)
        //             tile.data.geometryPrimitive[i]._primitives._isRender = 1;
        // }
        // else 
        if (this._availability) {
            this._state = this.isAvailable(context.time);
        }
        if (tile.data.geometryPrimitive && this._state && this._client && typeof tile.data.geometryPrimitive.update == 'function') {
            tile.data.geometryPrimitive.update(context, frameState, commandList);
            // tile.data.geometryPrimitive._isUpdateQuad = 1;
        }
    };

    VectorTileProviderEntity.prototype.computeDistanceToTile = function (tile, frameState) {
        function computeOccludeePoint(tileProvider, center, rectangle, height, result) {
            var ellipsoidalOccluder = tileProvider.quadtree._occluders.ellipsoid;
            var ellipsoid = ellipsoidalOccluder.ellipsoid;
            var cornerPositionsScratch = [new Cesium.Cartesian3(), new Cesium.Cartesian3(), new Cesium.Cartesian3(),
            new Cesium.Cartesian3()
            ];
            var cornerPositions = cornerPositionsScratch;
            Cesium.Cartesian3.fromRadians(rectangle.west, rectangle.south, height, ellipsoid, cornerPositions[0]);
            Cesium.Cartesian3.fromRadians(rectangle.east, rectangle.south, height, ellipsoid, cornerPositions[1]);
            Cesium.Cartesian3.fromRadians(rectangle.west, rectangle.north, height, ellipsoid, cornerPositions[2]);
            Cesium.Cartesian3.fromRadians(rectangle.east, rectangle.north, height, ellipsoid, cornerPositions[3]);

            return ellipsoidalOccluder.computeHorizonCullingPoint(center, cornerPositions, result);
        }

        function updateTileBoundingRegion(_maximumHeight, _minimumHeight, tile, terrainProvider, frameState) {
            var surfaceTile = tile.data;
            if (surfaceTile === undefined) {
                surfaceTile = tile.data = new Cesium.GlobeSurfaceTile();
            }
            if (tile._minimumHeight) {
                _minimumHeight = tile._minimumHeight;
            }
            if (tile._maximumHeight) {
                _maximumHeight = tile._maximumHeight;
            }
            if (surfaceTile.tileBoundingRegion === undefined) {
                surfaceTile.tileBoundingRegion = new Cesium.TileBoundingRegion({
                    computeBoundingVolumes: false,
                    rectangle: tile.rectangle,
                    ellipsoid: tile.tilingScheme.ellipsoid,
                    minimumHeight: _minimumHeight || 0.0,
                    maximumHeight: _maximumHeight || 0.0
                });
            }
            return tile;
        }
        var heightSource = updateTileBoundingRegion(this._maximumHeight, this._minimumHeight, tile, this.terrainProvider);
        var surfaceTile = tile.data;
        var tileBoundingRegion = surfaceTile.tileBoundingRegion;

        if (heightSource === undefined) {
            // Can't find any min/max heights anywhere? Ok, let's just say the
            // tile is really far away so we'll load and render it rather than
            // refining.
            return 9999999999.0;
        } else if (surfaceTile.boundingVolumeSourceTile !== heightSource) {
            // Heights are from a new source tile, so update the bounding volume.
            surfaceTile.boundingVolumeSourceTile = heightSource;

            var rectangle = tile.rectangle;
            if (rectangle && rectangle.width < Cesium.Math.PI_OVER_TWO + Cesium.Math.EPSILON5) {
                surfaceTile.orientedBoundingBox = Cesium.OrientedBoundingBox.fromRectangle(
                    tile.rectangle,
                    tileBoundingRegion.minimumHeight,
                    tileBoundingRegion.maximumHeight,
                    tile.tilingScheme.ellipsoid,
                    surfaceTile.orientedBoundingBox);

                surfaceTile.occludeePointInScaledSpace = computeOccludeePoint(this, surfaceTile
                    .orientedBoundingBox.center, tile.rectangle, tileBoundingRegion.maximumHeight,
                    surfaceTile.occludeePointInScaledSpace);
            }
        }

        var min = tileBoundingRegion.minimumHeight;
        var max = tileBoundingRegion.maximumHeight;

        if (surfaceTile.boundingVolumeSourceTile !== tile) {
            var cameraHeight = frameState.camera.positionCartographic.height;
            var distanceToMin = Math.abs(cameraHeight - min);
            var distanceToMax = Math.abs(cameraHeight - max);
            if (distanceToMin > distanceToMax) {
                tileBoundingRegion.minimumHeight = min;
                tileBoundingRegion.maximumHeight = min;
            } else {
                tileBoundingRegion.minimumHeight = max;
                tileBoundingRegion.maximumHeight = max;
            }
        }

        var result = tileBoundingRegion.distanceToCamera(frameState);

        tileBoundingRegion.minimumHeight = min;
        tileBoundingRegion.maximumHeight = max;

        return result;
    };

    VectorTileProviderEntity.prototype.isDestroyed = function () {
        return false;
    };

    VectorTileProviderEntity.prototype.destroy = function () {
        return Cesium.destroyObject(this);
    };

    VectorTileProviderEntity.prototype.remove = function () {
        this.destroy();
    };
    VectorTileProviderEntity.prototype.setStatus = function (state) {
        this._state = state;
        this._client = state;
    };

    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    VectorTileProviderEntity.prototype.edit = function (open, option) {
        let that = this;
        let viewer = this._viewer;
        !option && (option = {});

        if (this.editHandler) {
            this.editHandler.destroy();
            this.editHandler = undefined;
        }
        open === undefined && (open = true);
        if (!open) {
            endThisEdit();
            return;
        }

        // 创建监听的handler
        this.editHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        //当前编辑的实体对象、当前的编辑点、当前的编辑点位置和当前编辑类型
        var geo, currentPoint, currentPointpos, type;
        // 判断是否处于编辑状态
        this.isEditting = false;
        //移动点（拖拽可移动当前图形）和选中编辑点的类型
        let pointType;

        // 对鼠标按下事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            // 获取屏幕坐标
            let windowPosition = event.position;
            // 通过屏幕坐标获取当前位置的实体
            let pickedObject = viewer.scene.pick(windowPosition);
            if (pickedObject) {
                if (pickedObject && pickedObject.id && pickedObject.id.treeID !== that.treeID) {
                    return;
                }
            }
            if (pickedObject && pickedObject.id && (pickedObject.id instanceof Cesium.Entity || pickedObject.id.VectorType)) {
                // 获取当前点的实体
                let entity = pickedObject.id;
                if (!that.isEditting && tree.states == 0) {
                    option.callBack && option.callBack.start && option.callBack.start(entity);
                    type = entity.VectorType;
                    geo = that.createEditEntity(type, entity.VectorStyle);
                    geo.feature = entity;
                    geo.treeID = that.treeID;

                    //获取简单图形数据
                    that.getSimpleGraphicData(type, geo);

                    if (type === 'point' || type === 'billboard' || type === 'label' || type === 'model') {
                        // 设置编辑状态为true 
                        that.isEditting = true;
                        that.tooltip.showAt(event.position, '拖拽修改位置');
                    } else {
                        // 设置编辑状态为true 
                        that.isEditting = true;
                        SmartEarthPopupData.editGraphic.updataEditPoint();
                        SmartEarthPopupData.editGraphic.setTreeID(that.treeID);
                    }
                    that.setStatus(false);
                    tree.editVector = true;
                } else if ((entity == geo && (entity.VectorType === 'point' || entity.VectorType === 'billboard' || entity.VectorType === 'label' || entity.VectorType === 'model')) ||
                    entity.name == "_height_point" || entity.name == "_edit_point" || entity.name == "_move_point" || entity.name == "_add_point" || entity.name == "_size_point") {
                    viewer.container.style.cursor = 'crosshair';
                    // 禁止地球旋转和缩放，地球的旋转会对鼠标移动监听有影响，所以需要禁止
                    that.defaultEvent(false);
                    if (entity.name == "_height_point") {
                        //获取当前高度点位置
                        currentPointpos = {
                            windowPosition: windowPosition,
                            originHeight: that._cesium.Cartographic.fromCartesian(entity.position.getValue()).height
                        };
                        pointType = "_height_point";
                    } else if (entity.name == "_move_point") {
                        pointType = "_move_point";
                    } else if (entity.VectorType === 'point' || entity.VectorType === 'billboard' || entity.VectorType === 'label' || entity.VectorType === 'model') {
                        that.tooltip.showAt(event.position, '释放后完成修改');
                        pointType = "_move_point";
                        //隐藏模型
                        if (entity.VectorType === 'model') {
                            entity.show = false;
                        }
                    } else if (entity.name == "_edit_point") {
                        pointType = "_edit_point";
                    } else if (entity.name == "_add_point") {
                        pointType = "_add_point";
                    } else if (entity.name == "_size_point") {
                        pointType = "_size_point";
                    }
                    // 如果实体为编辑点，那么设置当前编辑点为该点
                    currentPoint = entity;
                } else ;
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);

        //// 对鼠标移动事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            let pickedObject = viewer.scene.pick(event.endPosition);
            if (pickedObject) {
                if (pickedObject && pickedObject.id && pickedObject.id.treeID !== that.treeID) {
                    return;
                }
            }
            if (that._cesium.defined(pickedObject)) {
                if (that.isEditting && !currentPoint) {
                    if ((type === 'point' || type === 'billboard' || type === 'label' || type === 'model') && pickedObject.id == geo) {
                        //点类
                        that.tooltip.showAt(event.endPosition, '拖拽修改位置，右键删除');
                    } else if (pickedObject.id && pickedObject.id.name === "_edit_point" && geo.pottingPoint) {
                        //编辑节点
                        if (type === 'polyline' && geo.pottingPoint.length > 2) {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置，右键删除点');
                        } else if (type === 'polygon' && geo.pottingPoint.length > 3) {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置，右键删除点');
                        } else {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置');
                        }
                    } else if (pickedObject.id && (pickedObject.id.name === "_move_point" || pickedObject.id.name === "_size_point")) {
                        that.tooltip.showAt(event.endPosition, '拖拽修改位置');
                    } else if (pickedObject.id && pickedObject.id.name === "_add_point") {
                        that.tooltip.showAt(event.endPosition, '拖拽增加节点');
                    } else if (pickedObject.id && pickedObject.id.name === "_height_point") {
                        that.tooltip.showAt(event.endPosition, '拖拽修改高度');
                    } else if (pickedObject.id == geo) {
                        that.tooltip.show(false);
                    }
                } else if (!that.isEditting && tree.states === 0) {
                    if (pickedObject.id && pickedObject.id.VectorType) {
                        // that.tooltip.showAt(event.endPosition, '点击激活编辑，右键删除');
                        that.tooltip.showAt(event.endPosition, '点击激活编辑');
                    } else {
                        that.tooltip.show(false);
                    }
                }
            } else if (tree.states == 0 && !currentPoint) {
                that.tooltip.show(false);
            }

            // 如果处于编辑状态且编辑点已定义，那么开始拖拽编辑
            if (that.isEditting && currentPoint) {
                that.tooltip.showAt(event.endPosition, '释放后完成修改');
                let cartesian = that._getPosition.getMousePosition(event);
                //拉伸节点不需要获取当前位置坐标
                if (!cartesian && pointType !== "_height_point") {
                    return;
                }            ///地面上点
                if (pointType === "_edit_point") {
                    // 更新编辑点的位置
                    currentPoint.position = cartesian;
                    let pointIndex = tree.editPointID.edit.indexOf(currentPoint.id);

                    //修改对应坐标数据
                    if (geo[type].height !== undefined) {
                        let degrees = that.toDegrees(cartesian);
                        geo.pottingPoint[pointIndex] = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, geo[type].height.getValue());
                        currentPoint.position = geo.pottingPoint[pointIndex];
                    } else {
                        geo.pottingPoint[pointIndex] = cartesian;
                    }

                    //修改对应的拉伸节点
                    // if (tree.editPointID.height.length > 0) {
                    //     let thisHeightPoint = viewer.entities.getById(tree.editPointID.height[pointIndex]);
                    //     if (thisHeightPoint) {
                    //         let degrees = that.toDegrees(cartesian);
                    //         //修改拉伸节点位置
                    //         let expiontcart = that._cesium.Cartographic.fromCartesian(thisHeightPoint.position.getValue());
                    //         thisHeightPoint.position = that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, expiontcart.height);
                    //     }
                    // }

                    //修改边上的新增节点
                    if (tree.editPointID.add.length > 0) {
                        //上一个新增节点
                        if (pointIndex > 0) {
                            let thisAddPoint1 = viewer.entities.getById(tree.editPointID.add[pointIndex - 1]);
                            if (thisAddPoint1) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[pointIndex - 1]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                                thisAddPoint1.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                        //下一个新增节点
                        if (pointIndex < geo.pottingPoint.length - 1) {
                            let thisAddPoint2 = viewer.entities.getById(tree.editPointID.add[pointIndex]);
                            if (thisAddPoint2) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[pointIndex + 1]);
                                thisAddPoint2.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                        //面的起点和终点之间的节点
                        if (type === 'polygon' && (pointIndex === 0 || pointIndex === geo.pottingPoint.length - 1)) {
                            let thisAddPoint3 = viewer.entities.getById(tree.editPointID.add[tree.editPointID.add.length - 1]);
                            if (thisAddPoint3) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[0]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[geo.pottingPoint.length - 1]);
                                thisAddPoint3.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                    }

                    let positions = geo.pottingPoint.concat([]);
                    //修改移动节点位置
                    let _center = new that._cesium.Cartesian3();
                    let pointLength = positions.length;
                    positions.forEach(item => {
                        _center.x += item.x;
                        _center.y += item.y;
                        _center.z += item.z;
                    });
                    _center.x /= pointLength;
                    _center.y /= pointLength;
                    _center.z /= pointLength;
                    tree.editPointID.move && (tree.editPointID.move.position = _center);

                    //修改实体对象坐标
                    if (type === 'polyline' || type === 'polygon' || type === 'rectangle') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    }
                } else if (pointType === "_height_point") {////拉伸高度点
                    let pointIndex = tree.editPointID.height.indexOf(currentPoint.id);
                    let e_point = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                    if (type === 'ellipse' || type === 'cylinder' || type === 'box') {
                        //圆和圆柱、圆锥、立方体没有对应的编辑节点，对应移动节点
                        e_point = tree.editPointID.move;
                    }
                    let e_degrees = that.toDegrees(e_point.position.getValue());
                    let originHeight = currentPointpos.originHeight - e_degrees.height;
                    let e_winPosition = viewer.scene.cartesianToCanvasCoordinates(e_point.position.getValue());

                    //移动后高度变化
                    let _height = (currentPointpos.windowPosition.y - event.endPosition.y) * originHeight / Math.abs(e_winPosition.y - currentPointpos.windowPosition.y);

                    let h = Math.abs(originHeight + _height);
                    tree.editPointID.height.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            let e_p = e.position.getValue();
                            let e_d = that.toDegrees(e_p);
                            e.position = that._cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, h + e_degrees.height);
                        }
                    });

                    if (geo[type].extrudedHeight) {
                        geo[type].extrudedHeight = h + e_degrees.height;
                    } else if (type === 'box') {
                        SmartEarthPopupData.editGraphic.setValue('height', h);
                    } else if (type === 'cylinder') {
                        SmartEarthPopupData.editGraphic.setValue('length', h);
                    }
                } else if (pointType === "_add_point") {////新增节点
                    let addIndex = tree.editPointID.add.indexOf(currentPoint.id);
                    //移除旧新增节点
                    viewer.entities.remove(currentPoint);
                    //添加新的编辑节点
                    let new_edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: cartesian,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    tree.editPointID.edit.splice(addIndex + 1, 0, new_edit_point.id);
                    geo.pottingPoint.splice(addIndex + 1, 0, cartesian.clone());

                    //添加新的拉伸节点
                    // if (tree.editPointID.height.length > 0) {
                    //     //拉伸节点
                    //     let degrees = that.toDegrees(cartesian);
                    //     degrees.height = geo[type].extrudedHeight.getValue();

                    //     let new_heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: that._cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.splice(addIndex + 1, 0, new_heightpoint.id);
                    // }

                    //添加两个新的新增节点
                    let add_position1 = Cesium.Cartesian3.midpoint(geo.pottingPoint[addIndex], geo.pottingPoint[addIndex + 1], new Cesium.Cartesian3());
                    //添加节点1
                    let add_point1 = viewer.entities.add({
                        name: "_add_point",
                        position: add_position1,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    let add_position2 = Cesium.Cartesian3.midpoint(geo.pottingPoint[addIndex + 1], geo.pottingPoint[addIndex + 2 === geo.pottingPoint.length ? 0 : addIndex + 2], new Cesium.Cartesian3());
                    //添加节点2
                    let add_point2 = viewer.entities.add({
                        name: "_add_point",
                        position: add_position2,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    tree.editPointID.add.splice(addIndex, 1, add_point1.id, add_point2.id);

                    SmartEarthPopupData.editGraphic.setTreeID(that.treeID);

                    //转为编辑节点状态
                    currentPoint = new_edit_point;
                    pointType = '_edit_point';

                    //修改实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'polygon') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    }
                } else if (pointType === "_size_point") {    //大小节点
                    let center = tree.editPointID.move.position.getValue();
                    let distance = that._cesium.Cartesian3.distance(center, cartesian);

                    //修改实体对象坐标
                    if (type === 'ellipse' || type === 'cylinder' || (type === 'ellipsoid' && geo.isSphere)) {
                        SmartEarthPopupData.editGraphic.setValue('radius', distance);
                    } else if (type === 'box') {
                        let s = currentPoint.angle === 90 ? 'long' : 'width';
                        SmartEarthPopupData.editGraphic.setValue(s, distance * 2);
                    }
                } else {
                    //点类移动
                    if (type === 'point' || type === 'billboard' || type === 'label' || type === 'model') {
                        currentPoint.position = cartesian;
                        return;
                    }

                    ///移动后变化
                    let degrees1 = that.toDegrees(cartesian);
                    ///移动前经纬度
                    currentPointpos = currentPoint.position.getValue();
                    let degrees2 = that.toDegrees(currentPointpos);
                    //计算差值
                    let _x = degrees1.lon - degrees2.lon, _y = degrees1.lat - degrees2.lat, _z = degrees1.height - degrees2.height;

                    //修改移动节点位置
                    currentPoint.position = cartesian;
                    if (geo[type].height) {
                        let height = that.toDegrees(cartesian).height;
                        geo[type].height = height;
                        geo.thisHeight = height;
                    }

                    //修改所有节点位置
                    geo.pottingPoint.forEach((item, index) => {
                        let oldPosition, newPosition;

                        //对应的编辑节点
                        let _edit = viewer.entities.getById(tree.editPointID.edit[index]);
                        if (!_edit) {
                            //对应的大小节点
                            _edit = viewer.entities.getById(tree.editPointID.size[index]);
                        }

                        if (_edit) {
                            oldPosition = that.toDegrees(_edit.position.getValue());
                        } else {
                            oldPosition = that.toDegrees(item);
                        }

                        // if (geo[type].height) {
                        //     oldPosition.height = geo[type].height.getValue ? geo[type].height.getValue() : geo[type].height;
                        // }

                        newPosition = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                        item.x = newPosition.x;
                        item.y = newPosition.y;
                        item.z = newPosition.z;
                        //修改编辑节点坐标
                        _edit && (_edit.position = newPosition);

                        //修改拉伸节点坐标
                        // if (tree.editPointID.height.length > 0) {
                        //     let _heightPoint = viewer.entities.getById(tree.editPointID.height[index]);
                        //     if (_heightPoint) {
                        //         oldPosition = _heightPoint.position.getValue();
                        //         oldCartographic = that._cesium.Cartographic.fromCartesian(oldPosition);
                        //         oldPosition = {
                        //             lon: that._cesium.Math.toDegrees(oldCartographic.longitude),
                        //             lat: that._cesium.Math.toDegrees(oldCartographic.latitude),
                        //             height: oldCartographic.height
                        //         }
                        //         _heightPoint.position = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                        //     }
                        // }

                        //修改新增节点坐标
                        if (tree.editPointID.add.length > 0 && tree.editPointID.add[index]) {
                            let _addPoint = viewer.entities.getById(tree.editPointID.add[index]);
                            if (_addPoint) {
                                oldPosition = that.toDegrees(_addPoint.position.getValue());
                                // if (geo[type].height) {
                                //     oldPosition.height = geo[type].height.getValue ? geo[type].height.getValue() : geo[type].height;
                                // }
                                _addPoint.position = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                            }
                        }
                    });

                    //修改实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'polygon' || type === 'rectangle') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                        // if (tree.editPointID.height.length > 0) {
                        //     SmartEarthPopupData.editGraphic.setValue('extrudedHeight', SmartEarthPopupData.editGraphic.getValue('extrudedHeight') + _z);
                        // }
                    } else if (type === 'ellipse') {
                        geo.pottingPoint[1] = cartesian;
                        geo.position = cartesian.clone();
                    } else if (type === 'box') {
                        geo.pottingPoint[2] = cartesian;
                        let size = geo.box.dimensions.getValue();
                        let center = that.toDegrees(cartesian);
                        geo.position = Cesium.Cartesian3.fromDegrees(center.lon, center.lat, center.height + size.z / 2);
                    } else if (type === 'cylinder') {
                        geo.pottingPoint[1] = cartesian;
                        let length = geo.cylinder.length.getValue();
                        let degrees = that.toDegrees(geo.pottingPoint[1]);
                        geo.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + length / 2);
                    } else if (type === 'ellipsoid') {
                        geo.pottingPoint[geo.pottingPoint.length - 1] = cartesian;
                        geo.position = cartesian.clone();
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //// 对鼠标抬起事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            if (currentPoint && currentPoint.VectorType === 'model') {
                currentPoint.show = true;
            }
            if (currentPoint) {
                option.callBack && option.callBack.updata && option.callBack.updata(currentPoint.name, geo);
            }
            viewer.container.style.cursor = 'default';
            // 移除当前编辑点
            currentPoint = undefined;
            // 恢复地球的旋转和缩放
            that.defaultEvent(true);
        }, this._cesium.ScreenSpaceEventType.LEFT_UP);
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            // 通过屏幕坐标获取当前位置的实体信息
            let pickedObject = viewer.scene.pick(event.position);
            if (pickedObject && pickedObject.id && pickedObject.id.treeID !== that.treeID) {
                return;
            }
            // 如果实体信息存在则说明该位置存在实体
            if (that._cesium.defined(pickedObject) && tree.states == 0) {
                // 获取当前点的实体
                let entity = pickedObject.id;
                if (entity.VectorType) ; else if (tree.editPointID.edit.indexOf(entity.id) > -1 &&
                    ((type === 'polyline' && tree.editPointID.edit.length > 2) || (type === 'polygon' && tree.editPointID.edit.length > 3))) {
                    let thisPointIndex = tree.editPointID.edit.indexOf(entity.id);

                    //移除编辑节点
                    viewer.entities.removeById(entity.id);
                    tree.editPointID.edit.splice(thisPointIndex, 1);

                    //移除拉伸节点
                    // if (tree.editPointID.height.length > 0) {
                    //     viewer.entities.removeById(tree.editPointID.height[thisPointIndex]);
                    //     tree.editPointID.height.splice(thisPointIndex, 1);
                    // }

                    //移除实体对象节点
                    geo.pottingPoint.splice(thisPointIndex, 1);

                    //移除并更新新增节点
                    if (tree.editPointID.add.length > 0) {
                        //删除下一个新增节点
                        if (tree.editPointID.add[thisPointIndex]) {
                            viewer.entities.removeById(tree.editPointID.add[thisPointIndex]);
                            tree.editPointID.add.splice(thisPointIndex, 1);
                            //更新上一个新增节点
                            if (thisPointIndex - 1 >= 0) {
                                let updataAddPoint = viewer.entities.getById(tree.editPointID.add[thisPointIndex - 1]);
                                if (updataAddPoint) {
                                    //删除的是面的最后一个节点的话就计算第一个节点（索引0）和最后一个节点的中点
                                    updataAddPoint.position = Cesium.Cartesian3.midpoint(
                                        geo.pottingPoint[thisPointIndex - 1],
                                        geo.pottingPoint[thisPointIndex === geo.pottingPoint.length ? 0 : thisPointIndex],
                                        new Cesium.Cartesian3());
                                }
                            } else if (thisPointIndex - 1 === -1 && type === 'polygon') {
                                //删除的是面的第一个节点
                                let updataAddPoint = viewer.entities.getById(tree.editPointID.add[tree.editPointID.add.length - 1]);
                                if (updataAddPoint) {
                                    updataAddPoint.position = Cesium.Cartesian3.midpoint(geo.pottingPoint[0], geo.pottingPoint[geo.pottingPoint.length - 1], new Cesium.Cartesian3());
                                }
                            }
                        } else {
                            //直接移除上一个新增节点
                            viewer.entities.removeById(tree.editPointID.add[thisPointIndex - 1]);
                            tree.editPointID.add.pop();
                        }
                    }

                    //修改移动节点位置
                    let _center = new that._cesium.Cartesian3();
                    let pointLength = geo.pottingPoint.length;
                    geo.pottingPoint.forEach(item => {
                        _center.x += item.x;
                        _center.y += item.y;
                        _center.z += item.z;
                    });
                    _center.x /= pointLength;
                    _center.y /= pointLength;
                    _center.z /= pointLength;
                    tree.editPointID.move && (tree.editPointID.move.position = _center);

                    //更新实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'polygon') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    }
                    that.tooltip.show(false);
                    option.callBack && option.callBack.updata && option.callBack.updata(currentPoint && currentPoint.name, geo);
                }
            }
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        endThisEdit();

        function endThisEdit() {
            // 恢复地球的旋转和缩放
            that.defaultEvent(true);

            // 移除编辑点，清空编辑点数组
            tree.editPointID.edit.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.edit = [];

            tree.editPointID.height.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.height = [];

            tree.editPointID.add.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.add = [];

            tree.editPointID.size.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.size = [];

            tree.editPointID.move && viewer.entities.remove(tree.editPointID.move);
            tree.editPointID.move = undefined;

            geo && viewer.entities.remove(geo);
            geo = undefined;
            type = undefined;

            SmartEarthPopupData.editGraphic = {};

            that.isEditting = false;
            that.setStatus(true);
            tree.editVector = false;
            that.delButton(false);
        }
        return {
            endThisEdit: endThisEdit,
            getEditData: function () {
                return {
                    entity: geo
                }
            }
        }
    };

    //创建历史编辑图形
    VectorTileProviderEntity.prototype.createEditEntity = function (type, option) {
        let entity;
        let that = this;
        let viewer = this._viewer;
        if (type === 'polygon') {
            let positions = option.positions;
            let height = that._core.defaultValue(option.height, undefined);
            let hierarchy;
            if (option.hierarchy) {
                hierarchy = option.hierarchy;
            } else {
                positions = option.haveZ ?
                    that._cesium.Cartesian3.fromDegreesArrayHeights(positions) :
                    that._cesium.Cartesian3.fromDegreesArray(positions)
                    ;
                hierarchy = new that._cesium.PolygonHierarchy(positions);
            }
            entity = viewer.entities.add({
                polygon: {
                    hierarchy: new that._cesium.CallbackProperty(function () {
                        return hierarchy;
                    }, false),
                    extrudedHeight: that._core.defaultValue(option.extrudedHeight, undefined),
                    height: height,
                    material: new that._cesium.ImageMaterialProperty({
                        image: that._core.defaultValue(option.image, null),
                        repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                        color: option.material
                    }),
                    shadows: that._cesium.ShadowMode.ENABLED,
                    fill: true
                }
            });
            entity.VectorType = 'polygon';
        } else if (type === 'polyline') {
            let positions = option.positions;
            positions = option.haveZ ?
                that._cesium.Cartesian3.fromDegreesArrayHeights(positions) :
                that._cesium.Cartesian3.fromDegreesArray(positions)
                ;
            entity = viewer.entities.add({
                polyline: {
                    positions: new that._cesium.CallbackProperty(function () {
                        return positions
                    }, false),
                    clampToGround: that._core.defaultValue(option.clampToGround, false),
                    material: new Cesium.PolylineOutlineMaterialProperty({
                        color: option.material,
                        outlineWidth: that._core.defaultValue(option.outlineWidth, 0),
                        outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                    }),
                    width: that._core.defaultValue(option.width, 3)
                }
            });
            entity.VectorType = 'polyline';
        } else if (type === 'wall') {
            let positions = option.positions;
            positions = option.haveZ ?
                that._cesium.Cartesian3.fromDegreesArrayHeights(positions) :
                that._cesium.Cartesian3.fromDegreesArray(positions)
                ;
            entity = viewer.entities.add({
                wall: {
                    positions: new that._cesium.CallbackProperty(function () {
                        return positions
                    }, false),
                    minimumHeights: option.minimumHeights,
                    maximumHeights: option.maximumHeights,
                    material: option.material,
                    outline: true,
                    outlineWidth: that._core.defaultValue(option.outlineWidth, 0),
                    outlineColor: option.outlineColor
                }
            });
            entity.VectorType = 'wall';
        } else if (type === 'label') {
            entity = viewer.entities.add({
                position: option.position,
                label: {
                    text: option.text, //文本
                    font: option.font,
                    scale: option.scale,
                    style: option.style,
                    fillColor: option.fillColor,
                    outlineColor: option.outlineColor,
                    outlineWidth: option.outlineWidth,
                    showBackground: option.showBackground,
                    backgroundColor: option.backgroundColor,
                    heightReference: option.heightReference,
                    horizontalOrigin: option.horizontalOrigin,
                    verticalOrigin: option.verticalOrigin,
                    scaleByDistance: option.scaleByDistance,
                    distanceDisplayCondition: option.distanceDisplayCondition
                }
            });
            entity.VectorType = 'label';
        } else if (type === 'billboard') {
            entity = viewer.entities.add({
                position: option.position,
                billboard: {
                    rotation: option.rotation,
                    width: option.width,
                    height: option.height,
                    image: option.image,
                    color: option.color,
                    scale: option.scale,
                    heightReference: option.heightReference,
                    horizontalOrigin: option.horizontalOrigin,
                    verticalOrigin: option.verticalOrigin,
                    scaleByDistance: option.scaleByDistance,
                    distanceDisplayCondition: option.distanceDisplayCondition
                }
            });
            entity.VectorType = 'billboard';
        } else if (type === 'point') {
            entity = viewer.entities.add({
                position: option.position,
                point: {
                    pixelSize: option.pixelSize,
                    color: option.color,
                    outlineWidth: option.outlineWidth,
                    outlineColor: option.outlineColor,
                    heightReference: option.heightReference,
                    scaleByDistance: option.scaleByDistance,
                    distanceDisplayCondition: option.distanceDisplayCondition
                }
            });
            entity.VectorType = 'point';
        }
        return entity;
    };

    //删除按钮
    VectorTileProviderEntity.prototype.delButton = function (show, position, even) {
        if (show) {
            let del = document.getElementById('DeleteMilitaryStandardDelete');
            if (!del) {
                del = document.createElement('button');
                del.id = 'DeleteMilitaryStandardDelete';
                del.innerText = '删除对象';
                del.style.cssText = `height: 38px;
                        line-height: 38px;
                        padding: 0 18px;
                        background-color: #052355;
                        color: #fff;
                        white-space: nowrap;
                        text-align: center;
                        font-size: 14px;
                        border: none;
                        border-radius: 2px;
                        cursor: pointer;
                        position: absolute;`;
                this._viewer.container.appendChild(del);
            }
            del.style.display = 'block';
            del.style.top = position.y + 'px';
            del.style.left = position.x + 'px';
            del.onclick = even;
        } else {
            let del = document.getElementById('DeleteMilitaryStandardDelete');
            if (del) {
                del.style.display = 'none';
                del.onclick = null;
            }

        }
    };

    //默认鼠标事件
    VectorTileProviderEntity.prototype.defaultEvent = function (isOpen) {
        let scene = this._viewer.scene;
        scene.screenSpaceCameraController.enableRotate = isOpen;
        scene.screenSpaceCameraController.enableTranslate = isOpen;
        scene.screenSpaceCameraController.enableZoom = isOpen;
        scene.screenSpaceCameraController.enableTilt = isOpen;
        scene.screenSpaceCameraController.enableLook = isOpen;
    };

    //获取entity对象的类型和关联的对象
    VectorTileProviderEntity.prototype.getEntityTypeAndObject = function (entity) {
        let data = {
            type: '',
            object: null
        };
        if (entity) {
            if (entity.billboard) {
                data.type = 'billboard';
                data.object = entity.billboard;
            } else if (entity.box) {
                data.type = 'box';
                data.object = entity.box;
            } else if (entity.corridor) {
                data.type = 'corridor';
                data.object = entity.corridor;
            } else if (entity.cylinder) {
                data.type = 'cylinder';
                data.object = entity.cylinder;
            } else if (entity.ellipse) {
                data.type = 'ellipse';
                data.object = entity.ellipse;
            } else if (entity.ellipsoid) {
                data.type = 'ellipsoid';
                data.object = entity.ellipsoid;
            } else if (entity.label) {
                data.type = 'label';
                data.object = entity.label;
            } else if (entity.model) {
                data.type = 'model';
                data.object = entity.model;
            } else if (entity.path) {
                data.type = 'path';
                data.object = entity.path;
            } else if (entity.plane) {
                data.type = 'plane';
                data.object = entity.plane;
            } else if (entity.point) {
                data.type = 'point';
                data.object = entity.point;
            } else if (entity.polygon) {
                data.type = 'polygon';
                data.object = entity.polygon;
            } else if (entity.polyline) {
                data.type = 'polyline';
                data.object = entity.polyline;
            } else if (entity.polylineVolume) {
                data.type = 'polylineVolume';
                data.object = entity.polylineVolume;
            } else if (entity.rectangle) {
                data.type = 'rectangle';
                data.object = entity.rectangle;
            } else if (entity.wall) {
                data.type = 'wall';
                data.object = entity.wall;
            }
        }
        return data;
    };


    /**
    * 
    * 世界坐标转经纬度
    * 
    */
    VectorTileProviderEntity.prototype.toDegrees = function (cartesian) {
        let cartographic = this._cesium.Cartographic.fromCartesian(cartesian);
        return {
            lon: this._cesium.Math.toDegrees(cartographic.longitude),
            lat: this._cesium.Math.toDegrees(cartographic.latitude),
            height: cartographic.height
        };
    };

    VectorTileProviderEntity.prototype.getSimpleGraphicData = function (type, geo) {
        let that = this;
        let viewer = this._viewer;
        SmartEarthPopupData.editGraphic = {
            entity: geo,
            type: type,
            graphic: geo[type],
            getValue: function (attr) {
                if (attr === 'position' || attr === 'name' || attr === 'id') {
                    return this.entity[attr] && (this.entity[attr].getValue ? this.entity[attr].getValue() : this.entity[attr]);
                } else if (attr === 'radius') {
                    if (this.type === 'ellipse') {
                        return this.graphic.semiMajorAxis.getValue();
                    } else if (this.type === 'ellipsoid') {
                        return this.graphic.radii.getValue().x;
                    } else if (this.type === 'cylinder') {
                        return this.graphic.bottomRadius.getValue();
                    }
                } else if (attr === 'pHeight') {
                    if (this.getValue('position')) {
                        let position = this.getValue('position');
                        let Cartographic = Cesium.Cartographic.fromCartesian(position);
                        return Cartographic.height;
                    }
                } else if (attr === 'repeat') {
                    return this.graphic.material[attr] && (this.graphic.material[attr].getValue ? this.graphic.material[attr].getValue() : this.graphic.material[attr]);
                } else {
                    return this.graphic[attr] && (this.graphic[attr].getValue ? this.graphic[attr].getValue() : this.graphic[attr]);
                }
            },
            changeHeightPoint: function (height) {
                if (tree.editPointID.height.length > 0) {
                    tree.editPointID.height.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            let e_p = e.position.getValue();
                            let e_d = that.toDegrees(e_p);
                            e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                        }
                    });
                }
            },
            changeEditPoint: function (height) {
                if (tree.editPointID.edit.length > 0) {
                    tree.editPointID.edit.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                if (tree.editPointID.size.length > 0) {
                    tree.editPointID.size.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                if (tree.editPointID.add.length > 0) {
                    tree.editPointID.add.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                let e = tree.editPointID.move;
                if (e) {
                    if (height === 'clampToGround') {
                        e.point.heightReference = 1;
                    } else {
                        e.point.heightReference = 0;
                        let e_p = e.position.getValue();
                        let e_d = that.toDegrees(e_p);
                        e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                    }
                }
            },
            clearAllEditPoint: function () {
                // 移除编辑点，清空编辑点数组
                tree.editPointID.edit.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.edit = [];

                tree.editPointID.height.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.height = [];

                tree.editPointID.add.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.add = [];

                tree.editPointID.size.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.size = [];

                tree.editPointID.move && viewer.entities.remove(tree.editPointID.move);
                tree.editPointID.move = undefined;
            },
            setTreeID: function (id) {
                // 移除编辑点，清空编辑点数组
                tree.editPointID.edit.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.height.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.add.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.size.forEach(item => {
                    let e = viewer.entities.getById(item);
                    e.treeID = id;
                });

                tree.editPointID.move && (tree.editPointID.move.treeID = id);
            }
        };
        if (type === 'billboard' || type === 'point' || type === 'label' || type === 'model') {
            //获取颜色值
            let color = SmartEarthPopupData.editGraphic.getValue('color') || SmartEarthPopupData.editGraphic.getValue('fillColor');
            if (color) {
                getFillColor(color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            if (type === 'label') {
                let backgroundColor = SmartEarthPopupData.editGraphic.getValue('backgroundColor');
                if (backgroundColor) {
                    getBackgroundColor(backgroundColor);
                } else {
                    SmartEarthPopupData.editGraphic.backgroundColor = '#000000';
                    SmartEarthPopupData.editGraphic.backgroundAlpha = 80;
                }
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'position' || attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor' || attr === 'backgroundColor' || attr === 'fillColor') {
                        value = Cesium.Color.fromCssColorString(value);
                    } else if (attr === 'fontSize') {
                        let font = this.getValue('font');
                        font = font.split(' ');
                        font[0] = value;
                        value = font.join(' ');
                    } else if (attr === 'alpha') {
                        if (this.type === 'label') {
                            this.graphic.fillColor._value.alpha = value;
                        } else {
                            this.graphic.color._value.alpha = value;
                        }
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'backgroundAlpha') {
                        this.graphic.backgroundColor._value.alpha = value;
                        return;
                    } else if (attr === 'pHeight') {
                        if (this.getValue('position')) {
                            let position = this.getValue('position');
                            let Cartographic = Cesium.Cartographic.fromCartesian(position);
                            Cartographic.height = value;
                            this.entity.position = Cesium.Cartographic.toCartesian(Cartographic);
                            return;
                        }
                    }
                    this.graphic[attr] = value;
                }
            };
        } else if (type === 'polyline') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            if (material.outlineColor) {
                getOutlineColor(material.outlineColor);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'outlineWidth') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.material.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic[attr] = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let pottingPoint = this.getValue('positions');
                this.entity.pottingPoint = pottingPoint;
                return pottingPoint;
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    // if (this.getValue('extrudedHeight') !== undefined) {
                    //     let cartographic = Cesium.Cartographic.fromCartesian(item);
                    //     let degrees = {
                    //         lon: Cesium.Math.toDegrees(cartographic.longitude),
                    //         lat: Cesium.Math.toDegrees(cartographic.latitude),
                    //         height: this.getValue('extrudedHeight')
                    //     }

                    //     if (this.getValue('height')) {
                    //         let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                    //         item.x = e_p.x;
                    //         item.y = e_p.y;
                    //         item.z = e_p.z;
                    //         edit_point.position = e_p;
                    //         this.entity.pottingPoint[index] = e_p.clone();
                    //     }

                    //     let heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: Cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.push(heightpoint.id);
                    // }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });

                for (let i = 0; i < points.length - 1; i++) {
                    let add_position = Cesium.Cartesian3.midpoint(points[i], points[i + 1], new Cesium.Cartesian3());
                    //添加节点
                    let add_point = viewer.entities.add({
                        name: "_add_point",
                        position: add_position,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.add.push(add_point.id);
                }
            };
        } else if (type === 'polygon') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic.hierarchy = new Cesium.CallbackProperty(function () {
                            return new Cesium.PolygonHierarchy(value);
                        }, false);
                        return;
                    } else if (attr === 'hierarchy') {
                        this.graphic.hierarchy = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'clampToGround') {
                        if (this.graphic.hierarchy instanceof Cesium.CallbackProperty) {
                            this.graphic.hierarchy = this.graphic.hierarchy.getValue();
                            setTimeout(() => {
                                changeGround(this.graphic, this.entity.pottingPoint, value);
                            }, 100);
                        } else {
                            changeGround(this.graphic, this.entity.pottingPoint, value);
                        }
                        //更新新增节点贴地状态
                        if (tree.editPointID.add.length > 0) {
                            tree.editPointID.add.forEach(item => {
                                let updataAddPoint = viewer.entities.getById(item);
                                if (updataAddPoint) {
                                    if (value) {
                                        updataAddPoint.point.heightReference = 1;
                                    } else {
                                        updataAddPoint.point.heightReference = 0;
                                    }
                                }
                            });
                        }

                        function changeGround(graphic, points, checked) {
                            if (checked) {
                                graphic.perPositionHeight = false;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.perPositionHeight = true;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            //更新节点高度
                            if (tree.editPointID.edit.length > 0 && !checked) {
                                points.forEach((item, index) => {
                                    let _editPoint = viewer.entities.getById(tree.editPointID.edit[index]);
                                    if (_editPoint) {
                                        let p = _editPoint.position.getValue();
                                        item.x = p.x;
                                        item.y = p.y;
                                        item.z = p.z;
                                    }
                                });
                            }
                            graphic.hierarchy = new Cesium.CallbackProperty(function () {
                                return new Cesium.PolygonHierarchy(points);
                            }, false);
                        }
                        return;
                    } else if (attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (attr === 'height') {
                        this.changeEditPoint(value);
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let hierarchy = this.getValue('hierarchy');
                let positions = hierarchy.positions.concat([]);
                if (this.getValue('height') !== undefined) {
                    let height = this.getValue('height');
                    positions.forEach(item => {
                        let degree = that.toDegrees(item);
                        let cartesian = Cesium.Cartesian3.fromDegrees(degree.lon, degree.lat, height);
                        item.x = cartesian.x;
                        item.y = cartesian.y;
                        item.z = cartesian.z;
                    });
                }
                this.entity.pottingPoint = positions;
                return positions;
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    // if (this.getValue('extrudedHeight') !== undefined) {
                    //     let cartographic = Cesium.Cartographic.fromCartesian(item);
                    //     let degrees = {
                    //         lon: Cesium.Math.toDegrees(cartographic.longitude),
                    //         lat: Cesium.Math.toDegrees(cartographic.latitude),
                    //         height: this.getValue('extrudedHeight')
                    //     }

                    //     if (this.getValue('height')) {
                    //         let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                    //         item.x = e_p.x;
                    //         item.y = e_p.y;
                    //         item.z = e_p.z;
                    //         edit_point.position = e_p;
                    //         this.entity.pottingPoint[index] = e_p.clone();
                    //     }

                    //     let heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: Cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.push(heightpoint.id);
                    // }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                //移动节点
                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });

                for (let i = 0; i < points.length - 1; i++) {
                    let add_position = Cesium.Cartesian3.midpoint(points[i], points[i + 1], new Cesium.Cartesian3());
                    //添加节点
                    let add_point = viewer.entities.add({
                        name: "_add_point",
                        position: add_position,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.add.push(add_point.id);
                }

                //首尾间的添加节点
                let add_position = Cesium.Cartesian3.midpoint(points[0], points[points.length - 1], new Cesium.Cartesian3());
                let add_point = viewer.entities.add({
                    name: "_add_point",
                    position: add_position,
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
                tree.editPointID.add.push(add_point.id);
            };
        } else if (type === 'ellipse' || type === 'cylinder' || geo.isSphere) {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'semiMajorAxis') {
                        this.graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'semiMinorAxis') {
                        this.graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'radii') {
                        this.graphic.radii = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'topRadius') {
                        this.graphic.topRadius = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'bottomRadius') {
                        this.graphic.bottomRadius = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'radius') {
                        if (this.type === 'ellipse') {
                            this.graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                            this.graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                        } else if (this.type === 'ellipsoid') {
                            if (this.graphic.material.image.getValue() !== null) {
                                this.graphic.radii = new Cesium.Cartesian3(value, value, value);
                            } else {
                                this.graphic.radii = new Cesium.CallbackProperty(function () {
                                    return new Cesium.Cartesian3(value, value, value);
                                }, false);
                            }
                        } else if (this.type === 'cylinder') {
                            this.graphic.bottomRadius = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                            if (this.entity.changeTop) {
                                this.graphic.topRadius = new Cesium.CallbackProperty(function () {
                                    return value;
                                }, false);
                            }
                        }
                        let center = tree.editPointID.move.position.getValue();
                        let newPosition = that.GetPositionFromA_D(center, value, 90);

                        // 更新编辑点的位置
                        let _sizePoint = viewer.entities.getById(tree.editPointID.size[0]);
                        _sizePoint.position = newPosition;
                        geo.pottingPoint[0] = newPosition;
                        geo.pottingPoint[geo.pottingPoint.length - 1] = center;

                        //修改对应的拉伸节点
                        let thisHeightPoint = viewer.entities.getById(tree.editPointID.height[0]);
                        if (thisHeightPoint) {
                            let degrees = that.toDegrees(newPosition);
                            //修改拉伸节点位置
                            let expiontcart = that._cesium.Cartographic.fromCartesian(thisHeightPoint.position.getValue());
                            thisHeightPoint.position = that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, expiontcart.height);
                        }
                        return;
                    } else if (this.type === 'cylinder' && attr === 'length') {
                        this.graphic.length = value;
                        let degrees = that.toDegrees(this.entity.pottingPoint[1]);
                        this.entity.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + value / 2);
                        this.changeHeightPoint(degrees.height + value);
                        return;
                    } else if (this.type === 'ellipse' && attr === 'clampToGround') {
                        if (this.graphic.semiMinorAxis instanceof Cesium.CallbackProperty) {
                            this.graphic.semiMinorAxis = this.graphic.semiMinorAxis.getValue();
                            this.graphic.semiMajorAxis = this.graphic.semiMajorAxis.getValue();
                            setTimeout(() => {
                                changeGround(this.entity, this.graphic, value);
                            }, 100);
                        } else {
                            changeGround(this.entity, this.graphic, value);
                        }

                        if (!value) {
                            this.changeEditPoint(this.entity.thisHeight);
                        } else {
                            this.changeEditPoint('clampToGround');
                        }

                        function changeGround(entity, graphic, checked) {
                            if (checked) {
                                if (entity.thisHeight === undefined) {
                                    entity.thisHeight = graphic.height && graphic.height.getValue();
                                }
                                graphic.height = undefined;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.height = entity.thisHeight;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            let radius = graphic.semiMinorAxis.getValue();
                            graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                                return radius;
                            }, false);
                            graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                                return radius;
                            }, false);
                        }
                        return;
                    } else if (this.type === 'ellipse' && attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (this.type === 'ellipse' && attr === 'height') {
                        this.changeEditPoint(value);
                        this.entity.thisHeight = value;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let radius = this.getValue('radius');
                let position = this.getValue('position');
                if (this.type === 'ellipse' || this.entity.isSphere) {
                    if (this.type === 'ellipse' && this.getValue('height') !== undefined) {
                        let height = this.getValue('height');
                        let degree = that.toDegrees(position);
                        position = Cesium.Cartesian3.fromDegrees(degree.lon, degree.lat, height);
                    }
                    let position0 = that.GetPositionFromA_D(position, radius, 90);
                    this.entity.pottingPoint = [position0, position];
                    return [position0, position];
                } else {
                    let degrees = that.toDegrees(position);
                    //求cylinder底部点位置
                    position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height - this.getValue('length') / 2);
                    let position0 = that.GetPositionFromA_D(position, radius, 90);
                    this.entity.pottingPoint = [position0, position];
                    return [position0, position];
                }
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;
                //大小节点
                let size_point = viewer.entities.add({
                    name: "_size_point",
                    position: points[0],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
                size_point.angle = 90;
                tree.editPointID.size.push(size_point.id);

                //拉伸节点
                // if (this.getValue('extrudedHeight') !== undefined) {
                //     let degrees = that.toDegrees(points[1]);
                //     degrees.height = this.getValue('extrudedHeight');

                //     let heightpoint = viewer.entities.add({
                //         name: "_height_point",
                //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                //         point: {
                //             color: Cesium.Color.YELLOW,
                //             pixelSize: 12,
                //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                //             outlineWidth: 2,
                //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                //         }
                //     });
                //     tree.editPointID.height.push(heightpoint.id);
                // } else if (type === 'cylinder') {
                //     let degrees = that.toDegrees(points[1]);
                //     let length = this.getValue('length');
                //     let heightpoint = viewer.entities.add({
                //         name: "_height_point",
                //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + length),
                //         point: {
                //             color: Cesium.Color.YELLOW,
                //             pixelSize: 12,
                //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                //             outlineWidth: 2,
                //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                //         }
                //     });
                //     tree.editPointID.height.push(undefined, heightpoint.id);
                // }

                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: points[1],
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'rectangle') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic.coordinates = new Cesium.CallbackProperty(function () {
                            return Cesium.Rectangle.fromCartesianArray(value);
                        }, false);
                        return;
                    } else if (attr === 'coordinates') {
                        this.graphic.coordinates = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'clampToGround') {
                        if (this.graphic.coordinates instanceof Cesium.CallbackProperty) {
                            this.graphic.coordinates = this.graphic.coordinates.getValue();
                            setTimeout(() => {
                                changeGround(this.entity, this.graphic, value);
                            }, 100);
                        } else {
                            changeGround(this.entity, this.graphic, value);
                        }

                        if (!value) {
                            this.changeEditPoint(this.entity.thisHeight);
                        } else {
                            this.changeEditPoint('clampToGround');
                        }

                        function changeGround(entity, graphic, checked) {
                            if (checked) {
                                if (entity.thisHeight === undefined) {
                                    entity.thisHeight = graphic.height && graphic.height.getValue();
                                }
                                graphic.height = undefined;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.height = entity.thisHeight;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            let coordinates = graphic.coordinates.getValue();
                            graphic.coordinates = new Cesium.CallbackProperty(function () {
                                return coordinates;
                            }, false);
                        }
                        return;
                    } else if (attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (attr === 'height') {
                        this.changeEditPoint(value);
                        this.entity.thisHeight = value;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let coordinates = this.getValue('coordinates');
                let position0, position1;
                let height = this.getValue('height');
                if (height !== undefined) {
                    position0 = Cesium.Cartesian3.fromRadians(coordinates.west, coordinates.north, height);
                    position1 = Cesium.Cartesian3.fromRadians(coordinates.east, coordinates.south, height);
                } else {
                    height = viewer.scene.sampleHeight(new Cesium.Cartographic(coordinates.west, coordinates.north, 0), [this.entity]);
                    position0 = Cesium.Cartesian3.fromRadians(coordinates.west, coordinates.north, height);
                    height = viewer.scene.sampleHeight(new Cesium.Cartographic(coordinates.east, coordinates.south, 0), [this.entity]);
                    position1 = Cesium.Cartesian3.fromRadians(coordinates.east, coordinates.south, height);
                }
                this.entity.pottingPoint = [position0, position1];
                return [position0, position1];
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "_edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    // if (this.getValue('extrudedHeight') !== undefined) {
                    //     let cartographic = Cesium.Cartographic.fromCartesian(item);
                    //     let degrees = {
                    //         lon: Cesium.Math.toDegrees(cartographic.longitude),
                    //         lat: Cesium.Math.toDegrees(cartographic.latitude),
                    //         height: this.getValue('extrudedHeight')
                    //     }

                    //     if (this.getValue('height')) {
                    //         let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                    //         item.x = e_p.x;
                    //         item.y = e_p.y;
                    //         item.z = e_p.z;
                    //         edit_point.position = e_p;
                    //         this.entity.pottingPoint[index] = e_p.clone();
                    //     }

                    //     let heightpoint = viewer.entities.add({
                    //         name: "_height_point",
                    //         position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    //         point: {
                    //             color: Cesium.Color.YELLOW,
                    //             pixelSize: 12,
                    //             outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                    //             outlineWidth: 2,
                    //             disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    //         }
                    //     });
                    //     tree.editPointID.height.push(heightpoint.id);
                    // }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                //移动节点
                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'box') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'long' || attr === 'width' || attr === 'height') {
                        let dimensions = this.getValue('dimensions');
                        if (attr === 'long') {
                            dimensions.x = value;
                        } else if (attr === 'width') {
                            dimensions.y = value;
                        } else {
                            dimensions.z = value;
                        }
                        this.graphic.dimensions = new Cesium.CallbackProperty(function () {
                            return dimensions;
                        }, false);

                        if (attr === 'long' || attr === 'width') {
                            let angle = attr === 'long' ? 90 : 180;
                            let pointIndex = attr === 'long' ? 0 : 1;
                            let center = tree.editPointID.move.position.getValue();
                            let newPosition = that.GetPositionFromA_D(center, value / 2, angle);

                            // 更新编辑点的位置
                            let _sizePoint = viewer.entities.getById(tree.editPointID.size[pointIndex]);
                            _sizePoint.position = newPosition;
                            this.entity.pottingPoint[pointIndex] = newPosition;
                            this.entity.pottingPoint[this.entity.pottingPoint.length - 1] = center;
                        } else {
                            let degrees = that.toDegrees(tree.editPointID.move.position.getValue());
                            this.entity.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + value / 2);
                            this.changeHeightPoint(degrees.height + value);
                        }
                        return;
                    } else if (attr === 'dimensions') {
                        this.graphic.dimensions = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let dimensions = this.getValue('dimensions');
                let position = this.getValue('position');
                let degrees = that.toDegrees(position);
                //求box底部点位置
                position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height - dimensions.z / 2);
                let position0 = that.GetPositionFromA_D(position, dimensions.x / 2, 90);
                let position1 = that.GetPositionFromA_D(position, dimensions.y / 2, 180);
                this.entity.pottingPoint = [position0, position1, position];
                return [position0, position1, position];
            };

            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;
                //大小节点
                let size_point1 = viewer.entities.add({
                    name: "_size_point",
                    position: points[0],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY
                    }
                });
                size_point1.angle = 90;

                let size_point2 = viewer.entities.add({
                    name: "_size_point",
                    position: points[1],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY
                    }
                });
                size_point2.angle = 180;
                tree.editPointID.size.push(size_point1.id);
                tree.editPointID.size.push(size_point2.id);

                //拉伸节点
                // let degrees = that.toDegrees(points[2]);
                // let dimensions = this.getValue('dimensions');
                // let heightpoint = viewer.entities.add({
                //     name: "_height_point",
                //     position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + dimensions.z),
                //     point: {
                //         color: Cesium.Color.YELLOW,
                //         pixelSize: 12,
                //         outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                //         outlineWidth: 2,
                //         disableDepthTestDistance: Number.POSITIVE_INFINITY,
                //     }
                // });
                // tree.editPointID.height.push(undefined, undefined, heightpoint.id);

                tree.editPointID.move = viewer.entities.add({
                    name: "_move_point",
                    position: points[2],
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'corridor') ; else if (type === 'ellipsoid' && !geo.isSphere) ; else ;

        function getFillColor(rgba) {
            SmartEarthPopupData.editGraphic.fillColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.alpha = rgba.alpha * 100;
        }

        function getOutlineColor(rgba) {
            SmartEarthPopupData.editGraphic.outlineColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.outlineAlpha = rgba.alpha * 100;
        }

        function getBackgroundColor(rgba) {
            SmartEarthPopupData.editGraphic.backgroundColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.backgroundAlpha = rgba.alpha * 100;
        }

        function colorHex(rgb) {
            let _this = rgb;
            let reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;
            if (/^(rgb|RGB)/.test(_this)) {
                let str = _this.replace(/(rgb|RGB)*/g, "");
                str = str.replace("(", "").replace(")", "");
                let aColor = str.split(",");
                let strHex = "#";
                for (let i = 0; i < aColor.length; i++) {
                    let hex = Number(aColor[i]).toString(16);
                    hex = hex.length === 1 ? 0 + '' + hex : hex;// 保证每个rgb的值为2位
                    if (hex === "0") {
                        hex += hex;
                    }
                    strHex += hex;
                }
                if (strHex.length !== 7) {
                    strHex = _this;
                }
                return strHex;
            } else if (reg.test(_this)) {
                let aNum = _this.replace(/#/, "").split("");
                if (aNum.length === 6) {
                    return _this;
                } else if (aNum.length === 3) {
                    let numHex = "#";
                    for (let i = 0; i < aNum.length; i += 1) {
                        numHex += (aNum[i] + aNum[i]);
                    }
                    return numHex;
                }
            } else {
                return _this;
            }
        }
    };

    /**
     *
     * 创建添加文本点Geojson要素图层。
     *
     * @alias LabelGeoJsonFeatureLayer
     * @constructor
     *
     * @param {Viewer} Viewer Cesium的viewer对象。
     *
     */
    function LabelGeoJsonFeatureLayercopy(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this._Provider = undefined;
        this.labelCollections1 = [];
        this.labelCollections2 = [];
        this.labelCollections = this._cesium.PointPrimitiveCollection();
        this.gd = 0;
        this.item = { show: true };
        this.model = [];
        //图例
        this.Legend = [];
        this.sj = true;
        /**
         * 是否强制清楚缓存
         */
        this._cache = false;
        this._forceRefreshPrvimitive = null;
    }

    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *        Name: "",
            text: "",
            font_size: '30px',
            font_family:'sans-serif'
            stylet: this._cesium.LabelStyle.FILL,
            fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
            outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
            show: true,//	optional A boolean Property specifying the visibility of the label.
            showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
            backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
            near: 0,
            far: 5000
       }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    LabelGeoJsonFeatureLayercopy.prototype.createLabelPointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        //this._viewer.dataSources.add(dataSource);
        var that = this;
        dataSource.then(function (dataSource) {
            var defaultOptions = {
                Name: "",
                text: "",
                font: ' 30px sans-serif',
                stylet: that._cesium.LabelStyle.OUTLINE,
                fillColor: that._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                outlineColor: that._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                show: true, //	optional A boolean Property specifying the visibility of the label.
                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                backgroundColor: new that._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                backgroundPadding: new that._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                horizontalOrigin: that._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                verticalOrigin: that._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                eyeOffset: that._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                pixelOffset: that._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                heightReference: that._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                scaleByDistance: new that._cesium.NearFarScalar(0, 0, 1, 1)
            };
            option.material;
            //填充颜色设置
            if (!that._core.isnull(option) && !that._core.isnull(option.fillColor)) {
                if (/^\[/.test(option.fillColor) && option.fillColor.toString().charAt(0) == "[" && option.fillColor.toString().charAt(option.fillColor.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(option.fillColor)) {
                        option.fillColor = that._color.colorFromHtmlColor(option.fillColor);
                    } else {
                        if (/^rgb/.test(option.fillColor)) {
                            option.fillColor = that._color.rgbaStringToRgbaObj(option.fillColor);
                        }
                        if (option.fillColor.r > 1) {
                            option.fillColor.r = option.fillColor.r / 255;
                        }
                        if (option.fillColor.g > 1) {
                            option.fillColor.g = option.fillColor.g / 255;
                        }
                        if (option.fillColor.b > 1) {
                            option.fillColor.b = option.fillColor.b / 255;
                        }
                        if (option.fillColor.a > 1) {
                            option.fillColor.a = option.fillColor.a / 255;
                        }
                        option.fillColor = that._color.createColor(option.fillColor.r, option.fillColor.g, option.fillColor.b, option.fillColor.a);
                    }
                }
            }
            //填充颜色设置material
            if (!that._core.isnull(option) && !that._core.isnull(option.material)) {
                if (/^\[/.test(option.material) && option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(option.material)) {
                        option.material = that._color.colorFromHtmlColor(option.material);
                    } else {
                        if (/^rgb/.test(option.material)) {
                            option.material = that._color.rgbaStringToRgbaObj(option.material);
                        }
                        if (option.material.r > 1) {
                            option.material.r = option.fillColor.r / 255;
                        }
                        if (option.material.g > 1) {
                            option.material.g = option.fillColor.g / 255;
                        }
                        if (option.material.b > 1) {
                            option.material.b = option.material.b / 255;
                        }
                        if (option.material.a > 1) {
                            option.material.a = option.material.a / 255;
                        }
                        option.material = that._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                    }
                }
            }
            //边框颜色设置
            if (!that._core.isnull(option) && !that._core.isnull(option.outlineColor)) {
                if (/^\[/.test(option.outlineColor) && option.outlineColor.toString().charAt(0) == "[" && option.outlineColor.toString().charAt(option.outlineColor.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(option.outlineColor)) {
                        option.outlineColor = that._color.colorFromHtmlColor(option.outlineColor);
                    } else {
                        if (/^rgb/.test(option.outlineColor)) {
                            option.outlineColor = that._color.rgbaStringToRgbaObj(option.outlineColor);
                        }
                        if (option.outlineColor.r > 1) {
                            option.outlineColor.r = option.outlineColor.r / 255;
                        }
                        if (option.outlineColor.g > 1) {
                            option.outlineColor.g = option.outlineColor.g / 255;
                        }
                        if (option.outlineColor.b > 1) {
                            option.outlineColor.b = option.outlineColor.b / 255;
                        }
                        if (option.outlineColor.a > 1) {
                            option.outlineColor.a = option.outlineColor.a / 255;
                        }
                        option.outlineColor = that._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
                    }
                }
            }
            //背景颜色设置
            if (!that._core.isnull(option) && !that._core.isnull(option.backgroundColor)) {
                if (/^\[/.test(option.backgroundColor) && option.backgroundColor.toString().charAt(0) == "[" && option.backgroundColor.toString().charAt(option.backgroundColor.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(option.backgroundColor)) {
                        option.backgroundColor = that._color.colorFromHtmlColor(option.backgroundColor);
                    } else {
                        if (/^rgb/.test(option.backgroundColor)) {
                            option.backgroundColor = that._color.rgbaStringToRgbaObj(option.backgroundColor);
                        }
                        if (option.backgroundColor.r > 1) {
                            option.backgroundColor.r = option.backgroundColor.r / 255;
                        }
                        if (option.backgroundColor.g > 1) {
                            option.backgroundColor.g = option.backgroundColor.g / 255;
                        }
                        if (option.backgroundColor.b > 1) {
                            option.backgroundColor.b = option.backgroundColor.b / 255;
                        }
                        if (option.backgroundColor.a > 1) {
                            option.backgroundColor.a = option.backgroundColor.a / 255;
                        }
                        option.backgroundColor = that._color.createColor(option.backgroundColor.r, option.backgroundColor.g, option.backgroundColor.b, option.backgroundColor.a);
                    }
                }
            }
            var options = that._core.extend(defaultOptions, option, true);
            that.item = dataSource;
            var entities = dataSource.entities.values;
            if (that._core.isnull(option.near)) {
                option.near = 0;
            }
            if (that._core.isnull(option.far)) {
                option.far = 999999999;
            }
            var min = parseFloat(option.near);
            var max = parseFloat(option.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            if (that._core.isnull(option.font_size)) {
                option.font_size = "30px";
            }
            if (that._core.isnull(option.font_family)) {
                option.font_family = " sans-serif";
            }
            //options.font = option.font_size + " " + option.font_family;
            options.font = parseFloat(option.font_size) + "px " + option.font_family;
            var labelCollections = new that._cesium.LabelCollection();

            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                options.position = entity.position._value;
                options.text = "a label";
                //图例
                var col = "fillColor:" + options.fillColor.red * 255 + "," + options.fillColor.green * 255 + "," + options.fillColor.blue * 255
                    + ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                that.Legend.push(col);
                labelCollections.add(options);
            }
            var ps = that._viewer.scene.primitives.add(labelCollections);
            // if (checked == "false") {
            //     that.setVisibility(false);
            // }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        // if (this._core.isnull(options.id)) {
        //     options.id = this._core.getuid();
        // }
        var guid = this._core.getuid();
        if (this._core.isnull(name)) {
            name = "新建图层" + guid;
        }
        //导出工程树
        var obj = {
            id: guid,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'labelPointLayer',
            item: this,
            url: geojsonOrurl,
            style: options,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": true, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    //lable点数据聚合demo
    LabelGeoJsonFeatureLayercopy.prototype.createLabelPolymerizationGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        //数据解析
        var defaultOptions = {
            Name: "",
            text: "",
            font: ' 30px sans-serif',
            style: this._cesium.LabelStyle.FILL_AND_OUTLINE,
            fillColor: this._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
            outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
            show: true, //	optional A boolean Property specifying the visibility of the label.
            showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
            backgroundPadding: new this._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.RELATIVE_TO_GROUND, //	optional A Property specifying what the height is relative to.
            scaleByDistance: new this._cesium.NearFarScalar(0, 0, 1, 1),
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
            pointHeight: 0
        };
        var that = this;
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.fillColor)) {
            if (this._core.isHtmlColor(option.fillColor)) {
                option.fillColor = this._color.colorFromHtmlColor(option.fillColor);
            } else {
                if (/^rgb/.test(option.fillColor)) {
                    option.fillColor = this._color.rgbaStringToRgbaObj(option.fillColor);
                }
                if (option.fillColor.r > 1) {
                    option.fillColor.r = option.fillColor.r / 255;
                }
                if (option.fillColor.g > 1) {
                    option.fillColor.g = option.fillColor.g / 255;
                }
                if (option.fillColor.b > 1) {
                    option.fillColor.b = option.fillColor.b / 255;
                }
                if (option.fillColor.a > 1) {
                    option.fillColor.a = option.fillColor.a / 255;
                }
                option.fillColor = this._color.createColor(option.fillColor.r, option.fillColor.g, option.fillColor.b, option.fillColor.a);
            }
        }
        //边框颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (this._core.isHtmlColor(option.outlineColor)) {
                option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
            } else {
                if (/^rgb/.test(option.outlineColor)) {
                    option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                }
                if (option.outlineColor.r > 1) {
                    option.outlineColor.r = option.outlineColor.r / 255;
                }
                if (option.outlineColor.g > 1) {
                    option.outlineColor.g = option.outlineColor.g / 255;
                }
                if (option.outlineColor.b > 1) {
                    option.outlineColor.b = option.outlineColor.b / 255;
                }
                if (option.outlineColor.a > 1) {
                    option.outlineColor.a = option.outlineColor.a / 255;
                }
                option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
            }
        }
        //背景颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.backgroundColor)) {
            if (this._core.isHtmlColor(option.backgroundColor)) {
                option.backgroundColor = this._color.colorFromHtmlColor(option.backgroundColor);
            } else {
                if (/^rgb/.test(option.backgroundColor)) {
                    option.backgroundColor = this._color.rgbaStringToRgbaObj(option.backgroundColor);
                }
                if (option.backgroundColor.r > 1) {
                    option.backgroundColor.r = option.backgroundColor.r / 255;
                }
                if (option.backgroundColor.g > 1) {
                    option.backgroundColor.g = option.backgroundColor.g / 255;
                }
                if (option.backgroundColor.b > 1) {
                    option.backgroundColor.b = option.backgroundColor.b / 255;
                }
                if (option.backgroundColor.a > 1) {
                    option.backgroundColor.a = option.backgroundColor.a / 255;
                }
                option.backgroundColor = this._color.createColor(option.backgroundColor.r, option.backgroundColor.g, option.backgroundColor.b, option.backgroundColor.a);
            }
        }

        if (that._core.isnull(option.near)) {
            option.near = 0;
        }
        if (that._core.isnull(option.far)) {
            option.far = 999999999;
        }
        var options = this._core.extend(defaultOptions, option, true);
        //开始聚合
        ({
            camera: this._viewer.scene.camera,
            canvas: this._viewer.scene.canvas
        });
        //var dataSourcePromise = viewer.dataSources.add(Cesium.KmlDataSource.load('../../SampleData/kml/facilities/facilities.kml', optionsp));
        var dataSourcePromise = this._viewer.dataSources.add(this._cesium.GeoJsonDataSource.load(geojsonOrurl));
        //this._viewer.dataSources.add(dataSource);
        var that = this;
        dataSourcePromise.then(function (dataSource) {
            that.item = dataSource;
            var pixelRange = 45;
            var minimumClusterSize = 3;
            var enabled = true;
            //解析并加载数据
            var entities = dataSource.entities.values;
            if (that._core.isnull(options.font_size)) {
                options.font_size = "30";
            }
            if (that._core.isnull(options.font_family)) {
                options.font_family = " sans-serif";
            }
            options.font = options.font_size + "px " + options.font_family;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.font = that._core.extendgl(entity, option.font, options.font);
                options.style = parseInt(that._core.extendgl(entity, options.stylet, options.style));
                options.fillColor = that._core.extendgl(entity, option.fillColor, options.fillColor);
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.showBackground = that._core.extendgl(entity, option.showBackground, options.showBackground);
                options.backgroundColor = that._core.extendgl(entity, option.backgroundColor, options.backgroundColor);
                options.backgroundPadding = that._core.extendgl(entity, option.backgroundPadding, options.backgroundPadding);
                options.scale = parseFloat(that._core.extendgl(entity, option.scale, options.scale));
                options.horizontalOrigin = that._core.extendgl(entity, option.horizontalOrigin, options.horizontalOrigin);
                options.pointHeight = parseFloat(that._core.extendgl(entity, option.pointHeight, options.pointHeight));
                options.text = that._core.extendgl(entity, option.text, options.text);
                var min = parseFloat(that._core.extendgl(entity, options.near));
                var max = parseFloat(that._core.extendgl(entity, options.far));
                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                options.distanceDisplayCondition = distance;

                options.text = entity.properties[options.text] == null ? options.text : entity.properties[options.text]._value;

                // entity.billboard.image = "";
                entity.billboard.color = that._cesium.Color.WHITE.withAlpha(0);
                entity.label = new that._cesium.LabelGraphics(options);
                //获取数据结束
                //判断是否是公告栏
                //if (options.image != undefined && options.image != null && options.image.length > 0) {
                //    entity.billboard.image = options.image;
                //    entity.billboard.scale = options.scale;
                //    entity.billboard.heightReference = options.heightReference;
                //    entity.billboard.distanceDisplayCondition = options.distanceDisplayCondition;
                //} else if (options.layertype == "ellipsoidlayer") {
                //    //entity.billboard = undefined;
                //    entity.billboard.image = "";
                //    entity.name = name;
                //    var ellipsoid = {
                //        show: true,
                //        radii: new that._cesium.Cartesian3(options.long_axis, options.short_axis, options.long_axis),
                //        material: that._cesium.Color.fromRandom({
                //            alpha: 1.0
                //        })
                //    }
                //    entity.ellipsoid = new that._cesium.EllipsoidGraphics(ellipsoid);
                //    entity.ellipsoid.heightReference = options.heightReference;
                //    entity.ellipsoid.material = url;
                //} else {
                //    //entity.billboard = undefined;
                //    entity.billboard.image = "";
                //    var labels = {
                //        text: options.text,
                //        font: options.font,
                //        style: options.stylet,
                //        fillColor: options.fillColor,
                //        outlineColor: options.outlineColor,
                //        outlineWidth: options.outlineWidth,
                //        show: options.show,
                //        showBackground: options.showBackground,
                //        backgroundColor: options.backgroundColor,
                //        backgroundPadding: options.backgroundPadding,
                //        scale: options.scale,
                //        horizontalOrigin: options.horizontalOrigin,
                //        verticalOrigin: options.verticalOrigin,
                //        eyeOffset: options.eyeOffset,
                //        pixelOffset: options.pixelOffset,
                //        heightReference: options.heightReference,
                //        distanceDisplayCondition: options.distanceDisplayCondition,
                //        scaleByDistance: options.scaleByDistance
                //    };
                //    entity.label = new that._cesium.LabelGraphics(labels);
                //    //entity.label.text = entity.properties[options.text] == null ? options.text : entity.properties[options.text]._value;
                //    //entity.position._value.z += options.pointHeight;
                //}
                //坐标转化
                that._viewer.scene.globe.ellipsoid;
                var scartographic = that._cesium.Cartographic.fromCartesian(entity.position._value);
                var slongitude = that._cesium.Math.toDegrees(scartographic.longitude);
                var slatitude = that._cesium.Math.toDegrees(scartographic.latitude);
                var sheight = scartographic.height + options.pointHeight;//
                var posit = new that._cesium.Cartesian3.fromDegrees(slongitude, slatitude, sheight);
                entity.position._value = posit;
            }

            dataSource.clustering.enabled = enabled;
            dataSource.clustering.pixelRange = pixelRange;
            dataSource.clustering.minimumClusterSize = minimumClusterSize;

            var removeListener;

            var pinBuilder = new that._cesium.PinBuilder();
            pinBuilder.fromText('50+', that._cesium.Color.RED, 48).toDataURL();
            pinBuilder.fromText('40+', that._cesium.Color.ORANGE, 48).toDataURL();
            pinBuilder.fromText('30+', that._cesium.Color.YELLOW, 48).toDataURL();
            pinBuilder.fromText('20+', that._cesium.Color.GREEN, 48).toDataURL();
            pinBuilder.fromText('10+', that._cesium.Color.BLUE, 48).toDataURL();

            var singleDigitPins = new Array(8);
            for (var i = 0; i < singleDigitPins.length; ++i) {
                singleDigitPins[i] = pinBuilder.fromText('' + (i + 2), that._cesium.Color.VIOLET, 48).toDataURL();
            }

            function customStyle() {
                if (that._cesium.defined(removeListener)) {
                    removeListener();
                    removeListener = undefined;
                } else {
                    removeListener = dataSource.clustering.clusterEvent.addEventListener(function (clusteredEntities, cluster) {
                        cluster.label.show = false;
                        cluster.point.show = false;
                        cluster.billboard.show = true;
                        cluster.billboard.id = cluster.label.id;
                        cluster.billboard.verticalOrigin = that._cesium.VerticalOrigin.BOTTOM;
                        if (clusteredEntities.length >= 50) {
                            //cluster.billboard.image = pin50;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.RED, 48).toDataURL();
                        } else if (clusteredEntities.length >= 40) {
                            //cluster.billboard.image = pin40;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.ORANGE, 48).toDataURL();
                        } else if (clusteredEntities.length >= 30) {
                            //cluster.billboard.image = pin30;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.YELLOW, 48).toDataURL();
                        } else if (clusteredEntities.length >= 20) {
                            //cluster.billboard.image = pin20;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.GREEN, 48).toDataURL();
                        } else if (clusteredEntities.length >= 10) {
                            //cluster.billboard.image = pin10;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.BLUE, 48).toDataURL();
                        } else {
                            cluster.billboard.image = singleDigitPins[clusteredEntities.length - 2];
                        }
                    });
                }

                // force a re-cluster with the new styling
                var pixelRange = dataSource.clustering.pixelRange;
                dataSource.clustering.pixelRange = 0;
                dataSource.clustering.pixelRange = pixelRange;
                if (!checked) {
                    that.setVisibility(checked);
                }
            }

            customStyle();
            var viewModel = {
                pixelRange: pixelRange,
                minimumClusterSize: minimumClusterSize
            };
            that._cesium.knockout.track(viewModel);
            //var toolbar = document.getElementById('toolbar');
            //Cesium.knockout.applyBindings(viewModel, toolbar);
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        // if (this._core.isnull(options.id)) {
        //     options.id = this._core.getuid();
        // }
        var guid = this._core.getuid();
        if (this._core.isnull(name)) {
            name = "新建图层" + guid;
        }
        //导出工程树
        var obj = {
            id: guid,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'labelPointLayer',
            item: this,
            url: geojsonOrurl,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
            //style: options
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    //point点数据聚合demo
    LabelGeoJsonFeatureLayercopy.prototype.createPointPolymerizationGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        //数据解析
        var defaultOptions = {
            color: this._cesium.Color.WHITE, //	optional A Property specifying the Color of the point.
            pixelSize: 1, //optional A numeric Property specifying the size in pixels.
            outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the Color of the outline.
            outlineWidth: 0, //	optional A numeric Property specifying the the outline width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the point.
            scaleByDistance: new this._cesium.NearFarScalar(0, 0, 1, 1)
        };
        //字体填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.color)) {
            if (option.color.toString().charAt(0) == "[" && option.color.toString().charAt(option.color.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.color)) {
                    option.color = this._color.colorFromHtmlColor(option.color);
                } else {
                    if (/^rgb/.test(option.color)) {
                        option.color = this._color.rgbaStringToRgbaObj(option.color);
                    }
                    if (option.color.r > 1) {
                        option.color.r = option.color.r / 255;
                    }
                    if (option.color.g > 1) {
                        option.color.g = option.color.g / 255;
                    }
                    if (option.color.b > 1) {
                        option.color.b = option.color.b / 255;
                    }
                    if (option.color.a > 1) {
                        option.color.a = option.color.a / 255;
                    }
                    option.color = this._color.createColor(option.color.r, option.color.g, option.color.b, option.color.a);
                }
            }
        }
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (option.outlineColor.toString().charAt(0) == "[" && option.outlineColor.toString().charAt(option.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.outlineColor)) {
                    option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
                } else {
                    if (/^rgb/.test(option.outlineColor)) {
                        option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                    }
                    if (option.outlineColor.r > 1) {
                        option.outlineColor.r = option.outlineColor.r / 255;
                    }
                    if (option.outlineColor.g > 1) {
                        option.outlineColor.g = option.outlineColor.g / 255;
                    }
                    if (option.outlineColor.b > 1) {
                        option.outlineColor.b = option.outlineColor.b / 255;
                    }
                    if (option.outlineColor.a > 1) {
                        option.outlineColor.a = option.outlineColor.a / 255;
                    }
                    option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        //开始聚合
        ({
            camera: this._viewer.scene.camera,
            canvas: this._viewer.scene.canvas
        });
        //var dataSourcePromise = viewer.dataSources.add(Cesium.KmlDataSource.load('../../SampleData/kml/facilities/facilities.kml', optionsp));
        var dataSourcePromise = this._viewer.dataSources.add(this._cesium.GeoJsonDataSource.load(geojsonOrurl));
        //this._viewer.dataSources.add(dataSource);
        var that = this;

        var time;
        //添加时间段
        if (option && option.time) {
            time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }
        dataSourcePromise.then(function (dataSource) {
            that.item = dataSource;
            var pixelRange = 45;
            var minimumClusterSize = 3;
            var enabled = true;
            //解析并加载数据
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.color = that._core.extendgl(entity, option.color, options.color);
                options.pixelSize = parseInt(that._core.extendgl(entity, option.pixelSize, options.pixelSize));
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.height = parseFloat(that._core.extendgl(entity, option.height, options.height));
                options.scaleByDistance = that._core.extendgl(entity, option.scaleByDistance, options.scaleByDistance);
                var min = parseFloat(that._core.extendgl(entity, options.minDistanceDisplay));
                var max = parseFloat(that._core.extendgl(entity, options.maxDistanceDisplay));
                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                //获取数据结束
                //entity.billboard = undefined;
                entity.billboard.image = "";
                options.distanceDisplayCondition = distance;
                entity.point = new that._cesium.PointGraphics(options);

                options.pointHeight = that._core.extendgl(entity, option.pointHeight, options.pointHeight);
                options.pointHeight = parseFloat(options.pointHeight);
                //坐标转化
                that._viewer.scene.globe.ellipsoid;
                var scartographic = that._cesium.Cartographic.fromCartesian(entity.position._value);
                var slongitude = that._cesium.Math.toDegrees(scartographic.longitude);
                var slatitude = that._cesium.Math.toDegrees(scartographic.latitude);
                var sheight = scartographic.height + options.pointHeight;//
                var posit = new that._cesium.Cartesian3.fromDegrees(slongitude, slatitude, sheight);
                entity.position._value = posit;

                time && (entity.availability = time);
                //entity.point.distanceDisplayCondition = new that._cesium.DistanceDisplayCondition(10, 1000000.0);
            }

            dataSource.clustering.enabled = enabled;
            dataSource.clustering.pixelRange = pixelRange;
            dataSource.clustering.minimumClusterSize = minimumClusterSize;

            var removeListener;

            var pinBuilder = new that._cesium.PinBuilder();
            pinBuilder.fromText('50+', that._cesium.Color.RED, 48).toDataURL();
            pinBuilder.fromText('40+', that._cesium.Color.ORANGE, 48).toDataURL();
            pinBuilder.fromText('30+', that._cesium.Color.YELLOW, 48).toDataURL();
            pinBuilder.fromText('20+', that._cesium.Color.GREEN, 48).toDataURL();
            pinBuilder.fromText('10+', that._cesium.Color.BLUE, 48).toDataURL();

            var singleDigitPins = new Array(8);
            for (var i = 0; i < singleDigitPins.length; ++i) {
                singleDigitPins[i] = pinBuilder.fromText('' + (i + 2), that._cesium.Color.VIOLET, 48).toDataURL();
            }

            function customStyle() {
                if (that._cesium.defined(removeListener)) {
                    removeListener();
                    removeListener = undefined;
                } else {
                    removeListener = dataSource.clustering.clusterEvent.addEventListener(function (clusteredEntities, cluster) {
                        cluster.label.show = false;
                        cluster.point.show = false;
                        cluster.billboard.show = true;
                        cluster.billboard.id = cluster.label.id;
                        cluster.billboard.verticalOrigin = that._cesium.VerticalOrigin.BOTTOM;
                        if (clusteredEntities.length >= 50) {
                            //cluster.billboard.image = pin50;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.RED, 48).toDataURL();
                        } else if (clusteredEntities.length >= 40) {
                            //cluster.billboard.image = pin40;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.ORANGE, 48).toDataURL();
                        } else if (clusteredEntities.length >= 30) {
                            //cluster.billboard.image = pin30;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.YELLOW, 48).toDataURL();
                        } else if (clusteredEntities.length >= 20) {
                            //cluster.billboard.image = pin20;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.GREEN, 48).toDataURL();
                        } else if (clusteredEntities.length >= 10) {
                            //cluster.billboard.image = pin10;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.BLUE, 48).toDataURL();
                        } else {
                            cluster.billboard.image = singleDigitPins[clusteredEntities.length - 2];
                        }
                    });
                }

                // force a re-cluster with the new styling
                var pixelRange = dataSource.clustering.pixelRange;
                dataSource.clustering.pixelRange = 0;
                dataSource.clustering.pixelRange = pixelRange;
                if (!checked) {
                    that.setVisibility(checked);
                }
            }

            customStyle();
            var viewModel = {
                pixelRange: pixelRange,
                minimumClusterSize: minimumClusterSize
            };
            that._cesium.knockout.track(viewModel);
            //var toolbar = document.getElementById('toolbar');
            //Cesium.knockout.applyBindings(viewModel, toolbar);
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        // if (this._core.isnull(options.id)) {
        //     options.id = this._core.getuid();
        // }
        var guid = this._core.getuid();
        if (this._core.isnull(name)) {
            name = "新建图层" + guid;
        }
        //导出工程树
        var obj = {
            id: guid,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'pointLayer',
            item: this,
            url: geojsonOrurl,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
            //style: options
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    //标签聚合视野移动XP
    LabelGeoJsonFeatureLayercopy.prototype._cameraMoveEndHandler = function () {
        var currentMagnitude = this._viewer.camera.getMagnitude();
        if (currentMagnitude < this.gd) {
            if (this.sj) {
                this._viewer.scene.primitives.remove(this.labelCollections);
                this.labelCollections = new this._cesium.LabelCollection();
                for (var i = 0; i < this.labelCollections1.length; i++) {
                    this.labelCollections.add(this.labelCollections1[i]);
                }
                this._viewer.scene.primitives.add(this.labelCollections);
                this.sj = false;
            }
        } else {
            this._viewer.scene.primitives.remove(this.labelCollections);
            new this._cesium.BillboardCollection();
            for (var i = 0; i < this.labelCollections2.length; i++) {
                this.BillboardCollections.add(this.labelCollections2[i]);
            }
            this._viewer.scene.primitives.add(this.BillboardCollections);
            this.sj = true;
        }
    };
    //lable聚合（标签聚合）XP
    LabelGeoJsonFeatureLayercopy.prototype.createLabelpolymerizationGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var data = geojsonOrurl;
        this._viewer.scene.primitives;
        this._cameraMoveEndHandler = this._cameraMoveEndHandler.bind(this);
        this._viewer.camera.moveEnd.addEventListener(this._cameraMoveEndHandler);
        this.gd = option.height;
        new this._cesium.BillboardCollection();
        //var labelCollections = new sgworld._cesium.LabelCollection();
        var map = {},
            dest = [];
        for (var i = 0; i < data.length; i++) {
            var position = new this._cesium.Cartesian3.fromDegrees(data[i].lng, data[i].lat, 100);
            var p = {
                position: position,
                text: data[i].name
            };
            this.labelCollections1.push(p);
            var ai = data[i];
            if (!map[ai[option.adminname]]) {
                dest.push({
                    adminname: ai[option.adminname],
                    name: ai.name,
                    showBackground: true,
                    lat: ai.lat,
                    lng: ai.lng,
                    data: [ai]
                });
                map[ai[option.adminname]] = ai;
            } else {
                for (var j = 0; j < dest.length; j++) {
                    var dj = dest[j];
                    if (dj.adminname == ai[option.adminname]) {
                        dj.data.push(ai);
                        break;
                    }
                }
            }
        }
        for (var i = 0; i < dest.length; i++) {
            var position = new this._cesium.Cartesian3.fromDegrees(dest[i].lng, dest[i].lat, 100);
            var p = {
                position: position,
                image: pinBuilder.fromText(dest[i].data.length + "", this._cesium.Color.BLACK, 48).toDataURL()
            };
            this.labelCollections2.push(p);
            this.BillboardCollections.add(p);
        }

        var time;
        //添加时间段
        if (option && option.time) {
            time = new this._cesium.TimeIntervalCollection([new this._cesium.TimeInterval({
                start: option.time.start ? this._cesium.JulianDate.fromDate(new Date(option.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? this._cesium.JulianDate.fromDate(new Date(option.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        //sgworld.Viewer.scene.primitives.add(labelCollections1);
        this._viewer.scene.primitives.add(this.BillboardCollections, time);

    };
    //标签lable聚合完善
    LabelGeoJsonFeatureLayercopy.prototype.createLabelpolymerizationGeoJsonFeatureLayers = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**name, geoOptions, styleOption, GroupID, checked, disFnc
         * 默认样式
         */
        var defaultOptions = {
            height: 0,
            material: this._cesium.Color.WHITE,
            size: 50,
            fill: this._cesium.Color.RED,
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else if (/^http/.test(styleOption.material)) ; else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.fill)) {
            if (styleOption.fill.toString().charAt(0) == "[" && styleOption.fill.toString().charAt(styleOption.fill.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.fill)) {
                    styleOption.fill = this._color.colorFromHtmlColor(styleOption.fill);
                } else if (/^http/.test(styleOption.fill)) ; else {
                    if (/^rgb/.test(styleOption.fill)) {
                        styleOption.fill = this._color.rgbaStringToRgbaObj(styleOption.fill);
                    }
                    if (styleOption.fill.r > 1) {
                        styleOption.fill.r = styleOption.fill.r / 255;
                    }
                    if (styleOption.fill.g > 1) {
                        styleOption.fill.g = styleOption.fill.g / 255;
                    }
                    if (styleOption.fill.b > 1) {
                        styleOption.fill.b = styleOption.fill.b / 255;
                    }
                    if (styleOption.fill.a > 1) {
                        styleOption.fill.a = styleOption.fill.a / 255;
                    }
                    styleOption.fill = this._color.createColor(styleOption.fill.r, styleOption.fill.g, styleOption.fill.b, styleOption.fill.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        var that = this;
        /**
         * 请求矢量切片
         */
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);
        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = (parseFloat(options.height) || 0);
        //请求
        //结束请求前
        this._Provider.loadTile = function (frameState, tile) {
            if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                    if (that._cache) {
                        tileUrl += '&' + that._core.getuid();
                    }
                    that._core.xhr({
                        url: tileUrl,
                        type: "get",
                        dataType: "json",
                        success: function (data) {
                            if (cluster == "") {
                                that.labelCollections = new that._cesium.PointPrimitiveCollection();
                            } else {
                                that.labelCollections = new that._cesium.BillboardCollection();
                            }
                            var pinBuilder = new that._cesium.PinBuilder();
                            if (data == undefined) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }
                            data.features.forEach(function (feature) {
                                options.id = feature;
                                var sheight = feature.geometry.coordinates[2] || 0;
                                if (feature.properties.height != undefined) {
                                    sheight = parseFloat(feature.properties.height);
                                }
                                if (/^\[/.test(options.height) && /\]$/.test(options.height)) {
                                    var extrudedHeight = options.height.replace(/\[/, '').replace(/\]/, '');
                                    sheight += parseFloat(feature.properties[extrudedHeight]);
                                }
                                else {
                                    sheight += (parseFloat(options.height) || 0);
                                }

                                var entity = {};
                                var position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                                if (cluster == "") {
                                    entity = {
                                        id: feature,
                                        color: options.material,
                                        position: position
                                    };
                                } else {
                                    entity = {
                                        position: position,
                                        image: pinBuilder.fromText(feature.count + "", options.fill, options.size).toDataURL(),
                                        verticalOrigin: that._cesium.VerticalOrigin.BOTTOM
                                    };
                                }
                                that.labelCollections.add(entity);
                            });
                            if (data.features.length == 0) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            tile.data.geometryPrimitive = that.labelCollections;
                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                        },
                        error: function () {
                            if (tile.count == undefined) {
                                tile.count = 0;
                            }
                            tile.count += 1;
                            if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // return;
                            }
                            else {
                                tile.state = Cesium.QuadtreeTileLoadState.START;
                            }
                        }
                    });
                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                    tile.renderable = true;
                    return;
                }
                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
            }
        };
        this._primitive = new this._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;

        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geoOptions] geojosn对象或者地址
     * {
     *   url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
     *       layer:'nanjing',
            upperLevelLimit: 13,
            lowerLevelLimit: 13,
            minx:118.51721649800015,
            miny:31.863232407499936,
            maxx:118.91648798400001,
            maxy:32.27649160409993
     * }
     * @param {object} [option] 参数对象{
     *        Name: "",
            text: "",
            font_size: '30px',
            font_family:'sans-serif'
            stylet: this._cesium.LabelStyle.FILL,
            fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
            outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
            show: true,//	optional A boolean Property specifying the visibility of the label.
            showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
            backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
            near: 0,
            far: 5000
       }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    LabelGeoJsonFeatureLayercopy.prototype.createLabelGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {

        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        styleOption.material;
        //填充颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.fillColor)) {
            if (/^\[/.test(styleOption.fillColor) && styleOption.fillColor.toString().charAt(0) == "[" && styleOption.fillColor.toString().charAt(styleOption.fillColor.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.fillColor)) {
                    styleOption.fillColor = that._color.colorFromHtmlColor(styleOption.fillColor);
                } else {
                    if (/^rgb/.test(styleOption.fillColor)) {
                        styleOption.fillColor = that._color.rgbaStringToRgbaObj(styleOption.fillColor);
                    }
                    if (styleOption.fillColor.r > 1) {
                        styleOption.fillColor.r = styleOption.fillColor.r / 255;
                    }
                    if (styleOption.fillColor.g > 1) {
                        styleOption.fillColor.g = styleOption.fillColor.g / 255;
                    }
                    if (styleOption.fillColor.b > 1) {
                        styleOption.fillColor.b = styleOption.fillColor.b / 255;
                    }
                    if (styleOption.fillColor.a > 1) {
                        styleOption.fillColor.a = styleOption.fillColor.a / 255;
                    }
                    styleOption.fillColor = that._color.createColor(styleOption.fillColor.r, styleOption.fillColor.g, styleOption.fillColor.b, styleOption.fillColor.a);
                }
            }
        }
        //填充颜色设置material
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.material)) {
            if (/^\[/.test(styleOption.material) && styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = that._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = that._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = that._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        //边框颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.outlineColor)) {
            if (/^\[/.test(styleOption.outlineColor) && styleOption.outlineColor.toString().charAt(0) == "[" && styleOption.outlineColor.toString().charAt(styleOption.outlineColor.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.outlineColor)) {
                    styleOption.outlineColor = that._color.colorFromHtmlColor(styleOption.outlineColor);
                } else {
                    if (/^rgb/.test(styleOption.outlineColor)) {
                        styleOption.outlineColor = that._color.rgbaStringToRgbaObj(styleOption.outlineColor);
                    }
                    if (styleOption.outlineColor.r > 1) {
                        styleOption.outlineColor.r = styleOption.outlineColor.r / 255;
                    }
                    if (styleOption.outlineColor.g > 1) {
                        styleOption.outlineColor.g = styleOption.outlineColor.g / 255;
                    }
                    if (styleOption.outlineColor.b > 1) {
                        styleOption.outlineColor.b = styleOption.outlineColor.b / 255;
                    }
                    if (styleOption.outlineColor.a > 1) {
                        styleOption.outlineColor.a = styleOption.outlineColor.a / 255;
                    }
                    styleOption.outlineColor = that._color.createColor(styleOption.outlineColor.r, styleOption.outlineColor.g, styleOption.outlineColor.b, styleOption.outlineColor.a);
                }
            }
        }
        //背景颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.backgroundColor)) {
            if (/^\[/.test(styleOption.backgroundColor) && styleOption.backgroundColor.toString().charAt(0) == "[" && styleOption.backgroundColor.toString().charAt(styleOption.backgroundColor.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.backgroundColor)) {
                    styleOption.backgroundColor = that._color.colorFromHtmlColor(styleOption.backgroundColor);
                } else {
                    if (/^rgb/.test(styleOption.backgroundColor)) {
                        styleOption.backgroundColor = that._color.rgbaStringToRgbaObj(styleOption.backgroundColor);
                    }
                    if (styleOption.backgroundColor.r > 1) {
                        styleOption.backgroundColor.r = styleOption.backgroundColor.r / 255;
                    }
                    if (styleOption.backgroundColor.g > 1) {
                        styleOption.backgroundColor.g = styleOption.backgroundColor.g / 255;
                    }
                    if (styleOption.backgroundColor.b > 1) {
                        styleOption.backgroundColor.b = styleOption.backgroundColor.b / 255;
                    }
                    if (styleOption.backgroundColor.a > 1) {
                        styleOption.backgroundColor.a = styleOption.backgroundColor.a / 255;
                    }
                    styleOption.backgroundColor = that._color.createColor(styleOption.backgroundColor.r, styleOption.backgroundColor.g, styleOption.backgroundColor.b, styleOption.backgroundColor.a);
                }
            }
        }
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = (parseFloat(styleOption.height) || 0);
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                    if (that._cache) {
                        tileUrl += '&' + that._core.getuid();
                    }
                    that._core.xhr({
                        url: tileUrl,
                        type: "get",
                        dataType: "json",
                        success: function (data) {
                            if (data == undefined) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }
                            var defaultOptions = {
                                Name: "",
                                text: "",
                                font: ' 30px sans-serif',
                                style: that._cesium.LabelStyle.FILL_AND_OUTLINE,
                                fillColor: that._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                                outlineColor: that._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                                show: true, //	optional A boolean Property specifying the visibility of the label.
                                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                                backgroundColor: new that._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                                backgroundPadding: new that._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                                horizontalOrigin: that._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: that._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: that._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: that._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                heightReference: that._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                                scaleByDistance: new that._cesium.NearFarScalar(0, 0, 1, 1),
                                maxDistanceDisplay: 99999999, //最大可视化距离
                                minDistanceDisplay: 0, //最小可视化距离
                                far: 99999999, //最大可视化距离
                                near: 0, //最小可视化距离
                            };

                            var options = that._core.extend(defaultOptions, styleOption, true);

                            if (that._core.isnull(styleOption.near)) {
                                styleOption.near = 0;
                            }
                            if (that._core.isnull(styleOption.far)) {
                                styleOption.far = 999999999;
                            }
                            var min = parseFloat(styleOption.near);
                            var max = parseFloat(styleOption.far);
                            var distance = new that._cesium.DistanceDisplayCondition(min, max);
                            options.distanceDisplayCondition = distance;
                            //options.pointHeight = parseFloat(that._core.extendgl(entity, option.pointHeight, options.pointHeight));
                            if (that._core.isnull(styleOption.font_size)) {
                                styleOption.font_size = "30px";
                            }
                            if (that._core.isnull(styleOption.font_family)) {
                                styleOption.font_family = " sans-serif";
                            }
                            //options.font = option.font_size + " " + option.font_family;
                            options.font = parseFloat(styleOption.font_size) + "px " + styleOption.font_family;
                            var labelCollections;
                            if (options.image != undefined && options.image != null) {
                                labelCollections = new that._cesium.BillboardCollection();
                            } else {
                                labelCollections = new that._cesium.LabelCollection();
                            }
                            data.features.forEach(function (feature) {
                                options.id = feature;
                                //options.position = that._cesium.Cartesian3.fromDegreesArray(feature.geometry.coordinates)[0];
                                //修改xp
                                var sheight = options.pointHeight;
                                if (/^\[/.test(sheight) && /\]$/.test(sheight)) {
                                    var heightStr = sheight.replace(/\[/, '').replace(/\]/, '');
                                    sheight = parseFloat(feature.properties[heightStr]);
                                } else if (sheight != undefined && sheight != '') {
                                    sheight = parseFloat(sheight);
                                } else if (feature.properties.height != undefined) {
                                    sheight = parseFloat(feature.properties.height);
                                }
                                options.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                                //填充色
                                if (/^\[/.test(styleOption.fillColor) && /\]$/.test(styleOption.fillColor)) {
                                    var material = styleOption.fillColor.replace(/\[/, '').replace(/\]/, '');
                                    options.fillColor = feature.properties[material];
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.fillColor)) {
                                        options.fillColor = that._color.colorFromHtmlColor(options.fillColor);
                                    } else {
                                        if (/^rgb/.test(options.fillColor)) {
                                            options.fillColor = that._color.rgbaStringToRgbaObj(options.fillColor);
                                        }
                                        if (options.fillColor.r > 1) {
                                            options.fillColor.r = options.fillColor.r / 255;
                                        }
                                        if (options.fillColor.g > 1) {
                                            options.fillColor.g = options.fillColor.g / 255;
                                        }
                                        if (options.fillColor.b > 1) {
                                            options.fillColor.b = options.fillColor.b / 255;
                                        }
                                        if (options.fillColor.a > 1) {
                                            options.fillColor.a = options.fillColor.a / 255;
                                        }
                                        options.fillColor = that._color.createColor(options.fillColor.r, options.fillColor.g, options.fillColor.b, options.fillColor.a);
                                    }
                                }
                                //边框色
                                if (/^\[/.test(styleOption.outlineColor) && /\]$/.test(styleOption.outlineColor)) {
                                    var material = styleOption.outlineColor.replace(/\[/, '').replace(/\]/, '');
                                    options.outlineColor = feature.properties[material];
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.outlineColor)) {
                                        options.outlineColor = that._color.colorFromHtmlColor(options.outlineColor);
                                    } else {
                                        if (/^rgb/.test(options.outlineColor)) {
                                            options.outlineColor = that._color.rgbaStringToRgbaObj(options.outlineColor);
                                        }
                                        if (options.outlineColor.r > 1) {
                                            options.outlineColor.r = options.outlineColor.r / 255;
                                        }
                                        if (options.outlineColor.g > 1) {
                                            options.outlineColor.g = options.outlineColor.g / 255;
                                        }
                                        if (options.outlineColor.b > 1) {
                                            options.outlineColor.b = options.outlineColor.b / 255;
                                        }
                                        if (options.outlineColor.a > 1) {
                                            options.outlineColor.a = options.outlineColor.a / 255;
                                        }
                                        options.outlineColor = that._color.createColor(options.outlineColor.r, options.outlineColor.g, options.outlineColor.b, options.outlineColor.a);
                                    }
                                }
                                var col = "fillColor:" + options.fillColor.red * 255 + "," + options.fillColor.green * 255 + "," + options.fillColor.blue * 255
                                    + ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                                that.Legend.push(col);
                                if (/^\[/.test(styleOption.text) && /\]$/.test(styleOption.text)) {
                                    var material = styleOption.text.replace(/\[/, '').replace(/\]/, '');
                                    options.text = feature.properties[material];
                                }

                                //样式属性
                                options.id.treeID = styleOption.id;
                                options.id.VectorType = 'label';
                                options.id.VectorStyle = {
                                    position: options.position,
                                    pointHeight: sheight,
                                    text: options.text, //文本
                                    font: options.font,
                                    scale: options.scale,
                                    style: options.style,
                                    fillColor: options.fillColor,
                                    outlineColor: options.outlineColor,
                                    outlineWidth: options.outlineWidth,
                                    showBackground: options.showBackground,
                                    backgroundColor: options.backgroundColor,
                                    heightReference: options.heightReference,
                                    horizontalOrigin: options.horizontalOrigin,
                                    verticalOrigin: options.verticalOrigin,
                                    scaleByDistance: options.scaleByDistance,
                                    distanceDisplayCondition: options.distanceDisplayCondition
                                };

                                labelCollections.add(options);
                            });
                            if (data.features.length == 0) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            tile.data.geometryPrimitive = labelCollections;
                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                        },
                        error: function () {
                            if (tile.count == undefined) {
                                tile.count = 0;
                            }
                            tile.count += 1;
                            if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // return;
                            }
                            else {
                                tile.state = Cesium.QuadtreeTileLoadState.START;
                            }
                        }
                    });
                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                    tile.renderable = true;
                    return;
                }
                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
            }
        };
        this._primitive = new this._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;

        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this._Provider.treeID = styleOption.id;
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    /**
     * createLabelImageGeoJsonFeatureLayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geoOptions] geojosn对象或者地址
     * {
     *   url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
     *       layer:'nanjing',
            upperLevelLimit: 13,
            lowerLevelLimit: 13,
            minx:118.51721649800015,
            miny:31.863232407499936,
            maxx:118.91648798400001,
            maxy:32.27649160409993
     * }
     * @param {object} [option] 参数对象{
     *        Name: "",
            text: "",
            font_size: '30px',
            font_family:'sans-serif'
            stylet: this._cesium.LabelStyle.FILL,
            fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
            outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
            show: true,//	optional A boolean Property specifying the visibility of the label.
            showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
            backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
            near: 0,
            far: 5000
       }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    LabelGeoJsonFeatureLayercopy.prototype.createLabelImageGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {

        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            Cesium: this._cesium
        };
        var that = this;
        styleOption.material;
        //填充颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.fillColor) && typeof styleOption.fillColor === 'string') {
            if (/^\[/.test(styleOption.fillColor) && /\]$/.test(styleOption.fillColor)) ; else {
                if (that._core.isHtmlColor(styleOption.fillColor) || /^rgb/.test(styleOption.fillColor)) {
                    styleOption.fillColor = Cesium.Color.fromCssColorString(styleOption.fillColor);
                }
            }
        }
        //边框颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.outlineColor) && typeof styleOption.outlineColor === 'string') {
            if (/^\[/.test(styleOption.outlineColor) && /\]$/.test(styleOption.outlineColor)) ; else {
                if (that._core.isHtmlColor(styleOption.outlineColor) || /^rgb/.test(styleOption.outlineColor)) {
                    styleOption.outlineColor = Cesium.Color.fromCssColorString(styleOption.outlineColor);
                }
            }
        }
        //图片颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.color) && typeof styleOption.color === 'string') {
            if (/^\[/.test(styleOption.color) && /\]$/.test(styleOption.color)) ; else {
                if (that._core.isHtmlColor(styleOption.color) || /^rgb/.test(styleOption.color)) {
                    styleOption.color = Cesium.Color.fromCssColorString(styleOption.color);
                }
            }
        }
        //背景颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.backgroundColor) && typeof styleOption.backgroundColor === 'string') {
            if (/^\[/.test(styleOption.backgroundColor) && /\]$/.test(styleOption.backgroundColor)) ; else {
                if (that._core.isHtmlColor(styleOption.backgroundColor) || /^rgb/.test(styleOption.backgroundColor)) {
                    styleOption.backgroundColor = Cesium.Color.fromCssColorString(styleOption.backgroundColor);
                }
            }
        }

        if (that._core.isnull(styleOption.font)) {
            if (that._core.isnull(styleOption.font_size)) {
                styleOption.font_size = "30px";
            }
            if (that._core.isnull(styleOption.font_family)) {
                styleOption.font_family = " sans-serif";
            }
            styleOption.font = styleOption.font_size + " " + styleOption.font_family;
            if (styleOption.bold) {
                styleOption.font = "bold " + styleOption.font;
            }
            if (styleOption.italic) {
                styleOption.font = "italic " + styleOption.font;
            }
        }

        if (that._core.isnull(styleOption.near)) {
            styleOption.near = 0;
        }
        if (that._core.isnull(styleOption.far)) {
            styleOption.far = 999999999;
        }
        var min = parseFloat(styleOption.near);
        var max = parseFloat(styleOption.far);
        var distance = new that._cesium.DistanceDisplayCondition(min, max);
        styleOption.distanceDisplayCondition = distance;

        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProviderEntity(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max + 1;
        this._Provider._minimumHeight = (parseFloat(styleOption.height) || 0);

        function getTEStyle(feature, style) {
            let value;
            if (typeof style.value === 'string') {
                if (/^\[/.test(style.value) && /\]$/.test(style.value)) {
                    value = style.value.replace(/\[/, '').replace(/\]/, '');
                    value = feature.properties[value];
                } else {
                    value = style.value;
                }
            } else {
                let styleValue = style.value;
                let Condition = styleValue.Condition;
                let propValue = feature.properties[Condition];
                value = styleValue.Value[propValue];
            }
            !value && (value = style.defaultValue);

            if (that._core.isHtmlColor(value)) {
                value = Cesium.Color.fromCssColorString(value);
            }
            return value;
        }

        //获取行列号范围
        that._core.xhr({
            url: geoOptions.url + "?service=WMTS&request=GetCapabilities",
            type: "get",
            isXml: true,
            success: function (data) {
                let xml2json = that._core.xml2json(data);
                let layers = xml2json.Contents && xml2json.Contents.Layer;
                let layer = layers.filter(item => {
                    return item.Identifier === geoOptions.layer;
                })[0];
                if (layer) {
                    let TileMatrixSetLink = layer.TileMatrixSetLink;
                    let srs = geoOptions.srs || 'EPSG:4490';
                    let TileMatrixSet = TileMatrixSetLink.filter(item => {
                        return item.TileMatrixSet === srs;
                    })[0];
                    if (TileMatrixSet) {
                        that.TileMatrixLimits = {};
                        TileMatrixSet.TileMatrixSetLimits && TileMatrixSet.TileMatrixSetLimits.TileMatrixLimits.forEach(item => {
                            let TileMatrix = item.TileMatrix;
                            TileMatrix = TileMatrix.split(":");
                            let level = TileMatrix[TileMatrix.length - 1];
                            that.TileMatrixLimits[level] = {
                                maxCol: item.MaxTileCol,
                                minCol: item.MinTileCol,
                                maxRow: item.MaxTileRow,
                                minRow: item.MinTileRow,
                            };
                        });
                    }
                }
            }
        });

        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;

        this._Provider.EntityCollection = new Cesium.EntityCollection();
        this._Provider.EntityCollection.isShow = true;
        this._Provider.EntityCollection.childrenCollection = {};

        //自定义集合
        function EntityCollection(viewer, collection, tile) {
            this.viewer = viewer;
            this.collection = collection;
            this.key = tile.level + '-' + tile.x + '-' + tile.y;
            this.isDestroy = false;
            this.values = [];
            this._time = undefined;
            this.show = true;
        }    EntityCollection.prototype.update = function () {
            clearTimeout(this._time);
            this.setVisibility(true);
            this._time = setTimeout(() => {
                this.setVisibility(false);
            }, 500);
        };
        EntityCollection.prototype.add = function (entity) {
            if (!this.isDestroy) {
                this.viewer && this.viewer.entities.add(entity);
                this.collection && this.collection.add(entity);
                this.values.push(entity.id);
            }
        };
        EntityCollection.prototype.setVisibility = function (show) {
            this.show = show;
            this.values.forEach(id => {
                let p = this.viewer.entities.getById(id);
                p && (p.show = show);
            });
        };
        EntityCollection.prototype.destroy = function () {
            this.isDestroy = true;
            this.add = () => { };
            this.update = () => { };
            this.values.forEach(id => {
                this.viewer && this.viewer.entities.removeById(id);
                this.collection && this.collection.removeById(id);
            });
            delete this.collection.childrenCollection[this.key];
            this.collection = undefined;
            this.values = [];
            this.viewer = undefined;
            Cesium.destroyObject(this);
        };

        let _time;
        function updataCache() {
            if (that._Provider.EntityCollection.show) {
                clearTimeout(_time);
                _time = setTimeout(function () {
                    updataTile();
                }, 500);
            }
        }
        this._Provider.loadTile = function (frameState, tile) {
            if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };

                if (tile.level >= styleOption.level_min && tile.level <= styleOption.level_max && that.item.show) {

                    //限制行列号范围
                    if (that.TileMatrixLimits) {
                        let Limit = that.TileMatrixLimits[tile.level];
                        if (Limit && (tile.x > Limit.maxCol || tile.x < Limit.minCol || tile.y > Limit.maxRow || tile.y < Limit.minRow)) {
                            tile.state = Cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            updataCache();
                            return;
                        }
                    }
                    if (that._Provider.EntityCollection.isShow) {
                        that._Provider.EntityCollection.show = true;
                    }

                    if (that._Provider.EntityCollection.childrenCollection[tile.level + '-' + tile.x + '-' + tile.y]) {
                        let _entityCollection = that._Provider.EntityCollection.childrenCollection[tile.level + '-' + tile.x + '-' + tile.y];
                        _entityCollection.setVisibility(true);
                        tile.data.geometryPrimitive = _entityCollection;

                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        updataCache();
                        return;
                    }
                    var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                    if (that._cache) {
                        tileUrl += '&' + that._core.getuid();
                    }
                    that._core.xhr({
                        url: tileUrl,
                        type: "get",
                        dataType: "json",
                        success: function (data) {
                            if (!data || !data.features || !data.features.length) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }

                            var defaultOptions = {
                                Name: "",
                                text: "",
                                font: ' 30px sans-serif',
                                style: that._cesium.LabelStyle.FILL_AND_OUTLINE,
                                fillColor: that._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                                outlineColor: that._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                                show: true, //	optional A boolean Property specifying the visibility of the label.
                                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                                backgroundColor: new that._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                                backgroundPadding: new that._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                                horizontalOrigin: that._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: that._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: that._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: that._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                heightReference: that._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                                scaleByDistance: new that._cesium.NearFarScalar(0, 0, 1, 1),
                                maxDistanceDisplay: 99999999, //最大可视化距离
                                minDistanceDisplay: 0, //最小可视化距离
                                far: 99999999, //最大可视化距离
                                near: 0, //最小可视化距离
                            };

                            var options = that._core.extend(defaultOptions, styleOption, true);

                            var labelCollections, billboardCollection;
                            if (options.image && !options.text) {
                                billboardCollection = true;
                            } else if (!options.image && options.text) {
                                labelCollections = true;
                            } else if (options.image && options.text) {
                                billboardCollection = true;
                                labelCollections = true;
                            } else {
                                labelCollections = true;
                            }

                            let entityCollection = new EntityCollection(that._viewer, that._Provider.EntityCollection, tile);

                            addData(data);

                            async function addData(data) {
                                data.features.forEach(function (feature, featureIndex) {
                                    if (entityCollection.isDestroy) {
                                        return;
                                    }
                                    addFeature(feature);
                                });
                            }

                            async function addFeature(feature) {
                                options.id = feature.id;

                                //修改xp
                                var sheight = options.pointHeight;
                                if (typeof sheight === 'string' && /^\[/.test(sheight) && /\]$/.test(sheight)) {
                                    var heightStr = sheight.replace(/\[/, '').replace(/\]/, '');
                                    sheight = parseFloat(feature.properties[heightStr]);
                                } else if (sheight != undefined && sheight != '') {
                                    sheight = parseFloat(sheight);
                                } else if (feature.properties.height != undefined) {
                                    sheight = parseFloat(feature.properties.height);
                                }
                                options.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);

                                if (typeof styleOption.font === 'object') {
                                    options.font = getTEStyle(feature, styleOption.font);
                                }
                                //填充色
                                if (typeof styleOption.fillColor === 'string' && /^\[/.test(styleOption.fillColor) && /\]$/.test(styleOption.fillColor)) {
                                    var material = styleOption.fillColor.replace(/\[/, '').replace(/\]/, '');
                                    options.fillColor = feature.properties[material];
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.fillColor) || /^rgb/.test(options.fillColor)) {
                                        options.fillColor = Cesium.Color.fromCssColorString(options.fillColor);
                                    }
                                } else if (typeof styleOption.fillColor === 'object' && styleOption.fillColor.value) {
                                    options.fillColor = getTEStyle(feature, styleOption.fillColor);
                                }

                                //边框色
                                if (typeof styleOption.outlineColor === 'string' && /^\[/.test(styleOption.outlineColor) && /\]$/.test(styleOption.outlineColor)) {
                                    var material = styleOption.outlineColor.replace(/\[/, '').replace(/\]/, '');
                                    options.outlineColor = feature.properties[material];
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.outlineColor) || /^rgb/.test(options.outlineColor)) {
                                        options.outlineColor = Cesium.Color.fromCssColorString(options.outlineColor);
                                    }
                                } else if (typeof styleOption.outlineColor === 'object' && styleOption.outlineColor.value) {
                                    options.outlineColor = getTEStyle(feature, styleOption.outlineColor);
                                }

                                //背景色
                                if (styleOption.showBackground) {
                                    if (typeof styleOption.backgroundColor === 'string' && /^\[/.test(styleOption.backgroundColor) && /\]$/.test(styleOption.backgroundColor)) {
                                        var material = styleOption.backgroundColor.replace(/\[/, '').replace(/\]/, '');
                                        options.backgroundColor = feature.properties[material];
                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.backgroundColor) || /^rgb/.test(options.backgroundColor)) {
                                            options.backgroundColor = Cesium.Color.fromCssColorString(options.backgroundColor);
                                        }
                                    } else if (typeof styleOption.backgroundColor === 'object' && styleOption.backgroundColor.value) {
                                        options.backgroundColor = getTEStyle(feature, styleOption.backgroundColor);
                                    }
                                }


                                var col = "fillColor:" + options.fillColor.red * 255 + "," + options.fillColor.green * 255 + "," + options.fillColor.blue * 255
                                    + ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                                that.Legend.push(col);

                                if (typeof styleOption.text === 'string' && /^\[/.test(styleOption.text) && /\]$/.test(styleOption.text)) {
                                    var material = styleOption.text.replace(/\[/, '').replace(/\]/, '');
                                    options.text = feature.properties[material];
                                } else if (typeof styleOption.text === 'object') {
                                    options.text = getTEStyle(feature, styleOption.text);
                                }

                                if (typeof styleOption.image === 'string' && /^\[/.test(styleOption.image) && /\]$/.test(styleOption.image)) {
                                    var material = styleOption.image.replace(/\[/, '').replace(/\]/, '');
                                    options.image = feature.properties[material];
                                } else if (typeof styleOption.image === 'object') {
                                    options.image = getTEStyle(feature, styleOption.image);
                                }

                                let entityOption = {
                                    position: options.position
                                };
                                if (labelCollections) {
                                    let labelOption = options;
                                    if (options.labelData) {
                                        labelOption = Object.assign({}, options, options.labelData, true);
                                    }
                                    if (options.offsetX || options.offsetY) {
                                        labelOption.pixelOffset = new Cesium.Cartesian2(options.offsetX || 0, options.offsetY || 0);
                                    }
                                    entityOption.label = labelOption;
                                }

                                if (billboardCollection) {
                                    let imageOption = options;
                                    if (options.imageData) {
                                        imageOption = Object.assign({}, options, options.imageData, true);
                                    }
                                    entityOption.billboard = imageOption;
                                }
                                let _entity = new Cesium.Entity(entityOption);
                                _entity.feature = feature;
                                entityCollection.add(_entity);
                            }

                            tile.data.geometryPrimitive = entityCollection;
                            //缓存
                            that._Provider.EntityCollection.childrenCollection[tile.level + '-' + tile.x + '-' + tile.y] = entityCollection;

                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                // tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            updataCache();
                        },
                        error: function () {
                            // if (tile.count == undefined) {
                            //     tile.count = 0;
                            // }
                            // tile.count += 1;
                            // if (tile.count >= 2) {
                            tile.state = Cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            updataCache();
                            // return;
                            // }
                            // else {
                            //     tile.state = Cesium.QuadtreeTileLoadState.START;
                            // }
                        }
                    });
                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                    tile.renderable = true;
                    that._Provider.EntityCollection.show = false;
                    return;
                }
                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
            }
            updataCache();
        };

        function updataTile() {
            if (that._Provider.quadtree && that._Provider.quadtree._tilesToRender && that._Provider.quadtree._tilesToRender.length) {
                let showTile = [];
                that._Provider.quadtree._tilesToRender.forEach(_tile => {
                    showTile.push(_tile.level + '-' + _tile.x + '-' + _tile.y);
                });
                for (let key in that._Provider.EntityCollection.childrenCollection) {
                    if (showTile.indexOf(key) < 0) {
                        that._Provider.EntityCollection.childrenCollection[key].setVisibility(false);
                    }
                }
            }
        }
        this._primitive = new this._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;

        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);

        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this._Provider.treeID = styleOption.id;
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    LabelGeoJsonFeatureLayercopy.prototype.createLabelImageGeoJsonFeatureLayerProvider1 = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {

        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        styleOption.material;

        var defaultOptions = {
            Name: "",
            text: "",
            font: ' 30px sans-serif',
            style: that._cesium.LabelStyle.FILL_AND_OUTLINE,
            fillColor: that._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
            outlineColor: that._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
            outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
            show: true, //	optional A boolean Property specifying the visibility of the label.
            showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new that._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
            backgroundPadding: new that._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: that._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
            verticalOrigin: that._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
            eyeOffset: that._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: that._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: that._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
            scaleByDistance: new that._cesium.NearFarScalar(0, 0, 1, 1),
            maxDistanceDisplay: 99999999, //最大可视化距离
            minDistanceDisplay: 0, //最小可视化距离
            far: 99999999, //最大可视化距离
            near: 0, //最小可视化距离
        };

        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        // this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._normalTile = 21;
        this._Provider._minimumHeight = (parseFloat(styleOption.height) || 0);
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {

                    // that._Provider.setStatus(true);

                    var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                    if (that._cache) {
                        tileUrl += '&' + that._core.getuid();
                    }
                    that._core.xhr({
                        url: tileUrl,
                        type: "get",
                        dataType: "json",
                        success: function (data) {
                            if (data == undefined) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }

                            var options = that._core.extend(defaultOptions, styleOption, true);

                            options.font = styleOption.font;


                            var labelCollections, billboardCollection, primitiveCollection;
                            if (options.image && !options.text) {
                                billboardCollection = new that._cesium.BillboardCollection({ scene: that._viewer.scene });
                            } else if (!options.image && options.text) {
                                labelCollections = new that._cesium.LabelCollection({ scene: that._viewer.scene });
                            } else if (options.image && options.text) {
                                labelCollections = new that._cesium.LabelCollection({ scene: that._viewer.scene });
                                billboardCollection = new that._cesium.BillboardCollection({ scene: that._viewer.scene });
                                primitiveCollection = new that._cesium.PrimitiveCollection();
                                primitiveCollection.add(labelCollections);
                                primitiveCollection.add(billboardCollection);
                            } else {
                                labelCollections = new that._cesium.LabelCollection({ scene: that._viewer.scene });
                            }
                            data.features.forEach(function (feature) {
                                options.id = feature;

                                var sheight = options.pointHeight;
                                if (/^\[/.test(sheight) && /\]$/.test(sheight)) {
                                    var heightStr = sheight.replace(/\[/, '').replace(/\]/, '');
                                    sheight = parseFloat(feature.properties[heightStr]);
                                } else if (sheight != undefined && sheight != '') {
                                    sheight = parseFloat(sheight);
                                } else if (feature.properties.height != undefined) {
                                    sheight = parseFloat(feature.properties.height);
                                }

                                options.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);

                                // 填充色
                                if (styleOption.fillColor) {
                                    // 读取属性颜色 例如 [color]
                                    if (/^\[/.test(styleOption.fillColor) && /\]$/.test(styleOption.fillColor)) {
                                        var material = styleOption.fillColor.replace(/\[/, '').replace(/\]/, '');
                                        options.fillColor = feature.properties[material];
                                    }
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.fillColor)) {
                                        options.fillColor = that._color.colorFromHtmlColor(options.fillColor);
                                    } else {
                                        if (/^rgb/.test(options.fillColor)) {
                                            options.fillColor = that._color.rgbaStringToRgbaObj(options.fillColor);
                                        }
                                        if (options.fillColor.r > 1) {
                                            options.fillColor.r = options.fillColor.r / 255;
                                        }
                                        if (options.fillColor.g > 1) {
                                            options.fillColor.g = options.fillColor.g / 255;
                                        }
                                        if (options.fillColor.b > 1) {
                                            options.fillColor.b = options.fillColor.b / 255;
                                        }
                                        if (options.fillColor.a > 1) {
                                            options.fillColor.a = options.fillColor.a / 255;
                                        }
                                        options.fillColor = that._color.createColor(options.fillColor.r, options.fillColor.g, options.fillColor.b, options.fillColor.a);
                                    }
                                }
                                else if (styleOption.fillColor && styleOption.fillColor.Class instanceof Array) {
                                    for (var i = 0; i < styleOption.fillColor.Class.length; i++) {
                                        var element = styleOption.fillColor.Class[i];
                                        var eli = element.Condition.replace("<", "").replace(">", "").split("=");
                                        eli[0] = eli[0].replace(/\[/, '').replace(/\]/, '').replace(/\"/, '').replace(/\"/, '');
                                        eli[1] = eli[1].replace(/\"/, '').replace(/\"/, '');
                                        if (feature.properties[eli[0]] == eli[1]) {
                                            options.fillColor = element.Value;
                                            //填充颜色设置
                                            if (that._core.isHtmlColor(options.fillColor)) {
                                                options.fillColor = that._color.colorFromHtmlColor(options.fillColor);
                                            } else {
                                                if (/^rgb/.test(options.fillColor)) {
                                                    options.fillColor = that._color.rgbaStringToRgbaObj(options.fillColor);
                                                }
                                                if (options.fillColor.r > 1) {
                                                    options.fillColor.r = options.fillColor.r / 255;
                                                }
                                                if (options.fillColor.g > 1) {
                                                    options.fillColor.g = options.fillColor.g / 255;
                                                }
                                                if (options.fillColor.b > 1) {
                                                    options.fillColor.b = options.fillColor.b / 255;
                                                }
                                                if (options.fillColor.a > 1) {
                                                    options.fillColor.a = options.fillColor.a / 255;
                                                }
                                                options.fillColor = that._color.createColor(options.fillColor.r, options.fillColor.g, options.fillColor.b, options.fillColor.a);
                                            }
                                            break;
                                        }
                                    }                            }
                                else if (styleOption.fillColor && styleOption.fillColor.Class.toString() != "{}") {

                                    options.fillColor = styleOption.fillColor.Value;

                                    if (that._core.isHtmlColor(options.fillColor)) {
                                        options.fillColor = that._color.colorFromHtmlColor(options.fillColor);
                                    } else {
                                        if (/^rgb/.test(options.fillColor)) {
                                            options.fillColor = that._color.rgbaStringToRgbaObj(options.fillColor);
                                        }
                                        if (options.fillColor.r > 1) {
                                            options.fillColor.r = options.fillColor.r / 255;
                                        }
                                        if (options.fillColor.g > 1) {
                                            options.fillColor.g = options.fillColor.g / 255;
                                        }
                                        if (options.fillColor.b > 1) {
                                            options.fillColor.b = options.fillColor.b / 255;
                                        }
                                        if (options.fillColor.a > 1) {
                                            options.fillColor.a = options.fillColor.a / 255;
                                        }
                                        options.fillColor = that._color.createColor(options.fillColor.r, options.fillColor.g, options.fillColor.b, options.fillColor.a);
                                    }
                                }
                                else if (style.fillColor && style.fillColor.toString() != "{}") {
                                    options.fillColor = styleOption.fillColor.Value;

                                    if (that._core.isHtmlColor(options.fillColor)) {
                                        options.fillColor = that._color.colorFromHtmlColor(options.fillColor);
                                    } else {
                                        if (/^rgb/.test(options.fillColor)) {
                                            options.fillColor = that._color.rgbaStringToRgbaObj(options.fillColor);
                                        }
                                        if (options.fillColor.r > 1) {
                                            options.fillColor.r = options.fillColor.r / 255;
                                        }
                                        if (options.fillColor.g > 1) {
                                            options.fillColor.g = options.fillColor.g / 255;
                                        }
                                        if (options.fillColor.b > 1) {
                                            options.fillColor.b = options.fillColor.b / 255;
                                        }
                                        if (options.fillColor.a > 1) {
                                            options.fillColor.a = options.fillColor.a / 255;
                                        }
                                        options.fillColor = that._color.createColor(options.fillColor.r, options.fillColor.g, options.fillColor.b, options.fillColor.a);
                                    }
                                }

                                //边框色
                                if (styleOption.outlineColor) {
                                    // 边框色 [color]
                                    if (/^\[/.test(styleOption.outlineColor) && /\]$/.test(styleOption.outlineColor)) {
                                        var material = styleOption.outlineColor.replace(/\[/, '').replace(/\]/, '').replace(/\"/, '').replace(/\"/, '');
                                        options.outlineColor = feature.properties[material];
                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.outlineColor)) {
                                            options.outlineColor = that._color.colorFromHtmlColor(options.outlineColor);
                                        } else {
                                            if (/^rgb/.test(options.outlineColor)) {
                                                options.outlineColor = that._color.rgbaStringToRgbaObj(options.outlineColor);
                                            }
                                            if (options.outlineColor.r > 1) {
                                                options.outlineColor.r = options.outlineColor.r / 255;
                                            }
                                            if (options.outlineColor.g > 1) {
                                                options.outlineColor.g = options.outlineColor.g / 255;
                                            }
                                            if (options.outlineColor.b > 1) {
                                                options.outlineColor.b = options.outlineColor.b / 255;
                                            }
                                            if (options.outlineColor.a > 1) {
                                                options.outlineColor.a = options.outlineColor.a / 255;
                                            }
                                            options.outlineColor = that._color.createColor(options.outlineColor.r, options.outlineColor.g, options.outlineColor.b, options.outlineColor.a);
                                        }
                                    }
                                }
                                else if (styleOption.outlineColor && styleOption.outlineColor.Class instanceof Array) {
                                    for (var i = 0; i < styleOption.fillColor.Class.length; i++) {
                                        var element = styleOption.fillColor.Class[i];
                                        var eli = element.Condition.replace("<", "").replace(">", "").split("=");
                                        eli[0] = eli[0].replace(/\[/, '').replace(/\]/, '').replace(/\"/, '').replace(/\"/, '');
                                        eli[1] = eli[1].replace(/\"/, '').replace(/\"/, '');
                                        if (feature.properties[eli[0]] == eli[1]) {
                                            options.outlineColor = eli.Value;
                                            //填充颜色设置
                                            if (that._core.isHtmlColor(options.outlineColor)) {
                                                options.outlineColor = that._color.colorFromHtmlColor(options.outlineColor);
                                            } else {
                                                if (/^rgb/.test(options.outlineColor)) {
                                                    options.outlineColor = that._color.rgbaStringToRgbaObj(options.outlineColor);
                                                }
                                                if (options.outlineColor.r > 1) {
                                                    options.outlineColor.r = options.outlineColor.r / 255;
                                                }
                                                if (options.outlineColor.g > 1) {
                                                    options.outlineColor.g = options.outlineColor.g / 255;
                                                }
                                                if (options.outlineColor.b > 1) {
                                                    options.outlineColor.b = options.outlineColor.b / 255;
                                                }
                                                if (options.outlineColor.a > 1) {
                                                    options.outlineColor.a = options.outlineColor.a / 255;
                                                }
                                                options.outlineColor = that._color.createColor(options.outlineColor.r, options.outlineColor.g, options.outlineColor.b, options.outlineColor.a);
                                            }
                                            break;
                                        }
                                    }
                                }
                                else if (styleOption.outlineColor && styleOption.outlineColor.Class.toString() != "{}") {
                                    options.outlineColor = styleOption.outlineColor.Value;
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.outlineColor)) {
                                        options.outlineColor = that._color.colorFromHtmlColor(options.outlineColor);
                                    } else {
                                        if (/^rgb/.test(options.outlineColor)) {
                                            options.outlineColor = that._color.rgbaStringToRgbaObj(options.outlineColor);
                                        }
                                        if (options.outlineColor.r > 1) {
                                            options.outlineColor.r = options.outlineColor.r / 255;
                                        }
                                        if (options.outlineColor.g > 1) {
                                            options.outlineColor.g = options.outlineColor.g / 255;
                                        }
                                        if (options.outlineColor.b > 1) {
                                            options.outlineColor.b = options.outlineColor.b / 255;
                                        }
                                        if (options.outlineColor.a > 1) {
                                            options.outlineColor.a = options.outlineColor.a / 255;
                                        }
                                        options.outlineColor = that._color.createColor(options.outlineColor.r, options.outlineColor.g, options.outlineColor.b, options.outlineColor.a);
                                    }
                                }
                                else if (styleOption.outlineColorTe && styleOption.outlineColor.toString() != "{}") {
                                    options.outlineColor = styleOption.outlineColor.Value;
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.outlineColor)) {
                                        options.outlineColor = that._color.colorFromHtmlColor(options.outlineColor);
                                    } else {
                                        if (/^rgb/.test(options.outlineColor)) {
                                            options.outlineColor = that._color.rgbaStringToRgbaObj(options.outlineColor);
                                        }
                                        if (options.outlineColor.r > 1) {
                                            options.outlineColor.r = options.outlineColor.r / 255;
                                        }
                                        if (options.outlineColor.g > 1) {
                                            options.outlineColor.g = options.outlineColor.g / 255;
                                        }
                                        if (options.outlineColor.b > 1) {
                                            options.outlineColor.b = options.outlineColor.b / 255;
                                        }
                                        if (options.outlineColor.a > 1) {
                                            options.outlineColor.a = options.outlineColor.a / 255;
                                        }
                                        options.outlineColor = that._color.createColor(options.outlineColor.r, options.outlineColor.g, options.outlineColor.b, options.outlineColor.a);
                                    }
                                }

                                //背景色 
                                if (styleOption.backgroundColor) {
                                    // 背景色 [color]
                                    if (/^\[/.test(styleOption.backgroundColor) && /\]$/.test(styleOption.backgroundColor)) {
                                        var material = styleOption.backgroundColor.replace(/\[/, '').replace(/\]/, '');
                                        options.backgroundColor = feature.properties[material];
                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.backgroundColor)) {
                                            options.backgroundColor = that._color.colorFromHtmlColor(options.backgroundColor);
                                        } else {
                                            if (/^rgb/.test(options.backgroundColor)) {
                                                options.backgroundColor = that._color.rgbaStringToRgbaObj(options.backgroundColor);
                                            }
                                            if (options.backgroundColor.r > 1) {
                                                options.backgroundColor.r = options.backgroundColor.r / 255;
                                            }
                                            if (options.backgroundColor.g > 1) {
                                                options.backgroundColor.g = options.backgroundColor.g / 255;
                                            }
                                            if (options.backgroundColor.b > 1) {
                                                options.backgroundColor.b = options.backgroundColor.b / 255;
                                            }
                                            if (options.backgroundColor.a > 1) {
                                                options.backgroundColor.a = options.backgroundColor.a / 255;
                                            }
                                            options.backgroundColor = that._color.createColor(options.backgroundColor.r, options.backgroundColor.g, options.backgroundColor.b, options.backgroundColor.a);
                                        }
                                    }
                                }
                                else if (styleOption.backgroundColor && styleOption.backgroundColor.Class instanceof Array) {
                                    for (var i = 0; i < styleOption.backgroundColor.Class.length; i++) {
                                        var element = styleOption.backgroundColor.Class[i];
                                        var eli = element.Condition.replace("<", "").replace(">", "").split("=");
                                        eli[0] = eli[0].replace(/\[/, '').replace(/\]/, '').replace(/\"/, '').replace(/\"/, '');
                                        eli[1] = eli[1].replace(/\"/, '').replace(/\"/, '');
                                        if (feature.properties[eli[0]] == eli[1]) {
                                            options.backgroundColor = getSGColor(eli.Value);
                                            //填充颜色设置
                                            if (that._core.isHtmlColor(options.backgroundColor)) {
                                                options.backgroundColor = that._color.colorFromHtmlColor(options.backgroundColor);
                                            } else {
                                                if (/^rgb/.test(options.backgroundColor)) {
                                                    options.backgroundColor = that._color.rgbaStringToRgbaObj(options.backgroundColor);
                                                }
                                                if (options.backgroundColor.r > 1) {
                                                    options.backgroundColor.r = options.backgroundColor.r / 255;
                                                }
                                                if (options.backgroundColor.g > 1) {
                                                    options.backgroundColor.g = options.backgroundColor.g / 255;
                                                }
                                                if (options.backgroundColor.b > 1) {
                                                    options.backgroundColor.b = options.backgroundColor.b / 255;
                                                }
                                                if (options.backgroundColor.a > 1) {
                                                    options.backgroundColor.a = options.backgroundColor.a / 255;
                                                }
                                                options.backgroundColor = that._color.createColor(options.backgroundColor.r, options.backgroundColor.g, options.backgroundColor.b, options.backgroundColor.a);
                                            }
                                            break;
                                        }
                                    }
                                }
                                else if (styleOption.backgroundColor && styleOption.backgroundColor.Class.toString() != "{}") {
                                    options.backgroundColor = getSGColor(styleOption.backgroundColor.Value);
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.backgroundColor)) {
                                        options.backgroundColor = that._color.colorFromHtmlColor(options.backgroundColor);
                                    } else {
                                        if (/^rgb/.test(options.backgroundColor)) {
                                            options.backgroundColor = that._color.rgbaStringToRgbaObj(options.backgroundColor);
                                        }
                                        if (options.backgroundColor.r > 1) {
                                            options.backgroundColor.r = options.backgroundColor.r / 255;
                                        }
                                        if (options.backgroundColor.g > 1) {
                                            options.backgroundColor.g = options.backgroundColor.g / 255;
                                        }
                                        if (options.backgroundColor.b > 1) {
                                            options.backgroundColor.b = options.backgroundColor.b / 255;
                                        }
                                        if (options.backgroundColor.a > 1) {
                                            options.backgroundColor.a = options.backgroundColor.a / 255;
                                        }
                                        options.backgroundColor = that._color.createColor(options.backgroundColor.r, options.backgroundColor.g, options.backgroundColor.b, options.backgroundColor.a);
                                    }
                                }
                                else if (styleOption.backgroundColor && styleOption.backgroundColor.toString() != "{}") {
                                    options.backgroundColor = styleOption.backgroundColor.Value;
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.backgroundColor)) {
                                        options.backgroundColor = that._color.colorFromHtmlColor(options.backgroundColor);
                                    } else {
                                        if (/^rgb/.test(options.backgroundColor)) {
                                            options.backgroundColor = that._color.rgbaStringToRgbaObj(options.backgroundColor);
                                        }
                                        if (options.backgroundColor.r > 1) {
                                            options.backgroundColor.r = options.backgroundColor.r / 255;
                                        }
                                        if (options.backgroundColor.g > 1) {
                                            options.backgroundColor.g = options.backgroundColor.g / 255;
                                        }
                                        if (options.backgroundColor.b > 1) {
                                            options.backgroundColor.b = options.backgroundColor.b / 255;
                                        }
                                        if (options.backgroundColor.a > 1) {
                                            options.backgroundColor.a = options.backgroundColor.a / 255;
                                        }
                                        options.backgroundColor = that._color.createColor(options.backgroundColor.r, options.backgroundColor.g, options.backgroundColor.b, options.backgroundColor.a);
                                    }
                                }

                                // 缩放比例
                                if (styleOption.scale) {
                                    if (/^\[/.test(styleOption.scale) && /\]$/.test(styleOption.scale)) {
                                        var material = styleOption.scale.replace(/\[/, '').replace(/\]/, '');
                                        options.scale = feature.properties[material];
                                    }
                                }
                                else if (styleOption.scale && styleOption.scale.Class instanceof Array) {
                                    for (var i = 0; i < styleOption.scale.Class.length; i++) {
                                        var element = styleOption.scale.Class[i];
                                        var eli = element.Condition.replace("<", "").replace(">", "").split("=");
                                        eli[0] = eli[0].replace(/\[/, '').replace(/\]/, '').replace(/\"/, '').replace(/\"/, '');
                                        eli[1] = eli[1].replace(/\"/, '').replace(/\"/, '');
                                        if (feature.properties[eli[0]] == eli[1]) {
                                            options.scale = element.Value;
                                        }
                                    }
                                }
                                else if (styleOption.scale && styleOption.scale.Class.toString() != "{}") {
                                    options.scale = styleOption.scale.Value;
                                }
                                else if (styleOption.scale && styleOption.scale.toString() != "[object Object]" && styleOption.scale.toString() != "{}") {
                                    options.scale = styleOption.scale;
                                }


                                if ((/^\[/.test(styleOption.text) && /\]$/.test(styleOption.text)) || styleOption.textTe) {
                                    // var material = styleOption.text.replace(/\[/, '').replace(/\]/, '');
                                    // options.text = feature.properties[material];
                                    if (styleOption.textTe) {
                                        if (styleOption.text.Class instanceof Object) {
                                            // options.text = feature.properties[styleOption.text.Class.Value];
                                            var _text = styleOption.text.Class.Value.replace(/\[/, '').replace(/\]/, '').replace(/\"/, '').replace(/\"/, '');                                        options.text = feature.properties[_text];
                                        }
                                        else if (styleOption.text && styleOption.text.Class && styleOption.text.Class.toString() != "{}") {
                                            var material = styleOption.text.Class.Value.replace(/\[/, '').replace(/\]/, '').replace(/\"/, '').replace(/\"/, '');
                                            options.text = feature.properties[material];
                                        }
                                        else {
                                            var material = styleOption.text.replace(/\[/, '').replace(/\]/, '').replace(/\"/, '').replace(/\"/, '');                                        options.text = feature.properties[material];
                                        }
                                    }
                                    else {
                                        if (styleOption.text && styleOption.text.toString() != "[object Object]" && styleOption.text.toString() != "{}")
                                            options.text = styleOption.text;
                                        else {
                                            var material = styleOption.text.Class.Value.replace(/\[/, '').replace(/\]/, '').replace(/\"/, '').replace(/\"/, '');                                        options.text = feature.properties[material];
                                        }
                                    }
                                }
                                else {
                                    if (styleOption.text && styleOption.text.toString() != "[object Object]" && styleOption.text.toString() != "{}")
                                        options.text = styleOption.text;
                                }
                                if (options.labelData) {
                                    options = that._core.extend(options, options.labelData, true);
                                }

                                options.verticalOrigin = Cesium.VerticalOrigin.CENTER;
                                options.horizontalOrigin = Cesium.HorizontalOrigin.LEFT;
                                labelCollections && labelCollections.add(options);
                                // if (options.imageData) {
                                //     if (styleOption.images.Class instanceof Array) {
                                //         for (var i = 0; i < styleOption.images.Class.length; i++) {
                                //             var element = styleOption.images.Class[i];
                                //             var eli = element.Condition.replace("<", "").replace(">", "").split("=");
                                //             eli[0] = eli[0].replace(/\[/, '').replace(/\]/, '');
                                //             if (feature.properties[eli[0]] == eli[1]) {
                                //                 options.image = element.Value;
                                //                 break;
                                //             }
                                //         };
                                //     }
                                //     else {
                                //         if (styleOption.images.Class.toString() != "{}") {
                                //             var material = styleOption.text.Class.Value.replace(/\[/, '').replace(/\]/, '');
                                //             options.image = feature.properties[material];
                                //         }
                                //         else {
                                //             var material = styleOption.text.Class.Value.replace(/\[/, '').replace(/\]/, '');
                                //             options.image = feature.properties[material];
                                //         }
                                //     }

                                //     options = that._core.extend(options, options.imageData, true);
                                // }

                                if (styleOption.image && styleOption.image.Class instanceof Array) {
                                    for (var i = 0; i < styleOption.image.Class.length; i++) {
                                        var element = styleOption.image.Class[i];
                                        var eli = element.Condition.replace("<", "").replace(">", "").split("=");
                                        eli[0] = eli[0].replace(/\[/, '').replace(/\]/, '').replace(/\"/, '').replace(/\"/, '');
                                        eli[1] = eli[1].replace(/\"/, '').replace(/\"/, '');                                    if (feature.properties[eli[0]] == eli[1]) {
                                            options.image = element.Value;
                                            break;
                                        }
                                    }                            }
                                else if (styleOption.image && styleOption.image.Class && styleOption.image.Class.toString() != "{}") {
                                    var material = styleOption.image.Class.Value.replace(/\[/, '').replace(/\]/, '').replace(/\"/, '').replace(/\"/, '');
                                    options.image = feature.properties[material];
                                }
                                else {
                                    if (styleOption.image && styleOption.image.toString() != "[object Object]" && styleOption.image.toString() != "{}")
                                        options.image = styleOption.image;
                                }
                                var options1 = lodash.cloneDeep(options);
                                options1.verticalOrigin = Cesium.VerticalOrigin.CENTER;
                                options1.horizontalOrigin = Cesium.HorizontalOrigin.RIGHT;
                                // options.pixelOffset =new Cesium.Cartesian2(-80,0);
                                billboardCollection && billboardCollection.add(options1);
                            });
                            if (data.features.length == 0) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            if (primitiveCollection) {
                                tile.data.geometryPrimitive = primitiveCollection;
                            } else {
                                if (billboardCollection) {
                                    tile.data.geometryPrimitive = billboardCollection;
                                } else {
                                    tile.data.geometryPrimitive = labelCollections;
                                }
                            }
                            // tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                        },
                        error: function () {
                            tile.state = Cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                        }
                    });
                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                    tile.renderable = true;
                    return;
                }
                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
            }
        };
        this._primitive = new this._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;

        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this._Provider.treeID = styleOption.id;
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    /**
        * 创建circleGeofeaturelayer
        *
        * @param {String} [name] 图层名称。
        * @param {object|String} [geoOptions] geojosn对象或者地址
        * {
        *   url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
        *       layer:'nanjing',
               upperLevelLimit: 13,
               lowerLevelLimit: 13,
               minx:118.51721649800015,
               miny:31.863232407499936,
               maxx:118.91648798400001,
               maxy:32.27649160409993
        * }
        * @param {object} [option] 参数对象{
        *        Name: "",
               text: "",
               font_size: '30px',
               font_family:'sans-serif'
               stylet: this._cesium.LabelStyle.FILL,
               fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
               outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
               outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
               show: true,//	optional A boolean Property specifying the visibility of the label.
               showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
               backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
               backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
               scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
               horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
               verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
               eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
               pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
               heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
               near: 0,
               far: 5000
          }
        * @param {Function} [disFnc] 回调函数
        * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
        */
    LabelGeoJsonFeatureLayercopy.prototype.createSXTLabelGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        styleOption.material;


        var defaultOptions = {
            show: true,
            position: that._cesium.Cartesian3.ZERO,
            pixelOffset: that._cesium.Cartesian2.ZERO,
            eyeOffset: that._cesium.Cartesian3.ZERO,
            heightReference: that._cesium.HeightReference.NONE,
            horizontalOrigin: that._cesium.HorizontalOrigin.CENTER,
            verticalOrigin: that._cesium.VerticalOrigin.CENTER,
            scale: 1.0,
            image: '',
            imageSubRegion: undefined,
            color: that._cesium.Color.WHITE,
            id: undefined,
            rotation: 0.0,
            alignedAxis: that._cesium.Cartesian3.ZERO,
            scaleByDistance: undefined,
            translucencyByDistance: undefined,
            pixelOffsetScaleByDistance: undefined,
            sizeInMeters: false,
            distanceDisplayCondition: undefined
        };


        if (styleOption.width) {
            defaultOptions.width = styleOption.width;
        }
        if (styleOption.height) {
            defaultOptions.height = styleOption.height;
        }
        if (styleOption.image) {
            defaultOptions.image = styleOption.image;
        }

        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = (parseFloat(styleOption.height) || 0);
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level <= styleOption.level_max && that.item.show) {
                    var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                    if (that._cache) {
                        tileUrl += '&' + that._core.getuid();
                    }
                    that._core.xhr({
                        url: tileUrl,
                        type: "get",
                        dataType: "json",
                        success: function (data) {
                            if (data == undefined) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }
                            var tempCollection;
                            if (tile.level == parseInt(styleOption.level_max) - 1) {
                                if (typeof initSXTData == 'function')
                                    tempCollection = initSXTData(data);
                            }
                            else {
                                tempCollection = new Cesium.BillboardCollection();
                                for (var feature of data.features) {
                                    var lon = feature.geometry.coordinates[0];
                                    var lat = feature.geometry.coordinates[1];
                                    var height = styleOption.pointHeight ? parseFloat(styleOption.pointHeight) : 0;

                                    // var options = {
                                    //     id: feature.id,
                                    //     name: "点",
                                    //     position: Cesium.Cartesian3.fromDegrees(lon,lat, 10),
                                    //     image: './video1.png',

                                    // }

                                    defaultOptions.position = Cesium.Cartesian3.fromDegrees(lon, lat, height);

                                    tempCollection.add(defaultOptions);
                                }
                            }
                            if (data.features.length == 0) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            tile.data.geometryPrimitive = tempCollection;
                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING && typeof (tile.data.geometryPrimitive.update) == 'function') {
                                tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            else {
                                tile.data.geometryPrimitive.destroy = function () { };
                                tile.data.geometryPrimitive.update = function () { };
                            }
                        },
                        error: function () {
                            if (tile.count == undefined) {
                                tile.count = 0;
                            }
                            tile.count += 1;
                            if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // return;
                            }
                            else {
                                tile.state = Cesium.QuadtreeTileLoadState.START;
                            }
                        }
                    });
                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                    tile.renderable = true;
                    return;
                }
                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
            }
        };
        this._primitive = new this._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;

        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    /**
    * 请求矢量切片执行自定义方法
    *
    * @param {String} [name] 图层名称。
    * @param {object|String} [geoOptions] geojosn对象或者地址
    * {
    *   url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
    *       layer:'nanjing',
           upperLevelLimit: 13,
           lowerLevelLimit: 13,
           minx:118.51721649800015,
           miny:31.863232407499936,
           maxx:118.91648798400001,
           maxy:32.27649160409993
    * }
    * @param {object} [option] 参数对象{
    *        Name: "",
           text: "",
           font_size: '30px',
           font_family:'sans-serif'
           stylet: this._cesium.LabelStyle.FILL,
           fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
           outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
           outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
           show: true,//	optional A boolean Property specifying the visibility of the label.
           showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
           backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
           backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
           scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
           horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
           verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
           eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
           pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
           heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
           near: 0,
           far: 5000
      }
    * @param {Function} [disFnc] 回调函数
    * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
    */
    LabelGeoJsonFeatureLayercopy.prototype.createCustomCallbackGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, customDataCallback, disFnc) {
        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        styleOption.material;


        ({
            show: true,
            position: that._cesium.Cartesian3.ZERO,
            pixelOffset: that._cesium.Cartesian2.ZERO,
            eyeOffset: that._cesium.Cartesian3.ZERO,
            heightReference: that._cesium.HeightReference.NONE,
            horizontalOrigin: that._cesium.HorizontalOrigin.CENTER,
            verticalOrigin: that._cesium.VerticalOrigin.CENTER,
            scale: 1.0,
            image: '',
            imageSubRegion: undefined,
            color: that._cesium.Color.WHITE,
            id: undefined,
            rotation: 0.0,
            alignedAxis: that._cesium.Cartesian3.ZERO,
            scaleByDistance: undefined,
            translucencyByDistance: undefined,
            pixelOffsetScaleByDistance: undefined,
            sizeInMeters: false,
            distanceDisplayCondition: undefined
        });


        if (styleOption.width) ;
        if (styleOption.height) ;
        if (styleOption.image) ;

        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = (parseFloat(styleOption.height) || 0);
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level <= styleOption.level_max && that.item.show) {
                    var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                    if (that._cache) {
                        tileUrl += '&' + that._core.getuid();
                    }
                    that._core.xhr({
                        url: tileUrl,
                        type: "get",
                        dataType: "json",
                        success: function (data) {
                            if (data == undefined) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }
                            var tempCollection;
                            if (typeof customDataCallback == 'function')
                                tempCollection = customDataCallback(data);
                            if (data.features.length == 0) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            tile.data.geometryPrimitive = tempCollection;
                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING && typeof (tile.data.geometryPrimitive.update) == 'function') {
                                tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            else {
                                tile.data.geometryPrimitive.destroy = function () { };
                                tile.data.geometryPrimitive.update = function () { };
                            }
                        },
                        error: function () {
                            if (tile.count == undefined) {
                                tile.count = 0;
                            }
                            tile.count += 1;
                            if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // return;
                            }
                            else {
                                tile.state = Cesium.QuadtreeTileLoadState.START;
                            }
                        }
                    });
                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                    tile.renderable = true;
                    return;
                }
                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
            }
        };
        this._primitive = new this._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;

        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //富文本lable普通加载
    LabelGeoJsonFeatureLayercopy.prototype.createLabelRichtextGeoJsonFeatureLayerProvider = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        this._viewer.dataSources.add(dataSource);
        var that = this;
        //数据存储
        var pointPrimitive = new this._cesium.PointPrimitiveCollection();
        that.optiontext = [];
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                var text;
                //获取数据开始
                if (/^\[/.test(option.text) && /\]$/.test(option.text)) {
                    var extrudedHeight = option.text.replace(/\[/, '').replace(/\]/, '');
                    text = entity.properties[extrudedHeight]._value;
                } else {
                    text = option.text;
                }
                that.optiontext.push(text);
                entity.billboard = undefined;
                //坐标转化
                that._viewer.scene.globe.ellipsoid;
                var scartographic = that._cesium.Cartographic.fromCartesian(entity.position._value);
                var slongitude = that._cesium.Math.toDegrees(scartographic.longitude);
                var slatitude = that._cesium.Math.toDegrees(scartographic.latitude);
                var sheight = scartographic.height + (option.pointHeight || 0);//

                var position = [slongitude, slatitude, sheight];
                var id = that._core.getuid();
                var Cartesian3;
                if (position instanceof Array) {
                    if (position.length === 2) {
                        Cartesian3 = that._cesium.Cartesian3.fromDegrees(position[0], position[1]);
                    } else if (position.length === 3) {
                        Cartesian3 = that._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]);
                    }
                } else {
                    if (position.z) {
                        Cartesian3 = that._cesium.Cartesian3.fromDegrees(position.x, position.y, position.z);
                    } else {
                        Cartesian3 = that._cesium.Cartesian3.fromDegrees(position.x, position.y);
                    }
                }
                var ids = 'DivPoint' + id;
                pointPrimitive.add({
                    id: ids,
                    position: Cartesian3,
                    color: that._cesium.Color.YELLOW,
                    description: option.text
                });
            }

            var time;
            //添加时间段
            if (option && option.time) {
                time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                    start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                    stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
                })]);
            }

            that.item = pointPrimitive;
            that.pointPrimitive = that._viewer.scene.primitives.add(pointPrimitive, time);
            var firstAdd = true;
            //div
            var divPoint, CanvasCoordinates, pointPosition;
            that.pointPrimitive.update = function () {
                for (var i = 0, item, divPointHtml; i < that.pointPrimitive.length; i++) {
                    item = that.pointPrimitive.get(i);
                    pointPosition = item.position;
                    CanvasCoordinates = that._viewer.scene.cartesianToCanvasCoordinates(pointPosition);
                    if (!CanvasCoordinates) return;
                    divPoint = document.getElementById(item.id);
                    if (!divPoint) {
                        divPointHtml = '<div id="' + item.id + '" style="position: absolute; width: 200px; height: 134px;left: 0px; top: 0px; pointer-events:none; background: url(' + window.SmartEarthRootUrl + configData$1.divpoint1 + ');transform: matrix(1, 0, 0, 1, 0, 0); transform-origin: left bottom 0px;">\n' +
                            '                   <div class="title" style="position: inherit;top: 22px;left: 70px;font-size: 14px;text-align: left;color: rgba(255,255,255,1);text-shadow: 0 0 9px rgba(0,0,0,.75)">' + that.optiontext[i] + '</div>\n' +
                            '           </div>';
                        $('.cesium-viewer').append(divPointHtml);
                        divPoint = document.getElementById(item.id);
                    }
                    if (item.description) {
                        divPoint.style.transform = 'matrix(1, 0, 0, 1, ' + (CanvasCoordinates.x) + ', ' + (CanvasCoordinates.y - 157) + ')';
                    } else {
                        divPoint.style.transform = 'matrix(1, 0, 0, 1, ' + (CanvasCoordinates.x) + ', ' + (CanvasCoordinates.y - 134) + ')';
                    }
                    divPoint && (divPoint.style.display = that.pointPrimitive.show ? 'block' : 'none');
                }
                if (firstAdd) {
                    if (checked) ; else {
                        that.setVisibility(false);
                    }
                    firstAdd = false;
                }
            };
            //this.item.type = 'DivPoint';

            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(option.id)) {
            option.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "富文本";
        }
        //导出工程树
        var obj = {
            id: option.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'DivPoint',
            item: this,
            url: geojsonOrurl,
            style: option,
            treeData: { "name": name, "geoOptions": geojsonOrurl, "styleOption": option, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    //富文本lable矢量切片加载
    LabelGeoJsonFeatureLayercopy.prototype.createLabelRichtextGeoJsonFeatureLayerProviderLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {

        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            var pointPrimitive = new that._cesium.PointPrimitiveCollection();
            that.optiontext = [];
            json.features.forEach(function (feature) {
                var sheight = options.pointHeight;
                if (feature.properties.height != undefined) {
                    sheight = parseFloat(feature.properties.height) + sheight;
                }
                if (/^\[/.test(options.pointHeight) && /\]$/.test(options.pointHeight)) {
                    var extrudedHeight = options.pointHeight.replace(/\[/, '').replace(/\]/, '');
                    sheight = parseFloat(feature.properties[extrudedHeight]);
                }
                styleOption.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                if (/^\[/.test(styleOption.text) && /\]$/.test(styleOption.text)) {
                    var material = styleOption.text.replace(/\[/, '').replace(/\]/, '');
                    styleOption.text = feature.properties[material];
                }
                var id = that._core.getuid();
                var ids = 'DivPoint' + id;
                pointPrimitive.add({
                    id: ids,
                    position: Cartesian3,
                    color: that._cesium.Color.YELLOW,
                    description: styleOption.text
                });
                that.optiontext.push(option.text);
            });
            that.pointPrimitive = that._viewer.scene.primitives.add(pointPrimitive);
            var divPoint, CanvasCoordinates, pointPosition;
            var firstAdd = true;
            that.pointPrimitive.update = function () {
                for (var i = 0, item, divPointHtml; i < that.pointPrimitive.length; i++) {
                    item = that.pointPrimitive.get(i);
                    pointPosition = item.position;
                    CanvasCoordinates = that._viewer.scene.cartesianToCanvasCoordinates(pointPosition);
                    if (!CanvasCoordinates) return;
                    divPoint = document.getElementById(item.id);
                    if (!divPoint) {
                        divPointHtml = '<div id="' + item.id + '" style="position: absolute; width: 200px; height: 134px;left: 0px; top: 0px; pointer-events:none; background: url(' + window.SmartEarthRootUrl + configData$1.divpoint1 + ');transform: matrix(1, 0, 0, 1, 0, 0); transform-origin: left bottom 0px;">\n' +
                            '                   <div class="title" style="position: inherit;top: 22px;left: 70px;font-size: 14px;text-align: left;color: rgba(255,255,255,1);text-shadow: 0 0 9px rgba(0,0,0,.75)">' + that.optiontext[i] + '</div>\n' +
                            '           </div>';
                        $('.cesium-viewer').append(divPointHtml);
                        divPoint = document.getElementById(item.id);
                    }
                    if (item.description) {
                        divPoint.style.transform = 'matrix(1, 0, 0, 1, ' + (CanvasCoordinates.x) + ', ' + (CanvasCoordinates.y - 157) + ')';
                    } else {
                        divPoint.style.transform = 'matrix(1, 0, 0, 1, ' + (CanvasCoordinates.x) + ', ' + (CanvasCoordinates.y - 134) + ')';
                    }

                }
                if (firstAdd) {
                    if (checked) ; else {
                        that.setVisibility(false);
                    }
                    firstAdd = false;
                }
            };
            that.item = pointPrimitive;
            return "";
        };
        //this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "富文本" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'DivPoint',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        if (typeof disFnc == 'function')
            disFnc(this.item);
        return this;
    };
    /**
    * 矢量切片加载（模型点加载）优化版
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    * 薛鹏 2020/07/30
    */
    //模型点加载
    LabelGeoJsonFeatureLayercopy.prototype.createModelGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            // rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        styleOption.material;
        //填充颜色设置material
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.color)) {
            if (/^\[/.test(styleOption.color) && styleOption.color.toString().charAt(0) == "[" && styleOption.color.toString().charAt(styleOption.color.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.color)) {
                    styleOption.color = that._color.colorFromHtmlColor(styleOption.color);
                } else {
                    if (/^rgb/.test(styleOption.color)) {
                        styleOption.color = that._color.rgbaStringToRgbaObj(styleOption.color);
                    }
                    if (styleOption.color.r > 1) {
                        styleOption.color.r = styleOption.color.r / 255;
                    }
                    if (styleOption.color.g > 1) {
                        styleOption.color.g = styleOption.color.g / 255;
                    }
                    if (styleOption.color.b > 1) {
                        styleOption.color.b = styleOption.color.b / 255;
                    }
                    if (styleOption.color.a > 1) {
                        styleOption.color.a = styleOption.color.a / 255;
                    }
                    styleOption.color = that._color.createColor(styleOption.color.r, styleOption.color.g, styleOption.color.b, styleOption.color.a);
                }
            }
        }
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = (parseFloat(styleOption.height) || 0);
        //请求
        //结束请求前
        this._Provider.loadTile = function (frameState, tile) {
            // (function (frameState, tile, that) {
            if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                    if (that._cache) {
                        tileUrl += '&' + that._core.getuid();
                    }
                    that._core.xhr({
                        url: tileUrl,
                        type: "get",
                        dataType: "json",
                        success: function (data) {
                            if (data == undefined) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }
                            var defaultOptions = {
                                url: "",        //如果为bgltf则为.bgltf
                                modelMatrix: that._cesium.Transforms.eastNorthUpToFixedFrame(origin),
                                color: that._cesium.Color.DARKSALMON,
                                //lightColor: that._cesium.Color.DARKSALMON,
                                scale: 2.0,   //放大倍数
                                //distanceDisplayCondition: attribute.distanceDisplayCondition
                            };

                            var options = that._core.extend(defaultOptions, styleOption, true);

                            if (that._core.isnull(styleOption.near)) {
                                styleOption.near = 0;
                            }
                            if (that._core.isnull(styleOption.far)) {
                                styleOption.far = 999999999;
                            }
                            var min = parseFloat(styleOption.near);
                            var max = parseFloat(styleOption.far);
                            var distance = new that._cesium.DistanceDisplayCondition(min, max);
                            options.distanceDisplayCondition = distance;
                            var collection = new that._cesium.PrimitiveCollection();
                            data.features.forEach(function (feature) {
                                options.id = feature;
                                //修改xp
                                var sheight = options.height;
                                if (feature.properties.height != undefined) {
                                    sheight = parseFloat(feature.properties.height);
                                }
                                if (/^\[/.test(options.height) && /\]$/.test(options.height)) {
                                    var extrudedHeight = options.height.replace(/\[/, '').replace(/\]/, '');
                                    sheight = parseFloat(feature.properties[extrudedHeight]);
                                }
                                options.modelMatrix = that._cesium.Transforms.eastNorthUpToFixedFrame(that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight));
                                var mol = that._cesium.Model.fromGltf({
                                    id: feature,
                                    url: options.uri,        //如果为bgltf则为.bgltf
                                    color: options.color,
                                    //lightColor: options.lightColor,
                                    modelMatrix: options.modelMatrix,
                                    scale: options.scale,   //放大倍数
                                    heightReference: parseInt(options.heightReference),
                                    distanceDisplayCondition: options.distanceDisplayCondition
                                });
                                collection.add(mol);
                            });
                            if (data.features.length == 0) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            tile.data.geometryPrimitive = collection;
                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                        },
                        error: function () {
                            if (tile.count == undefined) {
                                tile.count = 0;
                            }
                            tile.count += 1;
                            if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // return;
                            }
                            else {
                                tile.state = Cesium.QuadtreeTileLoadState.START;
                            }
                        }
                    });
                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                    tile.renderable = true;
                    return;
                }
                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
            }
        };
        this._primitive = new this._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    LabelGeoJsonFeatureLayercopy.prototype.createPointGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        //填充颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.color)) {
            if (/^\[/.test(styleOption.color) && styleOption.color.toString().charAt(0) == "[" && styleOption.color.toString().charAt(styleOption.color.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.color)) {
                    styleOption.color = that._color.colorFromHtmlColor(styleOption.color);
                } else {
                    if (/^rgb/.test(styleOption.color)) {
                        styleOption.color = that._color.rgbaStringToRgbaObj(styleOption.color);
                    }
                    if (styleOption.color.r > 1) {
                        styleOption.color.r = styleOption.color.r / 255;
                    }
                    if (styleOption.color.g > 1) {
                        styleOption.color.g = styleOption.color.g / 255;
                    }
                    if (styleOption.color.b > 1) {
                        styleOption.color.b = styleOption.color.b / 255;
                    }
                    if (styleOption.color.a > 1) {
                        styleOption.color.a = styleOption.color.a / 255;
                    }
                    styleOption.color = that._color.createColor(styleOption.color.r, styleOption.color.g, styleOption.color.b, styleOption.color.a);
                }
            }
        }
        //边框颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.outlineColor)) {
            if (/^\[/.test(styleOption.outlineColor) && styleOption.outlineColor.toString().charAt(0) == "[" && styleOption.outlineColor.toString().charAt(styleOption.outlineColor.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.outlineColor)) {
                    styleOption.outlineColor = that._color.colorFromHtmlColor(styleOption.outlineColor);
                } else {
                    if (/^rgb/.test(styleOption.outlineColor)) {
                        styleOption.outlineColor = that._color.rgbaStringToRgbaObj(styleOption.outlineColor);
                    }
                    if (styleOption.outlineColor.r > 1) {
                        styleOption.outlineColor.r = styleOption.outlineColor.r / 255;
                    }
                    if (styleOption.outlineColor.g > 1) {
                        styleOption.outlineColor.g = styleOption.outlineColor.g / 255;
                    }
                    if (styleOption.outlineColor.b > 1) {
                        styleOption.outlineColor.b = styleOption.outlineColor.b / 255;
                    }
                    if (styleOption.outlineColor.a > 1) {
                        styleOption.outlineColor.a = styleOption.outlineColor.a / 255;
                    }
                    styleOption.outlineColor = that._color.createColor(styleOption.outlineColor.r, styleOption.outlineColor.g, styleOption.outlineColor.b, styleOption.outlineColor.a);
                }
            }
        }
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = (parseFloat(styleOption.height) || 0);
        //请求
        //结束请求前
        this._Provider.loadTile = function (frameState, tile) {
            if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                    if (that._cache) {
                        tileUrl += '&' + that._core.getuid();
                    }
                    that._core.xhr({
                        url: tileUrl,
                        type: "get",
                        dataType: "json",
                        success: function (data) {
                            if (data == undefined) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }
                            var defaultOptions = {
                                Name: "",
                                text: "",
                                font: ' 30px sans-serif',
                                pixelSize: 10.0,
                                style: that._cesium.LabelStyle.OUTLINE,
                                fillColor: that._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                                outlineColor: that._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                                show: true, //	optional A boolean Property specifying the visibility of the label.
                                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                                backgroundColor: new that._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                                backgroundPadding: new that._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                                horizontalOrigin: that._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: that._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: that._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: that._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                heightReference: that._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                                scaleByDistance: new that._cesium.NearFarScalar(0, 0, 1, 1)
                            };
                            styleOption.material;

                            //背景颜色设置
                            if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.backgroundColor)) {
                                if (/^\[/.test(styleOption.backgroundColor) && styleOption.backgroundColor.toString().charAt(0) == "[" && styleOption.backgroundColor.toString().charAt(styleOption.backgroundColor.length - 1) == "]") ; else {
                                    if (that._core.isHtmlColor(styleOption.backgroundColor)) {
                                        styleOption.backgroundColor = that._color.colorFromHtmlColor(styleOption.backgroundColor);
                                    } else {
                                        if (/^rgb/.test(styleOption.backgroundColor)) {
                                            styleOption.backgroundColor = that._color.rgbaStringToRgbaObj(styleOption.backgroundColor);
                                        }
                                        if (styleOption.backgroundColor.r > 1) {
                                            styleOption.backgroundColor.r = styleOption.backgroundColor.r / 255;
                                        }
                                        if (styleOption.backgroundColor.g > 1) {
                                            styleOption.backgroundColor.g = styleOption.backgroundColor.g / 255;
                                        }
                                        if (styleOption.backgroundColor.b > 1) {
                                            styleOption.backgroundColor.b = styleOption.backgroundColor.b / 255;
                                        }
                                        if (styleOption.backgroundColor.a > 1) {
                                            styleOption.backgroundColor.a = styleOption.backgroundColor.a / 255;
                                        }
                                        styleOption.backgroundColor = that._color.createColor(styleOption.backgroundColor.r, styleOption.backgroundColor.g, styleOption.backgroundColor.b, styleOption.backgroundColor.a);
                                    }
                                }
                            }
                            var options = that._core.extend(defaultOptions, styleOption, true);

                            if (that._core.isnull(styleOption.near)) {
                                styleOption.near = 0;
                            }
                            if (that._core.isnull(styleOption.far)) {
                                styleOption.far = 999999999;
                            }
                            var min = parseFloat(styleOption.near);
                            var max = parseFloat(styleOption.far);
                            var distance = new that._cesium.DistanceDisplayCondition(min, max);
                            options.distanceDisplayCondition = distance;
                            //options.pointHeight = parseFloat(that._core.extendgl(entity, option.pointHeight, options.pointHeight));
                            if (that._core.isnull(styleOption.font_size)) {
                                styleOption.font_size = "30px";
                            }
                            if (that._core.isnull(styleOption.font_family)) {
                                styleOption.font_family = " sans-serif";
                            }
                            //options.font = option.font_size + " " + option.font_family;
                            options.font = parseFloat(styleOption.font_size) + "px " + styleOption.font_family;
                            // var labelCollections = new that._cesium.LabelCollection();
                            var labelCollections = new that._cesium.PointPrimitiveCollection();
                            data.features.forEach(function (feature) {
                                options.id = feature;
                                //options.position = that._cesium.Cartesian3.fromDegreesArray(feature.geometry.coordinates)[0];
                                //修改xp
                                var sheight = 0.0;
                                if (/^\[/.test(options.pointHeight) && /\]$/.test(options.pointHeight)) {
                                    var heightStr = options.pointHeight.replace(/\[/, '').replace(/\]/, '');
                                    sheight = parseFloat(feature.properties[heightStr]);
                                } else if (options.pointHeight !== undefined && options.pointHeight !== '') {
                                    sheight = parseFloat(options.pointHeight);
                                } else if (feature.properties.height != undefined) {
                                    sheight = parseFloat(feature.properties.height);
                                }
                                //填充色
                                if (/^\[/.test(styleOption.color) && /\]$/.test(styleOption.color)) {
                                    var material = styleOption.color.replace(/\[/, '').replace(/\]/, '');
                                    options.color = feature.properties[material];
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.color)) {
                                        options.color = that._color.colorFromHtmlColor(options.color);
                                    } else {
                                        if (/^rgb/.test(options.color)) {
                                            options.color = that._color.rgbaStringToRgbaObj(options.color);
                                        }
                                        if (options.color.r > 1) {
                                            options.color.r = options.color.r / 255;
                                        }
                                        if (options.color.g > 1) {
                                            options.color.g = options.color.g / 255;
                                        }
                                        if (options.color.b > 1) {
                                            options.color.b = options.color.b / 255;
                                        }
                                        if (options.color.a > 1) {
                                            options.color.a = options.color.a / 255;
                                        }
                                        options.color = that._color.createColor(options.color.r, options.color.g, options.color.b, options.color.a);
                                    }
                                }
                                //边框色
                                if (/^\[/.test(styleOption.outlineColor) && /\]$/.test(styleOption.outlineColor)) {
                                    var material = styleOption.outlineColor.replace(/\[/, '').replace(/\]/, '');
                                    options.outlineColor = feature.properties[material];
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.outlineColor)) {
                                        options.outlineColor = that._color.colorFromHtmlColor(options.outlineColor);
                                    } else {
                                        if (/^rgb/.test(options.outlineColor)) {
                                            options.outlineColor = that._color.rgbaStringToRgbaObj(options.outlineColor);
                                        }
                                        if (options.outlineColor.r > 1) {
                                            options.outlineColor.r = options.outlineColor.r / 255;
                                        }
                                        if (options.outlineColor.g > 1) {
                                            options.outlineColor.g = options.outlineColor.g / 255;
                                        }
                                        if (options.outlineColor.b > 1) {
                                            options.outlineColor.b = options.outlineColor.b / 255;
                                        }
                                        if (options.outlineColor.a > 1) {
                                            options.outlineColor.a = options.outlineColor.a / 255;
                                        }
                                        options.outlineColor = that._color.createColor(options.outlineColor.r, options.outlineColor.g, options.outlineColor.b, options.outlineColor.a);
                                    }
                                }
                                options.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                                options.text = feature.properties.name;
                                var p = {
                                    show: options.show,
                                    position: options.position,
                                    pixelSize: options.pixelSize,
                                    color: options.color,
                                    outlineColor: options.outlineColor,
                                    outlineWidth: options.outlineWidth,
                                    id: feature
                                };
                                //图例
                                var col = "color:" + options.color.red * 255 + "," + options.color.green * 255 + "," + options.color.blue * 255
                                    + ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                                that.Legend.push(col);
                                labelCollections.add(p);
                            });
                            if (data.features.length == 0) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            tile.data.geometryPrimitive = labelCollections;
                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                        },
                        error: function () {
                            if (tile.count == undefined) {
                                tile.count = 0;
                            }
                            tile.count += 1;
                            if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            else {
                                tile.state = Cesium.QuadtreeTileLoadState.START;
                            }
                        }
                    });
                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                    tile.renderable = true;
                    return;
                }
                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
            }
        };
        this._primitive = new this._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        // primitives.add(this._Provider._PrimitiveCollection);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //工程树添加
    LabelGeoJsonFeatureLayercopy.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 返回图例
     * @returns {object}
     */
    LabelGeoJsonFeatureLayercopy.prototype.getLegend = function () {
        var legend = [];
        if (this.Legend != null) {
            legend = this._core.unique(this.Legend);
        }
        return legend;
    };
    /**
     * 删除数据
     */
    LabelGeoJsonFeatureLayercopy.prototype.deleteObject = function () {
        this._viewer.scene.primitives.remove(this.item);
        if (this.probj && this.probj.length > 0) {
            this._viewer.scene.primitives.remove(this.probj[0]);
            this.probj.pop();
        }
        if (this.img != null) {
            this._viewer.imageryLayers.remove(this.img);
        }
        if (this.primitve && this.primitve.length > 0) {
            for (var i = 0; i < this.primitve.length; i++) {
                this._viewer.scene.primitives.remove(this.primitve[i]);
            }
            this.primitve = [];
        }
        if (this.loadAllKey && this.loadAllKey.length > 0) {
            this.loadAllKey = [];
        }
        try {
            this._Provider.remove();
        } catch (ex) {
        }
        if (this._Provider != undefined) {
            this._Provider.setStatus(false);
        }
        if (this.items != undefined && this.items != null && this.items.length > 0) {
            for (var i = 0; i < this.items.length; i++) {
                this._viewer.scene.primitives.remove(this.items[i]);
            }
        } else {
            this._viewer.scene.primitives.remove(this.item);
        }
        if (this.treeobj && this.treeobj.type === 'DivPoint' && this.item && this.item._pointPrimitives != undefined && this.item._pointPrimitives != null) {
            for (var i = 0; i < this.item._pointPrimitives.length; i++) {
                var divPoint = document.getElementById(this.item._pointPrimitives[i].id);
                divPoint && divPoint.remove();
            }
        }
        try {
            this._Provider.remove();
        } catch (ex) {
        }
    };
    /**
     * 导出工程数据
     */
    LabelGeoJsonFeatureLayercopy.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url
            },
            treeData: this.treeobj.treeData
        };
    };
    /**
     * 设置数据是否刷新
     */
    LabelGeoJsonFeatureLayercopy.prototype.setRefresh = function (b) {
        try {
            if (this._Provider) {
                this._Provider.setStatus(!b);
            }
        } catch (ex) {
        }
    };
    /**
     * 设置数据显示隐藏
     */
    LabelGeoJsonFeatureLayercopy.prototype.setVisibility = function (b) {
        try {
            this.loadAllKey = [];
            if (this.item != undefined && this.item.show != undefined) {
                this.item.show = b;
            }
            if (this.img != null) {
                this.img.show = b;
            }
            if (this.primitve && this.primitve.length > 0) {
                for (var i = 0; i < this.primitve.length; i++) {
                    this.primitve[i].show = b;
                }
            }
            if (this._Provider && this._Provider.setStatus && this._Provider._state !== undefined) {
                this._Provider.setStatus(b);
            }
            if (this._Provider && this._Provider.EntityCollection) {
                !b && (this._Provider.EntityCollection.show = b);
                this._Provider.EntityCollection.isShow = b;
            }
            if (this.probj && this.probj.length > 0) {
                for (var i = 0; i < this.probj.length; i++) {
                    //this._viewer.scene.primitives.remove(this.probj[i]);
                    this.probj[i].show = b;
                    // this._viewer.scene.primitives.remove(this.probj[i]);
                }
            }
        } catch (ex) {
        }
        if (this.treeobj != undefined && this.treeobj.type === 'DivPoint' && this.item && this.item._pointPrimitives != undefined && this.item._pointPrimitives != null) {
            for (var i = 0; i < this.item._pointPrimitives.length; i++) {
                var divPoint = document.getElementById(this.item._pointPrimitives[i].id);
                divPoint && (divPoint.style.display = b ? 'block' : 'none');
            }
        }
        if (this.item != undefined) {
            this.item.show = b;
        }
        if (this._Provider && this._Provider._stop !== undefined) {
            this._Provider.setStatus(!b);
        }


    };

    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    LabelGeoJsonFeatureLayercopy.prototype.edit = function (open, option) {
        this.isEditting = open;
        this.editoption = option;
        return this._Provider && this._Provider.edit && this._Provider.edit(open, option);
    };
    /**
     * 设置数据是否刷新
     */
    LabelGeoJsonFeatureLayercopy.prototype.forceRefresh = function () {
        try {
            this._cache = true;
            if (!this._forceRefreshPrvimitive)
                this._forceRefreshPrvimitive = lodash.cloneDeep(this._primitive);
            var temp = lodash.cloneDeep(this._forceRefreshPrvimitive);
            this._viewer.scene.primitives.remove(this._primitive);
            this._viewer.scene.primitives.add(temp);
            this.edit(this.isEditting, this.editoption);
        } catch (ex) {
        }
    };
    Object.defineProperties(LabelGeoJsonFeatureLayercopy.prototype, {
        /**
         * 设置geojson图层的显示文本
         * @param {String}  text [text]
         */
        labelText: {
            set: lodash.debounce(function (text) {
                var text1 = text;
                if (this._core.isnull(text)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(text)) {
                            text1 = text.replace(/\[/, '').replace(/\]/, '');
                            text1 = entities[i].properties[text1]._value;
                        }
                        if (!entities[i].label) {
                            try {
                                entities[i].point.show = false;
                            } catch (ex) { }
                            entities[i].label = new this._cesium.LabelGraphics({
                                text: text1,
                                font: '30px sans-serif',
                                style: this._cesium.LabelStyle.FILL,
                                fillColor: this._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                                outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                                show: true, //	optional A boolean Property specifying the visibility of the label.
                                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                                backgroundColor: new this._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                                backgroundPadding: new this._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                heightReference: this._cesium.HeightReference.NONE //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            entities[i].label.text = text1;
                            try {
                                entities[i].point.show = false;
                            } catch (ex) { }
                        }
                    }
                }
            }, 500)
        },
        /**
         * 设置geojson图层显示文本的样式
         * @param {object} labelStyle
         */
        labelStyles: {
            set: lodash.debounce(function (labelStyle) {
                if (this._core.isnull(labelStyle)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.style = labelStyle;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).style;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return entities[0].label.style;
                }
            }
        },
        labelFont: {
            set: lodash.debounce(function (font_family) {
                if (this._core.isnull(font_family)) return;
                var entities = this.item.entities && this.item.entities.values;
                font_family = font_family.toString().replace(/px/g, '');
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                var font = entities[0].label.font;
                var font_size = 16;
                if (font) {
                    font = font._value.trimLeft().trimRight();
                    font_size = font.split('px')[0];
                }
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.font = font_size + "px " + font_family;
                    }
                }
            }, 500)
        },

        /**
         * 设置geojson图层显示文本的样式
         * @param {Float} fontsize
         */
        labelFontSize1: {
            set: lodash.debounce(function (fontsize) {
                if (this._core.isnull(fontsize)) return;
                var entities = this.item.entities && this.item.entities.values;
                fontsize = fontsize.toString().replace(/px/g, '');
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                var font = entities[0].label.font;
                var font_family = 'sans-serif';
                if (font) {
                    font = font._value.trimLeft().trimRight();
                    font_family = font.split('px')[1];
                }
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.font = fontsize + "px  " + font_family;
                    }
                }
            }, 500)
        },
        /**
         * 设置geojson图层显示文本的样式
         * @param {Float} fontsize
         */
        labelFontSize: {
            set: lodash.debounce(function (fontsize) {
                if (this._core.isnull(fontsize)) return;
                var entities = this.item.entities && this.item.entities.values;
                fontsize = fontsize.toString().replace(/px/g, '');
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.font = fontsize + "px  sans-serif";
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).font;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return parseFloat(entities[0].label.font);
                }
            }
        },
        /**
         * 设置geojson图层显示文本的填充色
         * @param {object} color
         */
        labelFillColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.fillColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).fillColor;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var color = entities[0].label.fillColor;
                    return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            }
        },
        /**
         * 设置geojson图层显示文本边框的填充色
         * @param {object} color
         */
        labelOutlineColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.outlineColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).outlineColor;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var color = entities[0].label.outlineColor;
                    try {
                        return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置geojson图层显示文本边框的宽度
         * @param {Float} width [width]
         */
        labelOutlineWidth: {
            set: lodash.debounce(function (width) {
                if (this._core.isnull(width)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(width)) {
                            width = width.replace(/\[/, '').replace(/\]/, '');
                            width = entities[i].properties[width];
                        }
                        entities[i].label.outlineWidth = width;
                    }
                }
            }, 200),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).outlineWidth;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var width = entities[0].label.outlineWidth;
                    if (width) {
                        return width._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的背景色
         * @param {object} color
         */
        labelBackgroundColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.backgroundColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).backgroundColor;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var color = entities[0].label.backgroundColor;
                    return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            }
        },
        /**
         * 设置geojson图层显示文本是否显示背景色
         * @param {boolean} b
         */
        labelBackground: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.showBackground = b;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).background;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return entities[0].label.background;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的大小
         * @param {Float} scale [scale]
         */
        labelScale: {
            set: lodash.debounce(function (scale) {
                if (this._core.isnull(scale)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(scale)) {
                            scale = scale.replace(/\[/, '').replace(/\]/, '');
                            scale = entities[i].properties[scale];
                        }
                        entities[i].label.scale = scale;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).scale;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var scale = entities[0].label.scale;
                    if (scale) {
                        return scale._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的水平布局方式
         * @param {object} horizontalOrigin
         */
        labelHorizontalOrigin: {
            set: lodash.debounce(function (horizontalOrigin) {
                if (this._core.isnull(horizontalOrigin)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.horizontalOrigin = parseInt(horizontalOrigin);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).horizontalOrigin;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var horizontalOrigin = entities[0].label.horizontalOrigin;
                    if (horizontalOrigin)
                        return horizontalOrigin._value;
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的水平布局方式
         * @param {object} verticalOrigin
         */
        labelVerticalOrigin: {
            set: lodash.debounce(function (verticalOrigin) {
                if (this._core.isnull(verticalOrigin)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.verticalOrigin = parseInt(verticalOrigin);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).verticalOrigin;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var verticalOrigin = entities[0].label.verticalOrigin;
                    if (verticalOrigin)
                        return verticalOrigin._value;
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的高度类型
         * @param {object} verticalOrigin
         */
        labelHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).heightReference;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var heightReference = entities[0].label.heightReference;
                    if (heightReference)
                        return heightReference._value;
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的最大可视距离
         * @param {Float} far
         */
        labelDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var near = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, parseInt(far));
                        entities[i].label.scaleByDistance = new this._cesium.NearFarScalar(near, 1, parseInt(far), 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.far : Number.MAX_VALUE;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var far = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    return far;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的最小可视距离
         * @param {Float} near
         */
        labelDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var far = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(parseInt(near), far);
                        entities[i].label.scaleByDistance = new this._cesium.NearFarScalar(parseInt(near), 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.near : 0;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var near = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         *
         *
         */
        labelHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude);
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude);
                // var height=this._cesium.Math.toDegrees( Cartographic.height);
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        },
        /**
         * 设置geojson图层的label显示隐藏
         *
         *
         */
        labelShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities && this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id)) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].label && b) {
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                            entities[i].label = new this._cesium.LabelGraphics({
                                text: "label",
                                font: '30px sans-serif',
                                style: this._cesium.LabelStyle.FILL,
                                fillColor: this._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                                outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                                show: true, //	optional A boolean Property specifying the visibility of the label.
                                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                                backgroundColor: new this._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                                backgroundPadding: new this._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                heightReference: this._cesium.HeightReference.NONE //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            if (entities[i].label)
                                entities[i].label.show = b;

                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).show;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return entities[0].label.show;
                }
            }
        },

        /**
         * 模型图层的显示隐藏
         * @param {boolean} b
         */
        modelShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities && this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id)) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (entities[i].label) entities[i].label.show = !b;
                        if (entities[i].point) entities[i].point.show = !b;
                        if (entities[i].billboard) entities[i].billboard.show = !b;
                        if (!entities[i].model && b) {
                            entities[i].model = new this._cesium.ModelGraphics({
                                //uri: "glb/gltf",
                                show: true,
                                scale: 1.0,
                                minimumPixelSize: 0.0,
                                incrementallyLoadTextures: true,
                                runAnimations: true,
                                clampAnimations: true,
                                shadows: this._cesium.ShadowMode.ENABLED,
                                heightReference: this._cesium.HeightReference.NONE,
                                color: this._cesium.Color.WHITE
                            });
                        } else {
                            if (entities[i].model)
                                entities[i].model.show = b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).show;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    return entities[0].model.show;
                }
            }
        },
        /**
         * 模型图层的模型地址
         * @param {String} uri [uri]
         */
        modelUri: {
            set: lodash.debounce(function (uri) {
                if (this._core.isnull(uri)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].model) {
                            if (/^\[/.test(uri)) {
                                var uris = uri.split('[');
                                if (uris.length > 1) {
                                    uri = uris[0] + uris[1].replace(/\[/, '').replace(/\]/, '');
                                } else {
                                    uri = uri.replace(/\[/, '').replace(/\]/, '');
                                    uri = entities[i].properties[uri];
                                }
                            }
                            entities[i].model = new this._cesium.ModelGraphics({
                                uri: uri,
                                show: true,
                                scale: 1.0,
                                minimumPixelSize: 0.0,
                                incrementallyLoadTextures: true,
                                runAnimations: true,
                                clampAnimations: true,
                                shadows: this._cesium.ShadowMode.ENABLED,
                                heightReference: this._cesium.HeightReference.NONE,
                                color: this._cesium.Color.WHITE
                            });
                        } else {
                            entities[i].model.uri = uri;
                        }
                    }
                }
            }, 500)
        },
        /**
         * 模型图层的模型显示比例
         * @param {Float} scale [scale]
         */
        modelScale: {
            set: lodash.debounce(function (scale) {
                if (this._core.isnull(scale)) return;
                scale = parseFloat(scale);
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(scale)) {
                            scale = scale.replace(/\[/, '').replace(/\]/, '');
                            scale = entities[i].properties[scale];
                        }
                        entities[i].model.scale = scale;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).scale;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var scale = entities[0].model.scale;
                    if (scale) {
                        return scale._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 模型图层的模型的阴影
         * @param {Float} shadows sgworld.ShadowMode.*
         */
        modelShadows: {
            set: lodash.debounce(function (shadows) {
                if (this._core.isnull(shadows)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.shadows = shadows;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).shadows;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    return entities[0].model.shadows;
                }
            }
        },
        /**
         * 模型图层的模型的高度类型
         * @param {object} heightReference sgworld.HeightReference.*
         */
        modelHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).heightReference;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var heightReference = entities[0].model.heightReference;
                    if (heightReference) {
                        return heightReference._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层模型的最大可视距离
         * @param {Float} far
         */
        modelDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var near = entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.far : Number.MAX_VALUE;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                }
            }
        },
        /**
         * 设置geojson图层点模型最小可视距离
         * @param {Float} near
         */
        modelDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var far = entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.near : 0;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var near = entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层模型颜色
         * @param {object} color
         */
        modelColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.color = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).color;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var color = entities[0].model.color;
                    try {
                        return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置geojson图层模型高亮颜色
         * @param {object} color
         */
        modelLightColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.lightColor = color;
                    }
                }
            }, 100),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).lightColor;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var lightColor = entities[0].model.lightColor;
                    try {
                        return this._color.toHtmlColor('rgb(' + lightColor._value.red * 255 + ',' + lightColor._value.green * 255 + ',' + lightColor._value.blue * 255 + ',' + lightColor._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         */
        modelHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude)
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude)
                // var height=this._cesium.Math.toDegrees( Cartographic.height)
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        },

        /**
         * 设置位置点的颜色
         * @param {object} color
         */
        pointColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.color = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).color;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var fillColor = entities[0].point.color;
                    try {
                        return this._color.toHtmlColor('rgb(' + fillColor._value.red * 255 + ',' + fillColor._value.green * 255 + ',' + fillColor._value.blue * 255 + ',' + fillColor._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置位置点的颜色
         * @param {boolean} b
         */
        pointShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities && this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id) ) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].point && b) {
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                            entities[i].point = new this._cesium.PointGraphics({
                                color: this._cesium.Color.WHITE, //	optional A Property specifying the Color of the point.
                                pixelSize: 1, //optional A numeric Property specifying the size in pixels.
                                outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the Color of the outline.
                                outlineWidth: 0, //	optional A numeric Property specifying the the outline width in pixels.
                                show: true //	optional A boolean Property specifying the visibility of the point.
                            });
                        } else {
                            if (entities[i].point)
                                entities[i].point.show = b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).show;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    return entities[0].point.show;
                }
            }
        },
        /**
         * 设置位置点的大小
         * @param {Float} pixelSize [pixelSize]
         */
        pointPixelSize: {
            set: lodash.debounce(function (pixelSize) {
                if (this._core.isnull(pixelSize)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(pixelSize)) {
                            pixelSize = pixelSize.replace(/\[/, '').replace(/\]/, '');
                            pixelSize = entities[i].properties[pixelSize];
                        }
                        entities[i].point.pixelSize = pixelSize;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).pixelSize;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var pixelSize = entities[0].point.pixelSize;
                    if (pixelSize) {
                        return pixelSize._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置点的边框颜色
         * @param {object} color
         */
        pointOutlineColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.outlineColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).outlineColor;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var outlineColor = entities[0].point.outlineColor;
                    try {
                        return this._color.toHtmlColor('rgb(' + outlineColor._value.red * 255 + ',' + outlineColor._value.green * 255 + ',' + outlineColor._value.blue * 255 + ',' + outlineColor._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置点的边框宽度
         * @param {Float} width [width]
         */
        pointOutlineWidth: {
            set: lodash.debounce(function (width) {
                if (this._core.isnull(width)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(width)) {
                            width = width.replace(/\[/, '').replace(/\]/, '');
                            width = entities[i].properties[width];
                        }
                        entities[i].point.outlineWidth = width;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).outlineWidth;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var outlineWidth = entities[0].point.outlineWidth;
                    if (outlineWidth) {
                        return outlineWidth._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置点的高度类型
         * @param {object} heightReference
         */
        pointHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).heightReference;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var heightReference = entities[0].point.heightReference;
                    if (heightReference) {
                        return heightReference._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层点的最大可视距离
         * @param {Float} far
         */
        pointDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var near = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                        entities[i].point.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.far : Number.MAX_VALUE;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var far = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    return far;
                }
            }
        },
        /**
         * 设置geojson图层点的最小可视距离
         * @param {Float} verticalOrigin
         */
        pointDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var far = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);

                        entities[i].point.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.nera : 0;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var near = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         */
        pointHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude)
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude)
                // var height=this._cesium.Math.toDegrees( Cartographic.height)
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        },

        /**
         * 控制billboard的显示隐藏
         * @param {boolean} b
         */
        billboardShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities && this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id)) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].billboard && b) {
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            entities[i].billboard = new this._cesium.BillboardGraphics({
                                //image: "",//	Property		optional A Property specifying the Image, URI, or Canvas to use for the billboard.
                                show: true, //	optional A boolean Property specifying the visibility of the billboard.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the image size.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //	optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                rotation: 0, //	optional A numeric Property specifying the rotation about the alignedAxis.
                                alignedAxis: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the unit vector axis of rotation.
                                width: undefined, //		optional A numeric Property specifying the width of the billboard in pixels, overriding the native size.
                                height: undefined, //		optional A numeric Property specifying the height of the billboard in pixels, overriding the native size.
                                color: this._cesium.Color.WHITE, //	optional A Property specifying the tint Color of the image.
                                heightReference: this._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            if (entities[i].billboard)
                                entities[i].billboard.show = b;
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    return entities[0].billboard.show;
                }
            }
        },
        /**
         * 控制billboard的图片
         * @param {string} image [image]
         */
        billboardImage: {
            set: lodash.debounce(function (image) {
                if (this._core.isnull(image)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(image)) {
                            var images = image.split('[');
                            if (images.length > 1) {
                                image = images[0] + images[1].replace(/\[/, '').replace(/\]/, '');
                            } else {
                                image = image.replace(/\[/, '').replace(/\]/, '');
                                image = entities[i].properties[image];
                            }
                        }
                        if (!entities[i].billboard) {
                            entities[i].billboard = new this._cesium.BillboardGraphics({
                                image: image, //	Property		optional A Property specifying the Image, URI, or Canvas to use for the billboard.
                                show: true, //	optional A boolean Property specifying the visibility of the billboard.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the image size.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //	optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                rotation: 0, //	optional A numeric Property specifying the rotation about the alignedAxis.
                                alignedAxis: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the unit vector axis of rotation.
                                width: undefined, //		optional A numeric Property specifying the width of the billboard in pixels, overriding the native size.
                                height: undefined, //		optional A numeric Property specifying the height of the billboard in pixels, overriding the native size.
                                color: this._cesium.Color.WHITE, //	optional A Property specifying the tint Color of the image.
                                heightReference: this._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            entities[i].billboard.image = image;
                        }
                    }
                }
            }, 500)
        },
        /**
         * 控制billboard的图片scale
         * @param {Float} scale
         */
        billboardScale: {
            set: lodash.debounce(function (scale) {
                if (this._core.isnull(scale)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.scale = scale;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var scale = entities[0].billboard.scale;
                    if (scale) {
                        return scale._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 控制billboard的图片horizontalOrigin
         * @param {Float} horizontalOrigin
         */
        billboardHorizontalOrigin: {
            set: lodash.debounce(function (horizontalOrigin) {
                if (this._core.isnull(horizontalOrigin)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.horizontalOrigin = horizontalOrigin;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    return entities[0].billboard.horizontalOrigin;
                }
            }
        },
        /**
         * 控制billboard的图片verticalOrigin
         * @param {Float} verticalOrigin
         */
        billboardVerticalOrigin: {
            set: lodash.debounce(function (verticalOrigin) {
                if (this._core.isnull(verticalOrigin)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.verticalOrigin = verticalOrigin;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    return entities[0].billboard.verticalOrigin;
                }
            }
        },
        /**
         * 控制billboard的图片width
         * @param {Float} width
         */
        billboardWidth: {
            set: lodash.debounce(function (width) {
                if (this._core.isnull(width)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.width = width;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var width = entities[0].billboard.width;
                    if (width) {
                        return width._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 控制billboard的图片height
         * @param {Float} height
         */
        billboardHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.height = height;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var height = entities[0].billboard.height;
                    if (height) {
                        return height._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 控制billboard的图片color
         * @param {object} color
         */
        billboardColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.color = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var color = entities[0].billboard.color;
                    try {
                        return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * billboard图层的高度类型
         * @param {object} heightReference sgworld.HeightReference.*
         */
        billboardHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var heightReference = entities[0].billboard.heightReference;
                    if (heightReference) {
                        return heightReference._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层模型的最大可视距离
         * @param {Float} far
         */
        billboardDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var near = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                        entities[i].billboard.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var far = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    return far;
                }
            }
        },
        /**
         * 设置geojson图层点模型最小可视距离
         * @param {Float} near
         */
        billboardDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var far = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                        entities[i].billboard.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var near = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         */
        billboardPHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude)
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude)
                // var height=this._cesium.Math.toDegrees( Cartographic.height)
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        }
    });

    function GeoJSONVectorTileProvider1(viewer, cesium, options, callback) {
        this.UrlTemplateGeojsonProvider = new cesium.UrlTemplateGeojsonProvider(options, 1);
        this.UrlTemplateGeojsonProvider.loadtitle = callback;
        this.ent = viewer.imageryLayers.addImageryProvider(this.UrlTemplateGeojsonProvider);
    }

    /**
     * 切片工具-区块计算
     *
     */
    function LonLatProjection(width, height) {
        var imageSize = { width: width, height: height };
        function getBoundingRect(regions) {
            var LIMIT = Number.MAX_VALUE;
            var min, max;
            var boundingRect = { xMin: LIMIT, yMin: LIMIT, xMax: -LIMIT, yMax: -LIMIT };

            for (var i = 0, L = regions.length; i < L; i++) {
                var rect = regions[i].getBoundingRect();

                min = { x: rect.xMin, y: rect.yMin };
                max = { x: rect.xMax, y: rect.yMax };

                boundingRect.xMin = boundingRect.xMin < min.x ? boundingRect.xMin : min.x;
                boundingRect.yMin = boundingRect.yMin < min.y ? boundingRect.yMin : min.y;
                boundingRect.xMax = boundingRect.xMax > max.x ? boundingRect.xMax : max.x;
                boundingRect.yMax = boundingRect.yMax > max.y ? boundingRect.yMax : max.y;
            }

            return boundingRect
        }

        function project(coordinate, boundingRect) {
            var width = boundingRect.xMax - boundingRect.xMin;
            var height = boundingRect.yMin - boundingRect.yMax;
            var distanceX = Math.abs(coordinate[0] - boundingRect.xMin);
            var distanceY = coordinate[1] - boundingRect.yMax;

            var percentX = (distanceX / width);
            var percentY = (distanceY / height);

            var px = percentX * imageSize.width,
                py = percentY * imageSize.height;
            return { x: px, y: py };
        }

        function unproject(pt, boundingRect) {
            var width = boundingRect.xMax - boundingRect.xMin;
            var height = boundingRect.yMin - boundingRect.yMax;
            var lon = (pt.x / imageSize.width) * width,
                lat = (pt.y / imageSize.height) * height;
            return [lon, lat];
        }

        this.project = project;
        this.unproject = unproject;
        this.getBoundingRect = getBoundingRect;
    }

    /**
     *
     * 矢量切片图层。
     *
     * @alias VectorGeoJsonFeatureLayer
     * @constructor
     *
     */
    function VectorGeoJsonFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this.item = { show: true };
        this._option = undefined;
        this._primitive = undefined;
        this._Provider = undefined;
        //图例
        this.Legend = [];
        this.datas = [];
        //矢量切片数据存储
        this.entity = null;
        //
        this.primitve = [];
        this.probj = [];
        this.PrimitiveData = [];
        this.loadFinishKey = [];
        this.loadAllKey = [];
        this.PrimitiveObj = {
            key: "",
            data: {}
        };
        this.start = 0;
        this.Primitivekey = [];
        //请求前
        this.tilesLength = 0;
        //请求后
        this.returnCount = 0;
        // 瓦片 primitive，以 tile key 索引
        this._primitiveByTile = {};
        this._primitiveCollection = new this._cesium.PrimitiveCollection();
        //影像
        this.img = null;
        //动态单体化
        this._defaultStyle = null;
        this._canvas = null;
        this._context = null;
        /**
         * 是否强制清楚缓存
         */
        this._cache = false;
        /**
         * 强制刷新方法
         */
        this._forceRefreshPrvimitive = null;
    }

    function _toConsumableArray$2(arr) {
        if (Array.isArray(arr)) {
            for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
                arr2[i] = arr[i];
            }
            return arr2;
        } else {
            return Array.from(arr);
        }
    }
    //金磊修改
    function _getLoadLevelTile(tile, loadLevel) {
        var tileList = [];
        if (tile.level >= loadLevel) {
            _getParentLevelTile(tile, loadLevel, tileList);
        } else {
            _getAllChildLevelTile(tile, loadLevel, tileList);
        }
        return tileList;
    }
    function _getParentLevelTile(tile, loadLevel, tileList) {
        var nowTile = tile;
        for (var i = 0; i < 30; i++) {
            if (nowTile.level == loadLevel) {
                tileList.push({
                    x: nowTile.x,
                    y: nowTile.y,
                    level: nowTile.level
                });
                return true;
            }
            nowTile = nowTile.parent;
        }
        return true;
    }
    function _getAllChildLevelTile(tile, loadLevel, tileList) {
        if (tile.level == loadLevel) {
            tileList.push({
                x: tile.x,
                y: tile.y,
                level: tile.level
            });
            return true;
        } else if (tile.level > loadLevel) {
            return false;
        } else {
            for (var i = 0; i < tile.children.length; i++) {
                _getAllChildLevelTile(tile.children[i], loadLevel, tileList);
            }
        }
        return true;
    }
    //金磊修改
    var _typeof$5 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
        return typeof obj;
    } : function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    /**
     * 序列化参数对象
     *
     * @param {Object} params 参数对象
     * @returns {String} 序列化字符串
     */
    VectorGeoJsonFeatureLayer.prototype._serialize = function (params) {
        var queryArray = [];
        var encode = window.encodeURIComponent;

        for (var key in params) {
            var value = params[key];

            if ((typeof value === 'undefined' ? 'undefined' : _typeof$5(value)) === 'object') {
                queryArray.push(encode(key) + '=' + encode(JSON.stringify(value)));
            } else {
                queryArray.push(encode(key) + '=' + encode(params[key]));
            }
        }

        return queryArray.join('&');
    };

    /**
     * 矢量切片柱状图
     * @param {String} name 图层名
     * @param {Object} geoOptions 图层参数
     * @param {Object} [styleOption] 样式参数
     * @param {Number} [styleOption.radius=50] 柱状图半径
     * @param {Number} [styleOption.scale=1] 柱状图高度倍数
     * @param {Number} [styleOption.alpha=0.5] 底部面透明度
     * @param {String} [styleOption.defaultColor=#ffffff] 默认颜色
     * @param {String|Array} [styleOption.color=#ffffff] 柱状图颜色配置
     * @param {Number|String} [styleOption.height=100] 柱状图高度
     * @param {Boolean} [styleOption.showLabel=true] 显示文本
     * @param {Cesium.LabelGraphics} [styleOption.label] 文本样式
     * @param {String} GroupID 工程树父节点id
     * @param {Boolean} checked 是否显示
     * @param {Function} disFnc 回调函数
     */
    VectorGeoJsonFeatureLayer.prototype.createHistogramVectorGeoJsonFeatureLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            radius: 50,
            height: 100,
            scale: 1, //柱状图高度倍数
            defaultColor: "#ffffff",
            showLabel: true,
            label: {
                showBackground: false,
                fillColor: "#ffffff",
                outlineColor: "#000000",
                backgroundColor: "rgba(0,0,0,0.5)",
                style: 2,
                horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                outlineWidth: 1,
                font: "20px 微软雅黑",
            },
            alpha: 0.5,
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit
        };
        if (styleOption.label) {
            defaultOptions.label = this._core.extend(defaultOptions.label, styleOption.label, true);
            delete styleOption.label;
        }
        let options = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined) {
            console.log('geoOptions is required');
        }
        if (name == undefined) {
            console.log('layername is required');
        }
        let colorObject;
        if (Array.isArray(options.color)) {
            colorObject = {
                name: options.color[0].name,
                value: {
                    ">": {},
                    "<": {},
                }
            };
            options.color.forEach(item => {
                if (item.value.indexOf && item.value.indexOf(">") > -1) {
                    let value = item.value.split(">");
                    colorObject.value[">"][value[1]] = Cesium.Color.fromCssColorString(item.color).withAlpha(options.alpha);
                } else if (item.value.indexOf && item.value.indexOf("<") > -1) {
                    let value = item.value.split("<");
                    colorObject.value["<"][value[1]] = Cesium.Color.fromCssColorString(item.color).withAlpha(options.alpha);
                } else {
                    colorObject.value[item.value] = Cesium.Color.fromCssColorString(item.color).withAlpha(options.alpha);
                }
            });
        }
        let defaultColor = Cesium.Color.fromCssColorString(options.defaultColor).withAlpha(options.alpha);

        var that = this;

        var LabelStyle = {
            text: '',
            ...options.label,
            fillColor: Cesium.Color.fromCssColorString(options.label.fillColor),
            outlineColor: Cesium.Color.fromCssColorString(options.label.outlineColor),
            backgroundColor: Cesium.Color.fromCssColorString(options.label.backgroundColor),
        };
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = 0;
        //请求
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }

                        let polygonGeometries = [];
                        let labelCollections = new Cesium.LabelCollection();

                        let dataSource = Cesium.GeoJsonDataSource.load(tileUrl);
                        dataSource.then(dataSource => {
                            let entities = dataSource.entities.values;
                            if (!entities || !entities.length) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }
                            let collection = new Cesium.PrimitiveCollection();

                            entities.forEach(entity => {
                                let geoData = entity.properties.getValue();
                                let defaultHeight = options.height;
                                if (geoData && typeof options.height === 'string' && /^\[/.test(options.height) && /\]$/.test(options.height)) {
                                    let heightStr = options.height.replace(/\[/, '').replace(/\]/, '');
                                    defaultHeight = geoData[heightStr] || 100;
                                }
                                let height = defaultHeight * options.scale;
                                let color;
                                if (geoData && typeof options.color === 'string' && /^\[/.test(options.color) && /\]$/.test(options.color)) {
                                    let colorStr = options.color.replace(/\[/, '').replace(/\]/, '');
                                    colorStr = geoData[colorStr] || options.defaultColor;
                                    color = Cesium.Color.fromCssColorString(colorStr).withAlpha(options.alpha);
                                } else if (colorObject && geoData[colorObject.name]) {
                                    let value = geoData[colorObject.name];
                                    if (colorObject.value[value]) {
                                        color = colorObject.value[value];
                                    } else {
                                        for (let key in colorObject.value[">"]) {
                                            if (value > key) {
                                                color = colorObject.value[">"][key];
                                                break;
                                            }
                                        }
                                        if (!color) {
                                            for (let key in colorObject.value["<"]) {
                                                if (value < key) {
                                                    color = colorObject.value["<"][key];
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }
                                !color && (color = defaultColor.clone());
                                let pCenter;
                                //polygon
                                if (entity.polygon) {
                                    let pyPositions = entity.polygon.hierarchy.getValue().positions;
                                    //中心点
                                    pCenter = Cesium.BoundingSphere.fromPoints(pyPositions).center;

                                    //基础面
                                    var PolygonGeometry = new Cesium.PolygonGeometry({
                                        polygonHierarchy: new Cesium.PolygonHierarchy(pyPositions),
                                        height: 0,
                                        extrudedHeight: 0,
                                        vertexFormat: Cesium.VertexFormat.DEFAULT,
                                        perPositionHeight: false
                                    });

                                    var geometryInstance = new Cesium.GeometryInstance({
                                        id: geoData,
                                        geometry: PolygonGeometry,
                                        attributes: {
                                            color: new Cesium.ColorGeometryInstanceAttribute.fromColor(color),
                                        }
                                    });

                                    polygonGeometries.push(geometryInstance);
                                } else if (entity.point || entity.billboard) {
                                    //点
                                    pCenter = entity.position.getValue();
                                }

                                let EllipseInstance = new Cesium.GeometryInstance({
                                    geometry: new Cesium.EllipseGeometry({
                                        extrudedHeight: height,
                                        center: pCenter,
                                        semiMinorAxis: options.radius,
                                        semiMajorAxis: options.radius,
                                        vertexFormat: Cesium.VertexFormat.POSITION_AND_ST
                                    }),
                                    id: geoData
                                });

                                let material = Cesium.Material.fromType('Color');
                                material.uniforms.color = color.withAlpha(1);
                                let primitive = new that._cesium.Primitive({
                                    geometryInstances: EllipseInstance,
                                    appearance: new Cesium.EllipsoidSurfaceAppearance({
                                        material: material
                                    }),
                                    shadows: options.shadows
                                });
                                collection.add(primitive);

                                if (options.showLabel) {
                                    let degrees = that._core.toDegrees(pCenter);
                                    LabelStyle.text = defaultHeight + '';
                                    LabelStyle.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, height * 1.1);
                                    labelCollections.add(LabelStyle);
                                }


                                // let cylinder = sgworld.Creator.addSimpleGraphic("cylinder", {
                                //     position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, height / 2),
                                //     removeEdit: true,
                                //     length: height * scale,
                                //     radius: Histogramwidth,
                                //     outline: false,
                                //     color: ysk
                                // })
                                // let label = sgworld.Creator.addSimpleGraphic("label", {
                                //     position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, height * 1.1),
                                //     removeEdit: true,
                                //     text: height,
                                //     heightReference: 0,
                                //     outlineWidth: 2
                                // })
                            });

                            if (polygonGeometries.length) {
                                let polygonPrimitive = new that._cesium.GroundPrimitive({
                                    geometryInstances: polygonGeometries,
                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                        translucent: options.alpha < 1
                                    }),
                                    classificationType: that._cesium.ClassificationType.BOTH,
                                    shadows: options.shadows
                                });
                                collection.add(polygonPrimitive);
                            }

                            if (options.showLabel) {
                                collection.add(labelCollections);
                            }


                            that.probj.push(collection);
                            tile.data.geometryPrimitive = collection;

                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                        }, (err) => {
                            if (tile.count == undefined) {
                                tile.count = 0;
                            }
                            tile.count += 1;
                            if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // return;
                            }
                            else {
                                tile.state = Cesium.QuadtreeTileLoadState.START;
                            }
                        });
                        // Create random lines at the root level.

                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };


        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 5
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this._Provider.treeID = obj.id;

        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    /**
     * 矢量切片分层设色
     * @param {String} name 图层名
     * @param {Object} geoOptions 图层参数
     * @param {Object} [styleOption] 样式参数
     * @param {Number} [styleOption.type="2D"] 分层设色类型【2D | 3D】
     * @param {Number|String} [styleOption.height=100] 拉伸高度，仅在3D有效
     * @param {Number} [styleOption.scale=1] 拉伸高度倍数
     * @param {Number} [styleOption.alpha=0.5] 面透明度
     * @param {String} [styleOption.defaultColor=#ffffff] 默认颜色
     * @param {String|Array} [styleOption.color=#ffffff] 颜色配置
     * @param {String} GroupID 工程树父节点id
     * @param {Boolean} checked 是否显示
     * @param {Function} disFnc 回调函数
     */
    VectorGeoJsonFeatureLayer.prototype.createLaycolorVectorGeoJsonFeatureLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            type: '2D',
            height: 100,
            scale: 1, //拉伸高度倍数
            defaultColor: "#ffffff",
            alpha: 0.5,
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit
        };
        let options = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined) {
            console.log('geoOptions is required');
        }
        if (name == undefined) {
            console.log('layername is required');
        }
        let colorObject;
        if (Array.isArray(options.color)) {
            colorObject = {
                name: options.color[0].name,
                value: {
                    ">": {},
                    "<": {},
                }
            };
            options.color.forEach(item => {
                if (item.value.indexOf && item.value.indexOf(">") > -1) {
                    let value = item.value.split(">");
                    colorObject.value[">"][value[1]] = Cesium.Color.fromCssColorString(item.color).withAlpha(options.alpha);
                } else if (item.value.indexOf && item.value.indexOf("<") > -1) {
                    let value = item.value.split("<");
                    colorObject.value["<"][value[1]] = Cesium.Color.fromCssColorString(item.color).withAlpha(options.alpha);
                } else {
                    colorObject.value[item.value] = Cesium.Color.fromCssColorString(item.color).withAlpha(options.alpha);
                }
            });
        }
        let defaultColor = Cesium.Color.fromCssColorString(options.defaultColor).withAlpha(options.alpha);

        var that = this;

        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = 0;
        //请求
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }

                        let polygonGeometries = [];

                        let dataSource = Cesium.GeoJsonDataSource.load(tileUrl);
                        dataSource.then(dataSource => {
                            let entities = dataSource.entities.values;
                            if (!entities || !entities.length) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }

                            entities.forEach(entity => {
                                let geoData = entity.properties.getValue();
                                let defaultHeight, height;
                                if (options.type === "3D") {
                                    defaultHeight = options.height;
                                    if (geoData && typeof options.height === 'string' && /^\[/.test(options.height) && /\]$/.test(options.height)) {
                                        let heightStr = options.height.replace(/\[/, '').replace(/\]/, '');
                                        defaultHeight = geoData[heightStr] || 100;
                                    }
                                    height = defaultHeight * options.scale;
                                }

                                let color;
                                if (geoData && typeof options.color === 'string' && /^\[/.test(options.color) && /\]$/.test(options.color)) {
                                    let colorStr = options.color.replace(/\[/, '').replace(/\]/, '');
                                    colorStr = geoData[colorStr] || options.defaultColor;
                                    color = Cesium.Color.fromCssColorString(colorStr).withAlpha(options.alpha);
                                } else if (colorObject && geoData[colorObject.name]) {
                                    let value = geoData[colorObject.name];
                                    if (colorObject.value[value]) {
                                        color = colorObject.value[value];
                                    } else {
                                        for (let key in colorObject.value[">"]) {
                                            if (value > key) {
                                                color = colorObject.value[">"][key];
                                                break;
                                            }
                                        }
                                        if (!color) {
                                            for (let key in colorObject.value["<"]) {
                                                if (value < key) {
                                                    color = colorObject.value["<"][key];
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }
                                !color && (color = defaultColor.clone());
                                //polygon
                                if (entity.polygon) {
                                    let pyPositions = entity.polygon.hierarchy.getValue().positions;
                                    //基础面
                                    var PolygonGeometry = new Cesium.PolygonGeometry({
                                        polygonHierarchy: new Cesium.PolygonHierarchy(pyPositions),
                                        height: 0,
                                        extrudedHeight: options.type === "3D" ? height : 0,
                                        vertexFormat: Cesium.VertexFormat.DEFAULT,
                                        perPositionHeight: false
                                    });

                                    var geometryInstance = new Cesium.GeometryInstance({
                                        id: geoData,
                                        geometry: PolygonGeometry,
                                        attributes: {
                                            color: new Cesium.ColorGeometryInstanceAttribute.fromColor(color),
                                        }
                                    });

                                    polygonGeometries.push(geometryInstance);
                                }
                            });

                            let polygonPrimitive;
                            if (polygonGeometries.length) {
                                let Primitive = options.type === "3D" ? Cesium.Primitive : Cesium.GroundPrimitive;
                                polygonPrimitive = new Primitive({
                                    geometryInstances: polygonGeometries,
                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                        translucent: options.alpha < 1
                                    }),
                                    classificationType: that._cesium.ClassificationType.BOTH,
                                    shadows: options.shadows
                                });
                            }

                            that.probj.push(polygonPrimitive);
                            tile.data.geometryPrimitive = polygonPrimitive;

                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                        }, (err) => {
                            if (tile.count == undefined) {
                                tile.count = 0;
                            }
                            tile.count += 1;
                            if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // return;
                            }
                            else {
                                tile.state = Cesium.QuadtreeTileLoadState.START;
                            }
                        });
                        // Create random lines at the root level.

                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };


        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 5
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this._Provider.treeID = obj.id;

        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    /**
     * 矢量切片3dtiles模型
     * @param {String} name 图层名
     * @param {Object} [geoOptions] 图层参数
     * @param {String} geoOptions.url 地址模板
     * @param {Number} [geoOptions._x=0] x偏移量
     * @param {Number} [geoOptions._y=0] y偏移量
     * @param {Object} [styleOption] 样式参数
     * @param {String} [styleOption.color=#ffffff] 颜色
     * @param {Number} [styleOption.level_max=20] 最大显示级别
     * @param {Number} [styleOption.level_min=10] 最小显示级别
     * @param {Cesium.TilingScheme} [styleOption.tilingScheme=Cesium.WebMercatorTilingScheme] 切片方式
     * @param {String} GroupID 工程树父节点id
     * @param {Boolean} checked 是否显示
     * @param {Function} disFnc 回调函数
     */
    VectorGeoJsonFeatureLayer.prototype.createVector3DTilesFeatureLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            color: "#ffffff",
            level_max: 20,
            level_min: 10,
            tilingScheme: new Cesium.WebMercatorTilingScheme()
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            _x: geoOptions._x || 0, // x偏移量
            _y: geoOptions._y || 0, // y偏移量
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit
        };
        let options = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined) {
            console.log('geoOptions is required');
        }
        if (name == undefined) {
            console.log('layername is required');
        }

        var that = this;

        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url;
        var _urlTemplate = geoOptions.url;

        this._Provider = new VectorTileProvider(this._viewer, this._cesium, options.tilingScheme);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = 0;
        //请求
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        var tileUrl = _urlTemplate.replace('{x}', tile.x - defaultGeoOptions._x).replace('{y}', tile.y - defaultGeoOptions._y).replace('{z}', tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }

                        let tileset = new Cesium.Cesium3DTileset({
                            url: tileUrl,
                            ...options
                        });
                        tileset.readyPromise.then(function (tileset) {
                            that.probj.push(tileset);
                            tile.data.geometryPrimitive = tileset;
                            that._viewer.scene.primitives.add(tileset);

                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                        }).otherwise(function (error) {
                            if (tile.count == undefined) {
                                tile.count = 0;
                            }
                            tile.count += 1;
                            if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            } else {
                                tile.state = Cesium.QuadtreeTileLoadState.START;
                            }
                        });
                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };


        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 5
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'modelLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
        };
        this._Provider.treeID = obj.id;

        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };


    /**
    * 矢量切片加载（全面加载优化）
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    */
    VectorGeoJsonFeatureLayer.prototype.VectorGeoJsonFeatureLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        //矢量切片参数
        var defaultGeoOptions = this._core.VectorSlice(geoOptions, this._cesium);
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        var that = this;
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            var primitiveCollection = new that._cesium.PrimitiveCollection();
            //创建对象集合
            var pointCollections = new that._cesium.PointPrimitiveCollection();
            var labelCollections = new that._cesium.LabelCollection();
            var billboardCollections = new that._cesium.BillboardCollection();
            //线集合
            var geometries_line = [];
            //面集合
            var geometries_gon = [];
            //是否贴地
            var classificationType = -1;
            json.features.forEach(function (feature) {
                //线段和面的坐标
                var newArr = [];
                //添加lable
                if (styleOption.lable != undefined && feature.geometry.coordinates[0][0] == undefined) {
                    var sheight = 0;
                    if (styleOption.lable.height != undefined && /^\[/.test(styleOption.lable.height) && /\]$/.test(styleOption.lable.height)) {
                        var heightStr = styleOption.lable.height.replace(/\[/, '').replace(/\]/, '');
                        sheight = parseFloat(feature.properties[heightStr]);
                    }                var LabelStyle = that._core.StyleContrast("lable", styleOption.lable, that._cesium);
                    //颜色转化
                    LabelStyle.fillColor = that._color.VectorColorTransformation(LabelStyle.fillColor, feature);
                    LabelStyle.outlineColor = that._color.VectorColorTransformation(LabelStyle.outlineColor, feature);
                    LabelStyle.backgroundColor = that._color.VectorColorTransformation(LabelStyle.backgroundColor, feature);
                    LabelStyle.text = that._core.Analysis(LabelStyle.text, feature);

                    LabelStyle.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                    labelCollections.add(LabelStyle);
                }
                //添加billboard
                if (styleOption.billboard != undefined && feature.geometry.coordinates[0][0] == undefined) {
                    var sheight = 0;
                    var entity = styleOption.billboard;
                    if (entity.height != undefined && /^\[/.test(entity.height) && /\]$/.test(entity.height)) {
                        var heightStr = entity.height.replace(/\[/, '').replace(/\]/, '');
                        sheight = parseFloat(feature.properties[heightStr]);
                    }                var Style = that._core.StyleContrast("billboard", entity, that._cesium);
                    Style.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                    //Style.color = that._color.VectorColorTransformation(Style.color, feature);
                    //Style.text = that._core.Analysis(Style.text, entity);
                    billboardCollections.add(Style);
                }
                //添加point
                if (styleOption.point != undefined && feature.geometry.coordinates[0][0] == undefined) {
                    var sheight = 0;
                    var entity = styleOption.point;
                    if (entity.height != undefined && /^\[/.test(entity.height) && /\]$/.test(entity.height)) {
                        var heightStr = entity.height.replace(/\[/, '').replace(/\]/, '');
                        sheight = parseFloat(feature.properties[heightStr]);
                    }                var Style = that._core.StyleContrast("point", entity, that._cesium);
                    Style.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                    Style.color = that._color.VectorColorTransformation(Style.color, feature);
                    Style.outlineColor = that._color.VectorColorTransformation(Style.outlineColor, feature);
                    pointCollections.add(Style);
                }
                //添加线段
                if (styleOption.polyline != undefined) {
                    var sheight = 0;
                    var entity = styleOption.polyline;
                    if (entity.height != undefined && /^\[/.test(entity.height) && /\]$/.test(entity.height)) {
                        var heightStr = entity.height.replace(/\[/, '').replace(/\]/, '');
                        sheight = parseFloat(feature.properties[heightStr]);
                    }                var Style = that._core.StyleContrast("polyline", entity, that._cesium);
                    classificationType = Style.classificationType;
                    delete Style.classificationType;
                    //坐标解析
                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                newArr = [];
                                newArr = that._core.coordinate(newArr, feature.geometry.coordinates[j]);
                                Style.positions = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                var geometryInstance = that._core.createPolyline(Style, classificationType, feature, that._cesium);
                                geometries_line.push(geometryInstance);
                            }
                        } else {
                            newArr = that._core.coordinate(newArr, feature.geometry.coordinates);
                            Style.positions = that._cesium.Cartesian3.fromDegreesArray(newArr);
                            var geometryInstance = that._core.createPolyline(Style, classificationType, feature, that._cesium);
                            geometries_line.push(geometryInstance);
                        }
                    }
                }
                //创建面
                if (styleOption.polygon != undefined) {
                    var sheight = 0;
                    var entity = styleOption.polygon;
                    if (entity.height != undefined && /^\[/.test(entity.height) && /\]$/.test(entity.height)) {
                        var heightStr = entity.height.replace(/\[/, '').replace(/\]/, '');
                        sheight = parseFloat(feature.properties[heightStr]);
                    }                var Style = that._core.StyleContrast("polygon", entity, that._cesium);
                    Style.material = that._color.VectorColorTransformation(Style.material, feature);
                    classificationType = Style.classificationType;
                    delete Style.classificationType;
                    //坐标解析
                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                newArr = [];
                                feature.geometry.coordinates[j].pop();
                                newArr = that._core.coordinate(newArr, feature.geometry.coordinates[j]);
                                Style.polygonHierarchy = new that._cesium.PolygonHierarchy(that._cesium.Cartesian3.fromDegreesArray(newArr));
                                var geometryInstance = that._core.createPolygon(Style, classificationType, feature, that._cesium);
                                geometries_gon.push(geometryInstance);
                            }
                        } else {
                            newArr = that._core.coordinate(newArr, feature.geometry.coordinates);
                            Style.polygonHierarchy = new that._cesium.PolygonHierarchy(that._cesium.Cartesian3.fromDegreesArray(newArr));
                            var geometryInstance = that._core.createPolygon(Style, classificationType, feature, that._cesium);
                            geometries_gon.push(geometryInstance);
                        }
                    }
                }

            });
            //label
            primitiveCollection.add(labelCollections);
            //billboard
            primitiveCollection.add(billboardCollections);
            //point
            primitiveCollection.add(pointCollections);
            //polyline
            if (geometries_line.length > 0) {
                if (classificationType != -1) {
                    primitiveCollection.add(new that._cesium.GroundPolylinePrimitive({
                        geometryInstances: geometries_line,
                        classificationType: classificationType,
                        appearance: new that._cesium.PolylineMaterialAppearance()
                    }));
                } else {
                    primitiveCollection.add(new that._cesium.Primitive({
                        geometryInstances: geometries_line,
                        appearance: new that._cesium.PolylineMaterialAppearance()
                    }));
                }
            }
            //polygon
            if (geometries_gon.length > 0) {
                if (classificationType != -1) {
                    primitiveCollection.add(new that._cesium.GroundPrimitive({
                        geometryInstances: geometries_gon,
                        classificationType: classificationType,
                        appearance: new that._cesium.PerInstanceColorAppearance({
                            translucent: true,
                            vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                            fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                        })
                    }));
                } else {
                    primitiveCollection.add(new that._cesium.Primitive({
                        geometryInstances: geometries_gon,
                        appearance: new that._cesium.PerInstanceColorAppearance({
                            translucent: true,
                            vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                            fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                        })
                    }));
                }
            }
            return primitiveCollection;
        };
        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            //type: 'pointLayer',
            type: 'Vector',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        if (typeof disFnc == 'function')
            disFnc(this.item);
        return this;
    };

    /**
    * 矢量切片加载（全面加载优化）优化版
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    * 张恒 2020/04/27
    */
    VectorGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayerJCDthOptimizationxp = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    //var levelError = that.getLevelMaximumGeometricError(tile.level);
                    // if (tile.level < 16) {
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }
                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                if (data == undefined) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    return;
                                }
                                var geometries = [];
                                //图例
                                that.Legend = [];
                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                        }
                                    }
                                }
                                function createobj() {
                                    if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                        var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                    }
                                    //options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                    options.material = that._option.material;
                                    if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                        var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                        options.material = feature.properties[material];

                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.material)) {
                                            options.material = that._color.colorFromHtmlColor(options.material);
                                        } else {
                                            if (/^rgb/.test(options.material)) {
                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                            }
                                            if (options.material.red > 1) {
                                                options.material.red = options.material.red / 255;
                                            }
                                            if (options.material.green > 1) {
                                                options.material.green = options.material.green / 255;
                                            }
                                            if (options.material.blue > 1) {
                                                options.material.blue = options.material.blue / 255;
                                            }
                                            if (options.material.alpha > 1) {
                                                options.material.a = options.material.alpha / 255;
                                            }
                                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                        }
                                    } else {
                                        if (that._option.material) {
                                            options.material = that._option.material;
                                        }
                                        if (options.material) {
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }

                                        }
                                    }
                                    if (newArr.length >= 2) {
                                        var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                        options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                        //基础面
                                        var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                        //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                        var geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: extrudedPolygon,
                                            attributes: {
                                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                            }
                                        });
                                        //图例
                                        var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                        that.Legend.push(col);
                                        geometries.push(geometryInstance);
                                    }
                                    //geometries.push(geometryInstance1);
                                }
                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    var feature = data.features[i];

                                    //fun(data.features[i].geometry.coordinates[0]);
                                    //解析坐标
                                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                newArr = [];
                                                feature.geometry.coordinates[j].pop();
                                                fun(feature.geometry.coordinates[j]);
                                                createobj();
                                            }
                                        } else {
                                            fun(feature.geometry.coordinates);
                                            createobj();
                                        }
                                    }
                                }

                                /**
                                 * 请求到的数据为空
                                 */
                                if (geometries.length == 0) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                }

                                var Primitive = new that._cesium.Primitive({
                                    geometryInstances: geometries,
                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                        translucent: false,
                                        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                    }),
                                    shadows: that._option.shadows
                                });

                                tile.data.geometryPrimitive = Primitive;

                                // tile.data.geometryPrimitive = new Cesium.Primitive({
                                //     geometryInstances: geometries,
                                //     appearance: new Cesium.MaterialAppearance({
                                //         material: new Cesium.Material({
                                //             fabric: {
                                //                 type: 'Color',
                                //                 uniforms: {
                                //                     color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                //                 }
                                //             }
                                //         }),
                                //         faceForward: true,
                                //         flat: false
                                //     }),
                                //     shadows: Cesium.ShadowMode.ENABLED
                                // });

                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    tile.data.geometryPrimitive.update(frameState, []);
                                    //if (tile.data.geometryPrimitive._ready) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            },
                            error: function () {
                                if (tile.count == undefined) {
                                    tile.count = 0;
                                }
                                tile.count += 1;
                                if (tile.count >= 2) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    // return;
                                }
                                else {
                                    tile.state = Cesium.QuadtreeTileLoadState.START;
                                }
                            }
                        });
                        // Create random lines at the root level.

                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    /**
    * 矢量切片加载（全面加载优化）优化版
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    */
    VectorGeoJsonFeatureLayer.prototype.VolumeVectorGeoJsonFeatureLayerOptimization1ss = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = null;
            this.tile = tile;
            //解决内存溢出
            if (tile.state === this._cesium.QuadtreeTileLoadState.START && that.item.show) {
                var key = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new that._cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new that._cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });

                        tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                //tile.data.geometryPrimitive.update();
                                //if (tile.data.geometryPrimitive._ready) {
                                tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }
                    if (that.PrimitiveData.length > 0) {
                        for (var i = 0; i < that.PrimitiveData.length; i++) {
                            if (that.PrimitiveData[i].key == key) {
                                if (!that.Primitivekey.includes(key)) {
                                    that.Primitivekey.push(key);
                                }
                                return;
                            }
                        }
                    }
                    if (!that.Primitivekey.includes(key)) {
                        that.Primitivekey.push(key);
                        downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                        var jbli = that._option.level_min + (that._option.level_max - that._option.level_min) / 2;
                        var tileList = _getLoadLevelTile(tile, jbli);

                        for (var i = 0; i < tileList.length; i++) {
                            var levelTile = tileList[i];
                            var loadLevelKey = 'z' + levelTile.level + 'x' + levelTile.x + 'y' + levelTile.y;
                            if (!that.loadAllKey.includes(loadLevelKey)) {
                                that.loadAllKey.push(loadLevelKey);
                                /**
                                 * 请求区块数据
                                 */
                                (function (tile) {

                                    // Create random lines at the root level.
                                    var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                                    that.tilesLength++;

                                    if (that._cache) {
                                        tileUrl += '&' + that._core.getuid();
                                    }

                                    var downLoadKey = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                                    // $.ajax({
                                    that._core.xhr({
                                        url: tileUrl,
                                        type: "get",
                                        dataType: "json",
                                        success: function (data) {
                                            var geometries = [];
                                            //图例
                                            that.Legend = [];
                                            function fun(arr) {
                                                for (var i = 0; i < arr.length; i++) {
                                                    if (Array.isArray(arr[i])) {
                                                        fun(arr[i]);
                                                    } else {
                                                        newArr.push(arr[i]);
                                                    }
                                                }
                                            }
                                            function createobj() {
                                                if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                                    var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                                    options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                                }
                                                //options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                                options.material = that._option.material;
                                                if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                                    var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                                    options.material = feature.properties[material];

                                                    //填充颜色设置
                                                    if (that._core.isHtmlColor(options.material)) {
                                                        options.material = that._color.colorFromHtmlColor(options.material);
                                                    } else {
                                                        if (/^rgb/.test(options.material)) {
                                                            options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                        }
                                                        if (options.material.red > 1) {
                                                            options.material.red = options.material.red / 255;
                                                        }
                                                        if (options.material.green > 1) {
                                                            options.material.green = options.material.green / 255;
                                                        }
                                                        if (options.material.blue > 1) {
                                                            options.material.blue = options.material.blue / 255;
                                                        }
                                                        if (options.material.alpha > 1) {
                                                            options.material.a = options.material.alpha / 255;
                                                        }
                                                        options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                                    }
                                                } else {
                                                    if (that._option.material) {
                                                        options.material = that._option.material;
                                                    }
                                                    if (options.material) {
                                                        if (that._core.isHtmlColor(options.material)) {
                                                            options.material = that._color.colorFromHtmlColor(options.material);
                                                        } else {
                                                            if (/^rgb/.test(options.material)) {
                                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                            }
                                                            if (options.material.red > 1) {
                                                                options.material.red = options.material.red / 255;
                                                            }
                                                            if (options.material.green > 1) {
                                                                options.material.green = options.material.green / 255;
                                                            }
                                                            if (options.material.blue > 1) {
                                                                options.material.blue = options.material.blue / 255;
                                                            }
                                                            if (options.material.alpha > 1) {
                                                                options.material.a = options.material.alpha / 255;
                                                            }
                                                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                                        }

                                                    }
                                                }
                                                if (newArr.length >= 2) {
                                                    var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                                    options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                                    //基础面
                                                    var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                                    //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                                    var geometryInstance = new that._cesium.GeometryInstance({
                                                        id: feature,
                                                        geometry: extrudedPolygon,
                                                        attributes: {
                                                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                                        }
                                                    });
                                                    //图例
                                                    var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                                    that.Legend.push(col);
                                                    geometries.push(geometryInstance);
                                                }
                                                //geometries.push(geometryInstance1);
                                            }
                                            for (var i = 0; i < data.features.length; i++) {
                                                var newArr = [];
                                                var feature = data.features[i];

                                                //fun(data.features[i].geometry.coordinates[0]);
                                                //解析坐标
                                                if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                                    if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                                        for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                            newArr = [];
                                                            feature.geometry.coordinates[j].pop();
                                                            fun(feature.geometry.coordinates[j]);
                                                            createobj();
                                                        }
                                                    } else {
                                                        fun(feature.geometry.coordinates);
                                                        createobj();
                                                    }
                                                }
                                            }
                                            if (geometries.length > 0) {
                                                var Primitive = new that._cesium.Primitive({
                                                    geometryInstances: geometries,
                                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                                        translucent: false,
                                                        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                                        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                                    }),
                                                    shadows: that._option.shadows
                                                });
                                                var Obj = {
                                                    level: tile.level,
                                                    key: downLoadKey,
                                                    data: Primitive
                                                };
                                                that.probj.push(Primitive);
                                                that.loadFinishKey.push(downLoadKey);
                                                that.PrimitiveData.push(Obj);
                                                that._viewer.scene.primitives.add(Primitive);
                                                that.returnCount++;
                                            }
                                        },
                                        error: function () {
                                        },
                                        complete: function (XHR, TS) {
                                        }
                                    });
                                })(levelTile);

                            }
                        }
                    }
                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            //tile.data.geometryPrimitive.update(frameState);
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                    }
                    return;
                }
            }
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
    };

    /**
    * 矢量切片加载（全面加载优化）优化版
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    */
    VectorGeoJsonFeatureLayer.prototype.VolumeVectorGeoJsonFeatureLayerGis = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        ({
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        });

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var downLoadUrls = [];
        var options = {
            id: geoOptions.id,
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        //this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        this._urlTemplate = geoOptions.url + '/' + window.encodeURIComponent('{z}') + '/' + window.encodeURIComponent('{x}') + '/' + window.encodeURIComponent('{reverseY}') + '.json';
        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = null;
            this.tile = tile;
            //解决内存溢出
            if (tile.state === this._cesium.QuadtreeTileLoadState.START && that.item.show) {
                var key = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new that._cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new that._cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });

                        tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                //tile.data.geometryPrimitive.update();
                                //if (tile.data.geometryPrimitive._ready) {
                                tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }
                    if (that.PrimitiveData.length > 0) {
                        for (var i = 0; i < that.PrimitiveData.length; i++) {
                            if (that.PrimitiveData[i].key == key) {
                                if (!that.Primitivekey.includes(key)) {
                                    that.Primitivekey.push(key);
                                }
                                return;
                            }
                        }
                    }
                    if (!that.Primitivekey.includes(key)) {
                        that.Primitivekey.push(key);
                        downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                        /**
                         * 请求区块数据
                         */
                        (function (tile) {

                            // Create random lines at the root level.
                            var ys = tile.tilingScheme.getNumberOfYTilesAtLevel(tile.level) - tile.y - 1;
                            var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{reverseY}'), ys).replace(window.encodeURIComponent('{z}'), tile.level);
                            that.tilesLength++;
                            var downLoadKey = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;

                            if (that._cache) {
                                tileUrl += '&' + that._core.getuid();
                            }
                            var urls = lodash.filter(downLoadUrls, function (o) {
                                return o.url == tileUrl
                            });
                            if (urls.length > 0) {
                                return;
                            }
                            downLoadUrls.push({ url: tileUrl });
                            // $.ajax({
                            that._core.xhr({
                                url: tileUrl,
                                type: "get",
                                dataType: "json",
                                success: function (data) {
                                    var geometries = [];
                                    //图例
                                    that.Legend = [];
                                    function fun(arr) {
                                        for (var i = 0; i < arr.length; i++) {
                                            if (Array.isArray(arr[i])) {
                                                fun(arr[i]);
                                            } else {
                                                newArr.push(arr[i]);
                                            }
                                        }
                                    }
                                    function createobj() {
                                        options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                        if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                            var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                            options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]) * 3;
                                        }
                                        //options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                        options.material = that._option.material;
                                        if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                            var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                            options.material = feature.properties[material];

                                            //填充颜色设置
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }
                                        } else {
                                            if (that._option.material) {
                                                options.material = that._option.material;
                                            }
                                            if (options.material) {
                                                if (that._core.isHtmlColor(options.material)) {
                                                    options.material = that._color.colorFromHtmlColor(options.material);
                                                } else {
                                                    if (/^rgb/.test(options.material)) {
                                                        options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                    }
                                                    if (options.material.red > 1) {
                                                        options.material.red = options.material.red / 255;
                                                    }
                                                    if (options.material.green > 1) {
                                                        options.material.green = options.material.green / 255;
                                                    }
                                                    if (options.material.blue > 1) {
                                                        options.material.blue = options.material.blue / 255;
                                                    }
                                                    if (options.material.alpha > 1) {
                                                        options.material.a = options.material.alpha / 255;
                                                    }
                                                    options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                                }

                                            }
                                        }
                                        var color = that._cesium.Color.WHITE;
                                        if (newArr.length >= 2) {
                                            var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                            options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                            //基础面
                                            var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                            //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                            var geometryInstance = new that._cesium.GeometryInstance({
                                                id: feature,
                                                geometry: extrudedPolygon,
                                                attributes: {
                                                    color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(color),
                                                    //color: color,
                                                }
                                            });
                                            //图例
                                            var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                            that.Legend.push(col);
                                            geometries.push(geometryInstance);
                                        }
                                        //geometries.push(geometryInstance1);
                                    }
                                    for (var i = 0; i < data.features.length; i++) {
                                        var newArr = [];
                                        var feature = data.features[i];

                                        //fun(data.features[i].geometry.coordinates[0]);
                                        //解析坐标
                                        if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                            if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                                for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                    newArr = [];
                                                    feature.geometry.coordinates[j].pop();
                                                    fun(feature.geometry.coordinates[j]);
                                                    createobj();
                                                }
                                            } else {
                                                fun(feature.geometry.coordinates);
                                                createobj();
                                            }
                                        }
                                    }
                                    var Primitive = new that._cesium.Primitive({
                                        geometryInstances: geometries,
                                        //appearance: new that._cesium.EllipsoidSurfaceAppearance({
                                        //    material: that._cesium.Material.fromType('Checkerboard')
                                        //})
                                        appearance: new that._cesium.PerInstanceColorAppearance({
                                            translucent: false,
                                            vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                            fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                        }),
                                        shadows: that._option.shadows
                                    });
                                    that.probj.push(Primitive);
                                    var Obj = {
                                        level: tile.level,
                                        key: downLoadKey,
                                        data: Primitive
                                    };
                                    that.loadFinishKey.push(downLoadKey);
                                    that.PrimitiveData.push(Obj);
                                    that._viewer.scene.primitives.add(Primitive);
                                    that.returnCount++;
                                    /*      var index = that.Primitivekey.indexOf(downLoadKey);
                                         if (index > -1) {
                                         {
                                             that.Primitivekey.splice(index, 1);
                                         } */


                                    //that.removeObsoletePrimitives(tile);

                                    try {
                                        if (that.probj.length == 2) {
                                            that._viewer.scene.primitives.remove(that.probj[0]);
                                            that.probj.pop();
                                        }
                                    } catch (ex) { }
                                    //if (that.returnCount >= that.tilesLength) {
                                    //    that.returnCount = 0;
                                    //    that.tilesLength = 0;

                                    //that.Primitivekey = [];
                                    //}
                                    //});
                                },
                                error: function () {
                                    var index = that.Primitivekey.indexOf(downLoadKey);
                                    if (index > -1) {
                                        that.Primitivekey.splice(index, 1);
                                    }

                                    downLoadTiles = lodash.remove(downLoadTiles, function (o) {
                                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                                    });
                                },
                                complete: function (XHR, TS) {
                                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                                        if (tile.data.geometryPrimitive)
                                            //tile.data.geometryPrimitive.update(frameState);
                                            //if (tile.data.geometryPrimitive._ready) {
                                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                                        tile.renderable = true;
                                        //}
                                    }
                                }
                            });
                        })(tile);
                    }
                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            //tile.data.geometryPrimitive.update(frameState);
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                    }
                    return;
                }
            }
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    /**
    * 矢量切片（点）加载（全面加载优化）优化版
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    */
    VectorGeoJsonFeatureLayer.prototype.PointVectorGeoJsonFeatureLayerGis = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadUrls = [];
        var options = {
            id: geoOptions.id,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            arcType: this._cesium.ArcType.GEODESIC,
        };
        var that = this;
        // 矢量切片服务 URL 模板
        //this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        //this._urlTemplate = geoOptions.url + '/' + window.encodeURIComponent('{z}') + '/' + window.encodeURIComponent('{x}') + '/' + window.encodeURIComponent('{y}') + '.json';
        this._urlTemplate = geoOptions.url + '/{z}/{x}/{reverseY}.json';
        this._Provider = {};//new VectorTileProvider(this._viewer, this._cesium);
        this._Provider1 = new GeoJSONVectorTileProvider1(this._viewer, this._cesium, { url: this._urlTemplate }, function (obj) {
            that.Level = that.getLevel();
            if (that.Level < that._option.level_min) {
                if (that.primitve.length > 0) {
                    for (var i = 0; i < that.primitve.length; i++) {
                        that._viewer.scene.primitives.remove(that.primitve[i]);
                    }
                    that.primitve = [];
                }
                if (that.probj.length > 0) {
                    for (var i = 0; i < that.probj.length; i++) {
                        that._viewer.scene.primitives.remove(that.probj[i]);
                    }
                    that.probj = [];
                }
                downLoadUrls = [];
                return;
            }
            var primitiveCollection = new that._cesium.PrimitiveCollection();
            //创建对象集合
            var pointCollections = new that._cesium.PointPrimitiveCollection();
            var labelCollections = new that._cesium.LabelCollection();
            var billboardCollections = new that._cesium.BillboardCollection();

            'z' + obj.templateValues.z + 'x' + obj.templateValues.x + 'y' + obj.templateValues.reverseY;
            obj.data = {
                lines: [],
                geometryPrimitive: undefined
            };
            var tileUrl = obj.url.replace("png", "json");
            var urls = lodash.filter(downLoadUrls, function (o) {
                return o.url == tileUrl
            });
            if (urls.length > 0) {
                return;
            }
            //控制刷新
            if (that.start == 1) {
                return;
            }
            downLoadUrls.push({ url: tileUrl });
            // $.ajax({
            that._core.xhr({
                url: tileUrl,
                type: "get",
                dataType: "json",
                success: function (data) {
                    if (data.features.length == 0) {
                        return;
                    }
                    //图例
                    that.Legend = [];
                    function fun(arr) {
                        for (var i = 0; i < arr.length; i++) {
                            if (Array.isArray(arr[i])) {
                                fun(arr[i]);
                            } else {
                                newArr.push(arr[i]);
                            }
                        }
                    }
                    function createobj() {
                        //添加lable
                        if (styleOption.lable != undefined) {
                            var sheight = 0;
                            if (styleOption.lable.height != undefined && /^\[/.test(styleOption.lable.height) && /\]$/.test(styleOption.lable.height)) {
                                var heightStr = styleOption.lable.height.replace(/\[/, '').replace(/\]/, '');
                                sheight = parseFloat(feature.properties[heightStr]);
                            }                        var LabelStyle = that._core.StyleContrast("lable", styleOption.lable, that._cesium);
                            //颜色转化
                            LabelStyle.fillColor = that._color.VectorColorTransformation(LabelStyle.fillColor, feature);
                            LabelStyle.outlineColor = that._color.VectorColorTransformation(LabelStyle.outlineColor, feature);
                            LabelStyle.backgroundColor = that._color.VectorColorTransformation(LabelStyle.backgroundColor, feature);
                            LabelStyle.text = that._core.Analysis(LabelStyle.text, feature);
                            LabelStyle.position = new that._cesium.Cartesian3.fromDegrees(newArr[0], newArr[1], sheight);
                            labelCollections.add(LabelStyle);
                        }
                        //添加billboard
                        if (styleOption.billboard != undefined) {
                            var sheight = 0;
                            var entity = styleOption.billboard;
                            if (entity.height != undefined && /^\[/.test(entity.height) && /\]$/.test(entity.height)) {
                                var heightStr = entity.height.replace(/\[/, '').replace(/\]/, '');
                                sheight = parseFloat(feature.properties[heightStr]);
                            }                        var Style = that._core.StyleContrast("billboard", entity, that._cesium);
                            Style.position = new that._cesium.Cartesian3.fromDegrees(newArr[0], newArr[1], sheight);
                            //Style.color = that._color.VectorColorTransformation(Style.color, feature);
                            //Style.text = that._core.Analysis(Style.text, entity);
                            billboardCollections.add(Style);
                        }
                        //添加point
                        if (styleOption.point != undefined) {
                            var sheight = 0;
                            var entity = styleOption.point;
                            if (entity.height != undefined && /^\[/.test(entity.height) && /\]$/.test(entity.height)) {
                                var heightStr = entity.height.replace(/\[/, '').replace(/\]/, '');
                                sheight = parseFloat(feature.properties[heightStr]);
                            }                        var Style = that._core.StyleContrast("point", entity, that._cesium);
                            Style.position = new that._cesium.Cartesian3.fromDegrees(newArr[0], newArr[1], sheight);
                            Style.color = that._color.VectorColorTransformation(Style.color, feature);
                            Style.outlineColor = that._color.VectorColorTransformation(Style.outlineColor, feature);
                            pointCollections.add(Style);
                        }
                    }
                    for (var i = 0; i < data.features.length; i++) {
                        var newArr = [];
                        var feature = data.features[i];
                        //解析坐标
                        if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                            if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                    newArr = [];
                                    feature.geometry.coordinates[j].pop();
                                    fun(feature.geometry.coordinates[j]);
                                    createobj();
                                }
                            } else {
                                fun(feature.geometry.coordinates);
                                createobj();
                            }
                        }
                    }
                    //label
                    labelCollections.length > 0 && primitiveCollection.add(labelCollections);
                    //billboard
                    billboardCollections.length > 0 && primitiveCollection.add(billboardCollections);
                    //point
                    pointCollections.length > 0 && primitiveCollection.add(pointCollections);
                    that.primitve.push(primitiveCollection);
                    that.probj.push(primitiveCollection);
                    that._viewer.scene.primitives.add(primitiveCollection);
                    that.returnCount++;
                    try {
                        if (that.probj.length == 2) {
                            that._viewer.scene.primitives.remove(that.probj[0]);
                            that.probj.pop();
                        }
                    } catch (ex) { }
                }
            });

        });
        this.img = this._Provider1.ent;
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    /**
    * 矢量切片（线）加载（全面加载优化）优化版
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    */
    VectorGeoJsonFeatureLayer.prototype.PolylineVectorGeoJsonFeatureLayerGis = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadUrls = [];
        var options = {
            id: geoOptions.id,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            arcType: this._cesium.ArcType.GEODESIC,
        };
        var that = this;
        // 矢量切片服务 URL 模板
        //this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        //this._urlTemplate = geoOptions.url + '/' + window.encodeURIComponent('{z}') + '/' + window.encodeURIComponent('{x}') + '/' + window.encodeURIComponent('{y}') + '.json';
        this._urlTemplate = geoOptions.url + '/{z}/{x}/{reverseY}.json';
        this._Provider = {};//new VectorTileProvider(this._viewer, this._cesium);
        this._Provider1 = new GeoJSONVectorTileProvider1(this._viewer, this._cesium, { url: this._urlTemplate }, function (obj) {
            that.Level = that.getLevel();
            if (that.Level < that._option.level_min) {
                if (that.primitve.length > 0) {
                    for (var i = 0; i < that.primitve.length; i++) {
                        that._viewer.scene.primitives.remove(that.primitve[i]);
                    }
                    that.primitve = [];
                }
                if (that.probj.length > 0) {
                    for (var i = 0; i < that.probj.length; i++) {
                        that._viewer.scene.primitives.remove(that.probj[i]);
                    }
                    that.probj = [];
                }
                downLoadUrls = [];
                return;
            }
            //是否贴地
            var classificationType = -1;

            'z' + obj.templateValues.z + 'x' + obj.templateValues.x + 'y' + obj.templateValues.reverseY;
            obj.data = {
                lines: [],
                geometryPrimitive: undefined
            };
            var tileUrl = obj.url.replace("png", "json");
            var urls = lodash.filter(downLoadUrls, function (o) {
                return o.url == tileUrl
            });
            if (urls.length > 0) {
                return;
            }
            //控制刷新
            if (that.start == 1) {
                return;
            }
            downLoadUrls.push({ url: tileUrl });
            // $.ajax({
            that._core.xhr({
                url: tileUrl,
                type: "get",
                dataType: "json",
                success: function (data) {
                    if (data.features.length == 0) {
                        return;
                    }
                    var geometries = [];
                    //图例
                    that.Legend = [];
                    function fun(arr) {
                        for (var i = 0; i < arr.length; i++) {
                            if (Array.isArray(arr[i])) {
                                fun(arr[i]);
                            } else {
                                newArr.push(arr[i]);
                            }
                        }
                    }
                    function createobj() {
                        var entity = styleOption;
                        if (entity.height != undefined && /^\[/.test(entity.height) && /\]$/.test(entity.height)) {
                            var heightStr = entity.height.replace(/\[/, '').replace(/\]/, '');
                            parseFloat(feature.properties[heightStr]);
                        }                    var Style = that._core.StyleContrast("polyline", entity, that._cesium);
                        classificationType = Style.classificationType;
                        delete Style.classificationType;
                        Style.material = that._option.material;
                        if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                            var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                            Style.material = feature.properties[material];

                            //填充颜色设置
                            if (that._core.isHtmlColor(Style.material)) {
                                Style.material = that._color.colorFromHtmlColor(Style.material);
                            } else {
                                if (/^rgb/.test(Style.material)) {
                                    Style.material = that._color.rgbaStringToRgbaObj(Style.material);
                                }
                                if (Style.material.red > 1) {
                                    Style.material.red = Style.material.red / 255;
                                }
                                if (Style.material.green > 1) {
                                    Style.material.green = Style.material.green / 255;
                                }
                                if (Style.material.blue > 1) {
                                    Style.material.blue = Style.material.blue / 255;
                                }
                                if (Style.material.alpha > 1) {
                                    Style.material.a = Style.material.alpha / 255;
                                }
                                Style.material = that._color.createColor(Style.material.red, Style.material.green, Style.material.blue, Style.material.alpha);
                            }
                        } else {
                            if (that._option.material) {
                                Style.material = that._option.material;
                            }
                            if (Style.material) {
                                if (that._core.isHtmlColor(Style.material)) {
                                    Style.material = that._color.colorFromHtmlColor(Style.material);
                                } else {
                                    if (/^rgb/.test(Style.material)) {
                                        Style.material = that._color.rgbaStringToRgbaObj(Style.material);
                                    }
                                    if (Style.material.red > 1) {
                                        Style.material.red = Style.material.red / 255;
                                    }
                                    if (Style.material.green > 1) {
                                        Style.material.green = Style.material.green / 255;
                                    }
                                    if (Style.material.blue > 1) {
                                        Style.material.blue = Style.material.blue / 255;
                                    }
                                    if (Style.material.alpha > 1) {
                                        Style.material.a = Style.material.alpha / 255;
                                    }
                                    Style.material = that._color.createColor(Style.material.red, Style.material.green, Style.material.blue, Style.material.alpha);
                                }
                            }
                        }
                        //线
                        if (newArr.length >= 2) {
                            Style.positions = that._cesium.Cartesian3.fromDegreesArray(newArr);
                            var geometryInstance = new that._cesium.GeometryInstance({
                                id: feature, //拾取属性修改
                                geometry: new that._cesium.PolylineGeometry(Style),
                                attributes: {
                                    color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(Style.material)
                                }
                            });
                            //图例
                            var col = "material:" + Style.material.red * 255 + "," + Style.material.green * 255 + "," + Style.material.blue * 255;
                            that.Legend.push(col);
                            geometries.push(geometryInstance);
                        }
                    }
                    for (var i = 0; i < data.features.length; i++) {
                        var newArr = [];
                        var feature = data.features[i];
                        //解析坐标
                        if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                            if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                    newArr = [];
                                    feature.geometry.coordinates[j].pop();
                                    fun(feature.geometry.coordinates[j]);
                                    createobj();
                                }
                            } else {
                                fun(feature.geometry.coordinates);
                                createobj();
                            }
                        }
                    }
                    var Primitive = new that._cesium.Primitive({
                        geometryInstances: geometries,
                        appearance: new that._cesium.PolylineColorAppearance({
                            flat: true,
                            translucent: true,
                            faceForward: true,
                            closed: true
                        }),
                        shadows: that._option.shadows,
                        classificationType: classificationType
                    });
                    that.probj.push(Primitive);
                    that.primitve.push(Primitive);
                    that._viewer.scene.primitives.add(Primitive);
                    that.returnCount++;
                    try {
                        if (that.probj.length == 2) {
                            that._viewer.scene.primitives.remove(that.probj[0]);
                            that.probj.pop();
                        }
                    } catch (ex) { }
                }
            });

        });
        this.img = this._Provider1.ent;
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    /**
    * 矢量切片加载（全面加载优化）优化版gisserver//xp修改
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    */
    VectorGeoJsonFeatureLayer.prototype.VolumeVectorGeoJsonFeatureLayerGisOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        ({
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        });
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadUrls = [];
        var options = {
            id: geoOptions.id,
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        //this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        //this._urlTemplate = geoOptions.url + '/' + window.encodeURIComponent('{z}') + '/' + window.encodeURIComponent('{x}') + '/' + window.encodeURIComponent('{y}') + '.json';
        this._urlTemplate = geoOptions.url + '/{z}/{x}/{reverseY}.json';
        this._Provider = {};//new VectorTileProvider(this._viewer, this._cesium);
        this._Provider1 = new GeoJSONVectorTileProvider1(this._viewer, this._cesium, { url: this._urlTemplate }, function (obj) {
            that.Level = that.getLevel();
            if (that.Level < that._option.level_min) {
                if (that.primitve.length > 0) {
                    for (var i = 0; i < that.primitve.length; i++) {
                        that._viewer.scene.primitives.remove(that.primitve[i]);
                    }
                    that.primitve = [];
                }
                if (that.probj.length > 0) {
                    for (var i = 0; i < that.probj.length; i++) {
                        that._viewer.scene.primitives.remove(that.probj[i]);
                    }
                    that.probj = [];
                }
                downLoadUrls = [];
                return;
            }
            'z' + obj.templateValues.z + 'x' + obj.templateValues.x + 'y' + obj.templateValues.reverseY;
            obj.data = {
                lines: [],
                geometryPrimitive: undefined
            };
            var tileUrl = obj.url.replace("png", "json");
            var urls = lodash.filter(downLoadUrls, function (o) {
                return o.url == tileUrl
            });
            if (urls.length > 0) {
                return;
            }
            //控制刷新
            if (that.start == 1) {
                return;
            }

            downLoadUrls.push({ url: tileUrl });

            // $.ajax({
            that._core.xhr({
                url: tileUrl,
                type: "get",
                dataType: "json",
                success: function (data) {
                    if (data.features.length == 0) {
                        return;
                    }
                    var geometries = [];
                    //图例
                    that.Legend = [];
                    function fun(arr) {
                        for (var i = 0; i < arr.length; i++) {
                            if (Array.isArray(arr[i])) {
                                fun(arr[i]);
                            } else {
                                newArr.push(arr[i]);
                            }
                        }
                    }
                    function createobj() {
                        options.extrudedHeight = that._option.extrudedHeight;
                        if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                            var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                            options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]) * 3;
                        }
                        //options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                        options.material = that._option.material;
                        if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                            var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                            options.material = feature.properties[material];

                            //填充颜色设置
                            if (that._core.isHtmlColor(options.material)) {
                                options.material = that._color.colorFromHtmlColor(options.material);
                            } else {
                                if (/^rgb/.test(options.material)) {
                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                }
                                if (options.material.red > 1) {
                                    options.material.red = options.material.red / 255;
                                }
                                if (options.material.green > 1) {
                                    options.material.green = options.material.green / 255;
                                }
                                if (options.material.blue > 1) {
                                    options.material.blue = options.material.blue / 255;
                                }
                                if (options.material.alpha > 1) {
                                    options.material.a = options.material.alpha / 255;
                                }
                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                            }
                        } else {
                            if (that._option.material) {
                                options.material = that._option.material;
                            }
                            if (options.material) {
                                if (that._core.isHtmlColor(options.material)) {
                                    options.material = that._color.colorFromHtmlColor(options.material);
                                } else {
                                    if (/^rgb/.test(options.material)) {
                                        options.material = that._color.rgbaStringToRgbaObj(options.material);
                                    }
                                    if (options.material.red > 1) {
                                        options.material.red = options.material.red / 255;
                                    }
                                    if (options.material.green > 1) {
                                        options.material.green = options.material.green / 255;
                                    }
                                    if (options.material.blue > 1) {
                                        options.material.blue = options.material.blue / 255;
                                    }
                                    if (options.material.alpha > 1) {
                                        options.material.a = options.material.alpha / 255;
                                    }
                                    options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                }
                            }
                        }
                        if (newArr.length >= 2) {
                            var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                            options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                            //基础面
                            //debugger
                            var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                            //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                            var geometryInstance = new that._cesium.GeometryInstance({
                                id: feature,
                                geometry: extrudedPolygon,
                                attributes: {
                                    color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                }
                            });
                            //图例
                            "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                            //that.Legend.push(col);
                            geometries.push(geometryInstance);
                        }
                        //geometries.push(geometryInstance1);
                    }
                    for (var i = 0; i < data.features.length; i++) {
                        var newArr = [];
                        var feature = data.features[i];
                        //解析坐标
                        if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                            if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                    newArr = [];
                                    feature.geometry.coordinates[j].pop();
                                    fun(feature.geometry.coordinates[j]);
                                    createobj();
                                }
                            } else {
                                fun(feature.geometry.coordinates);
                                createobj();
                            }
                        }
                    }
                    var Primitive = new that._cesium.Primitive({
                        geometryInstances: geometries,
                        appearance: new that._cesium.PerInstanceColorAppearance({
                            translucent: false,
                            vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                            fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                        }),
                        shadows: that._option.shadows
                    });
                    //测试
                    //that._viewer.scene.primitives.remove(that.entity);
                    //that.entity = Primitive;
                    that.primitve.push(Primitive);
                    that.probj.push(Primitive);
                    that._viewer.scene.primitives.add(Primitive);
                    that.returnCount++;
                    try {
                        if (that.probj.length == 2) {
                            that._viewer.scene.primitives.remove(that.probj[0]);
                            that.probj.pop();
                        }
                    } catch (ex) { }
                }
            });

        });
        this.img = this._Provider1.ent;
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    /**
    * 矢量切片加载（全面加载优化）优化版(贴地)
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    */
    VectorGeoJsonFeatureLayer.prototype.VolumeVectorGeoJsonFeatureLayerClassOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 999999,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            //perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.WHITE,
            shadows: this._cesium.ShadowMode.ENABLED,
            show: true
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = null;
            this.tile = tile;
            //解决内存溢出
            if (tile.state === this._cesium.QuadtreeTileLoadState.START && that.item.show) {
                var key = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new that._cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new that._cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });

                        tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                //tile.data.geometryPrimitive.update();
                                //if (tile.data.geometryPrimitive._ready) {
                                tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }
                    if (that.PrimitiveData.length > 0) {
                        for (var i = 0; i < that.PrimitiveData.length; i++) {
                            if (that.PrimitiveData[i].key == key) {
                                that.Primitivekey.push(key);
                                return;
                            }
                        }
                    }
                    if (!that.Primitivekey.includes(key)) {
                        that.Primitivekey.push(key);
                        downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                        /**
                         * 请求区块数据
                         */
                        (function (tile) {

                            // Create random lines at the root level.
                            var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                            that.tilesLength++;

                            if (that._cache) {
                                tileUrl += '&' + that._core.getuid();
                            }
                            // $.ajax({
                            that._core.xhr({
                                url: tileUrl,
                                type: "get",
                                dataType: "json",
                                success: function (data) {
                                    var geometries = [];
                                    //图例
                                    that.Legend = [];
                                    function fun(arr) {
                                        for (var i = 0; i < arr.length; i++) {
                                            if (Array.isArray(arr[i])) {
                                                fun(arr[i]);
                                            } else {
                                                newArr.push(arr[i]);
                                                if (i === 2 && !haveZ) {
                                                    haveZ = true;
                                                }
                                            }
                                        }
                                    }
                                    function createobj() {
                                        var pos = haveZ ?
                                            that._cesium.Cartesian3.fromDegreesArrayHeights(newArr) :
                                            that._cesium.Cartesian3.fromDegreesArray(newArr)
                                            ;
                                        if (/^\[/.test(styleOption.extrudedHeight) && /\]$/.test(styleOption.extrudedHeight)) {
                                            var extrudedHeight = styleOption.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                            options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                        }
                                        options.extrudedHeight = parseFloat(options.extrudedHeight);
                                        if (options.heightReference == 1) {
                                            delete options.height;
                                        }
                                        if (options.extrudedHeightReference == 1) {
                                            delete options.extrudedHeight;
                                        }
                                        if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                                            var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                                            options.material = feature.properties[material];
                                            //填充颜色设置
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.r > 1) {
                                                    options.material.r = options.material.r / 255;
                                                }
                                                if (options.material.g > 1) {
                                                    options.material.g = options.material.g / 255;
                                                }
                                                if (options.material.b > 1) {
                                                    options.material.b = options.material.b / 255;
                                                }
                                                if (options.material.a > 1) {
                                                    options.material.a = options.material.a / 255;
                                                }
                                                options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                                            }
                                        }
                                        options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                        //基础面
                                        var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                        //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);

                                        //样式属性
                                        feature.treeID = options.id;
                                        feature.VectorType = 'polygon';
                                        feature.VectorStyle = {
                                            haveZ: haveZ,
                                            extrudedHeight: options.extrudedHeight,
                                            positions: newArr,
                                            material: options.material
                                        };

                                        var geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: extrudedPolygon,
                                            attributes: {
                                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                            }
                                        });
                                        //图例
                                        var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                        that.Legend.push(col);
                                        geometries.push(geometryInstance);
                                        //geometries.push(geometryInstance1);
                                    }
                                    for (var i = 0; i < data.features.length; i++) {
                                        var newArr = [];
                                        var haveZ = false;
                                        var feature = data.features[i];

                                        //fun(data.features[i].geometry.coordinates[0]);
                                        //解析坐标
                                        if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                            if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                                for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                    newArr = [];
                                                    feature.geometry.coordinates[j].pop();
                                                    fun(feature.geometry.coordinates[j]);
                                                    createobj();
                                                }
                                            } else {
                                                fun(feature.geometry.coordinates);
                                                createobj();
                                            }
                                        }
                                    }
                                    var Primitive = new that._cesium.ClassificationPrimitive({
                                        geometryInstances: geometries,
                                        appearance: new that._cesium.PerInstanceColorAppearance({
                                            translucent: false,
                                            vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                            fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                        }),
                                        classificationType: options.classificationType,
                                        shadows: that._cesium.ShadowMode.ENABLED
                                    });
                                    that.PrimitiveObj.data = Primitive;
                                    that.PrimitiveObj.key = that.Primitivekey[that.returnCount];
                                    var Obj = {
                                        level: tile.level,
                                        key: that.Primitivekey[that.returnCount],
                                        data: Primitive
                                    };
                                    that.loadFinishKey.push(that.Primitivekey[that.returnCount]);
                                    that.PrimitiveData.push(Obj);
                                    that._viewer.scene.primitives.add(Primitive);
                                    that.returnCount++;
                                    if (that.returnCount >= that.tilesLength) {
                                        that.returnCount = 0;
                                        that.tilesLength = 0;
                                        //that.removeObsoletePrimitives();
                                        that.Primitivekey = [];
                                    }
                                    //});
                                },
                                error: function () {
                                    downLoadTiles = lodash.remove(downLoadTiles, function (o) {
                                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                                    });
                                },
                                complete: function (XHR, TS) {
                                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                                        if (tile.data.geometryPrimitive)
                                            //tile.data.geometryPrimitive.update(frameState);
                                            //if (tile.data.geometryPrimitive._ready) {
                                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                                        tile.renderable = true;
                                        //}
                                    }
                                }
                            });
                        })(tile);
                    }
                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            //tile.data.geometryPrimitive.update(frameState);
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                    }
                    return;
                }
            }
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this._Provider.treeID = options.id;
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //单体化layername, url, option, GroupID, disFnc（全面加载优化）（拉伸面最终版江苏）
    /**
     * 2020/04/29
     */
    VectorGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayerDthOptimization2 = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;

        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        /**
                         * 请求区块数据
                         */
                        // Create random lines at the root level.
                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }

                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                if (data == undefined) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    return;
                                }
                                var PrimitiveCollection = new that._cesium.PrimitiveCollection();
                                //图例
                                that.Legend = [];
                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                        }
                                    }
                                }
                                function createobj() {
                                    if (that._option.extrudedHeight) {
                                        options.extrudedHeight = that._option.extrudedHeight;
                                    }
                                    if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                        var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                    }

                                    //options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                    options.material = that._option.material;
                                    if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                        var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                        options.material = feature.properties[material];

                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.material)) {
                                            options.material = that._color.colorFromHtmlColor(options.material);
                                        } else {
                                            if (/^rgb/.test(options.material)) {
                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                            }
                                            if (options.material.red > 1) {
                                                options.material.red = options.material.red / 255;
                                            }
                                            if (options.material.green > 1) {
                                                options.material.green = options.material.green / 255;
                                            }
                                            if (options.material.blue > 1) {
                                                options.material.blue = options.material.blue / 255;
                                            }
                                            if (options.material.alpha > 1) {
                                                options.material.a = options.material.alpha / 255;
                                            }
                                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                        }
                                    } else {
                                        if (that._option.material) {
                                            options.material = that._option.material;
                                        }
                                        if (options.material) {
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }

                                        }
                                    }
                                    if (newArr.length >= 2) {
                                        var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                        options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                        //基础面
                                        var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                        //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                        //var co = that._cesium.Color.fromRandom();
                                        var geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: extrudedPolygon,
                                            attributes: {
                                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                            }
                                        });
                                        var Primitivexp = new that._cesium.ClassificationPrimitive({
                                            geometryInstances: geometryInstance,
                                            //appearance: new that._cesium.EllipsoidSurfaceAppearance({
                                            //    material: that._cesium.Material.fromType('Checkerboard')
                                            //})
                                            appearance: new that._cesium.PerInstanceColorAppearance({
                                                translucent: false,
                                                vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                                fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                            }),
                                            classificationType: that._option.classificationType,
                                            //shadows: that._option.shadows
                                        });
                                        //图例
                                        var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                        that.Legend.push(col);
                                        //geometries.push(Primitivexp);
                                        PrimitiveCollection.add(Primitivexp);
                                    }
                                    //geometries.push(geometryInstance1);
                                }
                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    var feature = data.features[i];

                                    //fun(data.features[i].geometry.coordinates[0]);
                                    //解析坐标
                                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                newArr = [];
                                                feature.geometry.coordinates[j].pop();
                                                fun(feature.geometry.coordinates[j]);
                                                createobj();
                                            }
                                        } else {
                                            fun(feature.geometry.coordinates);
                                            createobj();
                                        }
                                    }
                                }
                                var Primitive = PrimitiveCollection;
                                tile.data.geometryPrimitive = Primitive;

                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    tile.data.geometryPrimitive.update(frameState, []);
                                    //if (tile.data.geometryPrimitive._ready) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            },
                            error: function () {
                                if (tile.count == undefined) {
                                    tile.count = 0;
                                }
                                tile.count += 1;
                                if (tile.count >= 2) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    // return;
                                }
                                else {
                                    tile.state = Cesium.QuadtreeTileLoadState.START;
                                }
                            }
                        });
                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    //单体化layername, url, option, GroupID, disFnc（全面加载优化）（拉伸面最终版江苏）
    /**
     * 2020/05/14
     */
    VectorGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayerDthOptimization3 = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;

        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        /**
                         * 请求区块数据
                         */
                        // Create random lines at the root level.
                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }
                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                if (data == undefined) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    return;
                                }
                                new that._cesium.PrimitiveCollection();
                                //图例
                                that.Legend = [];
                                var geometryInstances = [];
                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                        }
                                    }
                                }
                                function createobj() {
                                    if (that._option.extrudedHeight) {
                                        options.extrudedHeight = that._option.extrudedHeight;
                                    }
                                    if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                        var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                    }

                                    //options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                    options.material = that._option.material;
                                    if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                        var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                        options.material = feature.properties[material];

                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.material)) {
                                            options.material = that._color.colorFromHtmlColor(options.material);
                                        } else {
                                            if (/^rgb/.test(options.material)) {
                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                            }
                                            if (options.material.red > 1) {
                                                options.material.red = options.material.red / 255;
                                            }
                                            if (options.material.green > 1) {
                                                options.material.green = options.material.green / 255;
                                            }
                                            if (options.material.blue > 1) {
                                                options.material.blue = options.material.blue / 255;
                                            }
                                            if (options.material.alpha > 1) {
                                                options.material.a = options.material.alpha / 255;
                                            }
                                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                        }
                                    } else {
                                        if (that._option.material) {
                                            options.material = that._option.material;
                                        }
                                        if (options.material) {
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }

                                        }
                                    }
                                    if (newArr.length >= 2) {
                                        var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                        options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                        //基础面
                                        var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                        //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                        //var co = that._cesium.Color.fromRandom();
                                        var geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: extrudedPolygon,
                                            attributes: {
                                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                            }
                                        });
                                        geometryInstances.push(geometryInstance);
                                        // var Primitivexp = new that._cesium.ClassificationPrimitive({
                                        //     geometryInstances: geometryInstance,
                                        //     //appearance: new that._cesium.EllipsoidSurfaceAppearance({
                                        //     //    material: that._cesium.Material.fromType('Checkerboard')
                                        //     //})
                                        //     appearance: new that._cesium.PerInstanceColorAppearance({
                                        //         translucent: false,
                                        //         vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                        //         fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                        //     }),
                                        //     classificationType: that._option.classificationType,
                                        //     //shadows: that._option.shadows
                                        // });
                                        // //图例
                                        // var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                        // that.Legend.push(col);
                                        // //geometries.push(Primitivexp);
                                        // PrimitiveCollection.add(Primitivexp);
                                    }
                                    //geometries.push(geometryInstance1);
                                }
                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    var feature = data.features[i];

                                    //fun(data.features[i].geometry.coordinates[0]);
                                    //解析坐标
                                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                newArr = [];
                                                feature.geometry.coordinates[j].pop();
                                                fun(feature.geometry.coordinates[j]);
                                                createobj();
                                            }
                                        } else {
                                            fun(feature.geometry.coordinates);
                                            createobj();
                                        }
                                    }
                                }

                                var Primitivexp = new that._cesium.ClassificationPrimitive1({
                                    geometryInstances: geometryInstances,
                                    //appearance: new that._cesium.EllipsoidSurfaceAppearance({
                                    //    material: that._cesium.Material.fromType('Checkerboard')
                                    //})
                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                        translucent: false,
                                        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                    }),
                                    classificationType: that._option.classificationType,
                                    //shadows: that._option.shadows
                                });


                                tile.data.geometryPrimitive = Primitivexp;

                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    tile.data.geometryPrimitive.update(frameState, []);
                                    //if (tile.data.geometryPrimitive._ready) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            },
                            error: function () {
                                if (tile.count == undefined) {
                                    tile.count = 0;
                                }
                                tile.count += 1;
                                if (tile.count >= 2) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    // return;
                                }
                                else {
                                    tile.state = Cesium.QuadtreeTileLoadState.START;
                                }
                            }
                        });
                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //单体化layername, url, option, GroupID, disFnc（全面加载优化）（拉伸面最终版江苏）
    VectorGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayerDthOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = null;
            this.tile = tile;
            //解决内存溢出
            if (tile.state === this._cesium.QuadtreeTileLoadState.START && that.item.show) {
                var key = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new that._cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new that._cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });

                        tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                //tile.data.geometryPrimitive.update();
                                //if (tile.data.geometryPrimitive._ready) {
                                tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }
                    if (that.PrimitiveData.length > 0) {
                        for (var i = 0; i < that.PrimitiveData.length; i++) {
                            if (that.PrimitiveData[i].key == key) {
                                if (!that.Primitivekey.includes(key)) {
                                    that.Primitivekey.push(key);
                                }
                                return;
                            }
                        }
                    }
                    if (!that.Primitivekey.includes(key)) {
                        that.Primitivekey.push(key);
                        downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                        /**
                         * 请求区块数据
                         */
                        (function (tile) {

                            // Create random lines at the root level.
                            var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                            that.tilesLength++;
                            var downLoadKey = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;

                            if (that._cache) {
                                tileUrl += '&' + that._core.getuid();
                            }
                            // $.ajax({
                            that._core.xhr({
                                url: tileUrl,
                                type: "get",
                                dataType: "json",
                                success: function (data) {
                                    var PrimitiveCollection = new that._cesium.PrimitiveCollection();
                                    //图例
                                    that.Legend = [];
                                    function fun(arr) {
                                        for (var i = 0; i < arr.length; i++) {
                                            if (Array.isArray(arr[i])) {
                                                fun(arr[i]);
                                            } else {
                                                newArr.push(arr[i]);
                                            }
                                        }
                                    }
                                    function createobj() {
                                        if (that._option.extrudedHeight) {
                                            options.extrudedHeight = that._option.extrudedHeight;
                                        }
                                        if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                            var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                            options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                        }

                                        //options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                        options.material = that._option.material;
                                        if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                            var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                            options.material = feature.properties[material];

                                            //填充颜色设置
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }
                                        } else {
                                            if (that._option.material) {
                                                options.material = that._option.material;
                                            }
                                            if (options.material) {
                                                if (that._core.isHtmlColor(options.material)) {
                                                    options.material = that._color.colorFromHtmlColor(options.material);
                                                } else {
                                                    if (/^rgb/.test(options.material)) {
                                                        options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                    }
                                                    if (options.material.red > 1) {
                                                        options.material.red = options.material.red / 255;
                                                    }
                                                    if (options.material.green > 1) {
                                                        options.material.green = options.material.green / 255;
                                                    }
                                                    if (options.material.blue > 1) {
                                                        options.material.blue = options.material.blue / 255;
                                                    }
                                                    if (options.material.alpha > 1) {
                                                        options.material.a = options.material.alpha / 255;
                                                    }
                                                    options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                                }

                                            }
                                        }
                                        if (newArr.length >= 2) {
                                            var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                            options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                            //基础面
                                            var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                            //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                            //var co = that._cesium.Color.fromRandom();
                                            var geometryInstance = new that._cesium.GeometryInstance({
                                                id: feature,
                                                geometry: extrudedPolygon,
                                                attributes: {
                                                    color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                                }
                                            });
                                            var Primitivexp = new that._cesium.ClassificationPrimitive({
                                                geometryInstances: geometryInstance,
                                                //appearance: new that._cesium.EllipsoidSurfaceAppearance({
                                                //    material: that._cesium.Material.fromType('Checkerboard')
                                                //})
                                                appearance: new that._cesium.PerInstanceColorAppearance({
                                                    translucent: false,
                                                    vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                                    fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                                }),
                                                classificationType: that._option.classificationType,
                                                //shadows: that._option.shadows
                                            });
                                            //图例
                                            var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                            that.Legend.push(col);
                                            //geometries.push(Primitivexp);
                                            PrimitiveCollection.add(Primitivexp);
                                        }
                                        //geometries.push(geometryInstance1);
                                    }
                                    for (var i = 0; i < data.features.length; i++) {
                                        var newArr = [];
                                        var feature = data.features[i];

                                        //fun(data.features[i].geometry.coordinates[0]);
                                        //解析坐标
                                        if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                            if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                                for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                    newArr = [];
                                                    feature.geometry.coordinates[j].pop();
                                                    fun(feature.geometry.coordinates[j]);
                                                    createobj();
                                                }
                                            } else {
                                                fun(feature.geometry.coordinates);
                                                createobj();
                                            }
                                        }
                                    }
                                    var Primitive = PrimitiveCollection;
                                    that.probj.push(Primitive);
                                    var Obj = {
                                        level: tile.level,
                                        key: downLoadKey,
                                        data: Primitive
                                    };
                                    that.loadFinishKey.push(downLoadKey);
                                    that.PrimitiveData.push(Obj);
                                    that._viewer.scene.primitives.add(Primitive);
                                    that.returnCount++;
                                    /*      var index = that.Primitivekey.indexOf(downLoadKey);
                                         if (index > -1) {
                                         {
                                             that.Primitivekey.splice(index, 1);
                                         } */
                                    that.removeObsoletePrimitives(tile);

                                    //if (that.returnCount >= that.tilesLength) {
                                    //    that.returnCount = 0;
                                    //    that.tilesLength = 0;

                                    //that.Primitivekey = [];
                                    //}
                                    //});
                                },
                                error: function () {
                                    var index = that.Primitivekey.indexOf(downLoadKey);
                                    if (index > -1) {
                                        that.Primitivekey.splice(index, 1);
                                    }

                                    downLoadTiles = lodash.remove(downLoadTiles, function (o) {
                                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                                    });
                                },
                                complete: function (XHR, TS) {
                                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                                        if (tile.data.geometryPrimitive)
                                            //tile.data.geometryPrimitive.update(frameState);
                                            //if (tile.data.geometryPrimitive._ready) {
                                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                                        tile.renderable = true;
                                        //}
                                    }
                                }
                            });
                        })(tile);
                    }
                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            //tile.data.geometryPrimitive.update(frameState);
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                    }
                    return;
                }
            }
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //单体化layername, url, option, GroupID, disFnc（全面加载优化）（贴地面最终版江苏）
    VectorGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayerJCDthOptimization1 = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = null;
            this.tile = tile;
            //解决内存溢出
            if (tile.state === this._cesium.QuadtreeTileLoadState.START && that.item.show) {
                var key = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new that._cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new that._cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });

                        tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                        }
                        return;
                    }
                    if (that.PrimitiveData.length > 0) {
                        for (var i = 0; i < that.PrimitiveData.length; i++) {
                            if (that.PrimitiveData[i].key == key) {
                                if (!that.Primitivekey.includes(key)) {
                                    that.Primitivekey.push(key);
                                }
                                return;
                            }
                        }
                    }
                    if (!that.Primitivekey.includes(key)) {
                        that.Primitivekey.push(key);
                        downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                        var jbli = that._option.level_min + Math.floor((that._option.level_max - that._option.level_min) / 2);
                        var tileList = _getLoadLevelTile(tile, jbli);
                        for (var i = 0; i < tileList.length; i++) {
                            var levelTile = tileList[i];
                            var loadLevelKey = 'z' + levelTile.level + 'x' + levelTile.x + 'y' + levelTile.y;
                            if (!that.loadAllKey.includes(loadLevelKey)) {
                                that.loadAllKey.push(loadLevelKey);
                                /**
                                 * 请求区块数据
                                 */
                                (function (tile) {
                                    var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                                    that.tilesLength++;
                                    var downLoadKey = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;

                                    if (that._cache) {
                                        tileUrl += '&' + that._core.getuid();
                                    }
                                    // $.ajax({
                                    that._core.xhr({
                                        url: tileUrl,
                                        type: "get",
                                        dataType: "json",
                                        success: function (data) {
                                            var geometries = [];
                                            //var PrimitiveCollection = new that._cesium.PrimitiveCollection();
                                            //图例
                                            that.Legend = [];
                                            function fun(arr) {
                                                for (var i = 0; i < arr.length; i++) {
                                                    if (Array.isArray(arr[i])) {
                                                        fun(arr[i]);
                                                    } else {
                                                        newArr.push(arr[i]);
                                                    }
                                                }
                                            }
                                            function createobj() {
                                                if (that._option.extrudedHeight) {
                                                    options.extrudedHeight = that._option.extrudedHeight;
                                                }
                                                if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                                    var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                                    options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                                }

                                                //options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                                options.material = that._option.material;
                                                if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                                    var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                                    options.material = feature.properties[material];

                                                    //填充颜色设置
                                                    if (that._core.isHtmlColor(options.material)) {
                                                        options.material = that._color.colorFromHtmlColor(options.material);
                                                    } else {
                                                        if (/^rgb/.test(options.material)) {
                                                            options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                        }
                                                        if (options.material.red > 1) {
                                                            options.material.red = options.material.red / 255;
                                                        }
                                                        if (options.material.green > 1) {
                                                            options.material.green = options.material.green / 255;
                                                        }
                                                        if (options.material.blue > 1) {
                                                            options.material.blue = options.material.blue / 255;
                                                        }
                                                        if (options.material.alpha > 1) {
                                                            options.material.a = options.material.alpha / 255;
                                                        }
                                                        options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                                    }
                                                } else {
                                                    if (that._option.material) {
                                                        options.material = that._option.material;
                                                    }
                                                    if (options.material) {
                                                        if (that._core.isHtmlColor(options.material)) {
                                                            options.material = that._color.colorFromHtmlColor(options.material);
                                                        } else {
                                                            if (/^rgb/.test(options.material)) {
                                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                            }
                                                            if (options.material.red > 1) {
                                                                options.material.red = options.material.red / 255;
                                                            }
                                                            if (options.material.green > 1) {
                                                                options.material.green = options.material.green / 255;
                                                            }
                                                            if (options.material.blue > 1) {
                                                                options.material.blue = options.material.blue / 255;
                                                            }
                                                            if (options.material.alpha > 1) {
                                                                options.material.a = options.material.alpha / 255;
                                                            }
                                                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                                        }

                                                    }
                                                }
                                                if (newArr.length >= 2) {
                                                    var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                                    options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                                    //基础面
                                                    var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                                    //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                                    //var co = that._cesium.Color.fromRandom();
                                                    var geometryInstance = new that._cesium.GeometryInstance({
                                                        id: feature,
                                                        geometry: extrudedPolygon,
                                                        attributes: {
                                                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                                        }
                                                    });
                                                    //图例
                                                    var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                                    that.Legend.push(col);
                                                    geometries.push(geometryInstance);
                                                }
                                            }
                                            for (var i = 0; i < data.features.length; i++) {
                                                var newArr = [];
                                                var feature = data.features[i];
                                                //解析坐标
                                                if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                                    if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                                        for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                            newArr = [];
                                                            feature.geometry.coordinates[j].pop();
                                                            fun(feature.geometry.coordinates[j]);
                                                            createobj();
                                                        }
                                                    } else {
                                                        fun(feature.geometry.coordinates);
                                                        createobj();
                                                    }
                                                }
                                            }
                                            if (geometries.length > 0) {
                                                var Primitive = new that._cesium.GroundPrimitive({
                                                    geometryInstances: geometries,
                                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                                        translucent: false,
                                                        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                                        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                                    }),
                                                    classificationType: that._option.classificationType,
                                                    //shadows: that._option.shadows,
                                                    show: that.item.show
                                                });
                                                that.probj.push(Primitive);
                                                var Obj = {
                                                    level: tile.level,
                                                    key: downLoadKey,
                                                    data: Primitive
                                                };
                                                that.loadFinishKey.push(downLoadKey);
                                                that.PrimitiveData.push(Obj);
                                                that._viewer.scene.primitives.add(Primitive);
                                                that.returnCount++;
                                            }
                                        },
                                        error: function () {
                                        },
                                        complete: function (XHR, TS) {
                                        }
                                    });
                                })(levelTile);
                            }
                        }
                    }
                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            //tile.data.geometryPrimitive.update(frameState);
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                    }
                    return;
                }
            }
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    //单体化layername, url, option, GroupID, disFnc（全面加载优化）（贴地面最终版江苏）
    /**zhangheng
     * 2020/04/29
     */
    VectorGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayerJCDthOptimization2 = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }

        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    //var levelError = that.getLevelMaximumGeometricError(tile.level);
                    //if (tile.level == 16) {
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }
                        // fetch(tileUrl).then(response => {
                        //     if (!response.ok) {
                        //         if (tile.count == undefined) {
                        //             tile.count = 0;
                        //         }
                        //         tile.count += 1;
                        //         if (tile.count >= 2) {
                        //             tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        //             tile.renderable = true;

                        //         }
                        //         else {
                        //             tile.state = Cesium.QuadtreeTileLoadState.START;
                        //         }
                        //         return response.json();
                        //     }
                        // }).then(function (response) {
                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                if (data == undefined) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    return;
                                }
                                var geometries = [];
                                //var PrimitiveCollection = new that._cesium.PrimitiveCollection();
                                //图例
                                that.Legend = [];
                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                        }
                                    }
                                }
                                function createobj() {
                                    if (that._option.extrudedHeight) {
                                        options.extrudedHeight = that._option.extrudedHeight;
                                    }
                                    if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                        var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                    }

                                    //options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                    options.material = that._option.material;
                                    if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                        var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                        options.material = feature.properties[material];

                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.material)) {
                                            options.material = that._color.colorFromHtmlColor(options.material);
                                        } else {
                                            if (/^rgb/.test(options.material)) {
                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                            }
                                            if (options.material.red > 1) {
                                                options.material.red = options.material.red / 255;
                                            }
                                            if (options.material.green > 1) {
                                                options.material.green = options.material.green / 255;
                                            }
                                            if (options.material.blue > 1) {
                                                options.material.blue = options.material.blue / 255;
                                            }
                                            if (options.material.alpha > 1) {
                                                options.material.a = options.material.alpha / 255;
                                            }
                                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                        }
                                    } else {
                                        if (that._option.material) {
                                            options.material = that._option.material;
                                        }
                                        if (options.material) {
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }

                                        }
                                    }
                                    if (newArr.length >= 2) {
                                        var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                        options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                        //基础面
                                        var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                        //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                        //var co = that._cesium.Color.fromRandom();
                                        var geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: extrudedPolygon,
                                            attributes: {
                                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                            }
                                        });
                                        //图例
                                        var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                        that.Legend.push(col);
                                        geometries.push(geometryInstance);
                                    }
                                }
                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    var feature = data.features[i];
                                    //解析坐标
                                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                newArr = [];
                                                feature.geometry.coordinates[j].pop();
                                                fun(feature.geometry.coordinates[j]);
                                                createobj();
                                            }
                                        } else {
                                            fun(feature.geometry.coordinates);
                                            createobj();
                                        }
                                    }
                                }
                                /**
                                 * 请求到的数据为空
                                 */
                                if (geometries.length == 0) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                }
                                var Primitive = new that._cesium.GroundPrimitive1({
                                    geometryInstances: geometries,
                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                        translucent: false,
                                        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                    }),
                                    classificationType: that._option.classificationType,
                                    //shadows: that._option.shadows
                                });

                                tile.data.geometryPrimitive = Primitive;

                                // tile.data.geometryPrimitive = new Cesium.Primitive({
                                //     geometryInstances: geometries,
                                //     appearance: new Cesium.MaterialAppearance({
                                //         material: new Cesium.Material({
                                //             fabric: {
                                //                 type: 'Color',
                                //                 uniforms: {
                                //                     color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                //                 }
                                //             }
                                //         }),
                                //         faceForward: true,
                                //         flat: false
                                //     }),
                                //     shadows: Cesium.ShadowMode.ENABLED
                                // });

                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    tile.data.geometryPrimitive.update1(frameState, []);
                                    //if (tile.data.geometryPrimitive._ready) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            },
                            error: function () {
                                // if (tile.count == undefined) {
                                //     tile.count = 0;
                                // }
                                // tile.count += 1;
                                // if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // return;
                                // }
                                // else {
                                //     tile.state = Cesium.QuadtreeTileLoadState.START;
                                // }
                            }
                        });
                        // Create random lines at the root level.

                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this
    };

    //单体化layername, url, option, GroupID, disFnc（全面加载优化）（贴地面最终版江苏）
    /**
     * 2020/05/17
     */
    VectorGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayerJCDthOptimization3 = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {

        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }

        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    //var levelError = that.getLevelMaximumGeometricError(tile.level);
                    //if (tile.level == 16) {
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }

                        // fetch(tileUrl).then(response => {
                        //     if (!response.ok) {
                        //         if (tile.count == undefined) {
                        //             tile.count = 0;
                        //         }
                        //         tile.count += 1;
                        //         if (tile.count >= 2) {
                        //             tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        //             tile.renderable = true;

                        //         }
                        //         else {
                        //             tile.state = Cesium.QuadtreeTileLoadState.START;
                        //         }
                        //         return response.json();
                        //     }
                        // }).then(function (response) {
                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                var colors = ["#ffff00",
                                    "#ffcc00",
                                    "#ff3300",
                                    "#ccff00",
                                    "#cccc00",
                                    "#99ff66",
                                    "#999933",
                                    "#66cc99",
                                    "#6633ff",
                                    "#33ffff",
                                    "#3399cc",
                                    "#009933",
                                    "#ccccff",
                                    "#ff99ff",
                                    "#9966ff",
                                    "#336699"];
                                if (data == undefined) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    return;
                                }
                                var geometries = [];
                                //var PrimitiveCollection = new that._cesium.PrimitiveCollection();
                                //图例
                                that.Legend = [];
                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                        }
                                    }
                                }
                                function createobj() {
                                    if (that._option.extrudedHeight) {
                                        options.extrudedHeight = that._option.extrudedHeight;
                                    }
                                    if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                        var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                    }

                                    //options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                    options.material = that._option.material;
                                    if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                        var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                        options.material = feature.properties[material];

                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.material)) {
                                            options.material = that._color.colorFromHtmlColor(options.material);
                                        } else {
                                            if (/^rgb/.test(options.material)) {
                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                            }
                                            if (options.material.red > 1) {
                                                options.material.red = options.material.red / 255;
                                            }
                                            if (options.material.green > 1) {
                                                options.material.green = options.material.green / 255;
                                            }
                                            if (options.material.blue > 1) {
                                                options.material.blue = options.material.blue / 255;
                                            }
                                            if (options.material.alpha > 1) {
                                                options.material.a = options.material.alpha / 255;
                                            }
                                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                        }
                                    } else {
                                        if (that._option.material) {
                                            options.material = that._option.material;
                                        }
                                        if (options.material) {
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }

                                        }
                                    }
                                    if (newArr.length >= 2) {
                                        var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                        options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                        //基础面

                                        if (options.extrudedHeight == 0 || options.extrudedHeight == '0' || options.extrudedHeight == null || options.extrudedHeight == undefined) {
                                            options.extrudedHeight = 10000;
                                        }
                                        var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                        //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                        //var co = that._cesium.Color.fromRandom();
                                        var nowColor = colors[Math.floor(Math.random() * colors.length)];
                                        var geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: extrudedPolygon,
                                            attributes: {
                                                //  color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                                // color: that._cesium.Color.fromRandom({ alpha: 1.0 })
                                                color: that._cesium.ColorGeometryInstanceAttribute.fromColor(
                                                    that._cesium.Color.fromCssColorString(nowColor).withAlpha(0.5))
                                            }
                                        });
                                        //图例
                                        var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                        that.Legend.push(col);
                                        geometries.push(geometryInstance);
                                    }
                                }
                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    var feature = data.features[i];
                                    //解析坐标
                                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                newArr = [];
                                                feature.geometry.coordinates[j].pop();
                                                fun(feature.geometry.coordinates[j]);
                                                createobj();
                                            }
                                        } else {
                                            fun(feature.geometry.coordinates);
                                            createobj();
                                        }
                                    }
                                }
                                /**
                                 * 请求到的数据为空
                                 */
                                if (geometries.length == 0) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                }
                                // var Primitive = new that._cesium.GroundPrimitive1({
                                //     geometryInstances: geometries,
                                //     appearance: new that._cesium.PerInstanceColorAppearance({
                                //         translucent: false,
                                //         vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                //         fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                //     }),
                                //     classificationType: that._option.classificationType,
                                //     //shadows: that._option.shadows
                                // });

                                // var Primitivexp = new that._cesium.ClassificationPrimitive1({
                                //     geometryInstances: geometries,
                                //     //appearance: new that._cesium.EllipsoidSurfaceAppearance({
                                //     //    material: that._cesium.Material.fromType('Checkerboard')
                                //     //})
                                //     appearance: new that._cesium.PerInstanceColorAppearance({
                                //         translucent: false,
                                //         vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                //         fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                //     }),
                                //     classificationType: that._option.classificationType,
                                //     //shadows: that._option.shadows
                                // });
                                var Primitivexp = new that._cesium.ClassificationPrimitive1({
                                    geometryInstances: geometries,
                                    classificationType: that._cesium.ClassificationType.BOTH
                                });
                                tile.data.geometryPrimitive = Primitivexp;

                                // tile.data.geometryPrimitive = new Cesium.Primitive({
                                //     geometryInstances: geometries,
                                //     appearance: new Cesium.MaterialAppearance({
                                //         material: new Cesium.Material({
                                //             fabric: {
                                //                 type: 'Color',
                                //                 uniforms: {
                                //                     color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                //                 }
                                //             }
                                //         }),
                                //         faceForward: true,
                                //         flat: false
                                //     }),
                                //     shadows: Cesium.ShadowMode.ENABLED
                                // });

                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    tile.data.geometryPrimitive.update(frameState, []);
                                    //if (tile.data.geometryPrimitive._ready) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            },
                            error: function () {
                                // if (tile.count == undefined) {
                                //     tile.count = 0;
                                // }
                                // tile.count += 1;
                                // if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // return;
                                // }
                                // else {
                                //     tile.state = Cesium.QuadtreeTileLoadState.START;
                                // }
                            }
                        });
                        // Create random lines at the root level.

                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this
    };
    /**
     * 基础点加载
     * @param {*} name 
     * @param {*} geoOptions 
     * @param {*} styleOption 
     * @param {*} GroupID 
     * @param {*} checked 
     * @param {*} disFnc 
     */
    VectorGeoJsonFeatureLayer.prototype.createPointGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        //填充颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.color)) {
            if (/^\[/.test(styleOption.color) && styleOption.color.toString().charAt(0) == "[" && styleOption.color.toString().charAt(styleOption.color.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.color)) {
                    styleOption.color = that._color.colorFromHtmlColor(styleOption.color);
                } else {
                    if (/^rgb/.test(styleOption.color)) {
                        styleOption.color = that._color.rgbaStringToRgbaObj(styleOption.color);
                    }
                    if (styleOption.color.r > 1) {
                        styleOption.color.r = styleOption.color.r / 255;
                    }
                    if (styleOption.color.g > 1) {
                        styleOption.color.g = styleOption.color.g / 255;
                    }
                    if (styleOption.color.b > 1) {
                        styleOption.color.b = styleOption.color.b / 255;
                    }
                    if (styleOption.color.a > 1) {
                        styleOption.color.a = styleOption.color.a / 255;
                    }
                    styleOption.color = that._color.createColor(styleOption.color.r, styleOption.color.g, styleOption.color.b, styleOption.color.a);
                }
            }
        }
        //边框颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.outlineColor)) {
            if (/^\[/.test(styleOption.outlineColor) && styleOption.outlineColor.toString().charAt(0) == "[" && styleOption.outlineColor.toString().charAt(styleOption.outlineColor.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.outlineColor)) {
                    styleOption.outlineColor = that._color.colorFromHtmlColor(styleOption.outlineColor);
                } else {
                    if (/^rgb/.test(styleOption.outlineColor)) {
                        styleOption.outlineColor = that._color.rgbaStringToRgbaObj(styleOption.outlineColor);
                    }
                    if (styleOption.outlineColor.r > 1) {
                        styleOption.outlineColor.r = styleOption.outlineColor.r / 255;
                    }
                    if (styleOption.outlineColor.g > 1) {
                        styleOption.outlineColor.g = styleOption.outlineColor.g / 255;
                    }
                    if (styleOption.outlineColor.b > 1) {
                        styleOption.outlineColor.b = styleOption.outlineColor.b / 255;
                    }
                    if (styleOption.outlineColor.a > 1) {
                        styleOption.outlineColor.a = styleOption.outlineColor.a / 255;
                    }
                    styleOption.outlineColor = that._color.createColor(styleOption.outlineColor.r, styleOption.outlineColor.g, styleOption.outlineColor.b, styleOption.outlineColor.a);
                }
            }
        }
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;

        var defaultOptions = {
            Name: "",
            text: "",
            font: ' 30px sans-serif',
            pixelSize: 10.0,
            style: that._cesium.LabelStyle.OUTLINE,
            fillColor: that._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
            outlineColor: that._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
            outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
            show: true, //	optional A boolean Property specifying the visibility of the label.
            showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new that._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
            backgroundPadding: new that._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: that._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
            verticalOrigin: that._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
            eyeOffset: that._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: that._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: that._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
            scaleByDistance: new that._cesium.NearFarScalar(0, 0, 1, 1)
        };
        //背景颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.backgroundColor)) {
            if (/^\[/.test(styleOption.backgroundColor) && styleOption.backgroundColor.toString().charAt(0) == "[" && styleOption.backgroundColor.toString().charAt(styleOption.backgroundColor.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.backgroundColor)) {
                    styleOption.backgroundColor = that._color.colorFromHtmlColor(styleOption.backgroundColor);
                } else {
                    if (/^rgb/.test(styleOption.backgroundColor)) {
                        styleOption.backgroundColor = that._color.rgbaStringToRgbaObj(styleOption.backgroundColor);
                    }
                    if (styleOption.backgroundColor.r > 1) {
                        styleOption.backgroundColor.r = styleOption.backgroundColor.r / 255;
                    }
                    if (styleOption.backgroundColor.g > 1) {
                        styleOption.backgroundColor.g = styleOption.backgroundColor.g / 255;
                    }
                    if (styleOption.backgroundColor.b > 1) {
                        styleOption.backgroundColor.b = styleOption.backgroundColor.b / 255;
                    }
                    if (styleOption.backgroundColor.a > 1) {
                        styleOption.backgroundColor.a = styleOption.backgroundColor.a / 255;
                    }
                    styleOption.backgroundColor = that._color.createColor(styleOption.backgroundColor.r, styleOption.backgroundColor.g, styleOption.backgroundColor.b, styleOption.backgroundColor.a);
                }
            }
        }
        var options = that._core.extend(defaultOptions, styleOption, true);

        if (that._core.isnull(styleOption.near)) {
            styleOption.near = 0;
        }
        if (that._core.isnull(styleOption.far)) {
            styleOption.far = 999999999;
        }
        var min = parseFloat(styleOption.near);
        var max = parseFloat(styleOption.far);
        var distance = new that._cesium.DistanceDisplayCondition(min, max);
        options.distanceDisplayCondition = distance;
        //options.pointHeight = parseFloat(that._core.extendgl(entity, option.pointHeight, options.pointHeight));
        if (that._core.isnull(styleOption.font_size)) {
            styleOption.font_size = "30px";
        }
        if (that._core.isnull(styleOption.font_family)) {
            styleOption.font_family = " sans-serif";
        }
        //options.font = option.font_size + " " + option.font_family;
        options.font = parseFloat(styleOption.font_size) + "px " + styleOption.font_family;
        styleOption.material;
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    //var levelError = that.getLevelMaximumGeometricError(tile.level);
                    // if (tile.level < 16) {
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }
                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                if (data == undefined) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    return;
                                }
                                // var labelCollections = new that._cesium.LabelCollection();
                                var labelCollections = new that._cesium.PointPrimitiveCollection();
                                data.features.forEach(function (feature) {
                                    options.id = feature;
                                    //options.position = that._cesium.Cartesian3.fromDegreesArray(feature.geometry.coordinates)[0];
                                    //修改xp
                                    var sheight = 0.0;
                                    if (/^\[/.test(options.pointHeight) && /\]$/.test(options.pointHeight)) {
                                        var heightStr = options.pointHeight.replace(/\[/, '').replace(/\]/, '');
                                        sheight = parseFloat(feature.properties[heightStr]);
                                    } else if (options.pointHeight !== undefined && options.pointHeight !== '') {
                                        sheight = parseFloat(options.pointHeight);
                                    } else if (feature.properties.height != undefined) {
                                        sheight = parseFloat(feature.properties.height);
                                    }
                                    //填充色
                                    if (/^\[/.test(styleOption.color) && /\]$/.test(styleOption.color)) {
                                        var material = styleOption.color.replace(/\[/, '').replace(/\]/, '');
                                        options.color = feature.properties[material];
                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.color)) {
                                            options.color = that._color.colorFromHtmlColor(options.color);
                                        } else {
                                            if (/^rgb/.test(options.color)) {
                                                options.color = that._color.rgbaStringToRgbaObj(options.color);
                                            }
                                            if (options.color.r > 1) {
                                                options.color.r = options.color.r / 255;
                                            }
                                            if (options.color.g > 1) {
                                                options.color.g = options.color.g / 255;
                                            }
                                            if (options.color.b > 1) {
                                                options.color.b = options.color.b / 255;
                                            }
                                            if (options.color.a > 1) {
                                                options.color.a = options.color.a / 255;
                                            }
                                            options.color = that._color.createColor(options.color.r, options.color.g, options.color.b, options.color.a);
                                        }
                                    }
                                    //边框色
                                    if (/^\[/.test(styleOption.outlineColor) && /\]$/.test(styleOption.outlineColor)) {
                                        var material = styleOption.outlineColor.replace(/\[/, '').replace(/\]/, '');
                                        options.outlineColor = feature.properties[material];
                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.outlineColor)) {
                                            options.outlineColor = that._color.colorFromHtmlColor(options.outlineColor);
                                        } else {
                                            if (/^rgb/.test(options.outlineColor)) {
                                                options.outlineColor = that._color.rgbaStringToRgbaObj(options.outlineColor);
                                            }
                                            if (options.outlineColor.r > 1) {
                                                options.outlineColor.r = options.outlineColor.r / 255;
                                            }
                                            if (options.outlineColor.g > 1) {
                                                options.outlineColor.g = options.outlineColor.g / 255;
                                            }
                                            if (options.outlineColor.b > 1) {
                                                options.outlineColor.b = options.outlineColor.b / 255;
                                            }
                                            if (options.outlineColor.a > 1) {
                                                options.outlineColor.a = options.outlineColor.a / 255;
                                            }
                                            options.outlineColor = that._color.createColor(options.outlineColor.r, options.outlineColor.g, options.outlineColor.b, options.outlineColor.a);
                                        }
                                    }
                                    options.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                                    options.text = feature.properties.name;
                                    var p = {
                                        show: options.show,
                                        position: options.position,
                                        pixelSize: options.pixelSize,
                                        color: options.color,
                                        outlineColor: options.outlineColor,
                                        outlineWidth: options.outlineWidth,
                                        id: feature
                                    };
                                    //图例
                                    if (options.color && options.color.red) {

                                        var col = "color:" + options.color.red * 255 + "," + options.color.green * 255 + "," + options.color.blue * 255
                                            + ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                                        that.Legend.push(col);
                                    }

                                    //样式属性
                                    p.id.treeID = styleOption.id;
                                    p.id.VectorType = 'point';
                                    p.id.VectorStyle = {
                                        show: p.show,
                                        pointHeight: sheight,
                                        position: p.position,
                                        pixelSize: p.pixelSize,
                                        color: p.color,
                                        outlineColor: p.outlineColor,
                                        outlineWidth: p.outlineWidth
                                    };
                                    labelCollections.add(p);
                                });
                                // var Primitive = new that._cesium.Primitive({
                                //     geometryInstances: geometries,
                                //     appearance: new that._cesium.PerInstanceColorAppearance({
                                //         translucent: false,
                                //         vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                //         fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                //     }),
                                //     shadows: that._option.shadows
                                // });

                                tile.data.geometryPrimitive = labelCollections;


                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    tile.data.geometryPrimitive.update(frameState, []);
                                    //tile.data.geometryPrimitive.updateForPick = new that._cesium.QuadtreePrimitive({
                                    //    tileProvider: this._Provider
                                    //})._tileProvider.updateForPick(frameState);
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            },
                            error: function () {
                                if (tile.count == undefined) {
                                    tile.count = 0;
                                }
                                tile.count += 1;
                                if (tile.count >= 2) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    // return;
                                }
                                else {
                                    tile.state = Cesium.QuadtreeTileLoadState.START;
                                }
                            }
                        });
                        // Create random lines at the root level.

                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };


        this._primitive = new this._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 5
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;

        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        if (checked) {
            this.item.show = true;
            this.setVisibility(true);
        } else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'pointLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this._Provider.treeID = styleOption.id;
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        if (typeof disFnc == 'function')
            disFnc(this.item);
        return this;
    };
    /**
    * 矢量切片加载（全面加载优化）优化版
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    * 张恒 2020/04/27
    */
    VectorGeoJsonFeatureLayer.prototype.VolumeVectorGeoJsonFeatureLayerOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    //var levelError = that.getLevelMaximumGeometricError(tile.level);
                    // if (tile.level < 16) {
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }
                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                if (data == undefined) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    return;
                                }
                                var geometries = [];
                                //图例
                                that.Legend = [];
                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                            if (i === 2 && !haveZ) {
                                                haveZ = true;
                                            }
                                        }
                                    }
                                }
                                function createobj() {
                                    if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                        var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                    }
                                    else if (that._option.extrudedHeight) {
                                        options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                    }
                                    options.material = that._option.material;
                                    if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                        var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                        options.material = feature.properties[material];

                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.material)) {
                                            options.material = that._color.colorFromHtmlColor(options.material);
                                        } else {
                                            if (/^rgb/.test(options.material)) {
                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                            }
                                            if (options.material.red > 1) {
                                                options.material.red = options.material.red / 255;
                                            }
                                            if (options.material.green > 1) {
                                                options.material.green = options.material.green / 255;
                                            }
                                            if (options.material.blue > 1) {
                                                options.material.blue = options.material.blue / 255;
                                            }
                                            if (options.material.alpha > 1) {
                                                options.material.a = options.material.alpha / 255;
                                            }
                                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                        }
                                    } else {
                                        if (that._option.material) {
                                            options.material = that._option.material;
                                        }
                                        if (options.material) {
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }

                                        }
                                    }

                                    if (newArr.length >= 2) {
                                        var pos = haveZ ?
                                            that._cesium.Cartesian3.fromDegreesArrayHeights(newArr) :
                                            that._cesium.Cartesian3.fromDegreesArray(newArr)
                                            ;
                                        options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                        //基础面
                                        var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                        //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);

                                        //样式属性
                                        feature.treeID = options.id;
                                        feature.VectorType = 'polygon';
                                        feature.VectorStyle = {
                                            haveZ: haveZ,
                                            extrudedHeight: options.extrudedHeight,
                                            positions: newArr,
                                            material: options.material
                                        };

                                        var geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: extrudedPolygon,
                                            attributes: {
                                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                            }
                                        });
                                        //图例
                                        var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                        that.Legend.push(col);
                                        geometries.push(geometryInstance);
                                    }
                                    //geometries.push(geometryInstance1);
                                }
                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    var haveZ = false;
                                    var feature = data.features[i];

                                    //fun(data.features[i].geometry.coordinates[0]);
                                    //解析坐标
                                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                newArr = [];
                                                feature.geometry.coordinates[j].pop();
                                                fun(feature.geometry.coordinates[j]);
                                                createobj();
                                            }
                                        } else {
                                            fun(feature.geometry.coordinates);
                                            createobj();
                                        }
                                    }
                                }

                                /**
                                 * 请求到的数据为空
                                 */
                                if (geometries.length == 0) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                }

                                var Primitive = new that._cesium.Primitive({
                                    geometryInstances: geometries,
                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                        translucent: false,
                                        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                    }),
                                    shadows: that._option.shadows
                                });

                                tile.data.geometryPrimitive = Primitive;

                                // tile.data.geometryPrimitive = new Cesium.Primitive({
                                //     geometryInstances: geometries,
                                //     appearance: new Cesium.MaterialAppearance({
                                //         material: new Cesium.Material({
                                //             fabric: {
                                //                 type: 'Color',
                                //                 uniforms: {
                                //                     color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                //                 }
                                //             }
                                //         }),
                                //         faceForward: true,
                                //         flat: false
                                //     }),
                                //     shadows: Cesium.ShadowMode.ENABLED
                                // });

                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    tile.data.geometryPrimitive.update(frameState, []);
                                    //tile.data.geometryPrimitive.updateForPick = new that._cesium.QuadtreePrimitive({
                                    //    tileProvider: this._Provider
                                    //})._tileProvider.updateForPick(frameState);
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            },
                            error: function () {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // Add more detail to parent lines at every other level.
                                return;
                            }
                        });
                        // Create random lines at the root level.

                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };
        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 5
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this._Provider.treeID = obj.id;
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };


    /**
    * 矢量模型点切片加载（全面加载优化）优化版
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    * 张恒 2020/08/13
    */
    VectorGeoJsonFeatureLayer.prototype.createModelGeoJsonFeatureLayerProvider0825 = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var that = this;
        var defaultOptions = {
            url: "",        //如果为bgltf则为.bgltf
            // modelMatrix: that._cesium.Transforms.eastNorthUpToFixedFrame(origin),
            color: that._cesium.Color.DARKSALMON,
            //lightColor: that._cesium.Color.DARKSALMON,
            scale: 2.0,   //放大倍数
            //distanceDisplayCondition: attribute.distanceDisplayCondition
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.color)) {
            if (/^\[/.test(styleOption.color) && styleOption.color.toString().charAt(0) == "[" && styleOption.color.toString().charAt(styleOption.color.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.color)) {
                    styleOption.color = that._color.colorFromHtmlColor(styleOption.color);
                } else {
                    if (/^rgb/.test(styleOption.color)) {
                        styleOption.color = that._color.rgbaStringToRgbaObj(styleOption.color);
                    }
                    if (styleOption.color.r > 1) {
                        styleOption.color.r = styleOption.color.r / 255;
                    }
                    if (styleOption.color.g > 1) {
                        styleOption.color.g = styleOption.color.g / 255;
                    }
                    if (styleOption.color.b > 1) {
                        styleOption.color.b = styleOption.color.b / 255;
                    }
                    if (styleOption.color.a > 1) {
                        styleOption.color.a = styleOption.color.a / 255;
                    }
                    styleOption.color = that._color.createColor(styleOption.color.r, styleOption.color.g, styleOption.color.b, styleOption.color.a);
                }
            }
        }
        //填充颜色设置
        var options = that._core.extend(defaultOptions, styleOption, true);
        //填充颜色设置material
        if (that._core.isnull(styleOption.near)) {
            styleOption.near = 0;
        }
        if (that._core.isnull(styleOption.far)) {
            styleOption.far = 999999999;
        }
        var min = parseFloat(styleOption.near);
        var max = parseFloat(styleOption.far);
        var distance = new that._cesium.DistanceDisplayCondition(min, max);
        options.distanceDisplayCondition = distance;
        styleOption.material;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = (parseFloat(options.height) || 0);
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            // (function (frameState, tile, that) {
            if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                //var levelError = that.getLevelMaximumGeometricError(tile.level);
                // if (tile.level < 16) {
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    // (function (frameState, tile) {
                    var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                    if (that._cache) {
                        tileUrl += '&' + that._core.getuid();
                    }

                    // $.ajax({
                    that._core.xhr({
                        url: tileUrl,
                        type: "get",
                        dataType: "json",
                        success: function (data) {
                            if (data == undefined) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }

                            var collection = new that._cesium.PrimitiveCollection({ isModel: true });
                            data.features.forEach(function (feature) {
                                options.id = feature;
                                //修改xp
                                var sheight = feature.geometry.coordinates[2] || 0;
                                if (feature.properties.height != undefined) {
                                    sheight = parseFloat(feature.properties.height);
                                }

                                //取坐标高度

                                if (/^\[/.test(options.height) && /\]$/.test(options.height)) {
                                    var extrudedHeight = options.height.replace(/\[/, '').replace(/\]/, '');
                                    sheight += parseFloat(feature.properties[extrudedHeight]);
                                }
                                else {
                                    sheight += (parseFloat(options.height) || 0);
                                }
                                // tile._maximumHeight = tile._maximumHeight > sheight ? tile._maximumHeight : sheight;
                                // tile._minimumHeight = tile._minimumHeight < sheight ? tile._minimumHeight : sheight;
                                options.modelMatrix = that._cesium.Transforms.eastNorthUpToFixedFrame(that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight));
                                var mol = that._cesium.Model.fromGltf({
                                    id: feature,
                                    url: options.uri,        //如果为bgltf则为.bgltf
                                    color: options.color,
                                    //lightColor: options.lightColor,
                                    modelMatrix: options.modelMatrix,
                                    scale: options.scale,   //放大倍数
                                    heightReference: parseInt(options.heightReference),
                                    distanceDisplayCondition: options.distanceDisplayCondition
                                });
                                // mol._isRender = true;
                                //var models = that._viewer.scene.primitives.add(mol);
                                //that.model.push(mol);
                                //this.labelCollections1
                                collection.add(mol);
                            });

                            if (data.features.length == 0) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            //  var c = that._Provider._PrimitiveCollection.add(collection);
                            //  tile._PrimitiveCollection = that._Provider._PrimitiveCollection;
                            // tile.customDatazh.push(c);
                            tile.data.geometryPrimitive = collection;
                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                // if (tile.data.geometryPrimitive && tile.data.geometryPrimitive._isModel&& tile.data.geometryPrimitive._primitives)
                                // for (var ii = 0, ll = tile.data.geometryPrimitive._primitives.length; ii < ll; ii++)
                                //     tile.data.geometryPrimitive._primitives[ii]._isRender = 1;
                                tile.data.geometryPrimitive.update(frameState, []);
                                //if (tile.data.geometryPrimitive._ready) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                //}
                            }
                        },
                        error: function () {
                            if (tile.count == undefined) {
                                tile.count = 0;
                            }
                            tile.count += 1;
                            if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // return;
                            }
                            else {
                                tile.state = Cesium.QuadtreeTileLoadState.START;
                            }
                        }
                    });

                    // })(frameState, tile);
                    // Create random lines at the root level.

                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                    tile.renderable = true;
                    // Add more detail to parent lines at every other level.
                    return;
                }

                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
            }
            // })(frameState, tile, that);
        };


        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        // primitives.add(this._Provider._PrimitiveCollection);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    /**
    * 矢量模型点切片加载（全面加载优化）优化版
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    * 张恒 2020/08/25
    */
    VectorGeoJsonFeatureLayer.prototype.createModelGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var that = this;
        var defaultOptions = {
            url: "",        //如果为bgltf则为.bgltf
            // modelMatrix: that._cesium.Transforms.eastNorthUpToFixedFrame(origin),
            color: that._cesium.Color.DARKSALMON,
            //lightColor: that._cesium.Color.DARKSALMON,
            scale: 2.0,   //放大倍数
            //distanceDisplayCondition: attribute.distanceDisplayCondition
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            Cesium: this._cesium
        };
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.color)) {
            if (/^\[/.test(styleOption.color) && styleOption.color.toString().charAt(0) == "[" && styleOption.color.toString().charAt(styleOption.color.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.color)) {
                    styleOption.color = that._color.colorFromHtmlColor(styleOption.color);
                } else {
                    if (/^rgb/.test(styleOption.color)) {
                        styleOption.color = that._color.rgbaStringToRgbaObj(styleOption.color);
                    }
                    if (styleOption.color.r > 1) {
                        styleOption.color.r = styleOption.color.r / 255;
                    }
                    if (styleOption.color.g > 1) {
                        styleOption.color.g = styleOption.color.g / 255;
                    }
                    if (styleOption.color.b > 1) {
                        styleOption.color.b = styleOption.color.b / 255;
                    }
                    if (styleOption.color.a > 1) {
                        styleOption.color.a = styleOption.color.a / 255;
                    }
                    styleOption.color = that._color.createColor(styleOption.color.r, styleOption.color.g, styleOption.color.b, styleOption.color.a);
                }
            }
        }
        //填充颜色设置
        var options = that._core.extend(defaultOptions, styleOption, true);
        //填充颜色设置material
        if (that._core.isnull(styleOption.near)) {
            styleOption.near = 0;
        }
        if (that._core.isnull(styleOption.far)) {
            styleOption.far = 999999999;
        }
        var min = parseFloat(styleOption.near);
        var max = parseFloat(styleOption.far);
        var distance = new that._cesium.DistanceDisplayCondition(min, max);
        options.distanceDisplayCondition = distance;
        styleOption.material;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = (parseFloat(options.height) || 0);
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            // (function (frameState, tile, that) {
            if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                //var levelError = that.getLevelMaximumGeometricError(tile.level);
                // if (tile.level < 16) {
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    // (function (frameState, tile) {
                    var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                    if (that._cache) {
                        tileUrl += '&' + that._core.getuid();
                    }

                    // $.ajax({
                    that._core.xhr({
                        url: tileUrl,
                        type: "get",
                        dataType: "json",
                        success: function (data) {
                            if (data == undefined) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }

                            // var collection = new that._cesium.PrimitiveCollection({ isModel: true });
                            var instances = [];
                            data.features.forEach(function (feature) {
                                options.id = feature;
                                //修改xp
                                var sheight = feature.geometry.coordinates[2] || 0;
                                if (feature.properties.height != undefined) {
                                    sheight = parseFloat(feature.properties.height);
                                }

                                //取坐标高度

                                if (/^\[/.test(options.height) && /\]$/.test(options.height)) {
                                    var extrudedHeight = options.height.replace(/\[/, '').replace(/\]/, '');
                                    sheight += parseFloat(feature.properties[extrudedHeight]);
                                }
                                else {
                                    sheight += (parseFloat(options.height) || 0);
                                }
                                // tile._maximumHeight = tile._maximumHeight > sheight ? tile._maximumHeight : sheight;
                                // tile._minimumHeight = tile._minimumHeight < sheight ? tile._minimumHeight : sheight;
                                // options.modelMatrix = that._cesium.Transforms.eastNorthUpToFixedFrame(that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight));
                                // var mol = that._cesium.Model.fromGltf({
                                //     id: feature,
                                //     url: options.uri,        //如果为bgltf则为.bgltf
                                //     color: options.color,
                                //     //lightColor: options.lightColor,
                                //     modelMatrix: options.modelMatrix,
                                //     scale: options.scale,   //放大倍数
                                //     heightReference: parseInt(options.heightReference),
                                //     distanceDisplayCondition: options.distanceDisplayCondition
                                // })
                                // mol._isRender = true;
                                //var models = that._viewer.scene.primitives.add(mol);
                                //that.model.push(mol);
                                //this.labelCollections1
                                // collection.add(mol);
                                var modelMatrix = that._cesium.Transforms.eastNorthUpToFixedFrame(that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight));
                                Cesium.Matrix4.multiplyByUniformScale(modelMatrix, options.scale, modelMatrix);
                                instances.push({ modelMatrix: modelMatrix, modelId: feature });
                            });
                            var p = new Cesium.ModelInstanceCollection({
                                url: options.uri,
                                instances: instances,
                                color: options.color
                            });
                            if (data.features.length == 0) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                            //  var c = that._Provider._PrimitiveCollection.add(collection);
                            //  tile._PrimitiveCollection = that._Provider._PrimitiveCollection;
                            // tile.customDatazh.push(c);
                            // tile.data.geometryPrimitive = collection;
                            tile.data.geometryPrimitive = p;
                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                // if (tile.data.geometryPrimitive && tile.data.geometryPrimitive._isModel&& tile.data.geometryPrimitive._primitives)
                                // for (var ii = 0, ll = tile.data.geometryPrimitive._primitives.length; ii < ll; ii++)
                                //     tile.data.geometryPrimitive._primitives[ii]._isRender = 1;
                                tile.data.geometryPrimitive.update(frameState, []);
                                //if (tile.data.geometryPrimitive._ready) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                //}
                            }
                        },
                        error: function () {
                            if (tile.count == undefined) {
                                tile.count = 0;
                            }
                            tile.count += 1;
                            if (tile.count >= 2) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                // return;
                            }
                            else {
                                tile.state = Cesium.QuadtreeTileLoadState.START;
                            }
                        }
                    });

                    // })(frameState, tile);
                    // Create random lines at the root level.

                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                    tile.renderable = true;
                    // Add more detail to parent lines at every other level.
                    return;
                }

                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
            }
            // })(frameState, tile, that);
        };


        this._primitive = new this._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        // primitives.add(this._Provider._PrimitiveCollection);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //xp测试createVolumeVectorGeoJsonFeatureLayerJCDthOptimizationxp
    VectorGeoJsonFeatureLayer.prototype.VolumeVectorGeoJsonFeatureLayerOptimization1 = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        that._defaultStyle = {
            outlineColor: Cesium.Color.fromCssColorString("rgba(209,204,226,0)"),
            lineWidth: 0,
            outline: true,
            fill: true,
            fillColor: Cesium.Color.fromCssColorString("rgba(220,20,60,1)"),
            //fillColor:this._option.fill,
            fillShow: "nod",
            tileCacheSize: 200,
            showMaker: false,
            showCenterLabel: true,
            fontColor: Cesium.Color.fromCssColorString("rgba(255,0,0,1)"),
            labelOffsetX: -10,
            labelOffsetY: -5,
            fontSize: 13,
            fontFamily: "黑体",
            pointColor: Cesium.Color.fromCssColorString("rgba(255,0,0,0)"),
            centerLabelPropertyName: "NAME"
        };
        if (that._option.fill.indexOf("[") != -1) {
            that._defaultStyle.fillShow = that._option.fill;
        } else {
            that._defaultStyle.fillColor = Cesium.Color.fromCssColorString(that._option.fill);
        }
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = null;
            this.tile = tile;
            //解决内存溢出
            if (tile.state === this._cesium.QuadtreeTileLoadState.START && that.item.show) {
                var key = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level > styleOption.level_max + 2) {
                    //解决
                    if (that.probj.length > 0) {
                        for (var s = 0; s < that.probj.length; i++) {
                            that._viewer.entities.remove(that.probj[s]);
                            var index1 = that.probj.indexOf(that.probj[s]);
                            that.probj.splice(index1, 1);
                        }
                    }
                }
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new that._cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new that._cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });

                        tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                //tile.data.geometryPrimitive.update();
                                //if (tile.data.geometryPrimitive._ready) {
                                tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }
                    if (that.PrimitiveData.length > 0) {
                        for (var i = 0; i < that.PrimitiveData.length; i++) {
                            if (that.PrimitiveData[i].key == key) {
                                if (!that.Primitivekey.includes(key)) {
                                    that.Primitivekey.push(key);
                                }
                                return;
                            }
                        }
                    }
                    if (!that.Primitivekey.includes(key)) {
                        that.Primitivekey.push(key);
                        downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                        /**
                         * 请求区块数据
                         */
                        (function (tile) {

                            // Create random lines at the root level.
                            var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                            that.tilesLength++;
                            var downLoadKey = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;

                            if (that._cache) {
                                tileUrl += '&' + that._core.getuid();
                            }
                            //var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                            var boundingRect = {
                                xMin: Cesium.Math.toDegrees(tile._rectangle.west),
                                yMin: Cesium.Math.toDegrees(tile._rectangle.south),
                                xMax: Cesium.Math.toDegrees(tile._rectangle.east),
                                yMax: Cesium.Math.toDegrees(tile._rectangle.north)
                            };

                            // $.ajax({
                            that._core.xhr({
                                url: tileUrl,
                                type: "get",
                                dataType: "json",
                                success: function (data) {
                                    var de = data;
                                    that._tileWidth = 256;
                                    that._tileHeight = 256;
                                    that.x = tile._x;
                                    that.y = tile._y;
                                    that.level = tile._level;
                                    that._createCanvas();
                                    that._drawGeojson(that._context, 0, 0, data, boundingRect, that._tileWidth, that._tileHeight, that._fill, that._outline, that.x, that.y, that.level);
                                    var li = that._viewer.entities.add({
                                        ids: de,
                                        name: 'Rotating rectangle with rotating texture coordinate',
                                        rectangle: {
                                            coordinates: tile.rectangle,
                                            material: new that._cesium.ImageMaterialProperty({
                                                // image: new Cesium.CallbackProperty(drawCanvas, false),
                                                image: that._canvas,
                                                transparent: true
                                            }),
                                            zIndex: tile.level,
                                            classificationType: that._cesium.ClassificationType.BOTH
                                            // rotation: new Cesium.CallbackProperty(getRotationValue, false),
                                            // stRotation: new Cesium.CallbackProperty(getRotationValue, false)
                                        }
                                    });
                                    that.probj.push(li);
                                    var Obj = {
                                        level: tile.level,
                                        key: downLoadKey,
                                        data: li
                                    };
                                    that.loadFinishKey.push(downLoadKey);
                                    that.PrimitiveData.push(Obj);
                                    that.returnCount++;
                                    //that.removeObsoleteEntities(tile);
                                    that.removeObsoleteEntitiesxp(tile.rectangle);
                                },
                                error: function () {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                }
                            });

                        })(tile);
                    }
                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            //tile.data.geometryPrimitive.update(frameState);
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                    }
                    return;
                }
            }
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //动态单体化测试(图片服务测试2020/7/31)
    VectorGeoJsonFeatureLayer.prototype.VolumeVectorGeoJsonFeatureLayerOptimizationtest = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        that._defaultStyle = {
            outlineColor: Cesium.Color.fromCssColorString("rgba(209,204,226,0)"),
            lineWidth: 0,
            outline: true,
            fill: true,
            fillColor: Cesium.Color.fromCssColorString("rgba(220,20,60,1)"),
            //fillColor:this._option.fill,
            fillShow: "nod",
            tileCacheSize: 200,
            showMaker: false,
            showCenterLabel: true,
            fontColor: Cesium.Color.fromCssColorString("rgba(255,0,0,1)"),
            labelOffsetX: -10,
            labelOffsetY: -5,
            fontSize: 13,
            fontFamily: "黑体",
            pointColor: Cesium.Color.fromCssColorString("rgba(255,0,0,0)"),
            centerLabelPropertyName: "NAME"
        };
        if (that._option.fill.indexOf("[") != -1) {
            that._defaultStyle.fillShow = that._option.fill;
        } else {
            that._defaultStyle.fillColor = Cesium.Color.fromCssColorString(that._option.fill);
        }
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = null;
            this.tile = tile;
            //解决内存溢出
            if (tile.state === this._cesium.QuadtreeTileLoadState.START && that.item.show) {
                var key = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level > styleOption.level_max + 2) {
                    //解决
                    if (that.probj.length > 0) {
                        for (var s = 0; s < that.probj.length; i++) {
                            that._viewer.entities.remove(that.probj[s]);
                            var index1 = that.probj.indexOf(that.probj[s]);
                            that.probj.splice(index1, 1);
                        }
                    }
                }
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new that._cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new that._cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });

                        tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                //tile.data.geometryPrimitive.update();
                                //if (tile.data.geometryPrimitive._ready) {
                                tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }
                    if (that.PrimitiveData.length > 0) {
                        for (var i = 0; i < that.PrimitiveData.length; i++) {
                            if (that.PrimitiveData[i].key == key) {
                                if (!that.Primitivekey.includes(key)) {
                                    that.Primitivekey.push(key);
                                }
                                return;
                            }
                        }
                    }
                    if (!that.Primitivekey.includes(key)) {
                        that.Primitivekey.push(key);
                        downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                        /**
                         * 请求区块数据
                         */
                        (function (tile) {

                            // Create random lines at the root level.
                            var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                            that.tilesLength++;
                            var downLoadKey = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;

                            if (that._cache) {
                                tileUrl += '&' + that._core.getuid();
                            }
                            //var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                            ({
                                xMin: Cesium.Math.toDegrees(tile._rectangle.west),
                                yMin: Cesium.Math.toDegrees(tile._rectangle.south),
                                xMax: Cesium.Math.toDegrees(tile._rectangle.east),
                                yMax: Cesium.Math.toDegrees(tile._rectangle.north)
                            });

                            // $.ajax({
                            that._core.xhr({
                                url: tileUrl,
                                type: "get",
                                dataType: "json",
                                success: function (data) {
                                    var de = data;
                                    that._tileWidth = 256;
                                    that._tileHeight = 256;
                                    that.x = tile._x;
                                    that.y = tile._y;
                                    that.level = tile._level;
                                    // that._createCanvas();
                                    // that._drawGeojson(that._context, 0, 0, data, boundingRect, that._tileWidth, that._tileHeight, that._fill, that._outline, that.x, that.y, that.level);
                                    var li = that._viewer.entities.add({
                                        ids: de,
                                        name: 'Rotating rectangle with rotating texture coordinate',
                                        rectangle: {
                                            coordinates: tile.rectangle,
                                            material: new that._cesium.ImageMaterialProperty({
                                                // image: new Cesium.CallbackProperty(drawCanvas, false),
                                                // image: that._canvas,
                                                image: data,
                                                transparent: true
                                            }),
                                            zIndex: tile.level,
                                            classificationType: that._cesium.ClassificationType.BOTH
                                            // rotation: new Cesium.CallbackProperty(getRotationValue, false),
                                            // stRotation: new Cesium.CallbackProperty(getRotationValue, false)
                                        }
                                    });
                                    that.probj.push(li);
                                    var Obj = {
                                        level: tile.level,
                                        key: downLoadKey,
                                        data: li
                                    };
                                    that.loadFinishKey.push(downLoadKey);
                                    that.PrimitiveData.push(Obj);
                                    that.returnCount++;
                                    //that.removeObsoleteEntities(tile);
                                    that.removeObsoleteEntitiesxp(tile.rectangle);
                                },
                                error: function () {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                }
                            });

                        })(tile);
                    }
                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            //tile.data.geometryPrimitive.update(frameState);
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                    }
                    return;
                }
            }
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //动态单体化测试(grodprimate服务测试2020/7/31)
    VectorGeoJsonFeatureLayer.prototype.VolumeVectorGeoJsonFeatureLayerOptimizationGroundtest = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = parseFloat(styleOption.height || 0);
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    //var levelError = that.getLevelMaximumGeometricError(tile.level);
                    // if (tile.level < 16) {
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }

                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data1) {
                                var data = lodash.cloneDeep(data1);
                                if (data.features.length <= 0) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    return;
                                }
                                if (data == undefined) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    return;
                                }
                                var geometries = [];
                                //图例
                                that.Legend = [];
                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                            if (i === 2 && !haveZ) {
                                                haveZ = true;
                                            }
                                        }
                                    }
                                }
                                function createobj() {
                                    if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                        var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                    }
                                    //options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                    options.material = that._option.material;
                                    if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                        var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                        options.material = feature.properties[material];

                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.material)) {
                                            options.material = that._color.colorFromHtmlColor(options.material);
                                        } else {
                                            if (/^rgb/.test(options.material)) {
                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                            }
                                            if (options.material.red > 1) {
                                                options.material.red = options.material.red / 255;
                                            }
                                            if (options.material.green > 1) {
                                                options.material.green = options.material.green / 255;
                                            }
                                            if (options.material.blue > 1) {
                                                options.material.blue = options.material.blue / 255;
                                            }
                                            if (options.material.alpha > 1) {
                                                options.material.a = options.material.alpha / 255;
                                            }
                                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                        }
                                    } else {
                                        if (that._option.material) {
                                            options.material = that._option.material;
                                        }
                                        if (options.material) {
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }

                                        }
                                    }
                                    if (newArr.length >= 2) {
                                        var pos = haveZ ?
                                            that._cesium.Cartesian3.fromDegreesArrayHeights(newArr) :
                                            that._cesium.Cartesian3.fromDegreesArray(newArr)
                                            ;
                                        options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                        //基础面
                                        var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                        //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);

                                        //样式属性
                                        feature.treeID = options.id;
                                        feature.VectorType = 'polygon';
                                        feature.VectorStyle = {
                                            haveZ: haveZ,
                                            extrudedHeight: options.extrudedHeight,
                                            positions: newArr,
                                            material: options.material
                                        };

                                        var geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: extrudedPolygon,
                                            attributes: {
                                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                            }
                                        });
                                        //图例
                                        var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                        that.Legend.push(col);
                                        geometries.push(geometryInstance);
                                    }
                                    //geometries.push(geometryInstance1);
                                }
                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    var haveZ = false;
                                    var feature = data.features[i];

                                    //fun(data.features[i].geometry.coordinates[0]);
                                    //解析坐标
                                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                newArr = [];
                                                feature.geometry.coordinates[j].pop();
                                                fun(feature.geometry.coordinates[j]);
                                                createobj();
                                            }
                                        } else {
                                            fun(feature.geometry.coordinates);
                                            createobj();
                                        }
                                    }
                                }

                                /**
                                 * 请求到的数据为空
                                 */
                                if (geometries.length == 0) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                }

                                var Primitive = new that._cesium.GroundPrimitive({
                                    geometryInstances: geometries,
                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                        translucent: false,
                                        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                    }),
                                    classificationType: that._cesium.ClassificationType.BOTH,
                                    shadows: that._option.shadows
                                });
                                that.probj.push(Primitive);
                                tile.data.geometryPrimitive = Primitive;

                                // tile.data.geometryPrimitive = new Cesium.Primitive({
                                //     geometryInstances: geometries,
                                //     appearance: new Cesium.MaterialAppearance({
                                //         material: new Cesium.Material({
                                //             fabric: {
                                //                 type: 'Color',
                                //                 uniforms: {
                                //                     color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                //                 }
                                //             }
                                //         }),
                                //         faceForward: true,
                                //         flat: false
                                //     }),
                                //     shadows: Cesium.ShadowMode.ENABLED
                                // });

                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    tile.data.geometryPrimitive.update(frameState, []);
                                    //tile.data.geometryPrimitive.updateForPick = new that._cesium.QuadtreePrimitive({
                                    //    tileProvider: this._Provider
                                    //})._tileProvider.updateForPick(frameState);
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            },
                            error: function () {
                                if (tile.count == undefined) {
                                    tile.count = 0;
                                }
                                tile.count += 1;
                                if (tile.count >= 2) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    // return;
                                }
                                else {
                                    tile.state = Cesium.QuadtreeTileLoadState.START;
                                }
                            }
                        });
                        // Create random lines at the root level.

                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };


        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 5
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption,
            treeData: { "name": name, "geoOptions": geoOptions, "styleOption": styleOption, "GroupID": GroupID, "checked": checked, "disFnc": disFnc }
        };
        this._Provider.treeID = obj.id;

        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //json转图片测试
    VectorGeoJsonFeatureLayer.prototype.createGeojsonImage = function (url) {
        let eval2 = eval;
        Cesium.loadText("http://36.7.136.132:8090/geoserver/swagger/ows?service=WFS&version=1.0.0&request=GetFeature&typeName=swagger%3A_20200410153959_JZ11&maxFeatures=50&outputFormat=application%2Fjson").then(function (geojson) {
            geojson = eval2("(" + geojson + ")");
            for (var i = 0; i < geojson.features.length; i++) {
                if (i == 0) {
                    geojson.features[i].properties.nod = 'rgba(255,255,0,1)';
                } else if (i == 1) {
                    geojson.features[i].properties.nod = 'rgba(220,20,60,1)';
                } else if (i == 2) {
                    geojson.features[i].properties.nod = 'rgba(75,0,130,1)';
                } else if (i == 3) {
                    geojson.features[i].properties.nod = 'rgba(0,0,255,1)';
                } else if (i == 4) {
                    geojson.features[i].properties.nod = 'rgba(30,144,255,1)';
                } else {
                    geojson.features[i].properties.nod = 'rgba(50,205,50,1)';
                }
            }
            Cesium.turf;
            try {
                var bufferedOuterProvider = new VectorTileImageryProvider({
                    source: geojson,
                    zIndex: 99,
                    removeDuplicate: false,
                    defaultStyle: {
                        outlineColor: "rgba(209,204,226,1)",
                        lineWidth: 0,
                        outline: true,
                        fill: true,
                        fillColor: "rgba(209,204,226,1)",
                        fillShow: "[nod]",
                        tileCacheSize: 200,
                        showMaker: false,
                        showCenterLabel: true,
                        fontColor: "rgba(255,0,0,1)",
                        labelOffsetX: -10,
                        labelOffsetY: -5,
                        fontSize: 13,
                        fontFamily: "黑体",
                        centerLabelPropertyName: "NAME"
                    },
                    maximumLevel: 20,
                    minimumLevel: 15,
                    simplify: false
                });
                var bufferedOuterLayer;
                bufferedOuterProvider.readyPromise.then(function () {
                    bufferedOuterLayer = viewer.imageryLayers.addImageryProvider(bufferedOuterProvider);
                    Cesium.Camera.DEFAULT_VIEW_RECTANGLE = bufferedOuterProvider.rectangle;
                });
            } catch (e) {
                console.log(e);
            }
        });
    };
    //json生成图片
    VectorGeoJsonFeatureLayer.prototype._drawGeojson = function (context, x, y, geojson, boundingRect, width, height, fill, stroke, row, col, level) {
        var that = this;
        if (typeof fill == 'undefined') {
            fill = true;
        }
        if (typeof stroke == 'undefined') {
            stroke = true;
        }
        if (!fill && !stroke) {
            return undefined;
        }
        if (typeof width == 'undefined') {
            width = context.canvas.width - x;
        }
        if (typeof height == 'undefined') {
            height = context.canvas.height - y;
        }
        var projection = new LonLatProjection(width, height);
        var style = this._defaultStyle;
        var makerStyle = {
            labelStroke: style.labelStroke,
            labelStrokeWidth: style.labelStrokeWidth,
            labelStrokeColor: style.labelStrokeColor,
            pointSize: style.pointSize,
            fontSize: style.fontSize,
            fontFamily: style.fontFamily,
            color: style.fontColor.toCssColorString(),
            backgroundColor: style.pointColor.toCssColorString(),
            pointStyle: style.pointStyle,//'Solid','Ring','Circle'
            ringRadius: style.ringRadius,
            circleLineWidth: style.circleLineWidth,
            showMaker: style.showMaker,
            showLabel: style.showLabel,
            labelOffsetX: style.labelOffsetX,
            labelOffsetY: style.labelOffsetY,
            markerSymbol: style.makerImage instanceof Image ? style.makerImage : style.makerImageEl
        };
        var holes = [];
        if (that._styleFilter) {
            turf.featureEach(geojson, function (currentFeature, currentFeatureIndex) {
                if (that._styleFilter) {
                    style = that._defaultStyle.clone();
                    that._styleFilter(currentFeature, style, row, col, level);
                    currentFeature.style = style;
                }
            });
            geojson.features.sort(function (a, b) {
                if (a.style && a.style.lineDash) {
                    return 1;
                }
                if (b.style && b.style.lineDash) {
                    return -1;
                }
                return 0;
            });
        }

        function drawFeature(currentFeature, currentFeatureIndex) {

            if (that._styleFilter) {
                style = currentFeature.style;
                if (style.show == false) {
                    return;
                }

                makerStyle = {
                    labelStroke: style.labelStroke,
                    labelStrokeWidth: style.labelStrokeWidth,
                    labelStrokeColor: style.labelStrokeColor,
                    pointSize: style.pointSize,
                    fontSize: style.fontSize,
                    fontFamily: style.fontFamily,
                    color: style.fontColor.toCssColorString(),
                    backgroundColor: style.pointColor.toCssColorString(),
                    pointStyle: style.pointStyle,//'Solid','Ring','Circle'
                    ringRadius: style.ringRadius,
                    circleLineWidth: style.circleLineWidth,
                    showMaker: style.showMaker,
                    showLabel: style.showLabel,
                    labelOffsetX: style.labelOffsetX,
                    labelOffsetY: style.labelOffsetY,
                    markerSymbol: style.makerImage instanceof Image ? style.makerImage : style.makerImageEl
                };
            } else {
                style = that._defaultStyle;
            }
            context.lineWidth = style.lineWidth;
            context.strokeStyle = style.outlineColor.toCssColorString();// "rgb(255,255,0)";
            context.fillStyle = style.fillColor.toCssColorString();// "rgba(0,255,255,0.0)";
            //xp修改
            if (style.fillShow.indexOf("[") != -1) {
                var ki = style.fillShow.replace("[", "").replace("]", "");
                context.fillStyle = currentFeature.properties[ki];
            }
            //context.fillStyle = currentFeature.properties["nod"];
            if (style.lineDash) {
                context.setLineDash(style.lineDash);
            }

            context.lineCap = style.lineCap;
            if (style.shadowColor && style.shadowColor instanceof Cesium.Color) {
                context.shadowColor = style.shadowColor.toCssColorString();
            } else {
                context.shadowColor = style.shadowColor;
            }
            context.shadowBlur = style.shadowBlur;
            context.shadowOffsetX = style.shadowOffsetX;
            context.shadowOffsetY = style.shadowOffsetY;
            context.miterLimit = style.miterLimit;
            context.lineJoin = style.lineJoin;

            if (currentFeature.geometry.type == "Point") {
                drawMarker(context, projection, boundingRect, x, y, currentFeature, fill, stroke, style.labelPropertyName, makerStyle);
            }
            else if (currentFeature.geometry.type == "Polygon" && style.fill) {
                var contours = turf.getCoords(currentFeature);
                var tempHoles = drawContours(context, projection, boundingRect, x, y, contours, true, false);
                if (tempHoles) {
                    tempHoles.map(function (hole) {
                        hole.style = style;
                        holes.push(hole);
                    });
                }
                //drawContours(context, projection, boundingRect, x, y, contours, true, false, style);
            } else if (currentFeature.geometry.type == "MultiPolygon" && style.fill) {
                var polygons;
                try {
                    polygons = turf.getCoords(currentFeature);
                    polygons.map(function (contours) {
                        var tempHoles = drawContours(context, projection, boundingRect, x, y, contours, true, false, style);
                        if (tempHoles) {
                            tempHoles.map(function (hole) {
                                hole.style = style;
                                holes.push(hole);
                            });

                        }
                    });

                } catch (e) {
                    //     console.log(e);
                }
            } else if (currentFeature.geometry.type == "MultiLineString") {
                if (currentFeature.properties.isOutline && !style.outline) ; else {
                    var contours = turf.getCoords(currentFeature);
                    drawContours(context, projection, boundingRect, x, y, contours, false, true);
                    contours = null;
                }

            }
            else if (currentFeature.geometry.type == "LineString") {
                if (currentFeature.properties.isOutline && !style.outline) ; else {
                    var contour = turf.getCoords(currentFeature);
                    var contours = [contour];
                    drawContours(context, projection, boundingRect, x, y, contours, false, true);
                    contour = null;
                    contours = null;

                }
            }
        }
        /**
    * 挖孔
    * @param {any} context
    * @param {any} projection
    * @param {any} boundingRect
    * @param {any} x
    * @param {any} y
    * @param {any} holes
    */
        function createHoles(context, projection, boundingRect, x, y, holes) {
            var tileCanvas = context.canvas;
            var imgData = context.getImageData(0, 0, tileCanvas.width, tileCanvas.height);

            var holeMaskCanvas = document.createElement("canvas");
            holeMaskCanvas.width = tileCanvas.width;
            holeMaskCanvas.height = tileCanvas.height;
            var holeMaskCtx = holeMaskCanvas.getContext("2d");

            var mask = [];
            holes.map(function (hole) {
                holeMaskCtx.clearRect(0, 0, holeMaskCanvas.width, holeMaskCanvas.height);
                holeMaskCtx.beginPath();
                var pointIndex = 0;
                hole.map(function (coordinate) {
                    var pt = projection.project(coordinate, boundingRect);
                    if (pointIndex == 0) {
                        holeMaskCtx.moveTo(x + pt.x, y + pt.y);
                    } else {
                        holeMaskCtx.lineTo(x + pt.x, y + pt.y);
                    }
                    pointIndex++;
                });
                holeMaskCtx.closePath();


                holeMaskCtx.fillStyle = "rgba(255,255,255,1)";
                holeMaskCtx.fill();
                mask = holeMaskCtx.getImageData(0, 0, holeMaskCanvas.width, holeMaskCanvas.height).data;
                for (var i = 3; i < mask.length; i += 4) {
                    if (mask[i] > 0) {
                        imgData.data[i] = 0;
                    }
                }

            });
            context.putImageData(imgData, 0, 0);
        }
        turf.featureEach(geojson, function (fc, idx) {
            if (fc.geometry.type == "Polygon" || fc.geometry.type == "MultiPolygon") {
                //xp
                drawFeature(fc);
                //var li=viewer.entities.add({
                //    name: 'Rotating rectangle with rotating texture coordinate',
                //    rectangle: {
                //        coordinates: Cesium.Rectangle.fromDegrees(-90.0, 30.0, -70.0, 35.0),
                //        material: new Cesium.ImageMaterialProperty({
                //            // image: new Cesium.CallbackProperty(drawCanvas, false),
                //            image: context,
                //            transparent: true
                //        }),
                //        classificationType: Cesium.ClassificationType.BOTH
                //        // rotation: new Cesium.CallbackProperty(getRotationValue, false),
                //        // stRotation: new Cesium.CallbackProperty(getRotationValue, false)
                //    }
                //});
                //viewer.zoomTo(li);
            }
        });
        if (holes && holes.length) {
            createHoles(context, projection, boundingRect, x, y, holes);
        }
        turf.featureEach(geojson, function (fc, idx) {
            if (fc.geometry.type == "LineString" || fc.geometry.type == "MultiLineString") {
                drawFeature(fc);

            }
        });
        turf.featureEach(geojson, function (fc, idx) {
            if (fc.geometry.type == "Point" || fc.geometry.type == "MultiPoint") {
                drawFeature(fc);

            }
        });

    };
    //创建canvas
    VectorGeoJsonFeatureLayer.prototype._createCanvas = function () {
        this._canvas = document.createElement("canvas");
        this._canvas.width = this._tileWidth;
        this._canvas.height = this._tileHeight;
        this._context = this._canvas.getContext("2d");
        this._context.lineWidth = this._defaultStyle.lineWidth;
        this._context.strokeStyle = this._defaultStyle.outlineColor.toCssColorString();// "rgb(255,255,0)";
        this._context.fillStyle = this._defaultStyle.fillColor.toCssColorString();// "rgba(0,255,255,0.0)";
    };
    //绘制多边形（面或线）
    function drawContours(context, projection, boundingRect, x, y, contours, fill, stroke, style) {
        var count = 0;
        var holes = [];
        contours.map(function (contour) {
            if (!fill || count <= 0) {
                var pointIndex = 0;
                context.beginPath();
                contour.map(function (coordinate) {
                    var pt = projection.project(coordinate, boundingRect);
                    if (pointIndex == 0) {
                        context.moveTo(x + pt.x, y + pt.y);
                    } else {
                        context.lineTo(x + pt.x, y + pt.y);
                    }
                    pointIndex++;
                });

                if (fill) {
                    context.closePath();
                    context.fill(); //context.stroke();
                }
                if (stroke) {
                    context.stroke();
                }

            } else {
                holes.push(contour);
            }
            count++;
        });
        if (fill) {
            return holes;
        } else {
            holes = null;
        }
    }
    /**
     * 返回图例
     * @returns {object}
     */
    VectorGeoJsonFeatureLayer.prototype.getLegend = function () {
        var legend = [];
        if (this.Legend != null) {
            legend = this._core.unique(this.Legend);
        }
        return legend;
    };
    VectorGeoJsonFeatureLayer.prototype.removeObsoletePrimitives1 = function (title) {

    };
    /**
     * 移除过期的瓦片
     *
     * @param {Object} primitiveByTile 瓦片 primitive，以 tileKey 索引
     * @param {String[]} tileKeys 当前有效的瓦片 keys
     */
    VectorGeoJsonFeatureLayer.prototype.removeObsoletePrimitives = function (tile) {
        //删除超出层级的对象
        var tilesToRender = this._viewer.scene.globe._surface._tilesToRender;
        var levels = tilesToRender.map(function (tile) {
            return tile.level;
        });
        var minLevel = Math.min.apply(Math, _toConsumableArray$2(levels));
        var maxLevel = Math.max.apply(Math, _toConsumableArray$2(levels));

        for (var i = (this.PrimitiveData.length - 1); i >= 0; i--) {
            var PrimitiveObj = this.PrimitiveData[i];
            if (PrimitiveObj.level < (minLevel) || PrimitiveObj.level > (maxLevel)) {
                var removed = this._viewer.scene.primitives.remove(PrimitiveObj.data);
                if (removed) {
                    var index = this.Primitivekey.indexOf(this.loadFinishKey[i]);
                    if (index > -1) {
                        this.Primitivekey.splice(index, 1);
                    }
                    this.PrimitiveData.splice(i, 1);
                    this.loadFinishKey.splice(i, 1);
                }
            }
        }
        //删除相关节点对象
        //一共需要删除2层2个父节点，2层子节点，第一层4个，第二层16个，共需要删除22个
        var deleteTiles = [];

        var parentTile = tile.parent;
        //deleteTiles.push(parentTile);
        if (parentTile && parentTile.parent) {
            var parentTileParent = parentTile.parent;
            deleteTiles.push(parentTileParent);
        }
        var childrenTiles = tile.children;
        deleteTiles = deleteTiles.concat(childrenTiles);
        for (var i = 0; i < childrenTiles.length; i++) {
            var childrenTileChildrens = childrenTiles[i].children;
            deleteTiles = deleteTiles.concat(childrenTileChildrens);
        }

        for (var i = 0; i < deleteTiles.length; i++) {
            if (deleteTiles[i]) {
                var key = 'z' + deleteTiles[i].level + 'x' + deleteTiles[i].x + 'y' + deleteTiles[i].y;
                var index = this.loadFinishKey.indexOf(key);
                if (index > -1) {
                    var removed = this._viewer.scene.primitives.remove(this.PrimitiveData[index].data);
                    if (removed) {
                        var index = this.Primitivekey.indexOf(key);
                        if (index > -1) {
                            this.Primitivekey.splice(index, 1);
                        }
                        this.PrimitiveData.splice(index, 1);
                        this.loadFinishKey.splice(index, 1);
                    }
                }
            }
        }
        //var childrenTileChildrens = [];










        /*   var deleteTileKeys = [];
          if (tileKeys.length > 0) {
              // deleteTileKeys = tileKeys.slice(0, Math.ceil(tileKeys.length / 10));
              deleteTileKeys = tileKeys;
          }
          for (var tileKey in primitiveByTile) {
              if (!deleteTileKeys.includes(tileKey)) {
                  //var removed = this._viewer.scene.primitives.remove(primitiveByTile[tileKey]);
                  var removed = this._primitiveCollection.remove(primitiveByTile[tileKey]);
                  if (removed) {
                      delete primitiveByTile[tileKey];
                  } else { }
              }
          } */
    };

    /**
     * 移除过期的瓦片
     *
     * @param {Object} primitiveByTile 瓦片 primitive，以 tileKey 索引
     * @param {String[]} tileKeys 当前有效的瓦片 keys
     */
    VectorGeoJsonFeatureLayer.prototype.removeObsoleteEntities = function (tile) {
        //删除超出层级的对象
        var tilesToRender = this._viewer.scene.globe._surface._tilesToRender;
        var levels = tilesToRender.map(function (tile) {
            return tile.level;
        });
        var minLevel = Math.min.apply(Math, _toConsumableArray$2(levels)) - 1;
        var maxLevel = Math.max.apply(Math, _toConsumableArray$2(levels)) + 1;

        for (var i = (this.PrimitiveData.length - 1); i >= 0; i--) {
            var PrimitiveObj = this.PrimitiveData[i];
            if (PrimitiveObj.level < (minLevel) || PrimitiveObj.level > (maxLevel)) {
                var removed = this._viewer.entities.remove(PrimitiveObj.data);
                if (removed) {
                    var index = this.Primitivekey.indexOf(this.loadFinishKey[i]);
                    if (index > -1) {
                        this.Primitivekey.splice(index, 1);
                    }
                    this.PrimitiveData.splice(i, 1);
                    this.loadFinishKey.splice(i, 1);
                }
            }
        }
        //删除相关节点对象
        //一共需要删除2层2个父节点，2层子节点，第一层4个，第二层16个，共需要删除22个
        var deleteTiles = [];

        var parentTile = tile.parent;
        //deleteTiles.push(parentTile);
        if (parentTile && parentTile.parent) {
            var parentTileParent = parentTile.parent;
            deleteTiles.push(parentTileParent);
        }
        var childrenTiles = tile.children;
        deleteTiles = deleteTiles.concat(childrenTiles);
        for (var i = 0; i < childrenTiles.length; i++) {
            var childrenTileChildrens = childrenTiles[i].children;
            deleteTiles = deleteTiles.concat(childrenTileChildrens);
        }

        for (var i = 0; i < deleteTiles.length; i++) {
            if (deleteTiles[i]) {
                var key = 'z' + deleteTiles[i].level + 'x' + deleteTiles[i].x + 'y' + deleteTiles[i].y;
                var index = this.loadFinishKey.indexOf(key);
                if (index > -1) {
                    var removed = this._viewer.entities.remove(this.PrimitiveData[index].data);
                    if (removed) {
                        var index = this.Primitivekey.indexOf(key);
                        if (index > -1) {
                            this.Primitivekey.splice(index, 1);
                        }
                        this.PrimitiveData.splice(index, 1);
                        this.loadFinishKey.splice(index, 1);
                    }
                }
            }
        }
    };

    /**
    * 移除过期的瓦片xp
    *
    * @param {Object} primitiveByTile 瓦片 primitive，以 tileKey 索引
    * @param {String[]} tileKeys 当前有效的瓦片 keys
    */
    VectorGeoJsonFeatureLayer.prototype.removeObsoleteEntitiesxp = function (dqrectangle) {
        //删除上层面
        //左上经纬度
        var zs1 = this._cesium.Cartesian3.fromDegrees(this._cesium.Math.toDegrees(dqrectangle.west), this._cesium.Math.toDegrees(dqrectangle.south));
        //右下经纬度
        var yx1 = this._cesium.Cartesian3.fromDegrees(this._cesium.Math.toDegrees(dqrectangle.east), this._cesium.Math.toDegrees(dqrectangle.north));
        for (var j = 0; j < this.probj.length; j++) {
            this._cesium.Rectangle.contains(this.probj[j].rectangle.coordinates.getValue(), this._cesium.Cartographic.fromCartesian(zs1));
            this._cesium.Rectangle.contains(this.probj[j].rectangle.coordinates.getValue(), this._cesium.Cartographic.fromCartesian(yx1));
        }
        //删除视野范围外面
        var pmrectangle = this._viewer.camera.computeViewRectangle();
        for (var i = 0; i < this.probj.length; i++) {
            //弧度
            var kljx = this.probj[i].rectangle.coordinates.getValue();
            //左上经纬度
            var zs = this._cesium.Cartesian3.fromDegrees(this._cesium.Math.toDegrees(kljx.west), this._cesium.Math.toDegrees(kljx.south));
            //右下经纬度
            var yx = this._cesium.Cartesian3.fromDegrees(this._cesium.Math.toDegrees(kljx.east), this._cesium.Math.toDegrees(kljx.north));
            var v1 = this._cesium.Rectangle.contains(pmrectangle, this._cesium.Cartographic.fromCartesian(zs));
            var v2 = this._cesium.Rectangle.contains(pmrectangle, this._cesium.Cartographic.fromCartesian(yx));
            if (v1 || v2) {
                this.probj[i].show = true;
            } else {
                this.probj[i].show = false;
                //this._viewer.entities.remove(this.probj[i]);
                //var index = this.probj.indexOf(this.probj[i]);
                //this.probj.splice(index,1);
            }
        }
    };
    /**
     * 生成管状数据
     * @param {Float} radians
     */
    VectorGeoJsonFeatureLayer.prototype.computeCircle = function (radius) {
        if (this._core.isnull(radius)) {
            radius = 4;
        }
        var positions = [];
        for (var i = 0; i < 360; i++) {
            var radians = this._cesium.Math.toRadians(i);
            positions.push(new this._cesium.Cartesian2(radius * Math.cos(radians), radius * Math.sin(radians)));
        }
        return positions;
    };
    //工程树添加
    VectorGeoJsonFeatureLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 导出工程数据
     */
    VectorGeoJsonFeatureLayer.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url,
                pId: this.treeobj.pId
            },
            treeData: this.treeobj.treeData
        };
    };
    /**
     * 删除数据
     */
    VectorGeoJsonFeatureLayer.prototype.deleteObject = function () {
        this._viewer.scene.primitives.remove(this.item);
        if (this.probj && this.probj.length > 0) {
            this._viewer.scene.primitives.remove(this.probj[0]);
            this.probj.pop();
        }
        if (this.img != null) {
            this._viewer.imageryLayers.remove(this.img);
        }
        if (this.primitve && this.primitve.length > 0) {
            for (var i = 0; i < this.primitve.length; i++) {
                this._viewer.scene.primitives.remove(this.primitve[i]);
            }
            this.primitve = [];
        }
        if (this.loadAllKey && this.loadAllKey.length > 0) {
            this.loadAllKey = [];
        }
        try {
            this._Provider.remove();
        } catch (ex) {
        }
    };
    /**
     * 设置数据是否刷新
     */
    VectorGeoJsonFeatureLayer.prototype.setRefresh = function (b) {
        try {
            if (this._Provider) {
                this._Provider.setStatus(b);
            }
        } catch (ex) {
        }
    };
    /**
     * 获取层级
     */
    VectorGeoJsonFeatureLayer.prototype.getLevel = function () {
        var A = 40487.57;
        var B = 0.00007096758;
        var C = 91610.74;
        var D = -40467.74;

        var camera = this._viewer.camera, height, level;
        if (camera && camera.positionCartographic && camera.positionCartographic.height) {
            var groundHeightAtCameraPosition = this._viewer.scene.globe.getHeight(camera.positionCartographic);
            !groundHeightAtCameraPosition && (groundHeightAtCameraPosition = 0);
            height = camera.positionCartographic.height - groundHeightAtCameraPosition;
            level = Math.round(D + (A - D) / (1 + Math.pow(height / C, B)));
        } else {
            level = 0;
        }
        return level;
    };
    /**
     * 设置数据显示隐藏
     */
    VectorGeoJsonFeatureLayer.prototype.setVisibility = function (b) {
        try {
            this.loadAllKey = [];
            if (this.item != undefined && this.item.show != undefined) {
                this.item.show = b;
            }
            if (this.img != null) {
                this.img.show = b;
            }
            if (this.primitve && this.primitve.length > 0) {
                for (var i = 0; i < this.primitve.length; i++) {
                    this.primitve[i].show = b;
                }
            }
            if (this._Provider && this._Provider.setStatus) {
                this._Provider.setStatus(b);
            }
            if (this.probj && this.probj.length > 0) {
                for (var i = 0; i < this.probj.length; i++) {
                    //this._viewer.scene.primitives.remove(this.probj[i]);
                    this.probj[i].show = b;
                    // this._viewer.scene.primitives.remove(this.probj[i]);
                }
            }
        } catch (ex) {
        }
    };

    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    VectorGeoJsonFeatureLayer.prototype.edit = function (open, option) {
        this.isEditting = open;
        this.editoption = option;
        return this._Provider && this._Provider.edit && this._Provider.edit(open, option);
    };

    /**
     * 是否强制清除缓存
     * @param {Boolean} b 
     */
    VectorGeoJsonFeatureLayer.prototype.isCache = function (b) {
        this._cache = b;
    };

    /**
     * 设置数据是否刷新
     */
    VectorGeoJsonFeatureLayer.prototype.forceRefresh = function () {
        try {
            // this._cache = true;
            // if (!this._forceRefreshPrvimitive)
            //     this._forceRefreshPrvimitive = loadsh.cloneDeep(this._primitive)
            // var temp = loadsh.cloneDeep(this._forceRefreshPrvimitive)
            // this._viewer.scene.primitives.remove(this._primitive);
            // this._viewer.scene.primitives.add(temp);
            // this._viewer.scene.primitivesQuadTrees.push(temp);
            // // this.edit(this.isEditting, this.editoption);
            // // temp._tileProvider.edit(this.isEditting, this.editoption);

            for (var i = 0; i < this._Provider.quadtree._levelZeroTiles.length; i++) {
                this._Provider.quadtree._levelZeroTiles[i].freeResources();
            }
        } catch (ex) {
        }
    };

    /**
     *
     * 飞向对象。
     *
     * @alias flyTo
     * @constructor
     *
     */
    function flyTo(viewer, cesium, tree) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree;
    }

    flyTo.prototype.flyTo = function (target, Pattern) {
        if (Pattern == 0) {
            for (var i = 0; i < this._tree.length; i++) {
                if (target == this._tree[i].id) {
                    return this._viewer.camera.flyTo({
                        destination: this._cesium.Cartesian3.fromDegrees(this._tree[i].postion[0], this._tree[i].postion[1], this._tree[i].postion[2])
                    });
                }
            }
        }
    };
    //飞向兴趣点
    flyTo.prototype.flyToPointsInterest = function (target, fnc) {
        return this._viewer.camera.flyTo({
            destination: target.destination,
            orientation: target.orientation,
            duration: target.duration,
            complete: fnc
        });
    };
    flyTo.prototype.flyToPosition = function (x, y, z) {
        if (Math.abs(x) <= 180 && Math.abs(y) <= 90) {
            this._viewer.camera.flyTo({
                destination: this._cesium.Cartesian3.fromDegrees(x, y, z)
            });
        } else {
            this._viewer.camera.flyTo({
                destination: { x: x, y: y, z: z }
            });
        }
    };

    /**
     *
     * 线Geojsonu要素图层
     *
     * @alias PolylineGeoJsonFeatureLayer
     * @constructor
     * 
     * @param {Viewer} [viewer] 地图视图
     * @param {Cesium} [cesium] Cesium对象
     */
    function PolylineGeoJsonFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this.item = {
            show: true
        };
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this._flyTo = new flyTo(this._viewer, this._cesium, this._tree);
        this._Provider = undefined;
        //图例
        this.Legend = [];
        this.model = [];
        /**
         * 是否强制清楚缓存
         */
        this._cache = false;
        this._forceRefreshPrvimitive = null;
        this._forceRefreshProvider = null;
    }



    /**
     * 创建geosjon线图层
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象
     * @param {object} [GroupID] 再在工程树父节点id
     * @param {Function} [disFnc] 回调函数
     * @returns {PolylineGeoJsonFeatureLayer}
     */
    PolylineGeoJsonFeatureLayer.prototype.createPolylineGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            positions: [],
            arcType: this._cesium.ArcType.GEODESIC, //	optional The type of line the polyline segments must follow.
            clampToGround: false, //optional A boolean Property specifying whether the Polyline should be clamped to the ground.
            width: 1.0, //optional A numeric Property specifying the width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the polyline.
            material: this._cesium.Color.WHITE, //	optional A Property specifying the material used to draw the polyline.
            height: 30,
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        var that = this;
        dataSource.then(function (dataSource) {
            var entities = dataSource.entities.values;
            var collection = new that._cesium.PrimitiveCollection();
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                var geometryInstance = null;

                if (options.clampToGround) {
                    options.positions = entity.polyline.positions._value;
                    var Polyline = {
                        positions: entity.polyline.positions._value,
                        width: options.width,
                        //arcType: options.arcType
                    };
                    var Polyline = new that._cesium.GroundPolylineGeometry(Polyline);
                    geometryInstance = new that._cesium.GeometryInstance({
                        id: entity,
                        geometry: Polyline,
                        attributes: {
                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                        }
                    });
                } else {
                    var positionsp = [];
                    for (var i = 0; i < entity.polyline.positions._value.length; i++) {
                        that._viewer.scene.globe.ellipsoid;
                        var scartographic = that._cesium.Cartographic.fromCartesian(entity.polyline.positions._value[i]);
                        var slongitude = that._cesium.Math.toDegrees(scartographic.longitude);
                        var slatitude = that._cesium.Math.toDegrees(scartographic.latitude);
                        var sheight = scartographic.height + options.height; //
                        var posit = new that._cesium.Cartesian3.fromDegrees(slongitude, slatitude, sheight);
                        positionsp.push(posit);
                    }
                    options.positions = positionsp;
                    var extrudedPolygon = new that._cesium.PolylineGeometry(options);
                    var geometry = that._cesium.PolylineGeometry.createGeometry(extrudedPolygon);
                    geometryInstance = new that._cesium.GeometryInstance({
                        id: entity,
                        geometry: geometry,
                        attributes: {
                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                        }
                    });
                }
                entity.positions = options.positions;
                //图例
                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                that.Legend.push(col);
                var primitive = null;
                //添加
                if (options.clampToGround) {
                    primitive = new that._cesium.GroundPolylinePrimitive({
                        //classificationType: that._cesium.ClassificationType.BOTH,
                        geometryInstances: geometryInstance,
                        appearance: new that._cesium.MaterialAppearance({
                            material: new that._cesium.Material({
                                fabric: {
                                    type: 'Color',
                                    uniforms: {
                                        // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                        color: options.material
                                    }
                                }
                            }),
                            faceForward: true,
                            flat: false
                        }),
                    });
                } else {
                    primitive = new that._cesium.Primitive({
                        geometryInstances: geometryInstance,
                        //appearance: new that._cesium.PolylineColorAppearance({
                        //    flat: true,
                        //    translucent: true,
                        //    faceForward: true,
                        //    closed: true
                        //}),
                        appearance: new that._cesium.PolylineMaterialAppearance({
                            material: new that._cesium.Material({
                                fabric: {
                                    type: 'Color',
                                    uniforms: {
                                        // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                        color: options.material
                                    }
                                }
                            }),
                        }),
                        shadows: that._cesium.ShadowMode.ENABLED
                    });
                }
                collection.add(primitive);
            }
            //添加时间段
            var time;
            if (option && option.time) {
                time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                    start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                    stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
                })]);
            }
            var ps = that._viewer.scene.primitives.add(collection, time);
            ps.show = options.show;
            that.item = collection;
            //that._flyTo.flyToObj(dx);
            if (checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(that.item);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineLayer',
            item: this,
            url: geojsonOrurl,
            style: options
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    PolylineGeoJsonFeatureLayer.prototype.createGroundPolylineGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            positions: [],
            arcType: this._cesium.ArcType.GEODESIC, //	optional The type of line the polyline segments must follow.
            clampToGround: false, //optional A boolean Property specifying whether the Polyline should be clamped to the ground.
            width: 1.0, //optional A numeric Property specifying the width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the polyline.
            material: this._cesium.Color.WHITE, //	optional A Property specifying the material used to draw the polyline.
            height: 30,
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        var that = this;
        dataSource.then(function (dataSource) {
            var entities = dataSource.entities.values;
            var collection = new that._cesium.PrimitiveCollection();
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                var geometryInstance = null;

                if (options.clampToGround) {
                    options.positions = entity.polyline.positions._value;
                    var Polyline = {
                        positions: entity.polyline.positions._value,
                        width: options.width,
                        //arcType: options.arcType
                    };
                    var Polyline = new that._cesium.GroundPolylineGeometry(Polyline);
                    geometryInstance = new that._cesium.GeometryInstance({
                        id: entity,
                        geometry: Polyline,
                        attributes: {
                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                        }
                    });
                } else {
                    var positionsp = [];
                    for (var i = 0; i < entity.polyline.positions._value.length; i++) {
                        that._viewer.scene.globe.ellipsoid;
                        var scartographic = that._cesium.Cartographic.fromCartesian(entity.polyline.positions._value[i]);
                        var slongitude = that._cesium.Math.toDegrees(scartographic.longitude);
                        var slatitude = that._cesium.Math.toDegrees(scartographic.latitude);
                        var sheight = scartographic.height + options.height; //
                        var posit = new that._cesium.Cartesian3.fromDegrees(slongitude, slatitude, sheight);
                        positionsp.push(posit);
                    }
                    options.positions = positionsp;
                    var extrudedPolygon = new that._cesium.PolylineGeometry(options);
                    var geometry = that._cesium.PolylineGeometry.createGeometry(extrudedPolygon);
                    geometryInstance = new that._cesium.GeometryInstance({
                        id: entity,
                        geometry: geometry,
                        attributes: {
                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                        }
                    });
                }
                entity.positions = options.positions;
                //图例
                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                that.Legend.push(col);
                var primitive = null;
                //添加
                if (options.clampToGround) {
                    primitive = new that._cesium.GroundPolylinePrimitive({
                        //classificationType: that._cesium.ClassificationType.BOTH,
                        geometryInstances: geometryInstance,
                        appearance: new that._cesium.MaterialAppearance({
                            material: new that._cesium.Material({
                                fabric: {
                                    type: 'Color',
                                    uniforms: {
                                        // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                        color: options.material
                                    }
                                }
                            }),
                            faceForward: true,
                            flat: false
                        }),
                    });
                } else {
                    primitive = new that._cesium.Primitive({
                        geometryInstances: geometryInstance,
                        //appearance: new that._cesium.PolylineColorAppearance({
                        //    flat: true,
                        //    translucent: true,
                        //    faceForward: true,
                        //    closed: true
                        //}),
                        appearance: new that._cesium.PolylineMaterialAppearance({
                            material: new that._cesium.Material({
                                fabric: {
                                    type: 'Color',
                                    uniforms: {
                                        // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                        color: options.material
                                    }
                                }
                            }),
                        }),
                        shadows: that._cesium.ShadowMode.ENABLED
                    });
                }
                collection.add(primitive);
            }
            //添加时间段
            var time;
            if (option && option.time) {
                time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                    start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                    stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
                })]);
            }
            var ps = that._viewer.scene.primitives.add(collection, time);
            ps.show = options.show;
            that.item = collection;
            //that._flyTo.flyToObj(dx);
            if (checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(that.item);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineLayer',
            item: this,
            url: geojsonOrurl,
            style: options
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    PolylineGeoJsonFeatureLayer.prototype.createPolylineVectorGeoJsonFeatureLayerProvider1 = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            positions: [],
            arcType: this._cesium.ArcType.GEODESIC, //	optional The type of line the polyline segments must follow.
            clampToGround: false, //optional A boolean Property specifying whether the Polyline should be clamped to the ground.
            width: 1.0, //optional A numeric Property specifying the width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the polyline.
            material: this._cesium.Color.WHITE, //	optional A Property specifying the material used to draw the polyline.
            height: 30,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        //this.options=options;
        /**
         * 请求矢量切片
         */
        var that = this;
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            //测试
            //图例
            that.Legend = [];
            var collection = new that._cesium.PrimitiveCollection();
            json.features.forEach(function (feature) {
                var newArr = [];
                var haveZ = false;
                if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                    var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                    options.material = feature.properties[material];
                    //填充颜色设置
                    if (that._core.isHtmlColor(options.material)) {
                        options.material = that._color.colorFromHtmlColor(options.material);
                    } else {
                        if (/^rgb/.test(options.material)) {
                            options.material = that._color.rgbaStringToRgbaObj(options.material);
                        }
                        if (options.material.r > 1) {
                            options.material.r = options.material.r / 255;
                        }
                        if (options.material.g > 1) {
                            options.material.g = options.material.g / 255;
                        }
                        if (options.material.b > 1) {
                            options.material.b = options.material.b / 255;
                        }
                        if (options.material.a > 1) {
                            options.material.a = options.material.a / 255;
                        }
                        options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                    }
                }

                function fun(arr) {
                    for (var i = 0; i < arr.length; i++) {
                        if (Array.isArray(arr[i])) {
                            fun(arr[i]);
                        } else {
                            newArr.push(arr[i]);
                            if (i === 2 && !haveZ) {
                                haveZ = true;
                            }
                        }
                    }
                }
                //fun(feature.geometry.coordinates);
                if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                    if (Array.isArray(feature.geometry.coordinates[0][0])) {
                        for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                            newArr = [];
                            fun(feature.geometry.coordinates[j]);
                            createobj(newArr);
                        }
                    } else {
                        fun(feature.geometry.coordinates);
                        createobj(newArr);
                    }
                }

                function createobj(newArr) {
                    var pos = haveZ ?
                        that._cesium.Cartesian3.fromDegreesArrayHeights(newArr) :
                        that._cesium.Cartesian3.fromDegreesArray(newArr)
                        ;
                    options.positions = pos;
                    var Polyline = {
                        positions: options.positions,
                        width: options.width,
                        //arcType: options.arcType
                    };
                    feature.positions = pos;

                    //样式属性
                    feature.treeID = options.id;
                    feature.VectorType = 'polyline';
                    feature.VectorStyle = {
                        haveZ: haveZ,
                        width: options.width,
                        positions: newArr,
                        material: options.material,
                        clampToGround: options.clampToGround
                    };

                    var geometryInstance = null;
                    if (options.clampToGround) {
                        //var extrudedPolygon = new Cesium.PolylineGeometry(options);
                        var Polyline = new that._cesium.GroundPolylineGeometry(Polyline);
                        //var geometry = that._cesium.PolylineGeometry.createGeometry(Polyline);
                        geometryInstance = new that._cesium.GeometryInstance({
                            id: feature,
                            geometry: Polyline,
                            attributes: {
                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                            }
                        });
                    } else {
                        var newArrs = newArr;
                        var leg = newArr.length / 2 + 1 + newArr.length;
                        if (/^\[/.test(styleOption.height) && /\]$/.test(styleOption.height)) {
                            var _height = styleOption.height.replace(/\[/, '').replace(/\]/, '');
                            options.height = feature.properties[_height];
                        }
                        for (var i = 2; i < leg; i = i + 3) {
                            newArrs.splice(i, 0, parseFloat(options.height));
                        }
                        var posp = that._cesium.Cartesian3.fromDegreesArrayHeights(newArrs);
                        options.positions = posp;
                        feature.positions = posp;
                        var extrudedPolygon = new that._cesium.PolylineGeometry(options);
                        //var geometry = that._cesium.PolylineGeometry.createGeometry(extrudedPolygon);
                        geometryInstance = new that._cesium.GeometryInstance({
                            id: feature,
                            geometry: extrudedPolygon,
                            attributes: {
                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                            }
                        });
                    }
                    //图例
                    var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                    that.Legend.push(col);
                    //geomInstances.push(geometryInstance);
                    var primitive = null;
                    //添加
                    if (options.clampToGround) {
                        primitive = new that._cesium.GroundPolylinePrimitive({
                            //classificationType: that._cesium.ClassificationType.BOTH,
                            geometryInstances: geometryInstance,
                            appearance: new that._cesium.MaterialAppearance({
                                material: new that._cesium.Material({
                                    fabric: {
                                        type: 'Color',
                                        uniforms: {
                                            // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                            color: options.material
                                        }
                                    }
                                }),
                                faceForward: true,
                                flat: false
                            }),
                        });
                    } else {
                        primitive = new that._cesium.Primitive({
                            geometryInstances: geometryInstance,
                            //appearance: new that._cesium.PolylineColorAppearance({
                            //    flat: true,
                            //    translucent: true,
                            //    faceForward: true,
                            //    closed: true
                            //}),
                            appearance: new that._cesium.PolylineMaterialAppearance({
                                material: new that._cesium.Material({
                                    fabric: {
                                        type: 'Color',
                                        uniforms: {
                                            // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                            color: options.material
                                        }
                                    }
                                }),
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });
                    }
                    collection.add(primitive);
                }
            });
            //that._viewer.scene.groundPrimitives.add(primitive);
            return collection;
        };
        //添加时间段
        if (styleOption && styleOption.time) {
            geoJSONVectorTileProvider.availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this._Provider.treeID = options.id;
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    /**
     * geoserver 矢量切片 线
     * @param {String} name 名称
     * @param {Object} geoOptions 请求矢量参数
     * @param {Object} styleOption 样式参数
     * @param {String} GroupID 工程树所在文件夹id
     * @param {Boolean} checked 是否显示
     * @param {Function} disFnc 回调函数
     * @returns PolylineGeoJsonFeatureLayer
     */
    PolylineGeoJsonFeatureLayer.prototype.createPolylineVectorGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            positions: [],
            arcType: this._cesium.ArcType.GEODESIC, //	optional The type of line the polyline segments must follow.
            clampToGround: false, //optional A boolean Property specifying whether the Polyline should be clamped to the ground.
            width: 1.0, //optional A numeric Property specifying the width in pixels.
            outlineWidth: 1.0, //optional A numeric Property specifying the width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the polyline.
            material: this._cesium.Color.WHITE, //	optional A Property specifying the material used to draw the polyline.
            outlineColor: this._cesium.Color.WHITE, //	optional A Property specifying the material used to draw the polyline.
            height: 30,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4326') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4326'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: styleOption.level_min,
            lowerLevelLimit: styleOption.level_max,
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.outlineColor)) {
            if (styleOption.outlineColor.toString().charAt(0) == "[" && styleOption.outlineColor.toString().charAt(styleOption.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.outlineColor)) {
                    styleOption.outlineColor = this._color.colorFromHtmlColor(styleOption.outlineColor);
                } else {
                    if (/^rgb/.test(styleOption.outlineColor)) {
                        styleOption.outlineColor = this._color.rgbaStringToRgbaObj(styleOption.outlineColor);
                    }
                    if (styleOption.outlineColor.r > 1) {
                        styleOption.outlineColor.r = styleOption.outlineColor.r / 255;
                    }
                    if (styleOption.outlineColor.g > 1) {
                        styleOption.outlineColor.g = styleOption.outlineColor.g / 255;
                    }
                    if (styleOption.outlineColor.b > 1) {
                        styleOption.outlineColor.b = styleOption.outlineColor.b / 255;
                    }
                    if (styleOption.outlineColor.a > 1) {
                        styleOption.outlineColor.a = styleOption.outlineColor.a / 255;
                    }
                    styleOption.outlineColor = this._color.createColor(styleOption.outlineColor.r, styleOption.outlineColor.g, styleOption.outlineColor.b, styleOption.outlineColor.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        //this.options=options;
        /**
         * 请求矢量切片
         */
        var that = this;
        // var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        // this._Provider = geoJSONVectorTileProvider;

        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);

        //获取行列号范围
        that._core.xhr({
            url: geoOptions.url + "?service=WMTS&request=GetCapabilities",
            type: "get",
            isXml: true,
            async: false,
            success: function (data) {
                let xml2json = that._core.xml2json(data);
                let layers = xml2json.Contents && xml2json.Contents.Layer;
                let layer = layers.filter(item => {
                    return item.Identifier === geoOptions.layer;
                })[0];
                if (layer) {
                    let TileMatrixSetLink = layer.TileMatrixSetLink;
                    let srs = geoOptions.srs || 'EPSG:4326';
                    let TileMatrixSet = TileMatrixSetLink.filter(item => {
                        return item.TileMatrixSet === srs;
                    })[0];
                    if (TileMatrixSet) {
                        that.TileMatrixLimits = {};
                        TileMatrixSet.TileMatrixSetLimits && TileMatrixSet.TileMatrixSetLimits.TileMatrixLimits.forEach(item => {
                            let TileMatrix = item.TileMatrix;
                            TileMatrix = TileMatrix.split(":");
                            let level = TileMatrix[TileMatrix.length - 1];
                            that.TileMatrixLimits[level] = {
                                maxCol: item.MaxTileCol,
                                minCol: item.MinTileCol,
                                maxRow: item.MaxTileRow,
                                minRow: item.MinTileRow,
                            };
                        });
                    }
                }
            }
        });

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    //var levelError = that.getLevelMaximumGeometricError(tile.level);
                    // if (tile.level < 16) {
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {

                        //限制行列号范围
                        if (that.TileMatrixLimits) {
                            let Limit = that.TileMatrixLimits[tile.level];
                            if (tile.x > Limit.maxCol || tile.x < Limit.minCol || tile.y > Limit.maxRow || tile.y < Limit.minRow) {
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                                return;
                            }
                        }

                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }
                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                var geomInstances = [];
                                var newArr = [];
                                for (var feature of data.features) {
                                    var newArr = [];
                                    var haveZ = false;
                                    if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                                        var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                                        options.material = feature.properties[material];
                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.material)) {
                                            options.material = that._color.colorFromHtmlColor(options.material);
                                        } else {
                                            if (/^rgb/.test(options.material)) {
                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                            }
                                            if (options.material.r > 1) {
                                                options.material.r = options.material.r / 255;
                                            }
                                            if (options.material.g > 1) {
                                                options.material.g = options.material.g / 255;
                                            }
                                            if (options.material.b > 1) {
                                                options.material.b = options.material.b / 255;
                                            }
                                            if (options.material.a > 1) {
                                                options.material.a = options.material.a / 255;
                                            }
                                            options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                                        }
                                    }

                                    function fun(arr) {
                                        for (var i = 0; i < arr.length; i++) {
                                            if (Array.isArray(arr[i])) {
                                                fun(arr[i]);
                                            } else {
                                                newArr.push(arr[i]);
                                                if (i === 2 && !haveZ) {
                                                    haveZ = true;
                                                }
                                            }
                                        }
                                    }
                                    //fun(feature.geometry.coordinates);
                                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                newArr = [];
                                                fun(feature.geometry.coordinates[j]);
                                                createobj(newArr);
                                            }
                                        } else {
                                            fun(feature.geometry.coordinates);
                                            createobj(newArr);
                                        }
                                    }

                                    function createobj(newArr) {
                                        var pos = haveZ ?
                                            that._cesium.Cartesian3.fromDegreesArrayHeights(newArr) :
                                            that._cesium.Cartesian3.fromDegreesArray(newArr)
                                            ;
                                        options.positions = pos;
                                        var Polyline = {
                                            positions: options.positions,
                                            width: options.width,
                                            //arcType: options.arcType
                                        };
                                        feature.positions = pos;

                                        //样式属性
                                        feature.treeID = options.id;
                                        feature.VectorType = 'polyline';
                                        feature.VectorStyle = {
                                            haveZ: haveZ,
                                            width: options.width,
                                            positions: newArr,
                                            material: options.material,
                                            clampToGround: options.clampToGround
                                        };

                                        var geometryInstance = null;
                                        if (options.clampToGround) {
                                            //var extrudedPolygon = new Cesium.PolylineGeometry(options);
                                            var Polyline = new that._cesium.GroundPolylineGeometry(Polyline);
                                            //var geometry = that._cesium.PolylineGeometry.createGeometry(Polyline);
                                            geometryInstance = new that._cesium.GeometryInstance({
                                                id: feature,
                                                geometry: Polyline,
                                                attributes: {
                                                    color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                                    distanceDisplayCondition: new Cesium.DistanceDisplayConditionGeometryInstanceAttribute(options.near, options.far)
                                                }
                                            });
                                        } else {
                                            var newArrs = newArr;
                                            var leg = newArr.length / 2 + 1 + newArr.length;
                                            if (/^\[/.test(styleOption.height) && /\]$/.test(styleOption.height)) {
                                                var _height = styleOption.height.replace(/\[/, '').replace(/\]/, '');
                                                options.height = feature.properties[_height];
                                            }
                                            for (var i = 2; i < leg; i = i + 3) {
                                                newArrs.splice(i, 0, parseFloat(options.height));
                                            }
                                            var posp = that._cesium.Cartesian3.fromDegreesArrayHeights(newArrs);
                                            options.positions = posp;
                                            feature.positions = posp;
                                            var extrudedPolygon = new that._cesium.PolylineGeometry(options);
                                            //var geometry = that._cesium.PolylineGeometry.createGeometry(extrudedPolygon);
                                            geometryInstance = new that._cesium.GeometryInstance({
                                                id: feature,
                                                geometry: extrudedPolygon,
                                                attributes: {
                                                    color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                                    distanceDisplayCondition: new Cesium.DistanceDisplayConditionGeometryInstanceAttribute(options.near, options.far)
                                                }
                                            });
                                        }
                                        //图例
                                        var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                        that.Legend.push(col);
                                        geomInstances.push(geometryInstance);
                                    }
                                }
                                var geomeitryPrimitive = null;
                                //添加
                                if (options.clampToGround) {
                                    geomeitryPrimitive = new that._cesium.GroundPolylinePrimitive({
                                        //classificationType: that._cesium.ClassificationType.BOTH,
                                        geometryInstances: geomInstances,
                                        appearance: new that._cesium.MaterialAppearance({
                                            material: new that._cesium.Material({
                                                fabric: {
                                                    type: 'PolylineOutline',
                                                    uniforms: {
                                                        // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                                        color: options.material,
                                                        outlineColor: options.outlineColor,
                                                        outlineWidth: options.outlineWidth,
                                                    }
                                                }
                                            }),
                                            faceForward: true,
                                            flat: false
                                        }),
                                    });
                                } else {
                                    geomeitryPrimitive = new that._cesium.Primitive({
                                        geometryInstances: geomInstances,
                                        appearance: new that._cesium.PolylineMaterialAppearance({
                                            material: new that._cesium.Material({
                                                fabric: {
                                                    type: 'PolylineOutline',
                                                    uniforms: {
                                                        // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                                        color: options.material,
                                                        outlineColor: options.outlineColor,
                                                        outlineWidth: options.outlineWidth,
                                                    }
                                                }
                                            }),
                                        }),
                                        shadows: that._cesium.ShadowMode.ENABLED
                                    });
                                }
                                tile.data.geometryPrimitive = geomeitryPrimitive;
                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    tile.data.geometryPrimitive.update(frameState, []);
                                    //if (tile.data.geometryPrimitive._ready) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            },
                            error: function () {
                                if (tile.count == undefined) {
                                    tile.count = 0;
                                }
                                tile.count += 1;
                                if (tile.count >= 2) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                } else {
                                    tile.state = Cesium.QuadtreeTileLoadState.START;
                                }
                            }
                        });
                        // Create random lines at the root level.

                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };
        // this._forceRefreshProvider = loadsh.cloneDeep(this._Provider);
        this._forceRefreshProvider = this._Provider;
        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 5
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //添加时间段
        if (styleOption && styleOption.time) {
            geoJSONVectorTileProvider.availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }


        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this._Provider.treeID = options.id;
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //沿线模型分布(矢量切片)
    //已过期
    //张恒
    PolylineGeoJsonFeatureLayer.prototype.createPolylineVectorGeoJsonFeatureLayerProviderModel_obsolete = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            positions: [],
            arcType: this._cesium.ArcType.GEODESIC, //	optional The type of line the polyline segments must follow.
            clampToGround: false, //optional A boolean Property specifying whether the Polyline should be clamped to the ground.
            width: 1.0, //optional A numeric Property specifying the width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the polyline.
            material: this._cesium.Color.WHITE, //	optional A Property specifying the material used to draw the polyline.
            height: 30,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        //this.options=options;
        /**
         * 请求矢量切片
         */
        var that = this;
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json, tile) {
            //测试
            var collection = new that._cesium.PrimitiveCollection();
            var instances = [];
            //模型集合
            // var model = [];
            json.features.forEach(function (feature) {
                var newArr = [];
                if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                    var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                    options.material = feature.properties[material];
                    //填充颜色设置
                    if (that._core.isHtmlColor(options.material)) {
                        options.material = that._color.colorFromHtmlColor(options.material);
                    } else {
                        if (/^rgb/.test(options.material)) {
                            options.material = that._color.rgbaStringToRgbaObj(options.material);
                        }
                        if (options.material.r > 1) {
                            options.material.r = options.material.r / 255;
                        }
                        if (options.material.g > 1) {
                            options.material.g = options.material.g / 255;
                        }
                        if (options.material.b > 1) {
                            options.material.b = options.material.b / 255;
                        }
                        if (options.material.a > 1) {
                            options.material.a = options.material.a / 255;
                        }
                        options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                    }
                }

                function fun(arr) {
                    for (var i = 0; i < arr.length; i++) {
                        if (Array.isArray(arr[i])) {
                            fun(arr[i]);
                        } else {
                            newArr.push(arr[i]);
                        }
                    }
                }
                //fun(feature.geometry.coordinates);
                // if (that.model.length > 0) {
                //     for (var i = 0; i < that.model.length; i++) {
                //         //that.model[i].show = b;
                //         that._viewer.scene.primitives.remove(that.model[i]);
                //     }
                // }
                if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                    if (Array.isArray(feature.geometry.coordinates[0][0])) {
                        for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                            newArr = [];
                            fun(feature.geometry.coordinates[j]);
                            createobj(newArr);
                            createmodel(newArr);
                        }
                    } else {
                        fun(feature.geometry.coordinates);
                        createobj(newArr);
                        createmodel(newArr);
                    }
                }

                function createobj(newArr) {
                    var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                    options.positions = pos;
                    feature.positions = pos;
                    var Polyline = {
                        positions: options.positions,
                        width: options.width,
                        //arcType: options.arcType
                    };
                    var geometryInstance = null;
                    if (options.clampToGround) {
                        //var extrudedPolygon = new Cesium.PolylineGeometry(options);
                        var Polyline = new that._cesium.GroundPolylineGeometry(Polyline);
                        //var geometry = that._cesium.PolylineGeometry.createGeometry(Polyline);
                        geometryInstance = new that._cesium.GeometryInstance({
                            id: feature,
                            geometry: Polyline,
                            attributes: {
                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                            }
                        });
                    } else {
                        var newArrs = newArr;
                        var leg = newArr.length / 2 + 1 + newArr.length;
                        for (var i = 2; i < leg; i = i + 3) {
                            newArrs.splice(i, 0, parseFloat(options.height));
                        }
                        var posp = that._cesium.Cartesian3.fromDegreesArrayHeights(newArrs);
                        options.positions = posp;
                        var extrudedPolygon = new that._cesium.PolylineGeometry(options);
                        var geometry = that._cesium.PolylineGeometry.createGeometry(extrudedPolygon);
                        geometryInstance = new that._cesium.GeometryInstance({
                            id: feature,
                            geometry: geometry,
                            attributes: {
                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                            }
                        });
                    }
                    //geomInstances.push(geometryInstance);
                    var primitive = null;
                    //添加
                    if (options.clampToGround) {
                        primitive = new that._cesium.GroundPolylinePrimitive({
                            //classificationType: that._cesium.ClassificationType.BOTH,
                            geometryInstances: geometryInstance,
                            appearance: new that._cesium.MaterialAppearance({
                                material: new that._cesium.Material({
                                    fabric: {
                                        type: 'Color',
                                        uniforms: {
                                            // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                            color: options.material
                                        }
                                    }
                                }),
                                faceForward: true,
                                flat: false
                            }),
                        });
                    } else {
                        primitive = new that._cesium.Primitive({
                            geometryInstances: geometryInstance,
                            //appearance: new that._cesium.PolylineColorAppearance({
                            //    flat: true,
                            //    translucent: true,
                            //    faceForward: true,
                            //    closed: true
                            //}),
                            appearance: new that._cesium.PolylineMaterialAppearance({
                                material: new that._cesium.Material({
                                    fabric: {
                                        type: 'Color',
                                        uniforms: {
                                            // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                            color: options.material
                                        }
                                    }
                                }),
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });
                    }
                    collection.add(primitive);
                }

                function createmodel(newArr) {
                    var pos;
                    if (options.clampToGround) {
                        pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                    } else {
                        pos = that._cesium.Cartesian3.fromDegreesArrayHeights(newArr);
                    }
                    for (var r = 1; r < pos.length; r++) {
                        var positionsxp = [];
                        positionsxp.push(pos[r - 1]);
                        positionsxp.push(pos[r]);
                        var leftX = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r - 1]).x;
                        var leftY = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r - 1]).y;
                        var rightX = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r]).x;
                        var rightY = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r]).y;
                        that.setPolylinemodels(positionsxp, leftX, leftY, rightX, rightY, options, function (mol) {
                            instances.push(mol);
                        });
                    }
                }
            });
            //that._viewer.scene.groundPrimitives.add(primitive);
            if (instances.length) {
                var p = new that._cesium.ModelInstanceCollection({
                    url: options.url,
                    instances: instances,
                    color: options.color,
                    lightColor: options.lightColor,
                    scale: parseInt(options.scale), //放大倍数
                    heightReference: parseInt(options.heightReference),
                    distanceDisplayCondition: options.distanceDisplayCondition
                });
                collection.add(p);
            }
            return collection;
        };
        //添加时间段
        if (styleOption && styleOption.time) {
            geoJSONVectorTileProvider.availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    //沿线模型分布(矢量切片)
    PolylineGeoJsonFeatureLayer.prototype.createPolylineVectorGeoJsonFeatureLayerProviderModel = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            positions: [],
            arcType: this._cesium.ArcType.GEODESIC, //	optional The type of line the polyline segments must follow.
            clampToGround: false, //optional A boolean Property specifying whether the Polyline should be clamped to the ground.
            width: 1.0, //optional A numeric Property specifying the width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the polyline.
            material: this._cesium.Color.WHITE, //	optional A Property specifying the material used to draw the polyline.
            height: 30,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        this.item.show = checked;
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);
        var _urlTemplate = geoOptions.url + '?' + this._core._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    //var levelError = that.getLevelMaximumGeometricError(tile.level);
                    // if (tile.level < 16) {
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        var tileUrl = _urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }
                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                var instances = [];
                                var collection = new that._cesium.PrimitiveCollection();
                                var features = data.features;
                                var newArr = [];
                                if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                                    var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                                    options.material = feature.properties[material];
                                    //填充颜色设置
                                    if (that._core.isHtmlColor(options.material)) {
                                        options.material = that._color.colorFromHtmlColor(options.material);
                                    } else {
                                        if (/^rgb/.test(options.material)) {
                                            options.material = that._color.rgbaStringToRgbaObj(options.material);
                                        }
                                        if (options.material.r > 1) {
                                            options.material.r = options.material.r / 255;
                                        }
                                        if (options.material.g > 1) {
                                            options.material.g = options.material.g / 255;
                                        }
                                        if (options.material.b > 1) {
                                            options.material.b = options.material.b / 255;
                                        }
                                        if (options.material.a > 1) {
                                            options.material.a = options.material.a / 255;
                                        }
                                        options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                                    }
                                }

                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                        }
                                    }
                                }

                                function createobj(newArr) {
                                    var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                    options.positions = pos;
                                    feature.positions = pos;
                                    var Polyline = {
                                        positions: options.positions,
                                        width: options.width,
                                        //arcType: options.arcType
                                    };
                                    var geometryInstance = null;
                                    if (options.clampToGround) {
                                        //var extrudedPolygon = new Cesium.PolylineGeometry(options);
                                        var Polyline = new that._cesium.GroundPolylineGeometry(Polyline);
                                        //var geometry = that._cesium.PolylineGeometry.createGeometry(Polyline);
                                        geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: Polyline,
                                            attributes: {
                                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                            }
                                        });
                                    } else {
                                        var newArrs = newArr;
                                        var leg = newArr.length / 2 + 1 + newArr.length;
                                        for (var i = 2; i < leg; i = i + 3) {
                                            newArrs.splice(i, 0, parseFloat(options.height));
                                        }
                                        var posp = that._cesium.Cartesian3.fromDegreesArrayHeights(newArrs);
                                        options.positions = posp;
                                        var extrudedPolygon = new that._cesium.PolylineGeometry(options);
                                        var geometry = that._cesium.PolylineGeometry.createGeometry(extrudedPolygon);
                                        geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: geometry,
                                            attributes: {
                                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                            }
                                        });
                                    }
                                    //geomInstances.push(geometryInstance);
                                    var primitive = null;
                                    //添加
                                    if (options.clampToGround) {
                                        primitive = new that._cesium.GroundPolylinePrimitive({
                                            //classificationType: that._cesium.ClassificationType.BOTH,
                                            geometryInstances: geometryInstance,
                                            appearance: new that._cesium.MaterialAppearance({
                                                material: new that._cesium.Material({
                                                    fabric: {
                                                        type: 'Color',
                                                        uniforms: {
                                                            // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                                            color: options.material
                                                        }
                                                    }
                                                }),
                                                faceForward: true,
                                                flat: false
                                            }),
                                        });
                                    } else {
                                        primitive = new that._cesium.Primitive({
                                            geometryInstances: geometryInstance,
                                            //appearance: new that._cesium.PolylineColorAppearance({
                                            //    flat: true,
                                            //    translucent: true,
                                            //    faceForward: true,
                                            //    closed: true
                                            //}),
                                            appearance: new that._cesium.PolylineMaterialAppearance({
                                                material: new that._cesium.Material({
                                                    fabric: {
                                                        type: 'Color',
                                                        uniforms: {
                                                            // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                                            color: options.material
                                                        }
                                                    }
                                                }),
                                            }),
                                            shadows: that._cesium.ShadowMode.ENABLED
                                        });
                                    }
                                    collection.add(primitive);
                                }

                                function createmodel(newArr) {
                                    var pos;
                                    if (options.clampToGround) {
                                        pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                    } else {
                                        pos = that._cesium.Cartesian3.fromDegreesArrayHeights(newArr);
                                    }
                                    for (var r = 1; r < pos.length; r++) {
                                        try {
                                            var positionsxp = [];
                                            positionsxp.push(pos[r - 1]);
                                            positionsxp.push(pos[r]);
                                            var leftX = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r - 1]).x;
                                            var leftY = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r - 1]).y;
                                            var rightX = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r]).x;
                                            var rightY = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r]).y;
                                            that.setPolylinemodels(positionsxp, leftX, leftY, rightX, rightY, options, function (mol) {
                                                instances.push(mol);
                                            });
                                        } catch (ex) { }
                                    }
                                }
                                for (var n = 0; n < features.length; n++) {
                                    var feature = features[n];
                                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                newArr = [];
                                                fun(feature.geometry.coordinates[j]);
                                                createobj(newArr);
                                                createmodel(newArr);
                                            }
                                        } else {
                                            fun(feature.geometry.coordinates);
                                            createobj(newArr);
                                            createmodel(newArr);
                                        }
                                    }
                                }
                                if (instances.length) {
                                    var p = new that._cesium.ModelInstanceCollection({
                                        url: options.url,
                                        instances: instances,
                                        color: options.color,
                                        lightColor: options.lightColor,
                                        scale: parseInt(options.scale), //放大倍数
                                        heightReference: parseInt(options.heightReference),
                                        distanceDisplayCondition: options.distanceDisplayCondition
                                    });
                                    collection.add(p);
                                }
                                tile.data.geometryPrimitive = collection;
                            },
                            error: function () {
                                if (tile.count == undefined) {
                                    tile.count = 0;
                                }
                                tile.count += 1;
                                if (tile.count >= 2) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    // return;
                                } else {
                                    tile.state = Cesium.QuadtreeTileLoadState.START;
                                }
                            }
                        });
                        // Create random lines at the root level.

                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 5
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //沿线模型分布修改
    PolylineGeoJsonFeatureLayer.prototype.setPolylinemodels = function (_positions, leftX, leftY, rightX, rightY, attribute, callback) {
        var cesium = this._cesium;
        //起止点相关信息
        var julifr = this._core.getSpaceDistancem(_positions, cesium);
        var pointSum1 = 10;
        var cyjj = parseFloat(attribute.distance);
        if (cyjj == 0) ; else {
            pointSum1 = parseInt(julifr / cyjj);
        }
        var startPoint = _positions[0];
        var endPoint = _positions[_positions.length - 1];
        var scartographic = cesium.Cartographic.fromCartesian(startPoint);
        var slongitude = cesium.Math.toDegrees(scartographic.longitude);
        var slatitude = cesium.Math.toDegrees(scartographic.latitude);

        var ecartographic = cesium.Cartographic.fromCartesian(endPoint);
        var elongitude = cesium.Math.toDegrees(ecartographic.longitude);
        var elatitude = cesium.Math.toDegrees(ecartographic.latitude);


        var pointSum = pointSum1; //取样点个数
        var addXTT = cesium.Math.lerp(slongitude, elongitude, 1.0 / pointSum) - slongitude;
        var addYTT = cesium.Math.lerp(slatitude, elatitude, 1.0 / pointSum) - slatitude;

        for (var i = 0; i < pointSum; i++) {
            var longitude = slongitude + (i + 1) * addXTT;
            var latitude = slatitude + (i + 1) * addYTT;
            var modelMatrix = cesium.Transforms.eastNorthUpToFixedFrame(cesium.Cartesian3.fromDegrees(longitude, latitude, parseInt(attribute.height))); //gltf数据加载位置
            // var hi = parseInt(attribute.heightReference);
            // var mol = cesium.Model.fromGltf({
            //     url: attribute.url,        //如果为bgltf则为.bgltf
            //     modelMatrix: modelMatrix,
            //     color: attribute.color,
            //     lightColor: attribute.lightColor,
            //     scale: attribute.scale,   //放大倍数
            //     heightReference: parseInt(attribute.heightReference),
            //     //distanceDisplayCondition: attribute.distanceDisplayCondition
            // })
            Cesium.Matrix4.multiplyByUniformScale(modelMatrix, parseInt(attribute.scale), modelMatrix);
            callback && callback({
                modelMatrix: modelMatrix,
                modelId: attribute
            });
        }
    };
    PolylineGeoJsonFeatureLayer.prototype.getType = function () {
        return {
            label: "线",
            value: "polylineLayer"
        };
    };
    /**
     * 导出工程数据
     */
    PolylineGeoJsonFeatureLayer.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url
            }
        };
    };
    /**
     * 删除数据
     */
    PolylineGeoJsonFeatureLayer.prototype.deleteObject = function () {
        this._viewer.scene.primitives.remove(this.item);
        if (this.model != undefined && this.model != null && this.model.length > 0) {
            for (var i = 0; i < this.model.length; i++) {
                //this.model[i].show = b;
                this._viewer.scene.primitives.remove(this.model[i]);
            }
        }
        try {
            this._Provider.remove();
        } catch (ex) { }
    };
    //工程树添加
    PolylineGeoJsonFeatureLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 返回图例
     * @returns {object} 
     */
    PolylineGeoJsonFeatureLayer.prototype.getLegend = function () {
        var legend = [];
        if (this.Legend != null) {
            legend = this._core.unique(this.Legend);
        }
        return legend;
    };
    /**
     * 设置数据是否刷新
     */
    PolylineGeoJsonFeatureLayer.prototype.setRefresh = function (b) {
        try {
            if (this._Provider) {
                this._Provider.setStatus(!b);
            }
        } catch (ex) { }
    };
    /**
     * 设置数据显示隐藏
     */
    PolylineGeoJsonFeatureLayer.prototype.setVisibility = function (b) {
        if (this.item != undefined) {
            this.item.show = b;
        }
        if (this._Provider) {
            this._Provider.setStatus(b);
        }
        if (this.model != undefined && this.model != null && this.model.length > 0) {
            for (var i = 0; i < this.model.length; i++) {
                this.model[i].show = b;
                //this._viewer.scene.primitives.remove(this.model[i]);
            }
        }
    };

    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    PolylineGeoJsonFeatureLayer.prototype.edit = function (open, option) {
        this.editoption = option;
        this.isEditting = open;
        return this._Provider && this._Provider.edit && this._Provider.edit(open, option);
    };


    /**
    * 设置数据是否刷新
    */
    PolylineGeoJsonFeatureLayer.prototype.forceRefresh = function () {
        try {
            // // this._Provider.edit(false, {});
            // this._cache = true;
            // // if (!this._forceRefreshPrvimitive)
            // //     this._forceRefreshPrvimitive = loadsh.cloneDeep(this._primitive)
            // // var temp = loadsh.cloneDeep(this._forceRefreshPrvimitive)

            // var p = loadsh.cloneDeep(this._forceRefreshProvider)

            // this._Provider = p;

            // this._viewer.scene.primitives.remove(this._primitive);

            // this._primitive = new this._cesium.QuadtreePrimitivezh({
            //     tileProvider: this._Provider,
            //     tileCacheSize: 1,
            //     maximumScreenSpaceError: 5
            // });

            // // PolylineGeoJsonFeatureLayer.remove(this._viewer.scene.primitivesQuadTrees,this._primitive);
            // // this._viewer.scene.primitivesQuadTrees();
            // this._viewer.scene.primitives.add(this._primitive);
            // // try{}
            // this._viewer.scene.primitivesQuadTrees.push(this._primitive);
            // this.edit(this.isEditting, this.editoption);
            // // temp._tileProvider.edit(this.isEditting, this.editoption);

            for (var i = 0; i < this._Provider.quadtree._levelZeroTiles.length; i++) {
                this._Provider.quadtree._levelZeroTiles[i].freeResources();
            }
        } catch (ex) {
        }
    };

    /**
     *
     * 创建点模型。
     *
     * @alias PointModel
     * @constructor
     *
     */
    function PointModel(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this._createGroup = new createGroup();
        this.model = [];
        //旋转
        this.heading = this._cesium.Math.toRadians(0);
        this.pitch = this._cesium.Math.toRadians(0);
        this.roll = this._cesium.Math.toRadians(0);
        this.rotate = 10;
        this.state = 0; //1为新增 2为编辑 0为清除

        this.modelPointArr = [];
        this.modifyModel = null;
        this.modifyPoint = null;
        this.modifyHandler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        this.objId = Number((new Date()).getTime() + "" + Number(Math.random() * 1000).toFixed(0));
        this.position = null;
        this.tempPoints = [];
        this.scale = 0;
        //坐标系大小控制
        this.Radius = 20;
    }

    /**
     * 沿线模型分布图层添加
     */
    PointModel.prototype.exectPointModel = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            positions: [],
            arcType: this._cesium.ArcType.GEODESIC, //	optional The type of line the polyline segments must follow.
            clampToGround: false, //optional A boolean Property specifying whether the Polyline should be clamped to the ground.
            width: 1.0, //optional A numeric Property specifying the width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the polyline.
            material: this._cesium.Color.WHITE, //	optional A Property specifying the material used to draw the polyline.
            height: 30,
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        //填模型颜色
        if (!this._core.isnull(option) && !this._core.isnull(option.color)) {
            if (option.color.toString().charAt(0) == "[" && option.color.toString().charAt(option.color.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.color)) {
                    option.color = this._color.colorFromHtmlColor(option.color);
                } else {
                    if (/^rgb/.test(option.color)) {
                        option.color = this._color.rgbaStringToRgbaObj(option.color);
                    }
                    if (option.color.r > 1) {
                        option.color.r = option.color.r / 255;
                    }
                    if (option.color.g > 1) {
                        option.color.g = option.color.g / 255;
                    }
                    if (option.color.b > 1) {
                        option.color.b = option.color.b / 255;
                    }
                    if (option.color.a > 1) {
                        option.color.a = option.color.a / 255;
                    }
                    option.color = this._color.createColor(option.color.r, option.color.g, option.color.b, option.color.a);
                }
            }
        }
        //填模型高亮颜色
        if (!this._core.isnull(option) && !this._core.isnull(option.lightColor)) {
            if (option.lightColor.toString().charAt(0) == "[" && option.lightColor.toString().charAt(option.lightColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.lightColor)) {
                    option.lightColor = this._color.colorFromHtmlColor(option.lightColor);
                } else {
                    if (/^rgb/.test(option.lightColor)) {
                        option.lightColor = this._color.rgbaStringToRgbaObj(option.lightColor);
                    }
                    if (option.lightColor.r > 1) {
                        option.lightColor.r = option.lightColor.r / 255;
                    }
                    if (option.lightColor.g > 1) {
                        option.lightColor.g = option.lightColor.g / 255;
                    }
                    if (option.lightColor.b > 1) {
                        option.lightColor.b = option.lightColor.b / 255;
                    }
                    if (option.lightColor.a > 1) {
                        option.lightColor.a = option.lightColor.a / 255;
                    }
                    option.lightColor = this._color.createColor(option.lightColor.r, option.lightColor.g, option.lightColor.b, option.lightColor.a);
                }
            }
        }
        //线颜色
        if (!this._core.isnull(option) && !this._core.isnull(option.linecolor)) {
            if (option.linecolor.toString().charAt(0) == "[" && option.linecolor.toString().charAt(option.linecolor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.linecolor)) {
                    option.linecolor = this._color.colorFromHtmlColor(option.linecolor);
                } else {
                    if (/^rgb/.test(option.linecolor)) {
                        option.linecolor = this._color.rgbaStringToRgbaObj(option.linecolor);
                    }
                    if (option.linecolor.r > 1) {
                        option.linecolor.r = option.linecolor.r / 255;
                    }
                    if (option.linecolor.g > 1) {
                        option.linecolor.g = option.linecolor.g / 255;
                    }
                    if (option.linecolor.b > 1) {
                        option.linecolor.b = option.linecolor.b / 255;
                    }
                    if (option.linecolor.a > 1) {
                        option.linecolor.a = option.linecolor.a / 255;
                    }
                    option.linecolor = this._color.createColor(option.linecolor.r, option.linecolor.g, option.linecolor.b, option.linecolor.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (this._core.isnull(option.near)) {
            option.near = 0;
        }
        if (this._core.isnull(option.far)) {
            option.far = 999999999;
        }
        var min = parseFloat(option.near);
        var max = parseFloat(option.far);
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        options.distanceDisplayCondition = distance;
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        var that = this;
        dataSource.then(function (dataSource) {
            var entities = dataSource.entities.values;
            var geometries = [];
            //修改
            var entities = dataSource.entities.values;
            var geometries = [];
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                var geometry = new that._cesium.GeometryInstance({
                    id: entity, //拾取属性修改
                    geometry: new that._cesium.CorridorGeometry({
                        positions: entity.polyline.positions._value,
                        width: options.width,
                        height: options.height,
                        arcType: options.arcType,
                        vertexFormat: that._cesium.VertexFormat.POSITION_ONLY
                    }),
                    attributes: {
                        color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.linecolor)
                    }
                });
                geometries.push(geometry);
            }
            var time;
            //添加时间段
            if (option && option.time) {
                time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                    start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                    stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
                })]);
            }

            var ps = that._viewer.scene.primitives.add(new that._cesium.GroundPrimitive({
                geometryInstances: geometries,
                classificationType: that._cesium.ClassificationType.BOTH
            }), time);
            ps.show = options.show;
            that.item = ps;
            var instances = [];
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                var pos = entity.polyline.positions.getValue();
                for (var r = 1; r < pos.length; r++) {
                    try {
                        var positionsxp = [];
                        positionsxp.push(pos[r - 1]);
                        positionsxp.push(pos[r]);
                        var leftX = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r - 1]).x;
                        var leftY = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r - 1]).y;
                        var rightX = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r]).x;
                        var rightY = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, pos[r]).y;
                        instances = that.setPolylinemodels(positionsxp, leftX, leftY, rightX, rightY, instances, options, that._cesium, that._viewer, time);
                    } catch (ex) {
                        // console.log(ex)
                    }
                }
            }
            var p = new that._cesium.ModelInstanceCollection({
                url: options.url,
                instances: instances,
                color: options.color,
                lightColor: options.lightColor,
                scale: parseInt(options.scale),   //放大倍数
                heightReference: parseInt(options.heightReference),
                distanceDisplayCondition: options.distanceDisplayCondition
            });
            that._viewer.scene.primitives.add(p);
            that.model.push(p);
            //var GroupID = 0;
            //var dx=that._createGroup.createGroup("沿路模型", true, GroupID);
            //for (var t = 0; t < model.length; t++) {
            //    //that._getObject.insertProjectTree(GroupID, "沿路模型", 1, model[t], true);
            //    that._tree.insertGroupId({
            //        id: options.id,
            //        name: name,
            //        pId: that._core.isnull(dx) ? 0 : dx,
            //        type: 'polylineLayer',
            //        item: model[t]
            //    }, that._core.isnull(dx) ? 0 : dx);
            //}
            if (checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineLayer',
            item: this,
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 这个方法用于创建模型
     */
    PointModel.prototype.createPointModel = function (parameter, methond) {
        var _this = this;
        var handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positions = [];
        var poly = null;
        var distance = 0;
        var cartesian = null;
        var dx = [];
        var parameterd = parameter.parameterd;
        parameter.objid;
        var cyjj = parameter.cyjj;
        //模型地址
        var modelurl = parameter.url;
        this.modelurl = modelurl;
        //坐标集合
        var ent = [];
        var coloroptions = {
            "point": _this._cesium.Color.RED,
            "polyline": _this._cesium.Color.YELLOW
        };
        if (Object.keys(parameter).length > 0) {
            if (parameter.point != "" && parameter.point != undefined) {
                coloroptions.point = parameter.point;
            }
            if (parameter.polyline != "" && parameter.polyline != undefined) {
                coloroptions.polyline = parameter.polyline;
            }
        }
        var tooltip = this._core.CreateTooltip();
        //spot点坐标，distance距离，label距离对象数组
        var Distance = {
            spot: [],
            distance: [],
            label: [],
            polyline: [],
            model: []
        };
        handler.setInputAction(function (movement) {
            if (positions.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始,右键结束！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束！');
            }
            var ray = _this._viewer.camera.getPickRay(movement.endPosition);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive1(positions);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                }
                //distance = _this._core.getHorizontalDistance(positions, _this._cesium) * 1000;
                distance = _this._core.getHorizontalDistance(positions, _this._cesium);
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        handler.setInputAction(function (movement) {
            var ray = _this._viewer.camera.getPickRay(movement.position);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            if (positions.length == 0) {
                positions.push(cartesian.clone());
            }
            var lxy = {
                px: movement.position.x,
                py: movement.position.y
            };
            positions.push(cartesian);
            var pos = {
                positionsxp: cartesian,
                lxy: lxy
            };
            ent.push(pos);
            Distance.spot.push(cartesian);
            Distance.distance.push(distance);

        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        handler.setInputAction(function (movement) {
            handler.destroy(); //关闭事件句柄
            positions.pop(); //最后一个点无效
            for (var u = 0; u < dx.length; u++) {
                _this._viewer.entities.remove(dx[u]);
            }
            var model = [];
            for (var i = 1; i < ent.length; i++) {
                var positionsxp = [];
                var leftX = ent[i - 1].lxy.px;
                var leftY = ent[i - 1].lxy.py;
                var rightX = ent[i].lxy.px;
                var rightY = ent[i].lxy.py;
                var pointSum = parameterd;  //取样点个数
                positionsxp.push(ent[i - 1].positionsxp);
                positionsxp.push(ent[i].positionsxp);
                model = _this.setPolylinemodel(positionsxp, leftX, leftY, rightX, rightY, pointSum, cyjj, _this.modelurl, model, _this._cesium, _this._viewer);
                //Distance.model.push(dxjs);
            }
            Distance.model = model;
            if (methond != "" && methond != null) {
                if (typeof methond == 'function')
                    methond(Distance);
            }
            tooltip.show(false);
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        var PolyLinePrimitive1 = (function () {
            function execute(positions) {
                this.options = {
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: coloroptions.polyline,
                        width: 3,
                        clampToGround: true,
                    }
                };
                this.positions = positions;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                var polyline = _this._viewer.entities.add(this.options);
                _this.item = polyline;
                dx.push(polyline);
                Distance.polyline.push(polyline);
            };
            return execute;
        })();
        return this;
    };
    //沿线模型分布
    PointModel.prototype.setPolylinemodel = function (_positions, leftX, leftY, rightX, rightY, pointSum1, cyjj, url, modelsl, cesium, viewer) {
        //起止点相关信息
        var julifr = this._core.getSpaceDistancem(_positions, cesium);
        if (cyjj == 0) ; else {
            pointSum1 = parseInt(julifr / cyjj);
        }
        var startPoint = _positions[0];
        var endPoint = _positions[_positions.length - 1];
        var scartographic = cesium.Cartographic.fromCartesian(startPoint);
        var slongitude = cesium.Math.toDegrees(scartographic.longitude);
        var slatitude = cesium.Math.toDegrees(scartographic.latitude);
        scartographic.height;

        var ecartographic = cesium.Cartographic.fromCartesian(endPoint);
        var elongitude = cesium.Math.toDegrees(ecartographic.longitude);
        var elatitude = cesium.Math.toDegrees(ecartographic.latitude);
        ecartographic.height;


        //var pointSum = pointSum1;  //取样点个数
        var pointSum = pointSum1; //取样点个数
        var addXTT = cesium.Math.lerp(slongitude, elongitude, 1.0 / pointSum) - slongitude;
        var addYTT = cesium.Math.lerp(slatitude, elatitude, 1.0 / pointSum) - slatitude;


        var addX = cesium.Math.lerp(leftX, rightX, 1.0 / pointSum) - leftX;
        var addY = cesium.Math.lerp(leftY, rightY, 1.0 / pointSum) - leftY;
        for (var i = 0; i < pointSum; i++) {

            var longitude = slongitude + (i + 1) * addXTT;
            var latitude = slatitude + (i + 1) * addYTT;
            if (i == 0) {
                new cesium.Cartesian3(longitude, latitude, 0);
            } else if (i == 1) {
                new cesium.Cartesian3(longitude, latitude, 0);
            }
            var x = leftX + (i + 1) * addX;
            var y = leftY + (i + 1) * addY;
            var eventPosition = { x: x, y: y };
            var eventPosition = {
                x: x,
                y: y
            };
            //模型
            var cartesian = viewer.camera.pickEllipsoid(eventPosition, viewer.scene.globe.ellipsoid);
            var cartographic = cesium.Cartographic.fromCartesian(cartesian);
            var x = cesium.Math.toDegrees(cartographic.longitude);
            var y = cesium.Math.toDegrees(cartographic.latitude);
            var modelMatrix = cesium.Transforms.eastNorthUpToFixedFrame(cesium.Cartesian3.fromDegrees(x, y, 6.0));        //gltf数据加载位置
            var mol = cesium.Model.fromGltf({
                url: url,        //如果为bgltf则为.bgltf
                modelMatrix: modelMatrix,
                scale: 100    //放大倍数
            });
            viewer.scene.primitives.add(mol);
            modelsl.push(mol);
        }
        return modelsl;
    };
    //沿线模型分布修改
    PointModel.prototype.setPolylinemodels_obsolete = function (_positions, leftX, leftY, rightX, rightY, modelsl, attribute, cesium, viewer, time) {
        //起止点相关信息
        var julifr = this._core.getSpaceDistancem(_positions, cesium);
        var pointSum1 = 10;
        var cyjj = parseFloat(attribute.distance);
        if (cyjj == 0) ; else {
            pointSum1 = parseInt(julifr / cyjj);
        }
        var startPoint = _positions[0];
        var endPoint = _positions[_positions.length - 1];
        var scartographic = cesium.Cartographic.fromCartesian(startPoint);
        var slongitude = cesium.Math.toDegrees(scartographic.longitude);
        var slatitude = cesium.Math.toDegrees(scartographic.latitude);
        scartographic.height;

        var ecartographic = cesium.Cartographic.fromCartesian(endPoint);
        var elongitude = cesium.Math.toDegrees(ecartographic.longitude);
        var elatitude = cesium.Math.toDegrees(ecartographic.latitude);
        ecartographic.height;
        cesium.Math.toDegrees(scartographic.height);


        //var pointSum = pointSum1;  //取样点个数
        var pointSum = pointSum1; //取样点个数
        var addXTT = cesium.Math.lerp(slongitude, elongitude, 1.0 / pointSum) - slongitude;
        var addYTT = cesium.Math.lerp(slatitude, elatitude, 1.0 / pointSum) - slatitude;


        cesium.Math.lerp(leftX, rightX, 1.0 / pointSum) - leftX;
        cesium.Math.lerp(leftY, rightY, 1.0 / pointSum) - leftY;
        for (var i = 0; i < pointSum; i++) {

            var longitude = slongitude + (i + 1) * addXTT;
            var latitude = slatitude + (i + 1) * addYTT;
            // if (i == 0) {
            //     dp1 = new cesium.Cartesian3(longitude, latitude, 0);
            // } else if (i == 1) {
            //     dp2 = new cesium.Cartesian3(longitude, latitude, 0);
            // }
            // var x = leftX + (i + 1) * addX;
            // var y = leftY + (i + 1) * addY;
            // var eventPosition = {x: x, y: y};
            // var eventPosition = {
            //     x: x,
            //     y: y
            // };
            //var rayrt = viewer.scene.camera.getPickRay(eventPosition);
            //var positionrt = viewer.scene.globe.pick(rayrt, viewer.scene);
            //var cartographic1 = cesium.Ellipsoid.WGS84.cartesianToCartographic(positionrt);
            //模型
            // var cartesian = viewer.camera.pickEllipsoid(eventPosition, viewer.scene.globe.ellipsoid);
            // var cartographic = cesium.Cartographic.fromCartesian(cartesian);
            // var x = cesium.Math.toDegrees(cartographic.longitude);
            // var y = cesium.Math.toDegrees(cartographic.latitude);
            // var z = cesium.Math.toDegrees(cartographic.height);
            //var modelMatrix = cesium.Transforms.eastNorthUpToFixedFrame(cesium.Cartesian3.fromDegrees(x, y, 6.0));        //gltf数据加载位置
            var modelMatrix = cesium.Transforms.eastNorthUpToFixedFrame(cesium.Cartesian3.fromDegrees(longitude, latitude, attribute.height));        //gltf数据加载位置
            parseInt(attribute.heightReference);
            var mol = cesium.Model.fromGltf({
                url: attribute.url,        //如果为bgltf则为.bgltf
                modelMatrix: modelMatrix,
                color: attribute.color,
                lightColor: attribute.lightColor,
                scale: parseInt(attribute.scale),   //放大倍数
                heightReference: parseInt(attribute.heightReference),
                distanceDisplayCondition: attribute.distanceDisplayCondition
            });
            viewer.scene.primitives.add(mol, time);
            modelsl.push(mol);
        }
        return modelsl;
    };

    //沿线模型分布修改
    PointModel.prototype.setPolylinemodels = function (_positions, leftX, leftY, rightX, rightY, modelsl, attribute, cesium, viewer, time) {
        //起止点相关信息
        var julifr = this._core.getSpaceDistancem(_positions, cesium);
        var pointSum1 = 10;
        var cyjj = parseFloat(attribute.distance);
        if (cyjj == 0) ; else {
            pointSum1 = parseInt(julifr / cyjj);
        }
        var startPoint = _positions[0];
        var endPoint = _positions[_positions.length - 1];
        var scartographic = cesium.Cartographic.fromCartesian(startPoint);
        var slongitude = cesium.Math.toDegrees(scartographic.longitude);
        var slatitude = cesium.Math.toDegrees(scartographic.latitude);
        scartographic.height;

        var ecartographic = cesium.Cartographic.fromCartesian(endPoint);
        var elongitude = cesium.Math.toDegrees(ecartographic.longitude);
        var elatitude = cesium.Math.toDegrees(ecartographic.latitude);
        ecartographic.height;
        cesium.Math.toDegrees(scartographic.height);


        //var pointSum = pointSum1;  //取样点个数
        var pointSum = pointSum1; //取样点个数
        var addXTT = cesium.Math.lerp(slongitude, elongitude, 1.0 / pointSum) - slongitude;
        var addYTT = cesium.Math.lerp(slatitude, elatitude, 1.0 / pointSum) - slatitude;


        cesium.Math.lerp(leftX, rightX, 1.0 / pointSum) - leftX;
        cesium.Math.lerp(leftY, rightY, 1.0 / pointSum) - leftY;
        for (var i = 0; i < pointSum; i++) {

            var longitude = slongitude + (i + 1) * addXTT;
            var latitude = slatitude + (i + 1) * addYTT;
            // if (i == 0) {
            //     dp1 = new cesium.Cartesian3(longitude, latitude, 0);
            // } else if (i == 1) {
            //     dp2 = new cesium.Cartesian3(longitude, latitude, 0);
            // }
            // var x = leftX + (i + 1) * addX;
            // var y = leftY + (i + 1) * addY;
            // var eventPosition = {x: x, y: y};
            // var eventPosition = {
            //     x: x,
            //     y: y
            // };
            //var rayrt = viewer.scene.camera.getPickRay(eventPosition);
            //var positionrt = viewer.scene.globe.pick(rayrt, viewer.scene);
            //var cartographic1 = cesium.Ellipsoid.WGS84.cartesianToCartographic(positionrt);
            //模型
            // var cartesian = viewer.camera.pickEllipsoid(eventPosition, viewer.scene.globe.ellipsoid);
            // var cartographic = cesium.Cartographic.fromCartesian(cartesian);
            // var x = cesium.Math.toDegrees(cartographic.longitude);
            // var y = cesium.Math.toDegrees(cartographic.latitude);
            // var z = cesium.Math.toDegrees(cartographic.height);
            //var modelMatrix = cesium.Transforms.eastNorthUpToFixedFrame(cesium.Cartesian3.fromDegrees(x, y, 6.0));        //gltf数据加载位置
            var modelMatrix = cesium.Transforms.eastNorthUpToFixedFrame(cesium.Cartesian3.fromDegrees(longitude, latitude, parseInt(attribute.height ? attribute.height : 0)));        //gltf数据加载位置
            parseInt(attribute.heightReference);
            // var mol = cesium.Model.fromGltf({
            //     url: attribute.url,        //如果为bgltf则为.bgltf
            //     modelMatrix: modelMatrix,
            //     color: attribute.color,
            //     lightColor: attribute.lightColor,
            //     scale: parseInt(attribute.scale),   //放大倍数
            //     heightReference: parseInt(attribute.heightReference),
            //     distanceDisplayCondition: attribute.distanceDisplayCondition
            // })
            // var model = viewer.scene.primitives.add(mol, time);
            //var modelMatrix = that._cesium.Transforms.eastNorthUpToFixedFrame(that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight));
            Cesium.Matrix4.multiplyByUniformScale(modelMatrix, parseInt(attribute.scale), modelMatrix);
            modelsl.push({ modelMatrix: modelMatrix, modelId: attribute });
            // modelsl.push(mol);
        }
        return modelsl;
    };

    //面模型分布
    PointModel.prototype.createPolygonModel = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            height: 0, //	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
            extrudedHeight: 0, //		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
            heightReference: this._cesium.HeightReference.RELATIVE_TO_GROUND, //		optional A Property specifying what the extrudedHeight is relative to.
            show: true, //	optional A boolean Property specifying the visibility of the polygon.
            fill: true, //	optional A boolean Property specifying whether the polygon is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional A Property specifying the material used to fill the polygon.
            outline: false, //optional A boolean Property specifying whether the polygon is outlined.
            outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            stRotation: 0.0, //	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            perPositionHeight: false, //optional A boolean specifying whether or not the the height of each position is used.
            closeTop: true, //optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //	optional When false, leaves off the bottom of an extruded polygon open.
            shadows: this._cesium.ShadowMode.ENABLED, //	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
            clampToGround: true,
            scale: 1,
            classificationType: this._cesium.ClassificationType.BOTH
        };
        //面填充颜色设置
        // var urlop = option.material;
        var urlop = option.modelurl;
        if (!this._core.isnull(option) && !this._core.isnull(option.fill)) {
            if (this._core.isHtmlColor(option.fill)) {
                option.material = this._color.colorFromHtmlColor(option.fill);
            } else {
                if (/^rgb/.test(option.fill)) {
                    option.material = this._color.rgbaStringToRgbaObj(option.fill);
                }
                if (option.material.r > 1) {
                    option.material.r = option.material.r / 255;
                }
                if (option.material.g > 1) {
                    option.material.g = option.material.g / 255;
                }
                if (option.material.b > 1) {
                    option.material.b = option.material.b / 255;
                }
                if (option.material.a > 1) {
                    option.material.a = option.material.a / 255;
                }
                option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
            }
        }
        //面轮廓颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (this._core.isHtmlColor(option.outlineColor)) {
                option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
            } else {
                if (/^rgb/.test(option.outlineColor)) {
                    option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                }
                if (option.outlineColor.r > 1) {
                    option.outlineColor.r = option.outlineColor.r / 255;
                }
                if (option.outlineColor.g > 1) {
                    option.outlineColor.g = option.outlineColor.g / 255;
                }
                if (option.outlineColor.b > 1) {
                    option.outlineColor.b = option.outlineColor.b / 255;
                }
                if (option.outlineColor.a > 1) {
                    option.outlineColor.a = option.outlineColor.a / 255;
                }
                option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
            }
        }
        //模型颜色颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.color)) {
            if (this._core.isHtmlColor(option.color)) {
                option.color = this._color.colorFromHtmlColor(option.color);
            } else {
                if (/^rgb/.test(option.color)) {
                    option.color = this._color.rgbaStringToRgbaObj(option.color);
                }
                if (option.color.r > 1) {
                    option.color.r = option.color.r / 255;
                }
                if (option.color.g > 1) {
                    option.color.g = option.color.g / 255;
                }
                if (option.color.b > 1) {
                    option.color.b = option.color.b / 255;
                }
                if (option.color.a > 1) {
                    option.color.a = option.color.a / 255;
                }
                option.color = this._color.createColor(option.color.r, option.color.g, option.color.b, option.color.a);
            }
        }
        //模型高亮颜色颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.lightColor)) {
            if (this._core.isHtmlColor(option.lightColor)) {
                option.lightColor = this._color.colorFromHtmlColor(option.lightColor);
            } else {
                if (/^rgb/.test(option.lightColor)) {
                    option.lightColor = this._color.rgbaStringToRgbaObj(option.lightColor);
                }
                if (option.lightColor.r > 1) {
                    option.lightColor.r = option.lightColor.r / 255;
                }
                if (option.lightColor.g > 1) {
                    option.lightColor.g = option.lightColor.g / 255;
                }
                if (option.lightColor.b > 1) {
                    option.lightColor.b = option.lightColor.b / 255;
                }
                if (option.lightColor.a > 1) {
                    option.lightColor.a = option.lightColor.a / 255;
                }
                option.lightColor = this._color.createColor(option.lightColor.r, option.lightColor.g, option.lightColor.b, option.lightColor.a);
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        option.checked = checked;
        //修改
        options.heightReference = this._cesium.HeightReference.RELATIVE_TO_GROUND;
        var op = {
            clampToGround: true
        };
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl, op);
        }
        this._viewer.dataSources.add(dataSource);
        var that = this;

        var time;
        //添加时间段
        if (option && option.time) {
            time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        dataSource.then(function (dataSource) {
            that.item = dataSource;
            that.model = [];
            var entities = dataSource.entities.values;
            if (that._core.isnull(option.near)) {
                option.near = 0;
            }
            if (that._core.isnull(option.far)) {
                option.far = 999999999;
            }
            var min = parseFloat(option.near);
            var max = parseFloat(option.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            //options.classificationType = that._cesium.ClassificationType.BOTH;
            //var extrudedHeightReference = that._cesium.HeightReference.RELATIVE_TO_GROUND;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.height = parseFloat(that._core.extendgl(entity, option.height, options.height));
                options.extrudedHeight = parseFloat(that._core.extendgl(entity, option.extrudedHeight, options.extrudedHeight));
                options.heightReference = that._core.extendgl(entity, option.heightReference, options.heightReference);
                options.show = that._core.extendgl(entity, option.show, options.show);
                //options.fill = that._core.extendgl(entity, option.fill, options.fill);
                options.material = that._core.extendgl(entity, option.material, options.material);
                options.outline = that._core.extendgl(entity, option.outline, options.outline);
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.stRotation = that._core.extendgl(entity, option.stRotation, options.stRotation);
                options.granularity = that._core.extendgl(entity, option.granularity, options.granularity);
                options.distanceDisplayCondition = that._core.extendgl(entity, option.distanceDisplayCondition, options.distanceDisplayCondition);
                options.perPositionHeight = that._core.extendgl(entity, option.perPositionHeight, options.perPositionHeight);
                options.closeTop = that._core.extendgl(entity, option.closeTop, options.closeTop);
                options.closeBottom = that._core.extendgl(entity, option.closeBottom, options.closeBottom);
                options.shadows = that._core.extendgl(entity, option.shadows, options.shadows);
                options.classificationType = that._core.extendgl(entity, option.classificationType, options.classificationType);
                //获取数据结束
                entity.polygon._hierarchy._value.positions;
                //entity.billboard = undefined;
                //entity.polygon.height = options.height;
                //entity.polygon.extrudedHeightReference = options.extrudedHeightReference;
                //entity.polygon.extrudedHeightReference = that._cesium.HeightReference.RELATIVE_TO_GROUND;
                entity.polygon.heightReference = 1;
                // if (options.heightReference != 1) {
                //     entity.polygon.height = options.height;
                // }
                //if (options.extrudedHeightReference != 1) {
                //    entity.polygon.extrudedHeight = options.extrudedHeight;
                //}
                entity.polygon.show = options.show;
                //entity.polygon.fill = options.fill;
                entity.polygon.material = options.material;
                entity.polygon.outline = options.outline;
                entity.polygon.outlineColor = options.outlineColor;
                entity.polygon.outlineWidth = options.outlineWidth;
                entity.polygon.stRotation = options.stRotation;
                entity.polygon.granularity = options.granularity;
                entity.polygon.distanceDisplayCondition = distance;
                //entity.polygon.perPositionHeight = options.perPositionHeight;
                entity.polygon.closeTop = options.closeTop;
                entity.polygon.closeBottom = options.closeBottom;
                entity.polygon.shadows = options.shadows;
                entity.polygon.classificationType = options.classificationType;

                time && (entity.availability = time);

                var hierarchy = [];
                var dx = entity.polygon.hierarchy.getValue().positions;
                for (var j = 0; j < dx.length; j++) {
                    var x = that._cesium.Math.toDegrees(that._cesium.Cartographic.fromCartesian(dx[j]).longitude);
                    var y = that._cesium.Math.toDegrees(that._cesium.Cartographic.fromCartesian(dx[j]).latitude);
                    hierarchy.push(x);
                    hierarchy.push(y);
                }
                var bottomPoint = that.getTheBottomPoint(hierarchy);
                var pointsInPolygon = that.scanningPolygon(bottomPoint, options.offset_x, options.offset_y, hierarchy);
                pointsInPolygon.forEach(function (point) {
                    var modelMatrix = that._cesium.Transforms.eastNorthUpToFixedFrame(that._cesium.Cartesian3.fromDegrees(point.lon, point.lat, options.height));        //gltf数据加载位置
                    //var hi = parseInt(options.heightReference);
                    var mol = that._cesium.Model.fromGltf({
                        url: urlop,        //如果为bgltf则为.bgltf
                        color: options.color,
                        silhouetteColor: options.lightColor,
                        silhouetteSize: options.lightWidth,
                        modelMatrix: modelMatrix,
                        scale: options.scale,   //放大倍数
                        heightReference: parseInt(options.heightReference),
                        distanceDisplayCondition: distance
                    });
                    that._viewer.scene.primitives.add(mol, time);
                    mol.time = time;
                    that.model.push(mol);
                });
            }
            if (option.checked) ; else {
                that.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geojsonOrurl,
            style: options
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    PointModel.prototype.setItem = function (item) {
        this.item = item;
    };
    //模型移动
    PointModel.prototype.modelMove = function () {
        this._tree.removeHandler();
        this._tree.starttemporaryItem(this._viewer);
        this.yd = false;
        var that = this;
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        this._tree.handler.setInputAction(function (movement) {
            that._viewer.scene.pickPosition(movement.position);
            var pickedFeature = that._viewer.scene.pick(movement.position);
            // 鼠标事件
            if (that.yd != undefined && that.yd) {
                that._tree.handler.destroy();
            }
            that.yd = true;
            if (pickedFeature.tileset != undefined) {
                //pickedFeature.tileset
                var tileset = pickedFeature.tileset;
                var cartographic = that._cesium.Cartographic.fromCartesian(tileset.boundingSphere.center);
                var surface = that._cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, cartographic.height);
                //var offset = Cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, height);
                //tileset.modelMatrix = Cesium.Matrix4.fromTranslation(translation);
                that._tree.handler.setInputAction(function (movement) {
                    var cartesianxp = that._viewer.scene.pickPosition(movement.endPosition);
                    var cartographicxp = that._cesium.Cartographic.fromCartesian(cartesianxp);
                    var offset = that._cesium.Cartesian3.fromRadians(cartographicxp.longitude, cartographicxp.latitude, cartographic.height);
                    var translation = that._cesium.Cartesian3.subtract(offset, surface, new that._cesium.Cartesian3());
                    tileset.modelMatrix = that._cesium.Matrix4.fromTranslation(translation);
                }, that._cesium.ScreenSpaceEventType.MOUSE_MOVE);
            }

        }, that._cesium.ScreenSpaceEventType.LEFT_CLICK);
    };
    //获取纬度最低点
    PointModel.prototype.getTheBottomPoint = function (points) {
        var minLat = 90;
        var minIndex = 0;
        for (var i = 1; i < points.length; i += 2) {
            minLat = minLat < points[i] ? minLat : (minIndex = i) && points[i];
        }
        return {
            lon: points[minIndex - 1],
            lat: points[minIndex]
        };
    };
    //扫描多边形
    PointModel.prototype.scanningPolygon = function (bottomPoint, dx, dy, area) {
        var points = [];
        var minLon = 180, maxLon = -180, maxLat = -90;
        var d_lon, d_lat;
        var westPoint, eastPoint, centerPoint;
        for (var i = 0; i < area.length; i += 2) {
            maxLat = maxLat > area[i + 1] ? maxLat : area[i + 1];
            minLon = minLon < area[i] ? minLon : area[i];
            maxLon = maxLon > area[i] ? maxLon : area[i];
        }
        var point1 = this.GetPositionFromA_D(bottomPoint.lat, bottomPoint.lon, dy, 0);
        var point2 = this.GetPositionFromA_D(bottomPoint.lat, bottomPoint.lon, dx, 90);
        //获取经纬度差
        d_lon = point2[0] - bottomPoint.lon;
        d_lat = point1[1] - bottomPoint.lat;

        points.push({ lon: bottomPoint.lon, lat: bottomPoint.lat });
        centerPoint = { lon: bottomPoint.lon, lat: bottomPoint.lat };
        //扫描
        for (centerPoint.lat += d_lat; centerPoint.lat <= maxLat; centerPoint.lat += d_lat) {
            westPoint = { lon: centerPoint.lon - d_lon, lat: centerPoint.lat };
            eastPoint = { lon: centerPoint.lon + d_lon, lat: centerPoint.lat };
            if (this.IsInPolygon(centerPoint.lon, centerPoint.lat, area)) {
                points.push({ lon: centerPoint.lon, lat: centerPoint.lat });
            }
            for (; westPoint.lon >= minLon; westPoint.lon -= d_lon) {
                if (this.IsInPolygon(westPoint.lon, westPoint.lat, area)) {
                    points.push({ lon: westPoint.lon, lat: westPoint.lat });
                }
            }
            for (; eastPoint.lon <= maxLon; eastPoint.lon += d_lon) {
                if (this.IsInPolygon(eastPoint.lon, eastPoint.lat, area)) {
                    points.push({ lon: eastPoint.lon, lat: eastPoint.lat });
                }
            }
        }
        return points;
    };
    //通过角度和距离获取经纬度
    PointModel.prototype.GetPositionFromA_D = function (lat, lon, distance, angle) {
        var Ea = 6378137.0;     //   赤道半径
        var Eb = 6356725.0;     //   极半径
        var dx = distance * Math.sin(angle * Math.PI / 180.0);
        var dy = distance * Math.cos(angle * Math.PI / 180.0);

        var ec = Eb + (Ea - Eb) * (90.0 - lat) / 90.0;
        var ed = ec * Math.cos(lat * Math.PI / 180);

        var newLon = (dx / ed + lon * Math.PI / 180.0) * 180.0 / Math.PI;
        var newLat = (dy / ec + lat * Math.PI / 180.0) * 180.0 / Math.PI;

        return [newLon, newLat];
    };
    //是否在多边形内
    PointModel.prototype.IsInPolygon = function (lon, lat, area) {
        var isIn = 0;
        var dLon1, dLon2, dLat1, dLat2, dLon;
        if (area.length < 6) {
            return false;
        }
        area.push(area[0], area[1]);
        for (var i = 0; i < area.length - 2; i += 2) {
            dLon1 = area[i];
            dLat1 = area[i + 1];
            dLon2 = area[i + 2];
            dLat2 = area[i + 3];

            //判断点是否在边的两端点的水平平行线之间，在则可能有交点
            if (((lat >= dLat1) && (lat < dLat2)) || ((lat >= dLat2) && (lat < dLat1))) {
                if (Math.abs(dLat1 - dLat2) > 0) {
                    //得到点向左射线与边的交点的x坐标：
                    dLon = dLon1 - ((dLon1 - dLon2) * (dLat1 - lat)) / (dLat1 - dLat2);
                    //判断交点是否在左射线上
                    if (dLon <= lon)
                        isIn++;
                }
            }
        }
        //交点为奇数则在多边形内
        if (isIn % 2 !== 0) {
            return true;
        }
        return false;
    };

    /**
     * 向三维场景中添加一个模型。
     * @param {Array} [Position] 一个经纬度数组 例如：[x, y, z]。
     * @param {String} [FileName] 想要加载模型的完整路径名或URL。
     * @param {Object} [Option] 模型参数。
     * @param {String} [GroupID] 组的ID，模型在该组中被创建。如果GroupID设置为零，则对象在根节点下创建。
     * @param {String} [Description] 显示在信息树中模型的名称。
     * @param {function} [callback] 回调函数。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    PointModel.prototype.createModel = function (Position, FileName, Option, GroupID, Description, callback) {
        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取时返回的用户定义值。
            uri: FileName,
            show: true,
            heading: 0,
            pitch: 0,
            roll: 0,
            scale: 1
        };
        var options = this._core.extend(defaultOption, Option, true);

        this._position = Position;
        var ent = {
            id: options.id,
            position: this._cesium.Cartesian3.fromDegrees(this._position[0], this._position[1], this._position[2]),
            model: options
        };
        if (options.heading || options.pitch || options.roll) {
            this.heading = options.heading;
            this.pitch = options.pitch;
            this.roll = options.roll;
            ent.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                this._cesium.Cartesian3.fromDegrees(this._position[0], this._position[1], this._position[2]),
                new this._cesium.HeadingPitchRoll(
                    this._cesium.Math.toRadians(this._cesium.defaultValue(options.heading, 0)),
                    this._cesium.Math.toRadians(this._cesium.defaultValue(options.pitch, 0)),
                    this._cesium.Math.toRadians(this._cesium.defaultValue(options.roll, 0))
                )
            );
        }
        //判断模型是否自传
        var that = this;
        if (options.rotate) {
            ent.orientation = new this._cesium.CallbackProperty(changeRotate, false);
            that.rotate = options.rotate;
            delete options.rotate;
        }
        //自传函数
        function changeRotate() {
            that.heading = that.heading + that.rotate;
            return that._cesium.Transforms.headingPitchRollQuaternion(
                that._cesium.Cartesian3.fromDegrees(that._position[0], that._position[1], that._position[2]),
                new that._cesium.HeadingPitchRoll(
                    that._cesium.Math.toRadians(that._cesium.defaultValue(that.heading, 0)),
                    that._cesium.Math.toRadians(that._cesium.defaultValue(that.pitch, 0)),
                    that._cesium.Math.toRadians(that._cesium.defaultValue(that.roll, 0))
                )
            );
        }
        delete options.heading;
        delete options.pitch;
        delete options.roll;
        ent.model = options;
        this.item = this._viewer.entities.add(ent);
        //this.item = this._viewer.entities.add({
        //    position: this._cesium.Cartesian3.fromDegrees(this._position[0], this._position[1], this._position[2]),
        //    model: options
        //});
        //if (options.heading || options.pitch || options.roll) {
        //    this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
        //        this._cesium.Cartesian3.fromDegrees(this._position[0], this._position[1], this._position[2]),
        //        new this._cesium.HeadingPitchRoll(
        //            this._cesium.Math.toRadians(this._cesium.defaultValue(options.heading, 0)),
        //            this._cesium.Math.toRadians(this._cesium.defaultValue(options.pitch, 0)),
        //            this._cesium.Math.toRadians(this._cesium.defaultValue(options.roll, 0))
        //        )
        //    );
        //}
        //执行回调函数
        if (typeof callback == 'function') {
            callback(this.item);
        }

        var obj = {
            id: this.item.id,
            name: Description || '新建模型' + defaultOption.id,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'Point',
            item: this.item
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
    * 向三维场景中添加一个模型(可编辑模型)。
    * @param {Array} [Position] 一个经纬度数组 例如：[x, y, z]。
    * @param {String} [FileName] 想要加载模型的完整路径名或URL。
    * @param {Object} [Option] 模型参数。
    * @param {String} [GroupID] 组的ID，模型在该组中被创建。如果GroupID设置为零，则对象在根节点下创建。
    * @param {String} [Description] 显示在信息树中模型的名称。
    * @param {function} [callback] 回调函数。
    * @returns {Promise.<Object>} 返回一个Cesium的对象。
    *
    */
    PointModel.prototype.createModelEditable = function (Position, FileName, Option, GroupID, Description, callback) {
        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取时返回的用户定义值。
            uri: FileName,
            show: true,
            heading: 0,
            pitch: 0,
            roll: 0,
            scale: 1
        };
        var options = this._core.extend(defaultOption, Option, true);
        this._position = Position;
        var ent = {
            position: this._cesium.Cartesian3.fromDegrees(this._position[0], this._position[1], this._position[2]),
            model: options
        };
        var Pointposition = this._cesium.Cartesian3.fromDegrees(this._position[0], this._position[1], this._position[2]);
        //创建坐标系position, orientation,color, 
        var cylinder = this.createCylinder(Pointposition, new this._cesium.CallbackProperty(Orientation0, false), new this._cesium.CallbackProperty(changeRadius, false), new this._cesium.CallbackProperty(changeSlices, false), this._cesium.Color.LIMEGREEN, false);
        cylinder.oid = 1;
        this.modelPointArr.push(cylinder);
        var cylinder1 = this.createCylinder(Pointposition, new this._cesium.CallbackProperty(Orientation1, false), new this._cesium.CallbackProperty(changeRadius, false), new this._cesium.CallbackProperty(changeSlices, false), this._cesium.Color.MEDIUMBLUE, false);
        cylinder1.oid = 2;
        this.modelPointArr.push(cylinder1);
        var cylinder2 = this.createCylinder(Pointposition, new this._cesium.CallbackProperty(Orientation2, false), new this._cesium.CallbackProperty(changeRadius, false), new this._cesium.CallbackProperty(changeSlices, false), this._cesium.Color.RED, false);
        cylinder2.oid = 3;
        this.modelPointArr.push(cylinder2);

        //创建放大缩小按钮
        //放大
        var Billboard1 = this.creatBillboard(Pointposition, new this._cesium.CallbackProperty(changepixelOffset, false), "../../img/j.png", false);
        Billboard1.oid = 4;
        this.modelPointArr.push(Billboard1);
        //缩小
        var Billboard2 = this.creatBillboard(Pointposition, new this._cesium.CallbackProperty(changepixelOffset1, false), "../../img/s.png", false);
        Billboard2.oid = 5;
        this.modelPointArr.push(Billboard2);

        if (options.heading || options.pitch || options.roll) {
            this.heading = options.heading;
            this.pitch = options.pitch;
            this.roll = options.roll;
            ent.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                this._cesium.Cartesian3.fromDegrees(this._position[0], this._position[1], this._position[2]),
                new this._cesium.HeadingPitchRoll(
                    this._cesium.Math.toRadians(this._cesium.defaultValue(options.heading, 0)),
                    this._cesium.Math.toRadians(this._cesium.defaultValue(options.pitch, 0)),
                    this._cesium.Math.toRadians(this._cesium.defaultValue(options.roll, 0))
                )
            );
        }
        //判断模型是否自传
        var that = this;
        if (options.rotate) {
            ent.orientation = new this._cesium.CallbackProperty(changeRotate, false);
            that.rotate = options.rotate;
            delete options.rotate;
        }
        ent.orientation = new this._cesium.CallbackProperty(changeRotates, false);
        that.scale = options.scale;
        ent.model.scale = new this._cesium.CallbackProperty(changeScale, false);

        //辅助圆转动
        function Orientation0() {
            var Pointposition = that._cesium.Cartesian3.fromDegrees(that._position[0], that._position[1], that._position[2]);
            var heading = that._cesium.Math.toRadians(that.heading);
            var hpr = new that._cesium.HeadingPitchRoll(heading, that._cesium.Math.toRadians(that.pitch), that._cesium.Math.toRadians(that.roll));
            return that._cesium.Transforms.headingPitchRollQuaternion(Pointposition, hpr);
        }
        //辅助圆转动
        function Orientation1() {
            var Pointposition = that._cesium.Cartesian3.fromDegrees(that._position[0], that._position[1], that._position[2]);
            var heading = that._cesium.Math.toRadians(that.heading);
            var hpr = new that._cesium.HeadingPitchRoll(heading, that._cesium.Math.toRadians(90 + that.pitch), that._cesium.Math.toRadians(that.roll));
            return that._cesium.Transforms.headingPitchRollQuaternion(Pointposition, hpr);
        }
        //辅助圆转动1
        function Orientation2() {
            var Pointposition = that._cesium.Cartesian3.fromDegrees(that._position[0], that._position[1], that._position[2]);
            var heading = that._cesium.Math.toRadians(that.heading);
            var hpr = new that._cesium.HeadingPitchRoll(heading, that._cesium.Math.toRadians(that.pitch), that._cesium.Math.toRadians(90 + that.roll));
            return that._cesium.Transforms.headingPitchRollQuaternion(Pointposition, hpr);
        }
        //动态旋转
        function changeRotates() {
            return that._cesium.Transforms.headingPitchRollQuaternion(
                that._cesium.Cartesian3.fromDegrees(that._position[0], that._position[1], that._position[2]),
                new that._cesium.HeadingPitchRoll(
                    that._cesium.Math.toRadians(that._cesium.defaultValue(that.heading, 0)),
                    that._cesium.Math.toRadians(that._cesium.defaultValue(that.pitch, 0)),
                    that._cesium.Math.toRadians(that._cesium.defaultValue(that.roll, 0))
                )
            );
        }
        //自转函数
        function changeRotate() {
            that.heading = that.heading + that.rotate;
            return that._cesium.Transforms.headingPitchRollQuaternion(
                that._cesium.Cartesian3.fromDegrees(that._position[0], that._position[1], that._position[2]),
                new that._cesium.HeadingPitchRoll(
                    that._cesium.Math.toRadians(that._cesium.defaultValue(that.heading, 0)),
                    that._cesium.Math.toRadians(that._cesium.defaultValue(that.pitch, 0)),
                    that._cesium.Math.toRadians(that._cesium.defaultValue(that.roll, 0))
                )
            );
        }
        //修改大小函数
        function changeScale() {
            return that.scale;
        }
        //修改坐标系大小
        function changeRadius() {
            return that.Radius * that.scale;
        }
        //圆环
        function changeSlices() {
            return that.Radius * 100;
        }
        //修改放大缩小按钮大小
        function changepixelOffset() {
            return new that._cesium.Cartesian2(0, -(that.Radius * that.scale));
        }
        function changepixelOffset1() {
            return new that._cesium.Cartesian2(-(that.Radius * that.scale), 0);
        }
        delete options.heading;
        delete options.pitch;
        delete options.roll;
        ent.model = options;
        this.item = this._viewer.entities.add(ent);
        this.item.objId = this.objId;
        this._core.Entityadd(this);
        this.state = 1;
        //执行回调函数
        if (typeof callback == 'function') {
            callback(this.item);
        }
        var obj = {
            id: this.item.id,
            name: Description || '新建模型' + defaultOption.id,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'Point',
            item: this.item
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    PointModel.prototype.createOrientation = function (position, pitch, roll) {
        var heading = this._cesium.Math.toRadians(0);
        var hpr = new this._cesium.HeadingPitchRoll(heading, this._cesium.Math.toRadians(pitch), this._cesium.Math.toRadians(roll));
        return this._cesium.Transforms.headingPitchRollQuaternion(position, hpr);
    };
    PointModel.prototype.createCylinder = function (position, orientation, Radius, Slices, color, show) {
        if (!position) return;
        return this._viewer.entities.add({
            position: position,
            orientation: orientation,
            cylinder: {
                length: 10.0,
                topRadius: Radius,
                bottomRadius: Radius,
                fill: false,
                material: color.withAlpha(0.5),
                outline: true,
                outlineWidth: 10,
                outlineColor: color,
                numberOfVerticalLines: Slices,
                slices: Slices
            },
            show: show
        });
    };
    //修改模型
    PointModel.prototype.startModify = function () {
        if (this.state != 2 && this.state != 1) return; //表示还没绘制完成
        var $this = this;
        if (!this.modifyHandler) this.modifyHandler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        for (var i = 0; i < $this.modelPointArr.length; i++) {
            var point = $this.modelPointArr[i];
            if (point) point.show = true;
        }
        var a, b, c;
        var h, p, r;
        this.modifyHandler.setInputAction(function (evt) {
            var pick = $this._viewer.scene.pick(evt.position);
            if ($this._cesium.defined(pick) && pick.id) {
                if (!pick.id.objId) {
                    if ($this.modifyPoint && ($this.modifyPoint.oid == 4 || $this.modifyPoint.oid == 5)) {
                        if (pick.id.oid != $this.modifyPoint.oid) {
                            $this.modifyPoint = pick.id;
                        }
                        if ($this.modifyPoint.oid == 4) {
                            $this.scale = $this.scale + 1;
                        } else {
                            $this.scale = $this.scale - 1;
                        }
                    } else {
                        $this.modifyPoint = pick.id;
                    }
                } else {
                    $this.modifyModel = pick.id;
                }
                $this.forbidDrawWorld(true);
            }
            var position = $this._cesium.Cartesian3.fromDegrees($this._position[0], $this._position[1], $this._position[2]);
            a = $this._cesium.SceneTransforms.wgs84ToWindowCoordinates($this._viewer.scene, position);
            b = evt.position;
            h = $this.heading + 0.0;
            r = $this.roll + 0.0;
            p = $this.pitch + 0.0;
            $this.state = 2;
        }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);
        this.modifyHandler.setInputAction(function (evt) {
            var pick = $this._viewer.scene.pick(evt.position);
            if ($this._cesium.defined(pick) && pick.id) ; else {
                for (var i = 0; i < $this.modelPointArr.length; i++) {
                    var point = $this.modelPointArr[i];
                    if (point) point.show = false;
                }
                if ($this.modifyHandler) {
                    $this.modifyHandler.destroy();
                    $this.modifyHandler = null;
                }
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        this.modifyHandler.setInputAction(function (evt) { //移动时绘制线
            //提示框
            $this._viewer.scene.pick(evt.endPosition);
            if (!$this.modifyModel && !$this.modifyPoint) return;
            //var cartesian = $this.getCatesian3FromPX(evt.endPosition, $this._viewer, []);
            var cartesian = $this._viewer.scene.pickPosition(evt.endPosition);
            if (cartesian) {
                if ($this.modifyModel) {
                    $this.item.position.setValue(cartesian);
                    for (var i = 0; i < $this.modelPointArr.length; i++) {
                        var point = $this.modelPointArr[i];
                        if (point) point.position.setValue(cartesian);
                    }
                } else if ($this.modifyPoint) {
                    c = evt.endPosition;
                    var arg = $this.arge(a, b, c);
                    //var azimuth = $this._core.getSpaceDistancem($this.tempPoints[0], $this.tempPoints[1], $this.tempPoints[2], $this._cesium);
                    //this.heading = this._cesium.Math.toRadians(0);
                    //this.pitch = this._cesium.Math.toRadians(0);
                    //this.roll = this._cesium.Math.toRadians(0);
                    if ($this.modifyPoint.oid == 1) {
                        $this.heading = h + arg;
                    } else if ($this.modifyPoint.oid == 2) {
                        $this.roll = r + arg;
                    } else if ($this.modifyPoint.oid == 3) {
                        $this.pitch = p + arg;
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        this.modifyHandler.setInputAction(function (evt) {
            if (!$this.modifyPoint && !$this.modifyModel) return;
            if ($this.modifyPoint && ($this.modifyPoint.oid == 4 || $this.modifyPoint.oid == 5)) ; else {
                $this.modifyPoint = null;
                $this.modifyModel = null;
                $this.forbidDrawWorld(false);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_UP);

    };
    //添加放大缩小图片
    PointModel.prototype.creatBillboard = function (cartesian, pixelOffset, url, show) {
        var point = this._viewer.entities.add({
            position: cartesian,
            show: show,
            billboard: {
                image: url,
                pixelOffset: pixelOffset,
                verticalOrigin: this._cesium.VerticalOrigin.BOTTOM,
                //heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
            }
        });
        point.attr = "editPoint";
        return point;
    };
    PointModel.prototype.arge = function (pointA, pointB, pointC) {
        var lengthAB = Math.sqrt(Math.pow(pointA.x - pointB.x, 2) +
            Math.pow(pointA.y - pointB.y, 2)),
            lengthAC = Math.sqrt(Math.pow(pointA.x - pointC.x, 2) +
                Math.pow(pointA.y - pointC.y, 2)),
            lengthBC = Math.sqrt(Math.pow(pointB.x - pointC.x, 2) +
                Math.pow(pointB.y - pointC.y, 2));
        var cosA = (Math.pow(lengthAB, 2) + Math.pow(lengthAC, 2) - Math.pow(lengthBC, 2)) /
            (2 * lengthAB * lengthAC);
        return Math.round(Math.acos(cosA) * 180 / Math.PI);
    };
    PointModel.prototype.forbidDrawWorld = function (isForbid) {
        this._viewer.scene.screenSpaceCameraController.enableRotate = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableTilt = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableTranslate = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableInputs = !isForbid;
    };
    PointModel.prototype.getCatesian3FromPX = function (px, viewer, entitys) {
        var pick = viewer.scene.pick(px);
        var cartesian;
        var drillPick = viewer.scene.drillPick(px);
        var truePick = null;
        if (entitys) {
            for (var i = 0; i < drillPick.length; i++) {
                if (drillPick[i].id._id != entitys[0].id && drillPick[i].id._id != entitys[1].id) {
                    truePick = drillPick[i].id;
                    break;
                }
            }
        } else {
            truePick = pick;
        }
        if (viewer.scene.pickPositionSupported && Cesium.defined(truePick)) {
            cartesian = viewer.scene.pickPosition(px);
        } else {
            var ray = viewer.camera.getPickRay(px);
            if (!ray) return;
            cartesian = viewer.scene.globe.pick(ray, viewer.scene);
        }
        return cartesian;
    };
    //工程树添加
    PointModel.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 设置PointModel的显示隐藏
     * @param {boolean} [b] true|false
     */
    PointModel.prototype.setVisibility = function (b) {
        if (this.item.item) {
            this.item.item.show = b;
        } else {
            this.item.show = b;
        }
        if (this.model.length > 0) {
            for (var i = 0; i < this.model.length; i++) {
                this.model[i].show = b;
                if (this.model[i]._availability && !b) {
                    this.model[i]._availability = undefined;
                } else if (this.model[i].time && b) {
                    this.model[i]._availability = this.model[i].time;
                }
            }
        }
    };
    /**
     * 设置旋转
     */
    PointModel.prototype.setOrientation = function (data) {
        if (data.heading || data.pitch || data.roll) {
            this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                this._cesium.Cartesian3.fromDegrees(this._position[0], this._position[1], this._position[2]),
                new this._cesium.HeadingPitchRoll(
                    this._cesium.Math.toRadians(this._cesium.defaultValue(data.heading, 0)),
                    this._cesium.Math.toRadians(this._cesium.defaultValue(data.pitch, 0)),
                    this._cesium.Math.toRadians(this._cesium.defaultValue(data.roll, 0))
                )
            );
        }
    };
    /**
     * 设置大小
     */
    PointModel.prototype.setScale = function (num) {
        this.item && this.item.model && (this.item.model.scale = num);
    };
    /**
     * 设置位置
     */
    PointModel.prototype.setPosition = function (Position) {
        this.item && this.item.model && (this._position = Position, this.item.position = this._cesium.Cartesian3.fromDegrees(this._position[0], this._position[1], this._position[2]));
    };
    /**
     * 获取PointModel的显示隐藏
     */
    PointModel.prototype.getVisibility = function () {
        return this.item.show;
    };
    /**
     * 删除数据
     */
    PointModel.prototype.deleteObject = function () {
        if (this.model && this.model.length) {
            for (var i = 0; i < this.model.length; i++) {
                this._viewer.scene.primitives.remove(this.model[i]);
            }
        }
        try {
            this._viewer.scene.primitives.remove(this.item);
        }
        catch (ex) {

        }
        try {
            this._viewer.entities.remove(this.item);
        }
        catch (ex) {

        }
        try {
            this._viewer.dataSources.remove(this.item);
        }
        catch (ex) { }
        try {
            this._Provider.remove();
        } catch (ex) {
        }
    };

    /**
     *
     * 多边形Geojsonu要素图层
     *
     * @alias PolygonGeoJsonFeatureLayer
     * @constructor
     *
     */
    function PolygonGeoJsonFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this._Provider = undefined;
        this._primitive = undefined;
        this._taskProcessor = new this._cesium.TaskProcessor('vectorTileProvider');
        this.model = [];
        //图例
        this.Legend = [];
        this._ajax = null;
        this.datas = null;
    }
    /**
    * 创建PolylineGeoJsonFeatureLayer
    *
    * @param {String} [name] 图层名称。
    * @param {object|String} [geojsonOrurl] geojosn对象或者地址
    * @param {object} [option] 参数对象{
    *   polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: Cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: Cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: Cesium.ArcType.GEODESIC,
            material: Cesium.Color.WHITE,
            show: true
        }
    * @param {Function} [disFnc] 回调函数
    * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
    */
    PolygonGeoJsonFeatureLayer.prototype.createPolygonGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var defaultOptions = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.WHITE,
            show: true
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        var that = this;
        var geometries = [];
        dataSource.then(function (dataSource) {
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                options.polygonHierarchy = new that._cesium.PolygonHierarchy(entity.polygon.hierarchy._value.positions);
                var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                var geometryInstance = new that._cesium.GeometryInstance({
                    geometry: geometry,
                    // attributes: {
                    //     color: new Cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                    // }
                });
                geometries.push(geometryInstance);
            }
            var ps = that._viewer.scene.primitives.add(new that._cesium.Primitive({
                geometryInstances: geometries,
                // appearance: new Cesium.PerInstanceColorAppearance({
                //     flat: true,
                //     translucent: true,
                //     faceForward: true,
                //     closed: true
                // }),
                appearance: new that._cesium.MaterialAppearance({
                    material: new that._cesium.Material({
                        fabric: {
                            type: 'Color',
                            uniforms: {
                                // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                color: options.material
                            }
                        }
                    }),
                    faceForward: true,
                    flat: false
                }),
                // shadows: Cesium.ShadowMode.ENABLED
            }));
            var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
            that.Legend.push(col);
            that.item = ps;
            if (options.show == false) {
                ps.show = false;
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geojsonOrurl,
            style: options
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 删除数据
     */
    PolygonGeoJsonFeatureLayer.prototype.deleteObject = function () {
        if (this.items != undefined && this.items != null && this.items.length > 0) {
            for (var i = 0; i < this.items.length; i++) {
                this._viewer.scene.primitives.remove(this.items[i]);
            }
        } else {
            this._viewer.scene.primitives.remove(this.item);
        }
        if (this.model != undefined && this.model != null && this.model.length > 0) {
            for (var i = 0; i < this.model.length; i++) {
                //this.model[i].show = b;
                this._viewer.scene.primitives.remove(this.model[i]);
            }
        }
        try {
            this._Provider.remove();
        } catch (ex) { }
    };
    /**
    * 设置数据是否刷新
    */
    PolygonGeoJsonFeatureLayer.prototype.setRefresh = function (b) {
        try {
            if (this._Provider) {
                this._Provider.setStatus(!b);
            }
        } catch (ex) {
        }
    };
    /**
     * 设置数据显示隐藏
     */
    PolygonGeoJsonFeatureLayer.prototype.setVisibility = function (b) {
        //测试显示隐藏
        if (this.items != undefined && this.items != null && this.items.length > 0) {
            for (var i = 0; i < this.items.length; i++) {
                this.items[i].show = b;
            }
        } else {
            this.item.show = b;
        }
        if (this.model != undefined && this.model != null && this.model.length > 0) {
            for (var i = 0; i < this.model.length; i++) {
                this.model[i].show = b;
                //this._viewer.scene.primitives.remove(this.model[i]);
            }
        }
        if (this._Provider) {
            this._Provider.setStatus(!b);
        }
    };

    /**
     * 创建geojson矢量图层
     * @param {String} [name] 图层名称
     * @param {object} [geoOptions] geojosn图层
    *       url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
    *       layer:'nanjing',
            upperLevelLimit: 13,
            lowerLevelLimit: 13,
            minx:118.51721649800015,
            miny:31.863232407499936,
            maxx:118.91648798400001,
            maxy:32.27649160409993
     * @param {object} [styleOption] 图层样式
     *      polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: Cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: Cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: Cesium.ArcType.GEODESIC,
            material: Cesium.Color.WHITE,
            show: true
     * @param {Float}  [GroupID] 组itemID
     * @param {object} [disFnc] 回调函数
     */
    PolygonGeoJsonFeatureLayer.prototype.createPolygonVectorGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 999999,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            //perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.WHITE,
            shadows: this._cesium.ShadowMode.ENABLED,
            show: true
        };
        //4490
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        if (options.extrudedHeight == 0) {
            options.extrudedHeight = 999999;
        }
        this.items = [];
        var that = this;
        //this.options=options;
        /**
         * 请求矢量切片
         */
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            var geomInstances = [];
            var primitive = null;
            scene.primitives;
            that.Legend = [];
            //测试
            new that._cesium.PrimitiveCollection();
            //console.time("jinlei");
            json.features.forEach(function (feature) {
                if (geoJSONVectorTileProvider._isCameraMoving) {
                    return null;
                }

                var newArr = [];

                function fun(arr) {
                    for (var i = 0; i < arr.length; i++) {
                        if (Array.isArray(arr[i])) {
                            fun(arr[i]);
                        } else {
                            newArr.push(arr[i]);
                        }
                    }
                }
                if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                    if (Array.isArray(feature.geometry.coordinates[0][0])) {
                        for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                            newArr = [];
                            fun(feature.geometry.coordinates[j]);
                            createobj(newArr);
                        }
                    } else {
                        fun(feature.geometry.coordinates);
                        createobj(newArr);
                    }
                }
                function createobj(newArr) {
                    if (geoJSONVectorTileProvider._isCameraMoving) {
                        return null;
                    }
                    var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                    if (/^\[/.test(styleOption.extrudedHeight) && /\]$/.test(styleOption.extrudedHeight)) {
                        var extrudedHeight = styleOption.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                    }
                    options.extrudedHeight = parseFloat(options.extrudedHeight);
                    if (options.heightReference == 1) {
                        delete options.height;
                    }
                    if (options.extrudedHeightReference == 1) {
                        delete options.extrudedHeight;
                    }
                    if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                        var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                        options.material = feature.properties[material];
                        //填充颜色设置
                        if (that._core.isHtmlColor(options.material)) {
                            options.material = that._color.colorFromHtmlColor(options.material);
                        } else {
                            if (/^rgb/.test(options.material)) {
                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                            }
                            if (options.material.r > 1) {
                                options.material.r = options.material.r / 255;
                            }
                            if (options.material.g > 1) {
                                options.material.g = options.material.g / 255;
                            }
                            if (options.material.b > 1) {
                                options.material.b = options.material.b / 255;
                            }
                            if (options.material.a > 1) {
                                options.material.a = options.material.a / 255;
                            }
                            options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                        }
                    }
                    options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                    feature.positions = pos;
                    var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                    var geometryInstance = null;
                    geometryInstance = new that._cesium.GeometryInstance({
                        id: feature,  //拾取属性修改
                        geometry: extrudedPolygon,
                        attributes: {
                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material)
                        }
                    });
                    //图例
                    var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                    that.Legend.push(col);
                    geomInstances.push(geometryInstance);
                    //var classificationTypes=that._cesium.ClassificationType.TERRAIN;
                    //if(options.ground!=undefined||options.ground=="1"){
                    //    classificationTypes=options.classificationType;
                    //}else{
                    //    classificationTypes=options.classificationType;
                    //}
                    //if(options.classificationType==0){
                    //    classificationTypes= that._cesium.ClassificationType.BOTH;
                    //}
                    //primitive = new that._cesium.ClassificationPrimitive({
                    //    geometryInstances: geometryInstance,
                    //    appearance: new that._cesium.PerInstanceColorAppearance({
                    //        closed: true,
                    //        flat: false
                    //    }),
                    //    classificationType: options.classificationType,
                    //    shadows: that._cesium.ShadowMode.ENABLED
                    //});
                    //collection.add(primitive);
                }
            });
            if (geomInstances.length > 0) {
                primitive = new that._cesium.GroundPrimitive({
                    geometryInstances: geomInstances,
                    appearance: new that._cesium.PerInstanceColorAppearance({
                        closed: true,
                        flat: false
                    }),
                    classificationType: options.classificationType
                });
                //onsole.timeEnd("jinlei");
                return primitive;
            }
        };
        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //面模型矢量切片
    PolygonGeoJsonFeatureLayer.prototype.createPolygonVectorGeoJsonFeatureLayerProviderModel = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 999999,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            //perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.WHITE,
            shadows: this._cesium.ShadowMode.ENABLED,
            show: true
        };
        //4490
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        //面填充颜色设置
        var urlop = styleOption.material;
        var heightmodel = styleOption.height;
        //模型颜色颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.color)) {
            if (this._core.isHtmlColor(styleOption.color)) {
                styleOption.color = this._color.colorFromHtmlColor(styleOption.color);
            } else {
                if (/^rgb/.test(styleOption.color)) {
                    styleOption.color = this._color.rgbaStringToRgbaObj(styleOption.color);
                }
                if (styleOption.color.r > 1) {
                    styleOption.color.r = styleOption.color.r / 255;
                }
                if (styleOption.color.g > 1) {
                    styleOption.color.g = styleOption.color.g / 255;
                }
                if (styleOption.color.b > 1) {
                    styleOption.color.b = styleOption.color.b / 255;
                }
                if (styleOption.color.a > 1) {
                    styleOption.color.a = styleOption.color.a / 255;
                }
                styleOption.color = this._color.createColor(styleOption.color.r, styleOption.color.g, styleOption.color.b, styleOption.color.a);
            }
        }
        //模型高亮颜色颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.lightColor)) {
            if (this._core.isHtmlColor(styleOption.lightColor)) {
                styleOption.lightColor = this._color.colorFromHtmlColor(styleOption.lightColor);
            } else {
                if (/^rgb/.test(styleOption.lightColor)) {
                    styleOption.lightColor = this._color.rgbaStringToRgbaObj(styleOption.lightColor);
                }
                if (styleOption.lightColor.r > 1) {
                    styleOption.lightColor.r = styleOption.lightColor.r / 255;
                }
                if (styleOption.lightColor.g > 1) {
                    styleOption.lightColor.g = styleOption.lightColor.g / 255;
                }
                if (styleOption.lightColor.b > 1) {
                    styleOption.lightColor.b = styleOption.lightColor.b / 255;
                }
                if (styleOption.lightColor.a > 1) {
                    styleOption.lightColor.a = styleOption.lightColor.a / 255;
                }
                styleOption.lightColor = this._color.createColor(styleOption.lightColor.r, styleOption.lightColor.g, styleOption.lightColor.b, styleOption.lightColor.a);
            }
        }
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        if (options.extrudedHeight == 0) {
            options.extrudedHeight = 999999;
        }
        this.items = [];
        var that = this;
        //this.options=options;
        /**
         * 请求矢量切片
         */
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            var primitive = null;
            scene.primitives;
            //测试
            var collection = new that._cesium.PrimitiveCollection();
            //console.time("jinlei");
            //模型集合
            // var model = [];
            // if (that.model.length > 0) {
            //     for (var i = 0; i < that.model.length; i++) {
            //         that._viewer.scene.primitives.remove(that.model[i]);
            //     }
            // }
            //图例
            that.Legend = [];
            json.features.forEach(function (feature) {
                if (geoJSONVectorTileProvider._isCameraMoving) {
                    return null;
                }

                var newArr = [];

                function fun(arr) {
                    for (var i = 0; i < arr.length; i++) {
                        if (Array.isArray(arr[i])) {
                            fun(arr[i]);
                        } else {
                            newArr.push(arr[i]);
                        }
                    }
                }
                if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                    if (Array.isArray(feature.geometry.coordinates[0][0])) {
                        for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                            newArr = [];
                            fun(feature.geometry.coordinates[j]);
                            createobj(newArr);
                            createmodel(newArr);
                        }
                    } else {
                        fun(feature.geometry.coordinates);
                        createobj(newArr);
                        createmodel(newArr);
                    }
                }
                function createobj(newArr) {
                    if (geoJSONVectorTileProvider._isCameraMoving) {
                        return null;
                    }
                    var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                    if (/^\[/.test(styleOption.extrudedHeight) && /\]$/.test(styleOption.extrudedHeight)) {
                        var extrudedHeight = styleOption.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                    }
                    options.extrudedHeight = parseFloat(options.extrudedHeight);
                    if (options.heightReference == 1) {
                        delete options.height;
                    }
                    if (options.extrudedHeightReference == 1) {
                        delete options.extrudedHeight;
                    }
                    if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                        var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                        options.material = feature.properties[material];
                        //填充颜色设置
                        if (that._core.isHtmlColor(options.material)) {
                            options.material = that._color.colorFromHtmlColor(options.material);
                        } else {
                            if (/^rgb/.test(options.material)) {
                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                            }
                            if (options.material.r > 1) {
                                options.material.r = options.material.r / 255;
                            }
                            if (options.material.g > 1) {
                                options.material.g = options.material.g / 255;
                            }
                            if (options.material.b > 1) {
                                options.material.b = options.material.b / 255;
                            }
                            if (options.material.a > 1) {
                                options.material.a = options.material.a / 255;
                            }
                            options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                        }
                    }
                    options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                    var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                    var geometryInstance = null;
                    feature.positions = pos;
                    geometryInstance = new that._cesium.GeometryInstance({
                        id: feature,  //拾取属性修改
                        geometry: extrudedPolygon,
                        attributes: {
                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material)
                        }
                    });
                    //geomInstances.push(geometryInstance);
                    //var classificationTypes=that._cesium.ClassificationType.TERRAIN;
                    //if(options.ground!=undefined||options.ground=="1"){
                    //    classificationTypes=options.classificationType;
                    //}else{
                    //    classificationTypes=options.classificationType;
                    //}
                    //if(options.classificationType==0){
                    //    classificationTypes= that._cesium.ClassificationType.BOTH;
                    //}
                    //图例
                    var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                    that.Legend.push(col);
                    primitive = new that._cesium.ClassificationPrimitive({
                        geometryInstances: geometryInstance,
                        appearance: new that._cesium.PerInstanceColorAppearance({
                            closed: true,
                            flat: false
                        }),
                        classificationType: options.classificationType,
                        shadows: that._cesium.ShadowMode.ENABLED
                    });
                    collection.add(primitive);
                }
                function createmodel(newArr) {
                    var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                    var polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                    var hierarchy = [];
                    var dx = polygonHierarchy.positions;
                    for (var j = 0; j < dx.length; j++) {
                        var x = that._cesium.Math.toDegrees(that._cesium.Cartographic.fromCartesian(dx[j]).longitude);
                        var y = that._cesium.Math.toDegrees(that._cesium.Cartographic.fromCartesian(dx[j]).latitude);
                        hierarchy.push(x);
                        hierarchy.push(y);
                    }
                    var bottomPoint = that.getTheBottomPoint(hierarchy);
                    var pointsInPolygon = that.scanningPolygon(bottomPoint, options.offset_x, options.offset_y, hierarchy);
                    pointsInPolygon.forEach(function (point) {
                        var modelMatrix = that._cesium.Transforms.eastNorthUpToFixedFrame(that._cesium.Cartesian3.fromDegrees(point.lon, point.lat, heightmodel));        //gltf数据加载位置
                        //var hi = parseInt(options.heightReference);
                        var mol = that._cesium.Model.fromGltf({
                            url: urlop,        //如果为bgltf则为.bgltf
                            color: options.color,
                            lightColor: options.lightColor,
                            modelMatrix: modelMatrix,
                            scale: options.scale,   //放大倍数
                            //heightReference: parseInt(options.heightReference),
                            //distanceDisplayCondition: distance
                        });
                        collection.add(mol);
                        // that.model.push(mol);
                    });
                }
            });
            return collection;
        };
        //添加时间段
        if (styleOption && styleOption.time) {
            geoJSONVectorTileProvider.availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //通过角度和距离获取经纬度
    PolygonGeoJsonFeatureLayer.prototype.GetPositionFromA_D = function (lat, lon, distance, angle) {
        var Ea = 6378137.0;     //   赤道半径
        var Eb = 6356725.0;     //   极半径
        var dx = distance * Math.sin(angle * Math.PI / 180.0);
        var dy = distance * Math.cos(angle * Math.PI / 180.0);

        var ec = Eb + (Ea - Eb) * (90.0 - lat) / 90.0;
        var ed = ec * Math.cos(lat * Math.PI / 180);

        var newLon = (dx / ed + lon * Math.PI / 180.0) * 180.0 / Math.PI;
        var newLat = (dy / ec + lat * Math.PI / 180.0) * 180.0 / Math.PI;

        return [newLon, newLat];
    };
    //获取纬度最低点
    PolygonGeoJsonFeatureLayer.prototype.getTheBottomPoint = function (points) {
        var minLat = 90;
        var minIndex = 0;
        for (var i = 1; i < points.length; i += 2) {
            minLat = minLat < points[i] ? minLat : (minIndex = i) && points[i];
        }
        return {
            lon: points[minIndex - 1],
            lat: points[minIndex]
        };
    };
    //扫描多边形
    PolygonGeoJsonFeatureLayer.prototype.scanningPolygon = function (bottomPoint, dx, dy, area) {
        var points = [];
        var minLon = 180, maxLon = -180, maxLat = -90;
        var d_lon, d_lat;
        var westPoint, eastPoint, centerPoint;
        for (var i = 0; i < area.length; i += 2) {
            maxLat = maxLat > area[i + 1] ? maxLat : area[i + 1];
            minLon = minLon < area[i] ? minLon : area[i];
            maxLon = maxLon > area[i] ? maxLon : area[i];
        }
        var point1 = this.GetPositionFromA_D(bottomPoint.lat, bottomPoint.lon, dy, 0);
        var point2 = this.GetPositionFromA_D(bottomPoint.lat, bottomPoint.lon, dx, 90);
        //获取经纬度差
        d_lon = point2[0] - bottomPoint.lon;
        d_lat = point1[1] - bottomPoint.lat;

        points.push({ lon: bottomPoint.lon, lat: bottomPoint.lat });
        centerPoint = { lon: bottomPoint.lon, lat: bottomPoint.lat };
        //扫描
        for (centerPoint.lat += d_lat; centerPoint.lat <= maxLat; centerPoint.lat += d_lat) {
            westPoint = { lon: centerPoint.lon - d_lon, lat: centerPoint.lat };
            eastPoint = { lon: centerPoint.lon + d_lon, lat: centerPoint.lat };
            if (this.IsInPolygon(centerPoint.lon, centerPoint.lat, area)) {
                points.push({ lon: centerPoint.lon, lat: centerPoint.lat });
            }
            for (; westPoint.lon >= minLon; westPoint.lon -= d_lon) {
                if (this.IsInPolygon(westPoint.lon, westPoint.lat, area)) {
                    points.push({ lon: westPoint.lon, lat: westPoint.lat });
                }
            }
            for (; eastPoint.lon <= maxLon; eastPoint.lon += d_lon) {
                if (this.IsInPolygon(eastPoint.lon, eastPoint.lat, area)) {
                    points.push({ lon: eastPoint.lon, lat: eastPoint.lat });
                }
            }
        }
        return points;
    };
    //是否在多边形内
    PolygonGeoJsonFeatureLayer.prototype.IsInPolygon = function (lon, lat, area) {
        var isIn = 0;
        var dLon1, dLon2, dLat1, dLat2, dLon;
        if (area.length < 6) {
            return false;
        }
        area.push(area[0], area[1]);
        for (var i = 0; i < area.length - 2; i += 2) {
            dLon1 = area[i];
            dLat1 = area[i + 1];
            dLon2 = area[i + 2];
            dLat2 = area[i + 3];

            //判断点是否在边的两端点的水平平行线之间，在则可能有交点
            if (((lat >= dLat1) && (lat < dLat2)) || ((lat >= dLat2) && (lat < dLat1))) {
                if (Math.abs(dLat1 - dLat2) > 0) {
                    //得到点向左射线与边的交点的x坐标：
                    dLon = dLon1 - ((dLon1 - dLon2) * (dLat1 - lat)) / (dLat1 - dLat2);
                    //判断交点是否在左射线上
                    if (dLon <= lon)
                        isIn++;
                }
            }
        }
        //交点为奇数则在多边形内
        if (isIn % 2 !== 0) {
            return true;
        }
        return false;
    };
    //沿面模型分布修改
    PolygonGeoJsonFeatureLayer.prototype.setPolylinemodels = function (_positions, leftX, leftY, rightX, rightY, modelsl, attribute, cesium, viewer) {
        //起止点相关信息
        var julifr = this._core.getSpaceDistancem(_positions, cesium);
        var pointSum1 = 10;
        var cyjj = parseFloat(attribute.distance);
        if (cyjj == 0) ; else {
            pointSum1 = parseInt(julifr / cyjj);
        }
        var startPoint = _positions[0];
        var endPoint = _positions[_positions.length - 1];
        var scartographic = cesium.Cartographic.fromCartesian(startPoint);
        var slongitude = cesium.Math.toDegrees(scartographic.longitude);
        var slatitude = cesium.Math.toDegrees(scartographic.latitude);
        scartographic.height;

        var ecartographic = cesium.Cartographic.fromCartesian(endPoint);
        var elongitude = cesium.Math.toDegrees(ecartographic.longitude);
        var elatitude = cesium.Math.toDegrees(ecartographic.latitude);
        ecartographic.height;
        cesium.Math.toDegrees(scartographic.height);


        //var pointSum = pointSum1;  //取样点个数
        var pointSum = pointSum1; //取样点个数
        var addXTT = cesium.Math.lerp(slongitude, elongitude, 1.0 / pointSum) - slongitude;
        var addYTT = cesium.Math.lerp(slatitude, elatitude, 1.0 / pointSum) - slatitude;


        cesium.Math.lerp(leftX, rightX, 1.0 / pointSum) - leftX;
        cesium.Math.lerp(leftY, rightY, 1.0 / pointSum) - leftY;
        for (var i = 0; i < pointSum; i++) {
            var longitude = slongitude + (i + 1) * addXTT;
            var latitude = slatitude + (i + 1) * addYTT;
            var modelMatrix = cesium.Transforms.eastNorthUpToFixedFrame(cesium.Cartesian3.fromDegrees(longitude, latitude, attribute.height));        //gltf数据加载位置
            parseInt(attribute.heightReference);
            var mol = cesium.Model.fromGltf({
                url: attribute.url,        //如果为bgltf则为.bgltf
                modelMatrix: modelMatrix,
                color: attribute.color,
                lightColor: attribute.lightColor,
                scale: attribute.scale,   //放大倍数
                heightReference: parseInt(attribute.heightReference),
                //distanceDisplayCondition: attribute.distanceDisplayCondition
            });
            viewer.scene.primitives.add(mol);
            modelsl.push(mol);
        }
        return modelsl;
    };
    PolygonGeoJsonFeatureLayer.prototype.createPolygonVectorGeoJsonFeatureLayerProviderlsjl = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            //perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.WHITE,
            shadows: this._cesium.ShadowMode.ENABLED,
            show: true
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        var that = this;
        //this.options=options;
        /**
         * 请求矢量切片
         */
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;


        geoJSONVectorTileProvider._loadTile = function (json, tileKey) {
            //测试


            var verticesPromise = that._taskProcessor.scheduleTask({
                json: json,
                styleOption: styleOption,
                options: options,
                tileKey: tileKey

            });

            if (!that._cesium.defined(verticesPromise)) {
                // Postponed
                return undefined;
            }
            var that_t = that;
            that._cesium.when(verticesPromise, function (result) {
                if (!geoJSONVectorTileProvider._primitiveByTile[result.tileKey]) {
                    var collection = new that_t._cesium.PrimitiveCollection();
                    for (var i = 0; i < result.geomInstances.length; i++) {
                        var primitive = null;
                        var geometryInstance = result.geomInstances[i];
                        var tileKey = geometryInstance.id.id;
                        if (!geoJSONVectorTileProvider._primitiveByTile[tileKey]) {
                            var nMaterial = new that_t._cesium.Material({
                                fabric: {
                                    type: 'Color',
                                    uniforms: {
                                        // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                        color: result.materials[i]
                                    }
                                }
                            });
                            new that_t._cesium.MaterialAppearance({
                                material: nMaterial,
                                faceForward: true,
                                flat: false
                            });
                            var primitive = new that_t._cesium.Primitive({
                                allowPicking: true,
                                appearance: new that_t._cesium.PerInstanceColorAppearance(),
                                geometryInstances: geometryInstance,
                                shadows: that._cesium.ShadowMode.ENABLED
                            });
                            collection.add(primitive);


                        }

                    }
                    geoJSONVectorTileProvider._primitiveCollection.add(collection);
                    geoJSONVectorTileProvider._primitiveByTile[result.tileKey] = collection;
                }
            });
        };




        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    PolygonGeoJsonFeatureLayer.prototype.createPolygonVectorGeoJsonFeatureLayerProviderls = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            //perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.WHITE,
            shadows: this._cesium.ShadowMode.ENABLED,
            show: true
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else if (/^http/.test(styleOption.material)) ; else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.fill)) {
            if (styleOption.fill.toString().charAt(0) == "[" && styleOption.fill.toString().charAt(styleOption.fill.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.fill)) {
                    styleOption.fill = this._color.colorFromHtmlColor(styleOption.fill);
                } else if (/^http/.test(styleOption.fill)) ; else {
                    if (/^rgb/.test(styleOption.fill)) {
                        styleOption.fill = this._color.rgbaStringToRgbaObj(styleOption.fill);
                    }
                    if (styleOption.fill.r > 1) {
                        styleOption.fill.r = styleOption.fill.r / 255;
                    }
                    if (styleOption.fill.g > 1) {
                        styleOption.fill.g = styleOption.fill.g / 255;
                    }
                    if (styleOption.fill.b > 1) {
                        styleOption.fill.b = styleOption.fill.b / 255;
                    }
                    if (styleOption.fill.a > 1) {
                        styleOption.fill.a = styleOption.fill.a / 255;
                    }
                    styleOption.fill = this._color.createColor(styleOption.fill.r, styleOption.fill.g, styleOption.fill.b, styleOption.fill.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        var that = this;
        //this.options=options;
        /**
         * 请求矢量切片
         */
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            //测试
            that.Legend = [];
            var collection = new that._cesium.PrimitiveCollection();
            json.features.forEach(function (feature) {
                var newArr = [];

                function fun(arr) {
                    for (var i = 0; i < arr.length; i++) {
                        if (Array.isArray(arr[i])) {
                            fun(arr[i]);
                        } else {
                            newArr.push(arr[i]);
                        }
                    }
                }
                if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                    if (Array.isArray(feature.geometry.coordinates[0][0])) {
                        for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                            newArr = [];
                            fun(feature.geometry.coordinates[j]);
                            createobj(newArr);
                        }
                    } else {
                        fun(feature.geometry.coordinates);
                        createobj(newArr);
                    }
                }
                //fun(feature.geometry.coordinates[0]);
                function createobj(newArr) {
                    var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                    if (/^\[/.test(styleOption.extrudedHeight) && /\]$/.test(styleOption.extrudedHeight)) {
                        var extrudedHeight = styleOption.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                    }
                    options.extrudedHeight = parseFloat(options.extrudedHeight);
                    if (options.heightReference == 1) {
                        delete options.height;
                    }
                    if (options.extrudedHeightReference == 1) {
                        delete options.extrudedHeight;
                    }
                    if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                        var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                        options.material = feature.properties[material];
                        //填充颜色设置
                        if (that._core.isHtmlColor(options.material)) {
                            options.material = that._color.colorFromHtmlColor(options.material);
                        } else {
                            if (/^rgb/.test(options.material)) {
                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                            }
                            if (options.material.r > 1) {
                                options.material.r = options.material.r / 255;
                            }
                            if (options.material.g > 1) {
                                options.material.g = options.material.g / 255;
                            }
                            if (options.material.b > 1) {
                                options.material.b = options.material.b / 255;
                            }
                            if (options.material.a > 1) {
                                options.material.a = options.material.a / 255;
                            }
                            options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                        }
                    }

                    options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                    feature.positions = pos;
                    var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                    var geometryInstance = null;
                    //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                    var colorx = new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.fill);
                    //var materialx = new that._cesium.Material({
                    //    fabric: {
                    //        type: 'Color',
                    //        uniforms: {
                    //            // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                    //            color: options.material
                    //        }
                    //    }
                    //});

                    var materialx = {};
                    if (/^http/.test(options.material)) {
                        materialx = new that._cesium.Material({
                            fabric: {
                                type: 'Image',
                                uniforms: {
                                    //createPolygonVectorGeoJsonFeatureLayerProviderls
                                    //image : options.material
                                    image: options.material
                                }
                            }
                        });
                    } else {
                        //图例
                        var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                        that.Legend.push(col);
                        materialx = new that._cesium.Material({
                            fabric: {
                                type: 'Color',
                                uniforms: {
                                    // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                    color: options.material
                                }
                            }
                        });
                    }
                    geometryInstance = new that._cesium.GeometryInstance({
                        id: feature,  //拾取属性修改
                        geometry: extrudedPolygon,
                        attributes: {
                            color: colorx
                        }
                    });
                    //geomInstances.push(geometryInstance);
                    var primitive = null;
                    primitive = new that._cesium.Primitive({
                        allowPicking: true,
                        appearance: new that._cesium.MaterialAppearance({
                            material: materialx
                        }),
                        geometryInstances: geometryInstance,
                        shadows: that._cesium.ShadowMode.ENABLED
                    });

                    collection.add(primitive);
                }
            });
            return collection;
        };

        //添加时间段
        if (styleOption && styleOption.time) {
            geoJSONVectorTileProvider.availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //矢量切片山东(我们自己的)
    PolygonGeoJsonFeatureLayer.prototype.createPolygonVectorGeoJsonFeatureLayerProviderlsd = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };

        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.outlineColor)) {
            if (styleOption.outlineColor.toString().charAt(0) == "[" && styleOption.outlineColor.toString().charAt(styleOption.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.outlineColor)) {
                    styleOption.outlineColor = this._color.colorFromHtmlColor(styleOption.outlineColor);
                } else {
                    if (/^rgb/.test(styleOption.outlineColor)) {
                        styleOption.outlineColor = this._color.rgbaStringToRgbaObj(styleOption.outlineColor);
                    }
                    if (styleOption.outlineColor.r > 1) {
                        styleOption.outlineColor.r = styleOption.outlineColor.r / 255;
                    }
                    if (styleOption.outlineColor.g > 1) {
                        styleOption.outlineColor.g = styleOption.outlineColor.g / 255;
                    }
                    if (styleOption.outlineColor.b > 1) {
                        styleOption.outlineColor.b = styleOption.outlineColor.b / 255;
                    }
                    if (styleOption.outlineColor.a > 1) {
                        styleOption.outlineColor.a = styleOption.outlineColor.a / 255;
                    }
                    styleOption.outlineColor = this._color.createColor(styleOption.outlineColor.r, styleOption.outlineColor.g, styleOption.outlineColor.b, styleOption.outlineColor.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        var that = this;
        var urlzt = geoOptions.urlinit;

        var options = {
            polygonHierarchy: undefined,
            height: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        $.ajax({
            url: urlzt,
            type: "get",
            async: false,
            dataType: "json",
            success: function (data) {
                that.datas = data.features;
            }
        });
        //this.options=options;
        /**
         * 请求矢量切片
         */
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            //测试
            that.Legend = [];
            new that._cesium.PrimitiveCollection();

            var geometries = [];
            var geometries1 = [];
            var colect = new Cesium.PrimitiveCollection();
            json.features.forEach(function (feature) {
                var newArr = [];
                function fun(arr) {
                    for (var i = 0; i < arr.length; i++) {
                        if (Array.isArray(arr[i])) {
                            if (arr[i].length == 3) {
                                arr[i].splice(2, 1);
                                arr[i].push(that._option.height);
                            } else {
                                arr[i].push(that._option.height);
                            }
                            fun(arr[i]);
                        } else {
                            newArr.push(arr[i]);
                        }
                    }
                }
                //修改数据对比解析
                var sj = feature.id;
                var jl = parseInt(sj.split(".")[1]) - 1;
                feature = that.datas[jl];
                //var feature = that.datas[k];
                //解析坐标
                if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                    if (Array.isArray(feature.geometry.coordinates[0][0][0])) {
                        for (var j = 0; j < feature.geometry.coordinates[0].length; j++) {
                            newArr = [];
                            //feature.geometry.coordinates[j].pop();
                            fun(feature.geometry.coordinates[0][j]);
                            createobj(newArr);
                        }
                    }
                }
                //fun(feature.geometry.coordinates[0]);
                function createobj(newArr) {
                    if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                        var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                    }
                    options.material = that._option.material;
                    if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                        var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                        options.material = feature.properties[material];

                        //填充颜色设置
                        if (that._core.isHtmlColor(options.material)) {
                            options.material = that._color.colorFromHtmlColor(options.material);
                        } else {
                            if (/^rgb/.test(options.material)) {
                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                            }
                            if (options.material.red > 1) {
                                options.material.red = options.material.red / 255;
                            }
                            if (options.material.green > 1) {
                                options.material.green = options.material.green / 255;
                            }
                            if (options.material.blue > 1) {
                                options.material.blue = options.material.blue / 255;
                            }
                            if (options.material.alpha > 1) {
                                options.material.a = options.material.alpha / 255;
                            }
                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                        }
                    } else {
                        if (that._option.material) {
                            options.material = that._option.material;
                        }
                        if (options.material) {
                            if (that._core.isHtmlColor(options.material)) {
                                options.material = that._color.colorFromHtmlColor(options.material);
                            } else {
                                if (/^rgb/.test(options.material)) {
                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                }
                                if (options.material.red > 1) {
                                    options.material.red = options.material.red / 255;
                                }
                                if (options.material.green > 1) {
                                    options.material.green = options.material.green / 255;
                                }
                                if (options.material.blue > 1) {
                                    options.material.blue = options.material.blue / 255;
                                }
                                if (options.material.alpha > 1) {
                                    options.material.a = options.material.alpha / 255;
                                }
                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                            }
                        }
                    }
                    var pos = that._cesium.Cartesian3.fromDegreesArrayHeights(newArr);
                    options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                    //基础面      var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                    var extrudedPolygonsp = new that._cesium.PolygonGeometry(options);
                    //var geometry = Cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                    //options.material.alpha = 0;
                    var geometryInstance = new Cesium.GeometryInstance({
                        id: feature,
                        geometry: extrudedPolygonsp,
                        attributes: {
                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(that._option.randomColor ? Cesium.Color.fromRandom().withAlpha(options.material.alpha) : options.material),
                        }
                    });
                    geometries.push(geometryInstance);

                    //线
                    //var pos = Cesium.Cartesian3.fromDegreesArray(newArr);
                    var polyline = {
                        positions: pos,
                        width: that._option.width
                    };
                    var geometry = new that._cesium.GroundPolylineGeometry(polyline);
                    //var geometry4 = Cesium.PolylineGeometry.createGeometry(geometry);
                    var geometryInstance1 = new that._cesium.GeometryInstance({
                        geometry: geometry,
                        //attributes: {
                        //    color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.BLUE),
                        //}
                    });
                    //geometries_line.push(geometryInstance);
                    geometries1.push(geometryInstance1);
                    //图例
                    var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                    that.Legend.push(col);

                }
            });
            if (geometries.length > 0) {
                if (options.extrudedHeight) {
                    colect.add(new that._cesium.Primitive({
                        geometryInstances: geometries,
                        appearance: new that._cesium.PerInstanceColorAppearance({
                            translucent: false,
                            vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                            fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                        })
                    }));
                } else {
                    colect.add(new that._cesium.GroundPrimitive({
                        geometryInstances: geometries,
                        appearance: new that._cesium.PerInstanceColorAppearance({
                            translucent: true,
                            vertexShaderSource: that._core.Shaders("vertexShaderSource")
                        })
                    }));
                }
            }
            if (geometries1.length > 0) {
                colect.add(new that._cesium.GroundPolylinePrimitive({
                    geometryInstances: geometries1,
                    appearance: new that._cesium.PolylineMaterialAppearance({
                        material: new that._cesium.Material({
                            fabric: {
                                type: 'Color',
                                uniforms: {
                                    color: that._option.outlineColor
                                }
                            }
                        }),
                    }),
                    shadows: that._cesium.ShadowMode.ENABLED
                }));
            }
            return colect;
            //return colect;
        };
        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    //工程树添加
    PolygonGeoJsonFeatureLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 加载geojson动态单体化数据
     * @param {String} [name] 图层名称
     * @param {object} [geoOptions] geojosn图层
    *       url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
    *       layer:'nanjing',
            upperLevelLimit: 13,
            lowerLevelLimit: 13,
            minx:118.51721649800015,
            miny:31.863232407499936,
            maxx:118.91648798400001,
            maxy:32.27649160409993
     * @param {object} [styleOption] 图层样式
     *      polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: Cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: Cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: Cesium.ArcType.GEODESIC,
            material: Cesium.Color.WHITE,
            show: true
     * @param {Float}  [GroupID] 组itemID
     * @param {object} [disFnc] 回调函数
     */
    PolygonGeoJsonFeatureLayer.prototype.createPolygonVectorFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.WHITE,
            show: true
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        
        // defaultGeoOptions={
        //     url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
        //     urlParams: {
        //         REQUEST: 'GetTile',
        //         SERVICE: 'WMTS',
        //         VERSION: '1.0.0',
        //         LAYER: 'skyline:nanjing',
        //         STYLE: '',
        //         TILEMATRIX: 'EPSG:4490:{z}',
        //         TILEMATRIXSET: 'EPSG:4490',
        //         FORMAT: 'application/json;type=geojson',
        //         TILECOL: '{x}',
        //         TILEROW: '{y}'
        //     },
        //     upperLevelLimit: 13,
        //     lowerLevelLimit: 13,
        //     rectangle: Cesium.Rectangle.fromDegrees(118.51721649800015, 31.863232407499936, 118.91648798400001, 32.27649160409993),
        //     Cesium: Cesium
        // }
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        //this.options=options;
        /**
         * 请求矢量切片
         */
        var that = this;
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            var geomInstances = [];
            that.Legend = [];
            json.features.forEach(function (feature) {
                var newArr = [];

                function fun(arr) {
                    for (var i = 0; i < arr.length; i++) {
                        if (Array.isArray(arr[i])) {
                            fun(arr[i]);
                        } else {
                            newArr.push(arr[i]);
                        }
                    }
                }
                fun(feature.geometry.coordinates[0]);
                var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                if (/^\[/.test(styleOption.extrudedHeight) && /\]$/.test(styleOption.extrudedHeight)) {
                    var extrudedHeight = styleOption.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                    options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                }
                options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                //图例
                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                that.Legend.push(col);
                var geometryInstance = new that._cesium.GeometryInstance({
                    geometry: geometry,
                    attributes: {
                        color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material)
                    },
                    shadows: that._cesium.ShadowMode.ENABLED
                });
                geomInstances.push(geometryInstance);
            });


            var primitive = new this._cesium.Primitive({
                allowPicking: false,
                appearance: new this._cesium.PerInstanceColorAppearance({
                    translucent: false,
                    flat: true,
                    faceForward: true,
                    closed: true
                }),
                geometryInstances: geomInstances
            });

            return primitive;
        };
        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);

        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
    };

    /**
     * 加载geojson动态单体化数据
     * @param {String} [name] 图层名称
     * @param {object} [geoOptions] geojosn图层
    *       url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
    *       layer:'nanjing',
            upperLevelLimit: 13,
            lowerLevelLimit: 13,
            minx:118.51721649800015,
            miny:31.863232407499936,
            maxx:118.91648798400001,
            maxy:32.27649160409993
     * @param {object} [styleOption] 图层样式
     *      polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: Cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: Cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: Cesium.ArcType.GEODESIC,
            material: Cesium.Color.WHITE,
            show: true
     * @param {Float}  [GroupID] 组itemID
     * @param {object} [disFnc] 回调函数
     */
    PolygonGeoJsonFeatureLayer.prototype.createPolygonVectorMonomerFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            //granularity: CesiumMath.RADIANS_PER_DEGREE, //
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.WHITE,
            show: true
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        
        // defaultGeoOptions={
        //     url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
        //     urlParams: {
        //         REQUEST: 'GetTile',
        //         SERVICE: 'WMTS',
        //         VERSION: '1.0.0',
        //         LAYER: 'skyline:nanjing',
        //         STYLE: '',
        //         TILEMATRIX: 'EPSG:4490:{z}',
        //         TILEMATRIXSET: 'EPSG:4490',
        //         FORMAT: 'application/json;type=geojson',
        //         TILECOL: '{x}',
        //         TILEROW: '{y}'
        //     },
        //     upperLevelLimit: 13,
        //     lowerLevelLimit: 13,
        //     rectangle: Cesium.Rectangle.fromDegrees(118.51721649800015, 31.863232407499936, 118.91648798400001, 32.27649160409993),
        //     Cesium: Cesium
        // }
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        //this.options=options;
        /**
         * 请求矢量切片
         */

        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        var _this = this;
        geoJSONVectorTileProvider._loadTile = function (json) {
            var geomInstances = [];
            json.features.forEach(function (feature) {
                var newArr = [];

                function fun(arr) {
                    for (var i = 0; i < arr.length; i++) {
                        if (Array.isArray(arr[i])) {
                            fun(arr[i]);
                        } else {
                            newArr.push(arr[i]);
                        }
                    }
                }
                fun(feature.geometry.coordinates[0]);
                var pos = _this._cesium.Cartesian3.fromDegreesArray(newArr);
                if (/^\[/.test(styleOption.extrudedHeight) && /\]$/.test(styleOption.extrudedHeight)) {
                    var extrudedHeight = styleOption.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                    options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                }
                options.polygonHierarchy = new _this._cesium.PolygonHierarchy(pos);
                var geometry = new _this._cesium.PolygonGeometry(options);
                // var geometry = _this._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                // var geometryInstance = new Cesium.GeometryInstance({
                //     geometry: geometry,
                //     attributes: {
                //         color: new Cesium.ColorGeometryInstanceAttribute.fromColor(options.material)
                //     },
                //     shadows: Cesium.ShadowMode.ENABLED
                // });
                var geometryInstance = new _this._cesium.GeometryInstance({
                    geometry: geometry,
                    attributes: {
                        color: _this._cesium.ColorGeometryInstanceAttribute.fromColor(_this._cesium.Color.fromCssColorString('#004FFF').withAlpha(0.5)),
                        show: new _this._cesium.ShowGeometryInstanceAttribute(true)
                    }
                });
                geomInstances.push(geometryInstance);
            });
            // var primitive = new this._cesium.Primitive({
            //     allowPicking: false,
            //     appearance: new this._cesium.PerInstanceColorAppearance({
            //         translucent: false,
            //         flat: true,
            //         faceForward: true,
            //         closed: true
            //     }),
            //     geometryInstances: geomInstances
            // });
            var primitive = new _this._cesium.GroundPrimitive({
                classificationType: _this._cesium.ClassificationType.BOTH,
                geometryInstances: geomInstances
            });
            return primitive;
        };
        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);

        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
    };
    /**
    * 返回图例
    * @returns {object} 
    */
    PolygonGeoJsonFeatureLayer.prototype.getLegend = function () {
        var legend = [];
        if (this.Legend != null) {
            legend = this._core.unique(this.Legend);
        }
        return legend;
    };
    /**
     * 导出工程数据
     */
    PolygonGeoJsonFeatureLayer.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url
            }
        };
    };

    var ieee754 = {};
    ieee754.read = function (buffer, offset, isLE, mLen, nBytes) {
        var e, m;
        var eLen = nBytes * 8 - mLen - 1;
        var eMax = (1 << eLen) - 1;
        var eBias = eMax >> 1;
        var nBits = -7;
        var i = isLE ? (nBytes - 1) : 0;
        var d = isLE ? -1 : 1;
        var s = buffer[offset + i];

        i += d;

        e = s & ((1 << (-nBits)) - 1);
        s >>= (-nBits);
        nBits += eLen;
        for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) { }

        m = e & ((1 << (-nBits)) - 1);
        e >>= (-nBits);
        nBits += mLen;
        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) { }

        if (e === 0) {
            e = 1 - eBias;
        } else if (e === eMax) {
            return m ? NaN : ((s ? -1 : 1) * Infinity)
        } else {
            m = m + Math.pow(2, mLen);
            e = e - eBias;
        }
        return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
    };

    ieee754.write = function (buffer, value, offset, isLE, mLen, nBytes) {
        var e, m, c;
        var eLen = nBytes * 8 - mLen - 1;
        var eMax = (1 << eLen) - 1;
        var eBias = eMax >> 1;
        var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);
        var i = isLE ? 0 : (nBytes - 1);
        var d = isLE ? 1 : -1;
        var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;

        value = Math.abs(value);

        if (isNaN(value) || value === Infinity) {
            m = isNaN(value) ? 1 : 0;
            e = eMax;
        } else {
            e = Math.floor(Math.log(value) / Math.LN2);
            if (value * (c = Math.pow(2, -e)) < 1) {
                e--;
                c *= 2;
            }
            if (e + eBias >= 1) {
                value += rt / c;
            } else {
                value += rt * Math.pow(2, 1 - eBias);
            }
            if (value * c >= 2) {
                e++;
                c /= 2;
            }

            if (e + eBias >= eMax) {
                m = 0;
                e = eMax;
            } else if (e + eBias >= 1) {
                m = (value * c - 1) * Math.pow(2, mLen);
                e = e + eBias;
            } else {
                m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
                e = 0;
            }
        }

        for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) { }

        e = (e << mLen) | m;
        eLen += mLen;
        for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) { }

        buffer[offset + i - d] |= s * 128;
    };

    /**
    * pbf读取工具
    *
    */

    function Pbf(buf) {
        this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);
        this.pos = 0;
        this.type = 0;
        this.length = this.buf.length;
    }

    Pbf.Varint = 0; // varint: int32, int64, uint32, uint64, sint32, sint64, bool, enum
    Pbf.Fixed64 = 1; // 64-bit: double, fixed64, sfixed64
    Pbf.Bytes = 2; // length-delimited: string, bytes, embedded messages, packed repeated fields
    Pbf.Fixed32 = 5; // 32-bit: float, fixed32, sfixed32

    var SHIFT_LEFT_32 = (1 << 16) * (1 << 16),
        SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;

    Pbf.prototype = {

        destroy: function () {
            this.buf = null;
        },

        // === READING =================================================================

        readFields: function (readField, result, end) {
            end = end || this.length;

            while (this.pos < end) {
                var val = this.readVarint(),
                    tag = val >> 3,
                    startPos = this.pos;

                this.type = val & 0x7;
                readField(tag, result, this);

                if (this.pos === startPos) this.skip(val);
            }
            return result;
        },

        readMessage: function (readField, result) {
            return this.readFields(readField, result, this.readVarint() + this.pos);
        },

        readFixed32: function () {
            var val = readUInt32(this.buf, this.pos);
            this.pos += 4;
            return val;
        },

        readSFixed32: function () {
            var val = readInt32(this.buf, this.pos);
            this.pos += 4;
            return val;
        },

        // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)

        readFixed64: function () {
            var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
            this.pos += 8;
            return val;
        },

        readSFixed64: function () {
            var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
            this.pos += 8;
            return val;
        },

        readFloat: function () {
            var val = ieee754.read(this.buf, this.pos, true, 23, 4);
            this.pos += 4;
            return val;
        },

        readDouble: function () {
            var val = ieee754.read(this.buf, this.pos, true, 52, 8);
            this.pos += 8;
            return val;
        },

        readVarint: function (isSigned) {
            var buf = this.buf,
                val, b;

            b = buf[this.pos++]; val = b & 0x7f; if (b < 0x80) return val;
            b = buf[this.pos++]; val |= (b & 0x7f) << 7; if (b < 0x80) return val;
            b = buf[this.pos++]; val |= (b & 0x7f) << 14; if (b < 0x80) return val;
            b = buf[this.pos++]; val |= (b & 0x7f) << 21; if (b < 0x80) return val;
            b = buf[this.pos]; val |= (b & 0x0f) << 28;

            return readVarintRemainder(val, isSigned, this);
        },

        readVarint64: function () { // for compatibility with v2.0.1
            return this.readVarint(true);
        },

        readSVarint: function () {
            var num = this.readVarint();
            return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding
        },

        readBoolean: function () {
            return Boolean(this.readVarint());
        },

        readString: function () {
            var end = this.readVarint() + this.pos,
                str = readUtf8(this.buf, this.pos, end);
            this.pos = end;
            return str;
        },

        readBytes: function () {
            var end = this.readVarint() + this.pos,
                buffer = this.buf.subarray(this.pos, end);
            this.pos = end;
            return buffer;
        },

        // verbose for performance reasons; doesn't affect gzipped size

        readPackedVarint: function (arr, isSigned) {
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readVarint(isSigned));
            return arr;
        },
        readPackedSVarint: function (arr) {
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readSVarint());
            return arr;
        },
        readPackedBoolean: function (arr) {
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readBoolean());
            return arr;
        },
        readPackedFloat: function (arr) {
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readFloat());
            return arr;
        },
        readPackedDouble: function (arr) {
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readDouble());
            return arr;
        },
        readPackedFixed32: function (arr) {
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readFixed32());
            return arr;
        },
        readPackedSFixed32: function (arr) {
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readSFixed32());
            return arr;
        },
        readPackedFixed64: function (arr) {
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readFixed64());
            return arr;
        },
        readPackedSFixed64: function (arr) {
            var end = readPackedEnd(this);
            arr = arr || [];
            while (this.pos < end) arr.push(this.readSFixed64());
            return arr;
        },

        skip: function (val) {
            var type = val & 0x7;
            if (type === Pbf.Varint) while (this.buf[this.pos++] > 0x7f) { }
            else if (type === Pbf.Bytes) this.pos = this.readVarint() + this.pos;
            else if (type === Pbf.Fixed32) this.pos += 4;
            else if (type === Pbf.Fixed64) this.pos += 8;
            else throw new Error('Unimplemented type: ' + type);
        },

        // === WRITING =================================================================

        writeTag: function (tag, type) {
            this.writeVarint((tag << 3) | type);
        },

        realloc: function (min) {
            var length = this.length || 16;

            while (length < this.pos + min) length *= 2;

            if (length !== this.length) {
                var buf = new Uint8Array(length);
                buf.set(this.buf);
                this.buf = buf;
                this.length = length;
            }
        },

        finish: function () {
            this.length = this.pos;
            this.pos = 0;
            return this.buf.subarray(0, this.length);
        },

        writeFixed32: function (val) {
            this.realloc(4);
            writeInt32(this.buf, val, this.pos);
            this.pos += 4;
        },

        writeSFixed32: function (val) {
            this.realloc(4);
            writeInt32(this.buf, val, this.pos);
            this.pos += 4;
        },

        writeFixed64: function (val) {
            this.realloc(8);
            writeInt32(this.buf, val & -1, this.pos);
            writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
            this.pos += 8;
        },

        writeSFixed64: function (val) {
            this.realloc(8);
            writeInt32(this.buf, val & -1, this.pos);
            writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
            this.pos += 8;
        },

        writeVarint: function (val) {
            val = +val || 0;

            if (val > 0xfffffff || val < 0) {
                writeBigVarint(val, this);
                return;
            }

            this.realloc(4);

            this.buf[this.pos++] = val & 0x7f | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
            this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
            this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
            this.buf[this.pos++] = (val >>> 7) & 0x7f;
        },

        writeSVarint: function (val) {
            this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);
        },

        writeBoolean: function (val) {
            this.writeVarint(Boolean(val));
        },

        writeString: function (str) {
            str = String(str);
            this.realloc(str.length * 4);

            this.pos++; // reserve 1 byte for short string length

            var startPos = this.pos;
            // write the string directly to the buffer and see how much was written
            this.pos = writeUtf8(this.buf, str, this.pos);
            var len = this.pos - startPos;

            if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);

            // finally, write the message length in the reserved place and restore the position
            this.pos = startPos - 1;
            this.writeVarint(len);
            this.pos += len;
        },

        writeFloat: function (val) {
            this.realloc(4);
            ieee754.write(this.buf, val, this.pos, true, 23, 4);
            this.pos += 4;
        },

        writeDouble: function (val) {
            this.realloc(8);
            ieee754.write(this.buf, val, this.pos, true, 52, 8);
            this.pos += 8;
        },

        writeBytes: function (buffer) {
            var len = buffer.length;
            this.writeVarint(len);
            this.realloc(len);
            for (var i = 0; i < len; i++) this.buf[this.pos++] = buffer[i];
        },

        writeRawMessage: function (fn, obj) {
            this.pos++; // reserve 1 byte for short message length

            // write the message directly to the buffer and see how much was written
            var startPos = this.pos;
            fn(obj, this);
            var len = this.pos - startPos;

            if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);

            // finally, write the message length in the reserved place and restore the position
            this.pos = startPos - 1;
            this.writeVarint(len);
            this.pos += len;
        },

        writeMessage: function (tag, fn, obj) {
            this.writeTag(tag, Pbf.Bytes);
            this.writeRawMessage(fn, obj);
        },

        writePackedVarint: function (tag, arr) { this.writeMessage(tag, writePackedVarint, arr); },
        writePackedSVarint: function (tag, arr) { this.writeMessage(tag, writePackedSVarint, arr); },
        writePackedBoolean: function (tag, arr) { this.writeMessage(tag, writePackedBoolean, arr); },
        writePackedFloat: function (tag, arr) { this.writeMessage(tag, writePackedFloat, arr); },
        writePackedDouble: function (tag, arr) { this.writeMessage(tag, writePackedDouble, arr); },
        writePackedFixed32: function (tag, arr) { this.writeMessage(tag, writePackedFixed32, arr); },
        writePackedSFixed32: function (tag, arr) { this.writeMessage(tag, writePackedSFixed32, arr); },
        writePackedFixed64: function (tag, arr) { this.writeMessage(tag, writePackedFixed64, arr); },
        writePackedSFixed64: function (tag, arr) { this.writeMessage(tag, writePackedSFixed64, arr); },

        writeBytesField: function (tag, buffer) {
            this.writeTag(tag, Pbf.Bytes);
            this.writeBytes(buffer);
        },
        writeFixed32Field: function (tag, val) {
            this.writeTag(tag, Pbf.Fixed32);
            this.writeFixed32(val);
        },
        writeSFixed32Field: function (tag, val) {
            this.writeTag(tag, Pbf.Fixed32);
            this.writeSFixed32(val);
        },
        writeFixed64Field: function (tag, val) {
            this.writeTag(tag, Pbf.Fixed64);
            this.writeFixed64(val);
        },
        writeSFixed64Field: function (tag, val) {
            this.writeTag(tag, Pbf.Fixed64);
            this.writeSFixed64(val);
        },
        writeVarintField: function (tag, val) {
            this.writeTag(tag, Pbf.Varint);
            this.writeVarint(val);
        },
        writeSVarintField: function (tag, val) {
            this.writeTag(tag, Pbf.Varint);
            this.writeSVarint(val);
        },
        writeStringField: function (tag, str) {
            this.writeTag(tag, Pbf.Bytes);
            this.writeString(str);
        },
        writeFloatField: function (tag, val) {
            this.writeTag(tag, Pbf.Fixed32);
            this.writeFloat(val);
        },
        writeDoubleField: function (tag, val) {
            this.writeTag(tag, Pbf.Fixed64);
            this.writeDouble(val);
        },
        writeBooleanField: function (tag, val) {
            this.writeVarintField(tag, Boolean(val));
        }
    };

    function readVarintRemainder(l, s, p) {
        var buf = p.buf,
            h, b;

        b = buf[p.pos++]; h = (b & 0x70) >> 4; if (b < 0x80) return toNum(l, h, s);
        b = buf[p.pos++]; h |= (b & 0x7f) << 3; if (b < 0x80) return toNum(l, h, s);
        b = buf[p.pos++]; h |= (b & 0x7f) << 10; if (b < 0x80) return toNum(l, h, s);
        b = buf[p.pos++]; h |= (b & 0x7f) << 17; if (b < 0x80) return toNum(l, h, s);
        b = buf[p.pos++]; h |= (b & 0x7f) << 24; if (b < 0x80) return toNum(l, h, s);
        b = buf[p.pos++]; h |= (b & 0x01) << 31; if (b < 0x80) return toNum(l, h, s);

        throw new Error('Expected varint not more than 10 bytes');
    }

    function readPackedEnd(pbf) {
        return pbf.type === Pbf.Bytes ?
            pbf.readVarint() + pbf.pos : pbf.pos + 1;
    }

    function toNum(low, high, isSigned) {
        if (isSigned) {
            return high * 0x100000000 + (low >>> 0);
        }

        return ((high >>> 0) * 0x100000000) + (low >>> 0);
    }

    function writeBigVarint(val, pbf) {
        var low, high;

        if (val >= 0) {
            low = (val % 0x100000000) | 0;
            high = (val / 0x100000000) | 0;
        } else {
            low = ~(-val % 0x100000000);
            high = ~(-val / 0x100000000);

            if (low ^ 0xffffffff) {
                low = (low + 1) | 0;
            } else {
                low = 0;
                high = (high + 1) | 0;
            }
        }

        if (val >= 0x10000000000000000 || val < -0x10000000000000000) {
            throw new Error('Given varint doesn\'t fit into 10 bytes');
        }

        pbf.realloc(10);

        writeBigVarintLow(low, high, pbf);
        writeBigVarintHigh(high, pbf);
    }

    function writeBigVarintLow(low, high, pbf) {
        pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
        pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
        pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
        pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
        pbf.buf[pbf.pos] = low & 0x7f;
    }

    function writeBigVarintHigh(high, pbf) {
        var lsb = (high & 0x07) << 4;

        pbf.buf[pbf.pos++] |= lsb | ((high >>>= 3) ? 0x80 : 0); if (!high) return;
        pbf.buf[pbf.pos++] = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
        pbf.buf[pbf.pos++] = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
        pbf.buf[pbf.pos++] = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
        pbf.buf[pbf.pos++] = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
        pbf.buf[pbf.pos++] = high & 0x7f;
    }

    function makeRoomForExtraLength(startPos, len, pbf) {
        var extraLen =
            len <= 0x3fff ? 1 :
                len <= 0x1fffff ? 2 :
                    len <= 0xfffffff ? 3 : Math.ceil(Math.log(len) / (Math.LN2 * 7));

        // if 1 byte isn't enough for encoding message length, shift the data to the right
        pbf.realloc(extraLen);
        for (var i = pbf.pos - 1; i >= startPos; i--) pbf.buf[i + extraLen] = pbf.buf[i];
    }

    function writePackedVarint(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]); }
    function writePackedSVarint(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]); }
    function writePackedFloat(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]); }
    function writePackedDouble(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]); }
    function writePackedBoolean(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]); }
    function writePackedFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]); }
    function writePackedSFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]); }
    function writePackedFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]); }
    function writePackedSFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]); }

    // Buffer code below from https://github.com/feross/buffer, MIT-licensed

    function readUInt32(buf, pos) {
        return ((buf[pos]) |
            (buf[pos + 1] << 8) |
            (buf[pos + 2] << 16)) +
            (buf[pos + 3] * 0x1000000);
    }

    function writeInt32(buf, val, pos) {
        buf[pos] = val;
        buf[pos + 1] = (val >>> 8);
        buf[pos + 2] = (val >>> 16);
        buf[pos + 3] = (val >>> 24);
    }

    function readInt32(buf, pos) {
        return ((buf[pos]) |
            (buf[pos + 1] << 8) |
            (buf[pos + 2] << 16)) +
            (buf[pos + 3] << 24);
    }

    function readUtf8(buf, pos, end) {
        var str = '';
        var i = pos;

        while (i < end) {
            var b0 = buf[i];
            var c = null; // codepoint
            var bytesPerSequence =
                b0 > 0xEF ? 4 :
                    b0 > 0xDF ? 3 :
                        b0 > 0xBF ? 2 : 1;

            if (i + bytesPerSequence > end) break;

            var b1, b2, b3;

            if (bytesPerSequence === 1) {
                if (b0 < 0x80) {
                    c = b0;
                }
            } else if (bytesPerSequence === 2) {
                b1 = buf[i + 1];
                if ((b1 & 0xC0) === 0x80) {
                    c = (b0 & 0x1F) << 0x6 | (b1 & 0x3F);
                    if (c <= 0x7F) {
                        c = null;
                    }
                }
            } else if (bytesPerSequence === 3) {
                b1 = buf[i + 1];
                b2 = buf[i + 2];
                if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80) {
                    c = (b0 & 0xF) << 0xC | (b1 & 0x3F) << 0x6 | (b2 & 0x3F);
                    if (c <= 0x7FF || (c >= 0xD800 && c <= 0xDFFF)) {
                        c = null;
                    }
                }
            } else if (bytesPerSequence === 4) {
                b1 = buf[i + 1];
                b2 = buf[i + 2];
                b3 = buf[i + 3];
                if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {
                    c = (b0 & 0xF) << 0x12 | (b1 & 0x3F) << 0xC | (b2 & 0x3F) << 0x6 | (b3 & 0x3F);
                    if (c <= 0xFFFF || c >= 0x110000) {
                        c = null;
                    }
                }
            }

            if (c === null) {
                c = 0xFFFD;
                bytesPerSequence = 1;

            } else if (c > 0xFFFF) {
                c -= 0x10000;
                str += String.fromCharCode(c >>> 10 & 0x3FF | 0xD800);
                c = 0xDC00 | c & 0x3FF;
            }

            str += String.fromCharCode(c);
            i += bytesPerSequence;
        }

        return str;
    }

    function writeUtf8(buf, str, pos) {
        for (var i = 0, c, lead; i < str.length; i++) {
            c = str.charCodeAt(i); // code point

            if (c > 0xD7FF && c < 0xE000) {
                if (lead) {
                    if (c < 0xDC00) {
                        buf[pos++] = 0xEF;
                        buf[pos++] = 0xBF;
                        buf[pos++] = 0xBD;
                        lead = c;
                        continue;
                    } else {
                        c = lead - 0xD800 << 10 | c - 0xDC00 | 0x10000;
                        lead = null;
                    }
                } else {
                    if (c > 0xDBFF || (i + 1 === str.length)) {
                        buf[pos++] = 0xEF;
                        buf[pos++] = 0xBF;
                        buf[pos++] = 0xBD;
                    } else {
                        lead = c;
                    }
                    continue;
                }
            } else if (lead) {
                buf[pos++] = 0xEF;
                buf[pos++] = 0xBF;
                buf[pos++] = 0xBD;
                lead = null;
            }

            if (c < 0x80) {
                buf[pos++] = c;
            } else {
                if (c < 0x800) {
                    buf[pos++] = c >> 0x6 | 0xC0;
                } else {
                    if (c < 0x10000) {
                        buf[pos++] = c >> 0xC | 0xE0;
                    } else {
                        buf[pos++] = c >> 0x12 | 0xF0;
                        buf[pos++] = c >> 0xC & 0x3F | 0x80;
                    }
                    buf[pos++] = c >> 0x6 & 0x3F | 0x80;
                }
                buf[pos++] = c & 0x3F | 0x80;
            }
        }
        return pos;
    }

    /**
     * A standalone point geometry with useful accessor, comparison, and
     * modification methods.
     *
     * @class Point
     * @param {Number} x the x-coordinate. this could be longitude or screen
     * pixels, or any other sort of unit.
     * @param {Number} y the y-coordinate. this could be latitude or screen
     * pixels, or any other sort of unit.
     * @example
     * var point = new Point(-77, 38);
     */
    function Point$1(x, y) {
        this.x = x;
        this.y = y;
    }

    Point$1.prototype = {

        /**
         * Clone this point, returning a new point that can be modified
         * without affecting the old one.
         * @return {Point} the clone
         */
        clone: function () {
            return new Point$1(this.x, this.y);
        },

        /**
         * Add this point's x & y coordinates to another point,
         * yielding a new point.
         * @param {Point} p the other point
         * @return {Point} output point
         */
        add: function (p) {
            return this.clone()._add(p);
        },

        /**
         * Subtract this point's x & y coordinates to from point,
         * yielding a new point.
         * @param {Point} p the other point
         * @return {Point} output point
         */
        sub: function (p) {
            return this.clone()._sub(p);
        },

        /**
         * Multiply this point's x & y coordinates by point,
         * yielding a new point.
         * @param {Point} p the other point
         * @return {Point} output point
         */
        multByPoint: function (p) {
            return this.clone()._multByPoint(p);
        },

        /**
         * Divide this point's x & y coordinates by point,
         * yielding a new point.
         * @param {Point} p the other point
         * @return {Point} output point
         */
        divByPoint: function (p) {
            return this.clone()._divByPoint(p);
        },

        /**
         * Multiply this point's x & y coordinates by a factor,
         * yielding a new point.
         * @param {Point} k factor
         * @return {Point} output point
         */
        mult: function (k) {
            return this.clone()._mult(k);
        },

        /**
         * Divide this point's x & y coordinates by a factor,
         * yielding a new point.
         * @param {Point} k factor
         * @return {Point} output point
         */
        div: function (k) {
            return this.clone()._div(k);
        },

        /**
         * Rotate this point around the 0, 0 origin by an angle a,
         * given in radians
         * @param {Number} a angle to rotate around, in radians
         * @return {Point} output point
         */
        rotate: function (a) {
            return this.clone()._rotate(a);
        },

        /**
         * Rotate this point around p point by an angle a,
         * given in radians
         * @param {Number} a angle to rotate around, in radians
         * @param {Point} p Point to rotate around
         * @return {Point} output point
         */
        rotateAround: function (a, p) {
            return this.clone()._rotateAround(a, p);
        },

        /**
         * Multiply this point by a 4x1 transformation matrix
         * @param {Array<Number>} m transformation matrix
         * @return {Point} output point
         */
        matMult: function (m) {
            return this.clone()._matMult(m);
        },

        /**
         * Calculate this point but as a unit vector from 0, 0, meaning
         * that the distance from the resulting point to the 0, 0
         * coordinate will be equal to 1 and the angle from the resulting
         * point to the 0, 0 coordinate will be the same as before.
         * @return {Point} unit vector point
         */
        unit: function () {
            return this.clone()._unit();
        },

        /**
         * Compute a perpendicular point, where the new y coordinate
         * is the old x coordinate and the new x coordinate is the old y
         * coordinate multiplied by -1
         * @return {Point} perpendicular point
         */
        perp: function () {
            return this.clone()._perp();
        },

        /**
         * Return a version of this point with the x & y coordinates
         * rounded to integers.
         * @return {Point} rounded point
         */
        round: function () {
            return this.clone()._round();
        },

        /**
         * Return the magitude of this point: this is the Euclidean
         * distance from the 0, 0 coordinate to this point's x and y
         * coordinates.
         * @return {Number} magnitude
         */
        mag: function () {
            return Math.sqrt(this.x * this.x + this.y * this.y);
        },

        /**
         * Judge whether this point is equal to another point, returning
         * true or false.
         * @param {Point} other the other point
         * @return {boolean} whether the points are equal
         */
        equals: function (other) {
            return this.x === other.x &&
                this.y === other.y;
        },

        /**
         * Calculate the distance from this point to another point
         * @param {Point} p the other point
         * @return {Number} distance
         */
        dist: function (p) {
            return Math.sqrt(this.distSqr(p));
        },

        /**
         * Calculate the distance from this point to another point,
         * without the square root step. Useful if you're comparing
         * relative distances.
         * @param {Point} p the other point
         * @return {Number} distance
         */
        distSqr: function (p) {
            var dx = p.x - this.x,
                dy = p.y - this.y;
            return dx * dx + dy * dy;
        },

        /**
         * Get the angle from the 0, 0 coordinate to this point, in radians
         * coordinates.
         * @return {Number} angle
         */
        angle: function () {
            return Math.atan2(this.y, this.x);
        },

        /**
         * Get the angle from this point to another point, in radians
         * @param {Point} b the other point
         * @return {Number} angle
         */
        angleTo: function (b) {
            return Math.atan2(this.y - b.y, this.x - b.x);
        },

        /**
         * Get the angle between this point and another point, in radians
         * @param {Point} b the other point
         * @return {Number} angle
         */
        angleWith: function (b) {
            return this.angleWithSep(b.x, b.y);
        },

        /*
         * Find the angle of the two vectors, solving the formula for
         * the cross product a x b = |a||b|sin(��) for ��.
         * @param {Number} x the x-coordinate
         * @param {Number} y the y-coordinate
         * @return {Number} the angle in radians
         */
        angleWithSep: function (x, y) {
            return Math.atan2(
                this.x * y - this.y * x,
                this.x * x + this.y * y);
        },

        _matMult: function (m) {
            var x = m[0] * this.x + m[1] * this.y,
                y = m[2] * this.x + m[3] * this.y;
            this.x = x;
            this.y = y;
            return this;
        },

        _add: function (p) {
            this.x += p.x;
            this.y += p.y;
            return this;
        },

        _sub: function (p) {
            this.x -= p.x;
            this.y -= p.y;
            return this;
        },

        _mult: function (k) {
            this.x *= k;
            this.y *= k;
            return this;
        },

        _div: function (k) {
            this.x /= k;
            this.y /= k;
            return this;
        },

        _multByPoint: function (p) {
            this.x *= p.x;
            this.y *= p.y;
            return this;
        },

        _divByPoint: function (p) {
            this.x /= p.x;
            this.y /= p.y;
            return this;
        },

        _unit: function () {
            this._div(this.mag());
            return this;
        },

        _perp: function () {
            var y = this.y;
            this.y = this.x;
            this.x = -y;
            return this;
        },

        _rotate: function (angle) {
            var cos = Math.cos(angle),
                sin = Math.sin(angle),
                x = cos * this.x - sin * this.y,
                y = sin * this.x + cos * this.y;
            this.x = x;
            this.y = y;
            return this;
        },

        _rotateAround: function (angle, p) {
            var cos = Math.cos(angle),
                sin = Math.sin(angle),
                x = p.x + cos * (this.x - p.x) - sin * (this.y - p.y),
                y = p.y + sin * (this.x - p.x) + cos * (this.y - p.y);
            this.x = x;
            this.y = y;
            return this;
        },

        _round: function () {
            this.x = Math.round(this.x);
            this.y = Math.round(this.y);
            return this;
        }
    };

    /**
     * Construct a point from an array if necessary, otherwise if the input
     * is already a Point, or an unknown type, return it unchanged
     * @param {Array<Number>|Point|*} a any kind of input value
     * @return {Point} constructed point, or passed-through value.
     * @example
     * // this
     * var point = Point.convert([0, 1]);
     * // is equivalent to
     * var point = new Point(0, 1);
     */
    Point$1.convert = function (a) {
        if (a instanceof Point$1) {
            return a;
        }
        if (Array.isArray(a)) {
            return new Point$1(a[0], a[1]);
        }
        return a;
    };


    function VectorTileFeature(pbf, end, extent, keys, values) {
        // Public
        this.properties = {};
        this.extent = extent;
        this.type = 0;

        // Private
        this._pbf = pbf;
        this._geometry = -1;
        this._keys = keys;
        this._values = values;

        pbf.readFields(readFeature, this, end);
    }

    function readFeature(tag, feature, pbf) {
        if (tag == 1) feature.id = pbf.readVarint();
        else if (tag == 2) readTag(pbf, feature);
        else if (tag == 3) feature.type = pbf.readVarint();
        else if (tag == 4) feature._geometry = pbf.pos;
    }

    function readTag(pbf, feature) {
        var end = pbf.readVarint() + pbf.pos;

        while (pbf.pos < end) {
            var key = feature._keys[pbf.readVarint()],
                value = feature._values[pbf.readVarint()];
            feature.properties[key] = value;
        }
    }

    VectorTileFeature.types = ['Unknown', 'Point', 'LineString', 'Polygon'];

    VectorTileFeature.prototype.loadGeometry = function () {
        var pbf = this._pbf;
        pbf.pos = this._geometry;

        var end = pbf.readVarint() + pbf.pos,
            cmd = 1,
            length = 0,
            x = 0,
            y = 0,
            lines = [],
            line;

        while (pbf.pos < end) {
            if (length <= 0) {
                var cmdLen = pbf.readVarint();
                cmd = cmdLen & 0x7;
                length = cmdLen >> 3;
            }

            length--;

            if (cmd === 1 || cmd === 2) {
                x += pbf.readSVarint();
                y += pbf.readSVarint();

                if (cmd === 1) { // moveTo
                    if (line) lines.push(line);
                    line = [];
                }

                line.push(new Point$1(x, y));

            } else if (cmd === 7) {

                // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
                if (line) {
                    line.push(line[0].clone()); // closePolygon
                }

            } else {
                throw new Error('unknown command ' + cmd);
            }
        }

        if (line) lines.push(line);

        return lines;
    };

    VectorTileFeature.prototype.bbox = function () {
        var pbf = this._pbf;
        pbf.pos = this._geometry;

        var end = pbf.readVarint() + pbf.pos,
            cmd = 1,
            length = 0,
            x = 0,
            y = 0,
            x1 = Infinity,
            x2 = -Infinity,
            y1 = Infinity,
            y2 = -Infinity;

        while (pbf.pos < end) {
            if (length <= 0) {
                var cmdLen = pbf.readVarint();
                cmd = cmdLen & 0x7;
                length = cmdLen >> 3;
            }

            length--;

            if (cmd === 1 || cmd === 2) {
                x += pbf.readSVarint();
                y += pbf.readSVarint();
                if (x < x1) x1 = x;
                if (x > x2) x2 = x;
                if (y < y1) y1 = y;
                if (y > y2) y2 = y;

            } else if (cmd !== 7) {
                throw new Error('unknown command ' + cmd);
            }
        }

        return [x1, y1, x2, y2];
    };

    VectorTileFeature.prototype.toGeoJSON = function (x, y, z, extent) {
        var size = this.extent * Math.pow(2, z),
            x0 = this.extent * x,
            //y0 = this.extent * y,
            y0 = this.extent * y / 2,
            coords = this.loadGeometry(),
            type = VectorTileFeature.types[this.type],
            i, j;

        function project(line) {
            for (var j = 0; j < line.length; j++) {
                var p = line[j], y2 = 90 - (p.y + y0) * 180 / (size / 2);
                line[j] = [
                    (p.x + x0) * 360 / size - 180,
                    y2
                    //360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90
                ];
                //var p = line[j];
                //var x = extent.XMax - ((p.x + x0) * (extent.XMax - extent.XMin)) / size;
                //var y = extent.YMin + ((p.y + y0) * (extent.YMax - extent.YMin)) / size;
                //line[j] = [x,y];
            }
        }

        switch (this.type) {
            case 1:
                var points = [];
                for (i = 0; i < coords.length; i++) {
                    points[i] = coords[i][0];
                }
                coords = points;
                project(coords);
                break;

            case 2:
                for (i = 0; i < coords.length; i++) {
                    project(coords[i]);
                }
                break;

            case 3:
                coords = classifyRings(coords);
                for (i = 0; i < coords.length; i++) {
                    for (j = 0; j < coords[i].length; j++) {
                        project(coords[i][j]);
                    }
                }
                break;
        }

        if (coords.length === 1) {
            coords = coords[0];
        } else {
            type = 'Multi' + type;
        }

        var result = {
            type: "Feature",
            geometry: {
                type: type,
                coordinates: coords
            },
            properties: this.properties
        };

        if ('id' in this) {
            result.id = this.id;
        }

        return result;
    };

    // classifies an array of rings into polygons with outer rings and holes

    function classifyRings(rings) {
        var len = rings.length;

        if (len <= 1) return [rings];

        var polygons = [],
            polygon,
            ccw;

        for (var i = 0; i < len; i++) {
            var area = signedArea(rings[i]);
            if (area === 0) continue;

            if (ccw === undefined) ccw = area < 0;

            if (ccw === area < 0) {
                if (polygon) polygons.push(polygon);
                polygon = [rings[i]];

            } else {
                polygon.push(rings[i]);
            }
        }
        if (polygon) polygons.push(polygon);

        return polygons;
    }

    function signedArea(ring) {
        var sum = 0;
        for (var i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {
            p1 = ring[i];
            p2 = ring[j];
            sum += (p2.x - p1.x) * (p1.y + p2.y);
        }
        return sum;
    }

    function VectorTileLayer(pbf, end) {
        // Public
        this.version = 1;
        this.name = null;
        this.extent = 4096;
        this.length = 0;

        // Private
        this._pbf = pbf;
        this._keys = [];
        this._values = [];
        this._features = [];

        pbf.readFields(readLayer, this, end);

        this.length = this._features.length;
    }

    function readLayer(tag, layer, pbf) {
        if (tag === 15) layer.version = pbf.readVarint();
        else if (tag === 1) layer.name = pbf.readString();
        else if (tag === 5) layer.extent = pbf.readVarint();
        else if (tag === 2) layer._features.push(pbf.pos);
        else if (tag === 3) layer._keys.push(pbf.readString());
        else if (tag === 4) layer._values.push(readValueMessage(pbf));
    }

    function readValueMessage(pbf) {
        var value = null,
            end = pbf.readVarint() + pbf.pos;

        while (pbf.pos < end) {
            var tag = pbf.readVarint() >> 3;

            value = tag === 1 ? pbf.readString() :
                tag === 2 ? pbf.readFloat() :
                    tag === 3 ? pbf.readDouble() :
                        tag === 4 ? pbf.readVarint64() :
                            tag === 5 ? pbf.readVarint() :
                                tag === 6 ? pbf.readSVarint() :
                                    tag === 7 ? pbf.readBoolean() : null;
        }

        return value;
    }

    // return feature `i` from this layer as a `VectorTileFeature`
    VectorTileLayer.prototype.feature = function (i) {
        if (i < 0 || i >= this._features.length) throw new Error('feature index out of bounds');

        this._pbf.pos = this._features[i];

        var end = this._pbf.readVarint() + this._pbf.pos;
        return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
    };

    function VectorTile(pbf, end) {
        this.layers = pbf.readFields(readTile, {}, end);
    }

    function readTile(tag, layers, pbf) {
        if (tag === 3) {
            var layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
            if (layer.length) layers[layer.name] = layer;
        }
    }

    /**
     *
     * 多边形切片pbf要素图层
     *
     * @alias PolygonVectorTileLayerArcgis
     * @constructor
     *
     */
    function PolygonVectorTileLayerArcgis(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this.item = { show: true };
        this._option = undefined;
        this._primitive = undefined;
        this._Provider = undefined;
        //修改
        this.labelCollections = new this._cesium.PointPrimitiveCollection();
        this.geometries_line = [];
        this.geometries_polygon = [];
    }

    var _typeof$4 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
        return typeof obj;
    } : function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    /**
     * 序列化参数对象
     *
     * @param {Object} params 参数对象
     * @returns {String} 序列化字符串
     */
    PolygonVectorTileLayerArcgis.prototype._serialize = function (params) {
        var queryArray = [];
        var encode = window.encodeURIComponent;

        for (var key in params) {
            var value = params[key];

            if ((typeof value === 'undefined' ? 'undefined' : _typeof$4(value)) === 'object') {
                queryArray.push(encode(key) + '=' + encode(JSON.stringify(value)));
            } else {
                queryArray.push(encode(key) + '=' + encode(params[key]));
            }
        }

        return queryArray.join('&');
    };

    /**
     * 创建VolumeGeoJsonFeatureLayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *     height: 0,//	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
          extrudedHeight: 0,//		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
          heightReference: this._cesium.HeightReference.NONE,//		optional A Property specifying what the extrudedHeight is relative to.
          show: true,//	optional A boolean Property specifying the visibility of the polygon.
          fill: true,//	optional A boolean Property specifying whether the polygon is filled with the provided material.
          material: this._cesium.Color.WHITE,//optional A Property specifying the material used to fill the polygon.
          outline: false,//optional A boolean Property specifying whether the polygon is outlined.
          outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the Color of the outline.
          outlineWidth: 1.0,//optional A numeric Property specifying the width of the outline.
          stRotation: 0.0,//	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
          granularity: this._cesium.Math.RADIANS_PER_DEGREE,//	optional A numeric Property specifying the angular distance between each latitude and longitude point.
          perPositionHeight: false,	//optional A boolean specifying whether or not the the height of each position is used.
          closeTop: true,	//optional When false, leaves off the top of an extruded polygon open.
          closeBottom: true,//	optional When false, leaves off the bottom of an extruded polygon open.
          shadows: this._cesium.ShadowMode.DISABLED,//	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
          near: 0,
          far: 5000
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    PolygonVectorTileLayerArcgis.prototype.createVolumeVectorGeoJsonFeatureLayer = function (layername, url, option, GroupID, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };

        ({
            url: url.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: url.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: url.upperLevelLimit,
            lowerLevelLimit: url.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(url.minx, url.miny, url.maxx, url.maxy),
            Cesium: this._cesium
        });
        this.extent = { XMin: url.minx || 0, YMin: url.miny || 0, XMax: url.maxx || 0, YMax: url.maxy || 0 };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.fill)) {
            if (option.fill.toString().charAt(0) == "[" && option.fill.toString().charAt(option.fill.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.fill)) {
                    option.fill = this._color.colorFromHtmlColor(option.fill);
                } else {
                    if (/^rgb/.test(option.fill)) {
                        option.fill = this._color.rgbaStringToRgbaObj(option.fill);
                    }
                    if (option.fill.r > 1) {
                        option.fill.r = option.fill.r / 255;
                    }
                    if (option.fill.g > 1) {
                        option.fill.g = option.fill.g / 255;
                    }
                    if (option.fill.b > 1) {
                        option.fill.b = option.fill.b / 255;
                    }
                    if (option.fill.a > 1) {
                        option.fill.a = option.fill.a / 255;
                    }
                    option.fill = this._color.createColor(option.fill.r, option.fill.g, option.fill.b, option.fill.a);
                }
            }
        }
        //填充颜色设置polylinefill
        if (!this._core.isnull(option) && !this._core.isnull(option.polylinefill)) {
            if (option.polylinefill.toString().charAt(0) == "[" && option.polylinefill.toString().charAt(option.polylinefill.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.polylinefill)) {
                    option.polylinefill = this._color.colorFromHtmlColor(option.polylinefill);
                } else {
                    if (/^rgb/.test(option.polylinefill)) {
                        option.polylinefill = this._color.rgbaStringToRgbaObj(option.polylinefill);
                    }
                    if (option.polylinefill.r > 1) {
                        option.polylinefill.r = option.polylinefill.r / 255;
                    }
                    if (option.polylinefill.g > 1) {
                        option.polylinefill.g = option.polylinefill.g / 255;
                    }
                    if (option.polylinefill.b > 1) {
                        option.polylinefill.b = option.polylinefill.b / 255;
                    }
                    if (option.polylinefill.a > 1) {
                        option.polylinefill.a = option.polylinefill.a / 255;
                    }
                    option.polylinefill = this._color.createColor(option.polylinefill.r, option.polylinefill.g, option.polylinefill.b, option.polylinefill.a);
                }
            }
        }
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (option.outlineColor.toString().charAt(0) == "[" && option.outlineColor.toString().charAt(option.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.outlineColor)) {
                    option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
                } else {
                    if (/^rgb/.test(option.outlineColor)) {
                        option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                    }
                    if (option.outlineColor.r > 1) {
                        option.outlineColor.r = option.outlineColor.r / 255;
                    }
                    if (option.outlineColor.g > 1) {
                        option.outlineColor.g = option.outlineColor.g / 255;
                    }
                    if (option.outlineColor.b > 1) {
                        option.outlineColor.b = option.outlineColor.b / 255;
                    }
                    if (option.outlineColor.a > 1) {
                        option.outlineColor.a = option.outlineColor.a / 255;
                    }
                    option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, option, true);

        //if (this._core.isnull(option.level_max)) {
        //    max = 16;
        //}
        //if (this._core.isnull(option.level_min )) {
        //    min = 14;
        //}
        if (url == undefined)
            console.log('url is required');
        if (layername == undefined) {
            console.log('layername is required');
        }
        var that = this;
        ({
            polygonHierarchy: undefined,
            height: 30,
            extrudedHeight: 100,
            vertexFormat: Cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: Cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: Cesium.ArcType.GEODESIC,
            material: Cesium.Color.WHITE
        });
        var tileUrls = "http://124.128.48.210:81/arcgis/rest/services/Hosted/tdtsd0408/VectorTileServer/resources/styles/root.json";

        // $.ajax({
        that._core.xhr({
            url: tileUrls,
            type: "get",
            dataType: "json",
            success: function (data) {
                var newArr = [];
                var datas = data.layers;
                var tileUrl = "http://124.128.48.210:81/arcgis/rest/services/Hosted/tdtsd0408/VectorTileServer/tile/0/0/0.pbf";
                //var tileUrl = "http://124.128.48.210:81/arcgis/rest/services/Hosted/tdtsd0408/VectorTileServer/tile/1/0/1.pbf";
                Cesium.Resource.createIfNeeded(tileUrl).fetchArrayBuffer().then(function (data) {
                    //坐标解析
                    function fun(arr) {
                        for (var i = 0; i < arr.length; i++) {
                            if (Array.isArray(arr[i])) {
                                fun(arr[i]);
                            } else {
                                newArr.push(arr[i]);
                            }
                        }
                    }
                    //创建线
                    function createpolyline(newArr) {
                        var pos = Cesium.Cartesian3.fromDegreesArray(newArr);
                        var polyline = {
                            positions: pos,
                            width: 10.0,
                            color: Cesium.ColorGeometryInstanceAttribute.fromColor(that._option.polylinefill)
                        };
                        var geometry = new Cesium.PolylineGeometry(polyline);
                        var geometryInstance = new Cesium.GeometryInstance({
                            geometry: geometry
                        });
                        geometries_line.push(geometryInstance);
                    }
                    //创建面
                    function createpolygon(newArr) {
                        var polygon = new Cesium.PolygonGeometry({
                            polygonHierarchy: new Cesium.PolygonHierarchy(
                                Cesium.Cartesian3.fromDegreesArray(newArr)
                            )
                        });
                        var geometry = Cesium.PolygonGeometry.createGeometry(polygon);
                        var geometryInstance = new Cesium.GeometryInstance({
                            geometry: geometry,
                            attributes: {
                                color: colors,
                            }
                        });
                        geometries_polygon.push(geometryInstance);
                    }
                    var pbf = new Pbf(data);
                    var tTile = new VectorTile(pbf);
                    var geometries_line = [];
                    var geometries_polygon = [];
                    that.labelCollections = new that._cesium.LabelCollection();
                    for (var key in tTile.layers) {
                        var layer = tTile.layers[key];
                        for (var i = 0; i < layer.length; i++) {
                            var feature = layer.feature(i);
                            var geomList = feature.loadGeometry();
                            //var geoJson;
                            for (var j = 0; j < geomList.length; j++) {
                                var geoms = geomList[j];
                                for (var n = 0; n < geoms.length; n++) {
                                    var geom = geoms[n];
                                    //解析数据样式
                                    var style = null;
                                    if (feature.properties["_symbol"] != undefined) {
                                        var l = feature.properties["_symbol"];
                                        for (var k = 0; k < datas.length; k++) {
                                            if (datas[k].filter != undefined && datas[k].filter[0] == "==" && datas[k].filter[1] == "_symbol" && datas[k].filter[2] == l) {
                                                style = datas[k];
                                            }
                                        }
                                    } else {
                                        if (layer.name != undefined) {
                                            var name1 = layer.name;
                                            for (var k = 0; k < datas.length; k++) {
                                                if (datas[k]["source-layer"] != undefined && datas[k]["source-layer"] == name1) {
                                                    style = datas[k];
                                                }
                                            }
                                        }
                                    }
                                    if (feature.type == 1) {
                                        try {
                                            // var geom = geoms[0];
                                            //var geoJson = feature.toGeoJSON(tile.x, tile.y, tile.level, that.extent);
                                            var geoJson = feature.toGeoJSON(0, 0, 0, that.extent);
                                            // 1. Draw a translucent ellipse on the surface with a checkerboard pattern
                                            if (option.text != undefined) {
                                                if (/^\[/.test(option.text) && /\]$/.test(option.text)) {
                                                    var material = option.text.replace(/\[/, '').replace(/\]/, '');
                                                    that._option.text = feature.properties[material];
                                                }
                                            }
                                            if (style.paint != undefined && style.paint["icon-color"]) {
                                                that._option.fill = that._color.createColorTransformation(style.paint["icon-color"]);
                                            }
                                            that._option.position = new that._cesium.Cartesian3.fromDegrees(geoJson.geometry.coordinates[0], geoJson.geometry.coordinates[1], that._option.height);
                                            var entity = {};
                                            if (geoJson.geometry.type == "point") {
                                                entity = {
                                                    id: geoJson,
                                                    color: that._option.fill,
                                                    position: that._option.position
                                                };
                                                // } else if (geoJson.geometry.type == "Point" || geoJson.geometry.type == "Label" || geoJson.geometry.type == "label") {
                                                //     entity = options;
                                                // }
                                            } else {
                                                entity = that._option;
                                            }
                                            that.labelCollections.add(entity);
                                            //that._viewer.scene.primitives.add(that.labelCollections);
                                        } catch (e) {
                                        }
                                    }
                                    if (feature.type == 2) {
                                        var geom = geoms[0];
                                        var geoJson = feature.toGeoJSON(0, 0, 0, that.extent);
                                        if (!that._core.isnull(option.polylinefill) && style.paint != undefined && style.paint["icon-color"]) {
                                            that._option.polylinefill = that._color.createColorTransformation(style.paint["icon-color"]);
                                        }
                                        if (Array.isArray(geoJson.geometry.coordinates) && geoJson.geometry.coordinates.length > 0) {
                                            if (Array.isArray(geoJson.geometry.coordinates[0][0])) {
                                                for (var j = 0; j < geoJson.geometry.coordinates.length; j++) {
                                                    newArr = [];
                                                    fun(geoJson.geometry.coordinates[j]);
                                                    createpolyline(newArr);
                                                }
                                            } else {
                                                fun(geoJson.geometry.coordinates);
                                                createpolyline(newArr);
                                            }
                                        }
                                    }
                                    if (feature.type == 3) {
                                        try {
                                            var geom = geoms[0];
                                            var geoJson = feature.toGeoJSON(0, 0, 0, that.extent);
                                            var colors = Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.AQUA);
                                            if (style.paint["fill-color"] != undefined) {
                                                colors = Cesium.ColorGeometryInstanceAttribute.fromColor(that._color.createColorTransformation(style.paint["fill-color"]));
                                            }
                                            //new Cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                            if (Array.isArray(geoJson.geometry.coordinates) && geoJson.geometry.coordinates.length > 0) {
                                                if (Array.isArray(geoJson.geometry.coordinates[0][0])) {
                                                    for (var j = 0; j < geoJson.geometry.coordinates.length; j++) {
                                                        newArr = [];
                                                        fun(geoJson.geometry.coordinates[j]);
                                                        createpolygon(newArr);
                                                    }
                                                } else {
                                                    fun(geoJson.geometry.coordinates);
                                                    createpolygon(newArr);
                                                }
                                            }
                                        } catch (ex) { }
                                    }
                                }
                            }
                        }
                    }
                    if (that.labelCollections.length > 0) {
                        that._viewer.scene.primitives.add(that.labelCollections);
                    }

                    if (geometries_line.length > 0) {
                        //that._viewer.scene.primitives.add(new Cesium.ClassificationPrimitive({
                        //    geometryInstances: geometries_line,
                        //    appearance: new that._cesium.PerInstanceColorAppearance({
                        //        closed: true,
                        //        flat: false
                        //    }),
                        //    classificationType: that._cesium.ClassificationType.BOTH,
                        //    shadows: that._cesium.ShadowMode.ENABLED
                        //}));
                        that._viewer.scene.primitives.add(new Cesium.Primitive({
                            geometryInstances: geometries_line,
                            appearance: new Cesium.PolylineColorAppearance()
                        }));
                    }

                    if (geometries_polygon.length > 0) {
                        that._viewer.scene.primitives.add(new Cesium.Primitive({
                            geometryInstances: geometries_polygon,
                            appearance: new that._cesium.MaterialAppearance({
                                material: new Cesium.Material({
                                    fabric: {
                                        type: 'Color',
                                        uniforms: {
                                            color: Cesium.Color.fromRandom({
                                                alpha: 1.0
                                            })
                                        }
                                    }
                                }),
                                faceForward: true,
                                flat: false
                            }),
                            shadows: Cesium.ShadowMode.ENABLED
                        }));
                    }

                });
            }
        });
    };
    PolygonVectorTileLayerArcgis.prototype.createVolumeVectorGeoJsonFeatureLayers = function (layername, url, option, GroupID, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };

        var defaultGeoOptions = {
            url: url.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: url.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: url.upperLevelLimit,
            lowerLevelLimit: url.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(url.minx, url.miny, url.maxx, url.maxy),
            Cesium: this._cesium
        };
        this.extent = { XMin: url.minx || 0, YMin: url.miny || 0, XMax: url.maxx || 0, YMax: url.maxy || 0 };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }

        this._option = this._core.extend(defaultOptions, option, true);

        //if (this._core.isnull(option.level_max)) {
        //    max = 16;
        //}
        //if (this._core.isnull(option.level_min )) {
        //    min = 14;
        //}
        if (url == undefined)
            console.log('url is required');
        if (layername == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 100,
            vertexFormat: Cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: Cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: Cesium.ArcType.GEODESIC,
            material: Cesium.Color.WHITE
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = url.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;

        this._Provider.loadTile = function (frameState, tile) {
            this.tile = tile;
            if (tile.state === Cesium.QuadtreeTileLoadState.START && that.item.show) {

                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };

                // 
                if (tile.level >= option.level_min && tile.level < option.level_max) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new Cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new Cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: Cesium.ShadowMode.ENABLED
                        });

                        tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                tile.data.geometryPrimitive.update(frameState, []);
                            //if (tile.data.geometryPrimitive._ready) {
                            tile.state = Cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }

                    //downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                    /**
                     * 请求区块数据
                     */
                    (function (tile) {
                        // Create random lines at the root level.
                        //var ny = tile.y;
                        //var qps = 1 << tile.level;
                        //ny = qps - 1 - tile.y;
                        //var tileUrl = "http://192.168.1.40:8090/geoserver/gwc/service/tms/1.0.0/swagger:20190628083926__nanjingmodel2@EPSG:4490@pbf/" + tile.level + "/" + tile.x + "/" + ny + ".pbf";
                        //var tileUrl = "https://basemaps.arcgis.com/arcgis/rest/services/World_Basemap_v2/VectorTileServer/tile/1/1/1.pbf";
                        //var tileUrl = "http://124.128.48.210:81/arcgis/rest/services/Hosted/tdtsd0408/VectorTileServer/tile/0/0/0.pbf";
                        //var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                        var tileUrl = "http://124.128.48.210:81/arcgis/rest/services/Hosted/tdtsd0408/VectorTileServer/tile/0/0/0.pbf";
                        Cesium.Resource.createIfNeeded(tileUrl).fetchArrayBuffer().then(function (data) {
                            var pbf = new Pbf(data);
                            var tTile = new VectorTile(pbf);
                            that.labelCollections = new that._cesium.PointPrimitiveCollection();
                            var geometries_line = [];
                            var geometries_polygon = [];
                            for (var key in tTile.layers) {
                                var layer = tTile.layers[key];
                                for (var i = 0; i < layer.length; i++) {
                                    var feature = layer.feature(i);
                                    var geomList = feature.loadGeometry();
                                    //var geoJson;
                                    for (var j = 0; j < geomList.length; j++) {
                                        var geoms = geomList[j];
                                        for (var n = 0; n < geoms.length; n++) {
                                            geoms[n];
                                            if (feature.type == 1) {
                                                try {
                                                    // var geom = geoms[0];
                                                    //var geoJson = feature.toGeoJSON(tile.x, tile.y, tile.level, that.extent);
                                                    var geoJson = feature.toGeoJSON(0, 0, 0, that.extent);
                                                    // 1. Draw a translucent ellipse on the surface with a checkerboard pattern
                                                    if (that._option.text != undefined) {
                                                        if (/^\[/.test(that._option.text) && /\]$/.test(that._option.text)) {
                                                            var material = that._option.text.replace(/\[/, '').replace(/\]/, '');
                                                            options.text = feature.properties[material];
                                                        }
                                                    }
                                                    options.position = new that._cesium.Cartesian3.fromDegrees(geoJson.geometry.coordinates[0], geoJson.geometry.coordinates[1], options.height);
                                                    var entity = {};
                                                    if (geoJson.geometry.type == "point") {
                                                        entity = {
                                                            id: geoJson,
                                                            color: options.material,
                                                            position: options.position
                                                        };
                                                        // } else if (geoJson.geometry.type == "Point" || geoJson.geometry.type == "Label" || geoJson.geometry.type == "label") {
                                                        //     entity = options;
                                                        // }
                                                    } else {
                                                        entity = options;
                                                    }
                                                    that.labelCollections.add(entity);
                                                } catch (e) {
                                                }
                                            }
                                            if (feature.type == 2) {
                                                geoms[0];
                                                var geoJson = feature.toGeoJSON(tile.x, tile.y, tile.level, that.extent);
                                                for (var n = 0; n < geoJson.geometry.coordinates.length; n++) {
                                                    try {
                                                        var DegreesArray = [];
                                                        geoJson.geometry.coordinates[n].forEach(function (degrees) {
                                                            DegreesArray.push(degrees[0], degrees[1]);
                                                        });
                                                        var polyline = new Cesium.PolylineGeometry({
                                                            positions: Cesium.Cartesian3.fromDegreesArray(DegreesArray),
                                                            width: 10.0
                                                        });
                                                        var geometry = Cesium.PolylineGeometry.createGeometry(polyline);
                                                        var geometryInstance = new Cesium.GeometryInstance({
                                                            geometry: geometry
                                                        });
                                                        geometries_line.push(geometryInstance);
                                                    } catch (e) {
                                                    }
                                                }
                                            }
                                            if (feature.type == 3) {
                                                geoms[0];
                                                var geoJson = feature.toGeoJSON(tile.x, tile.y, tile.level, that.extent);
                                                for (var n = 0; n < geoJson.geometry.coordinates.length; n++) {
                                                    try {
                                                        var DegreesArray = [];
                                                        geoJson.geometry.coordinates[n].forEach(function (degrees) {
                                                            DegreesArray.push(degrees[0], degrees[1]);
                                                        });
                                                        var polygon = new Cesium.PolygonGeometry({
                                                            polygonHierarchy: new Cesium.PolygonHierarchy(
                                                                Cesium.Cartesian3.fromDegreesArray(DegreesArray)
                                                            )
                                                        });
                                                        var geometry = Cesium.PolygonGeometry.createGeometry(polygon);
                                                        var geometryInstance = new Cesium.GeometryInstance({
                                                            geometry: geometry
                                                        });
                                                        geometries_polygon.push(geometryInstance);
                                                    } catch (e) {
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    //if (geom[0][0]) {
                                    //    geoJson = feature.toGeoJSON(geom[0][0].x, geom[0][0].y, 0);
                                    //}

                                    //if (geom.length > 1) {
                                    //    geoJson = feature.toGeoJSON(geom[0][0].x, geom[0][0].y, z);
                                    //}
                                    //if (geom[0].length > 1) {
                                    //    geoJson = feature.toGeoJSON(geom[0][0].x, geom[0][0].y, z);
                                    //}

                                    //if (geom[0][1]) {
                                    //    geoJson = feature.toGeoJSON(geom[0].Point.x, geom[0].Point.y, z);
                                    //}

                                }
                            }
                            //var tile = Tile.read(pbf);
                            //for (var i = 0; i < tile.layers.length; i++) {
                            //    var features = tile.layers[i].features;
                            //    for (var j = 0; j < features.length; j++) {
                            //        var feature = features[j];

                            //    }
                            //}
                            if (that.labelCollections.length > 0) {
                                that._viewer.scene.primitives.add(that.labelCollections);
                            }

                            if (geometries_line.length > 0) {
                                that._viewer.scene.primitives.add(new Cesium.Primitive({
                                    geometryInstances: geometries_line,
                                    appearance: new that._cesium.MaterialAppearance({
                                        material: new Cesium.Material({
                                            fabric: {
                                                type: 'Color',
                                                uniforms: {
                                                    color: Cesium.Color.fromRandom({
                                                        alpha: 1.0
                                                    })
                                                }
                                            }
                                        }),
                                        faceForward: true,
                                        flat: false
                                    }),
                                    shadows: Cesium.ShadowMode.ENABLED
                                }));
                            }

                            if (geometries_polygon.length > 0) {
                                that._viewer.scene.primitives.add(new Cesium.Primitive({
                                    geometryInstances: geometries_polygon,
                                    appearance: new that._cesium.MaterialAppearance({
                                        material: new Cesium.Material({
                                            fabric: {
                                                type: 'Color',
                                                uniforms: {
                                                    color: Cesium.Color.fromRandom({
                                                        alpha: 1.0
                                                    })
                                                }
                                            }
                                        }),
                                        faceForward: true,
                                        flat: false
                                    }),
                                    shadows: Cesium.ShadowMode.ENABLED
                                }));
                            }

                        });


                    })(tile);
                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive) {
                            tile.data.geometryPrimitive.update(frameState, []);
                            if (tile._parent && tile._parent.data && tile._parent.data.geometryPrimitive) {
                                tile._parent.data.geometryPrimitive.destroy();
                                tile._parent.data.geometryPrimitive = null;
                                tile._parent.state = Cesium.QuadtreeTileLoadState.START;
                            }
                            if (tile._southwestChild && tile._southwestChild.data && tile._southwestChild.data.geometryPrimitive) {
                                tile._southwestChild.data.geometryPrimitive.destroy();
                                tile._southwestChild.data.geometryPrimitive = null;
                                tile._southwestChild.state = Cesium.QuadtreeTileLoadState.START;
                            }
                            if (tile._southeastChild && tile._southeastChild.data && tile._southeastChild.data.geometryPrimitive) {
                                tile._southeastChild.data.geometryPrimitive.destroy();
                                tile._southeastChild.data.geometryPrimitive = null;
                                tile._southeastChild.state = Cesium.QuadtreeTileLoadState.START;
                            }
                            if (tile._northwestChild && tile._northwestChild.data && tile._northwestChild.data.geometryPrimitive) {
                                tile._northwestChild.data.geometryPrimitive.destroy();
                                tile._northwestChild.data.geometryPrimitive = null;
                                tile._northwestChild.state = Cesium.QuadtreeTileLoadState.START;
                            }
                            if (tile._northeastChild && tile._northeastChild.data && tile._northeastChild.data.geometryPrimitive) {
                                tile._northeastChild.data.geometryPrimitive.destroy();
                                tile._northeastChild.data.geometryPrimitive = null;
                                tile._northeastChild.state = Cesium.QuadtreeTileLoadState.START;
                            }

                        }
                        //if (tile.data.geometryPrimitive._ready) {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        //}
                    }
                    // Add more detail to parent lines at every other level.
                    return;
                }

                //  }
            }
            //if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
            //    if (tile.data.geometryPrimitive && tile.data.geometryPrimitive.update) {
            //        tile.data.geometryPrimitive.update(frameState, []);
            //        if (tile.data.geometryPrimitive._ready) {
            //            tile.state = Cesium.QuadtreeTileLoadState.DONE;
            //            tile.renderable = true;
            //        }
            //    } else {
            //        tile.state = Cesium.QuadtreeTileLoadState.DONE;
            //        tile.renderable = true;
            //    }
            //}

        };

        this._primitive = new that._cesium.QuadtreePrimitive({
            tileProvider: this._Provider
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
    };

    /**
     * 创建VolumeGeoJsonFeatureLayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *       radius: 2,
            material: "#FFFFFF",
            show: true
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    PolygonVectorTileLayerArcgis.prototype.createVolumeGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var defaultOptions = {
            polylinePositions: undefined,
            shapePositions: undefined,
            ellipsoid: this._cesium.Ellipsoid.WGS84,
            granularity: this._cesium.Math.RADIANS_PER_DEGREE,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            cornerType: this._cesium.CornerType.ROUNDED
        };
        // var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        var that = this;
        var geometries = [];

        defaultOptions.shapePositions = this.computeCircle(option.radius);
        dataSource.then(function (dataSource) {
            //填充颜色设置
            var material = that._cesium.Color.WHITE;
            if (!that._core.isnull(option) && !that._core.isnull(option.material)) {
                if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") {
                    material = option.material.replace(/\[/, '').replace('/\]/', '');
                } else {
                    material = lodash.clone(option.material);
                }
                {
                    if (that._core.isHtmlColor(material)) {
                        material = that._color.colorFromHtmlColor(option.material);
                    } else {
                        if (/^rgb/.test(material)) {
                            material = that._color.rgbaStringToRgbaObj(material);
                        }
                        if (material.r > 1) {
                            material.r = material.r / 255;
                        }
                        if (material.g > 1) {
                            material.g = material.g / 255;
                        }
                        if (material.b > 1) {
                            material.b = material.b / 255;
                        }
                        if (material.a > 1) {
                            material.a = material.a / 255;
                        }
                        material = that._color.createColor(material.r, material.g, material.b, material.a);
                    }
                }
            }
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                defaultOptions.polylinePositions = entity.polyline.positions._value;

                var extrudedPolyline = new that._cesium.PolylineVolumeGeometry(defaultOptions);
                var geometry = that._cesium.PolylineVolumeGeometry.createGeometry(extrudedPolyline);
                var geometryInstance = new that._cesium.GeometryInstance({
                    geometry: geometry,
                    // attributes: {
                    //     color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(material),
                    // }
                });
                geometries.push(geometryInstance);
            }
            var ps = that._viewer.scene.primitives.add(new that._cesium.Primitive({
                geometryInstances: geometries,
                appearance: new that._cesium.MaterialAppearance({
                    material: new that._cesium.Material({
                        fabric: {
                            type: 'Color',
                            uniforms: {
                                color: material
                            }
                        }
                    }),
                    faceForward: true,
                    flat: false
                }),
                // appearance: new that._cesium.PerInstanceColorAppearance({
                //     flat: true,
                //     translucent: true,
                //     faceForward: true,
                //     closed: true
                // }),
                // shadows: Cesium.ShadowMode.ENABLED
            }));
            that.item = ps;
            if (option.show == false) {
                ps.show = false;
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        if (this._core.isnull(option.id)) {
            option.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建管状图层" + option.id;
        }
        //导出工程树
        var obj = {
            id: option.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineVolumeLayer',
            item: this,
            url: geoOptions.url,
            style: option
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 生成管状数据
     * @param {Float} radians
     */
    PolygonVectorTileLayerArcgis.prototype.computeCircle = function (radius) {
        if (this._core.isnull(radius)) {
            radius = 4;
        }
        var positions = [];
        for (var i = 0; i < 360; i++) {
            var radians = this._cesium.Math.toRadians(i);
            positions.push(new this._cesium.Cartesian2(radius * Math.cos(radians), radius * Math.sin(radians)));
        }
        return positions;
    };
    /**
     * geojson管线矢量图层
     * @param {String} [name] 图层名称
     * @param {object} [geoOptions] geojosn图层
     *       url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
     *       layer:'nanjing',
     upperLevelLimit: 13,
     lowerLevelLimit: 13,
     minx:118.51721649800015,
     miny:31.863232407499936,
     maxx:118.91648798400001,
     maxy:32.27649160409993
     * @param {object} [styleOption] 图层样式
     material: this._cesium.Color.WHITE, //    optional A Property specifying the material used to draw the polyline.
     radius:3
     * @param {Float}  [GroupID] 组itemID
     * @param {object} [disFnc] 回调函数
     */
    PolygonVectorTileLayerArcgis.prototype.createVolumeGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.RECEIVE_ONLY, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            // rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        //this.options=options;
        /**
         * 请求矢量切片
         */

        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        var _this = this;
        geoJSONVectorTileProvider._loadTile = function (json) {
            //测试
            var collection = new _this._cesium.PrimitiveCollection();
            json.features.forEach(function (feature) {

                var pos = [];
                //fun(feature.geometry.coordinates);
                if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                    var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                    options.material = feature.properties[material];
                    //填充颜色设置
                    if (that._core.isHtmlColor(options.material)) {
                        options.material = that._color.colorFromHtmlColor(options.material);
                    } else {
                        if (/^rgb/.test(options.material)) {
                            options.material = that._color.rgbaStringToRgbaObj(options.material);
                        }
                        if (options.material.r > 1) {
                            options.material.r = options.material.r / 255;
                        }
                        if (options.material.g > 1) {
                            options.material.g = options.material.g / 255;
                        }
                        if (options.material.b > 1) {
                            options.material.b = options.material.b / 255;
                        }
                        if (options.material.a > 1) {
                            options.material.a = options.material.a / 255;
                        }
                        options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                    }
                }
                //var pos = _this._cesium.Cartesian3.fromDegreesArray(newArr);

                for (var i = 0; i < feature.geometry.coordinates.length; i++) {
                    var up = feature.geometry.coordinates[i];

                    if (up.length > 0) {
                        if (Array.isArray(up[0])) {
                            for (var j = 0; j < up.length; j++) {
                                var child = up[j];
                                var childFt = _this._cesium.Cartesian3.fromDegrees(child[0], child[1], options.height);
                                pos.push(childFt);
                            }
                        } else {
                            var ft = _this._cesium.Cartesian3.fromDegrees(up[0], up[1], options.height);
                            pos.push(ft);
                        }
                    }

                    //var ft=_this._cesium.Cartesian3.fromDegrees(up[0],up[1],options.height);
                    //pos.push(ft);
                }
                options.position = pos;
                if (options.slttype == "0" || options.slttype == 0) {
                    options.shape = _this._core.computeCircle(options.radius);
                } else if (options.slttype == "1" || options.slttype == 1) {
                    options.shape = _this._core.starPositions(options.number, options.exradius, options.inradius);
                } else if (options.slttype == "2" || options.slttype == 2) {
                    var x = options.orth_width / 2;
                    var y = options.orth_height / 2;
                    options.shape = [new _this._cesium.Cartesian2(-x, -y),
                    new _this._cesium.Cartesian2(x, -y),
                    new _this._cesium.Cartesian2(x, y),
                    new _this._cesium.Cartesian2(-x, y)];
                }
                feature.positions = pos;
                //options.shape = _this.computeCircle(styleOption.radius);
                var dx = {
                    polylinePositions: options.position,
                    shapePositions: options.shape,
                    cornerType: options.cornerType,
                    VertexFormat: {
                        bitangent: true,
                        color: true,
                        position: true,
                        st: true,
                        normal: true,
                        tangent: true
                    }
                };
                var volime = new _this._cesium.PolylineVolumeGeometry(dx);
                var geometry = _this._cesium.PolylineVolumeGeometry.createGeometry(volime);
                var geometryInstance = new _this._cesium.GeometryInstance({
                    id: feature,
                    geometry: geometry,
                    attributes: {
                        color: new _this._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                    }
                });
                //geomInstances.push(geometryInstance);
                var primitive = new _this._cesium.Primitive({
                    allowPicking: true,
                    appearance: new _this._cesium.MaterialAppearance({
                        material: new _this._cesium.Material({
                            fabric: {
                                type: 'Color',
                                uniforms: {
                                    // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                    color: options.material
                                }
                            }
                        }),
                        faceForward: true,
                        flat: false
                    }),
                    shadows: options.shadows,
                    geometryInstances: geometryInstance
                });
                collection.add(primitive);
            });
            return collection;
        };
        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineVolumeLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
    };
    //工程树添加
    PolygonVectorTileLayerArcgis.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 导出工程数据
     */
    PolygonVectorTileLayerArcgis.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url
            }
        };
    };
    /**
     * 删除数据
     */
    PolygonVectorTileLayerArcgis.prototype.deleteObject = function () {
        this._viewer.scene.primitives.remove(this.item);
        try {
            this._Provider.remove();
        } catch (ex) {
        }
    };
    /**
     * 设置数据是否刷新
     */
    PolygonVectorTileLayerArcgis.prototype.setRefresh = function (b) {
        try {
            if (this._Provider) {
                this._Provider.setStatus(b);
            }
        } catch (ex) {
        }
    };
    /**
     * 设置数据显示隐藏
     */
    PolygonVectorTileLayerArcgis.prototype.setVisibility = function (b) {
        this.item.show = b;
        if (this._Provider) {
            this._Provider.setStatus(b);
        }
    };

    /**
     *
     * 墙Geosjon要素图层
     *
     * @alias VolumeGeoJsonFeatureLayer
     * @constructor
     *
     */
    function WallGeoFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this._VectorTileProvider = new VectorTileProvider(this._viewer, this._cesium);
        this._primitive = undefined;
        this._Provider = undefined;
        //图例
        this.Legend = [];
    }
    /**
    * 创建VolumeGeoJsonFeatureLayer
    *
    * @param {String} [name] 图层名称。
    * @param {object|String} [geojsonOrurl] geojosn对象或者地址
    * @param {object} [option] 参数对象{
    *     height: 0,//	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
          extrudedHeight: 0,//		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
          heightReference: this._cesium.HeightReference.NONE,//		optional A Property specifying what the extrudedHeight is relative to.
          show: true,//	optional A boolean Property specifying the visibility of the polygon.
          fill: true,//	optional A boolean Property specifying whether the polygon is filled with the provided material.
          material: this._cesium.Color.WHITE,//optional A Property specifying the material used to fill the polygon.
          outline: false,//optional A boolean Property specifying whether the polygon is outlined.
          outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the Color of the outline.
          outlineWidth: 1.0,//optional A numeric Property specifying the width of the outline.
          stRotation: 0.0,//	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
          granularity: this._cesium.Math.RADIANS_PER_DEGREE,//	optional A numeric Property specifying the angular distance between each latitude and longitude point.
          perPositionHeight: false,	//optional A boolean specifying whether or not the the height of each position is used.
          closeTop: true,	//optional When false, leaves off the top of an extruded polygon open.
          closeBottom: true,//	optional When false, leaves off the bottom of an extruded polygon open.
          shadows: this._cesium.ShadowMode.DISABLED,//	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
          near: 0,
          far: 5000
        }
    * @param {Function} [disFnc] 回调函数
    * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
    */
    WallGeoFeatureLayer.prototype.createWallGeoFeatureLayer = function (layername, url, option, max, min, GroupID, disFnc) {
        var defaultOptions = {
            // show: true, // optional A boolean Property specifying the visibility of the wall.
            positions: [], // optional A Property specifying the array of Cartesian3 positions which define the top of the wall.
            minimumHeights: [], // optional A Property specifying an array of heights to be used for the bottom of the wall instead of the globe surface.
            maximumHeights: [], // optional A Property specifying an array of heights to be used for the top of the wall instead of the height of each position.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, // optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, // optional A boolean Property specifying whether the wall is filled with the provided material.
            material: this._cesium.Color.WHITE, // optional A Property specifying the material used to fill the wall.
            outline: false, // optional A boolean Property specifying whether the wall is outlined.
            outlineColor: this._cesium.Color.BLACK, // optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, // optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, // optional An enum Property specifying whether the wall casts or receives shadows from each light source.
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (this._core.isnull(max)) {
            max = 16;
        }
        if (this._core.isnull(min)) {
            min = 14;
        }
        if (url == undefined)
            console.log('url is required');
        if (layername == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var that = this;
        var downLoadTiles = [];
        this._VectorTileProvider.loadTile = function (frameState, tile) {
            this.tile = tile;
            if (tile.state === that._cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                /**
                 * 限定级别刷新
                 */
                if (tile.level >= min && tile.level < max) {
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    /**
                     * 判断相同级别的数据是否已经请求
                     */
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new that._cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new that._cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });

                        tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                tile.data.geometryPrimitive.update(frameState, []);
                            //if (tile.data.geometryPrimitive._ready) {
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }
                    /**
                     * 保存已经下载的数据
                     */
                    downLoadTiles.push({
                        level: tile.level,
                        x: tile.x,
                        y: tile.y,
                        data: undefined
                    });
                    /**
                     * 请求区块数据
                     */
                    (function (tile) {
                        //'http://192.168.1.40:8090/geoserver/gwc/service/wmts?REQUEST=GetTile&SERVICE=WMTS&VERSION=1.0.0&LAYER=skyline:nanjing&STYLE=&TILEMATRIX=EPSG:4490:' +
                        //tile.level + '&TILEMATRIXSET=EPSG:4490&FORMAT=application/json;type=geojson&TILECOL=' + tile.x + '&TILEROW=' + tile.y
                        // $.ajax({
                        that._core.xhr({
                            url: url + '?REQUEST=GetTile&SERVICE=WMTS&VERSION=1.0.0&LAYER=' + layername + '&STYLE=&TILEMATRIX=EPSG:4490:' +
                                tile.level + '&TILEMATRIXSET=EPSG:4490&FORMAT=application/json;type=geojson&TILECOL=' + tile.x + '&TILEROW=' + tile.y,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                var geometries = [];
                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                        }
                                    }
                                }
                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    fun(data.features[i].geometry.coordinates[0]);

                                    var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                    options.positions = pos;
                                    var geometryInstance = new that._cesium.GeometryInstance({
                                        geometry: new that._cesium.WallGeometry({
                                            positions: options.positions
                                        }),
                                        attributes: {
                                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.WHITE)
                                        }
                                    });
                                    geometries.push(geometryInstance);
                                }
                                var tempTiles = lodash.filter(downLoadTiles, function (o) {
                                    return o.x == tile.x && o.y == tile.y;
                                });
                                tempTiles[0].data = geometries;
                                tile.data.geometryPrimitive = new that._cesium.Primitive({
                                    geometryInstances: geometries,
                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                        flat: true,
                                        translucent: true,
                                        faceForward: true,
                                        closed: true
                                    }),
                                    shadows: that._cesium.ShadowMode.ENABLED
                                });
                                //});
                            },
                            error: function () {
                                downLoadTiles = lodash.remove(downLoadTiles, function (o) {
                                    return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                                });
                            },
                            complete: function () {
                                tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                                    if (tile.data.geometryPrimitive)
                                        tile.data.geometryPrimitive.update(frameState, []);
                                    //if (tile.data.geometryPrimitive._ready) {
                                    tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            }
                        });
                    })(tile);

                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            tile.data.geometryPrimitive.update(frameState, []);
                        //if (tile.data.geometryPrimitive._ready) {
                        tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        //}
                    }
                }
            }    };

        this._primitive = new that._cesium.QuadtreePrimitive({
            tileProvider: this._VectorTileProvider
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
    };
    /**
     * primivites加载wall数据 全加载方式
     * @param {String} [name] 名称
     * @param {String|object} [geojsonOrurl] 数据服务地址或者是
     * @param {Object} [option] 显示样式
     * {
     *      granularity: undefined,
            maximumHeights: 0, 
            minimumHeights: 0, 
            vertexFormat: undefined,
            material:'#ff0000'
     * }
     * @param {Float} [GroupID] 组编号
     */
    WallGeoFeatureLayer.prototype.createWallPrimitiveGeoFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var defaultOptions = {
            positions: undefined,
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //optional The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
            maximumHeights: 0, //		optional An array parallel to positions that give the maximum height of the wall at positions. If undefined, the height of each position in used.
            minimumHeights: 0, //		optional An array parallel to positions that give the minimum height of the wall at positions. If undefined, the height at each position is 0.0.
            vertexFormat: this._cesium.VertexFormat.DEFAULT, //	optional The vertex attributes to be computed.om each light source.
        };

        // var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        var that = this;
        var geometries = [];
        dataSource.then(function (dataSource) {
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                defaultOptions.positions = entity.polyline.positions._value;
                var minimumHeights = new Array(defaultOptions.positions.length);
                var maximumHeights = new Array(defaultOptions.positions.length);
                var minimumHeight = undefined;
                var maximumHeight = undefined;

                if (/^\[/.test(option.minimumHeights)) {
                    minimumHeight = option.minimumHeights.replace(/\[/, '').replace('/\]/', '');
                    minimumHeight = entity.properties[minimumHeight]._value;
                } else
                    minimumHeight = option.minimumHeights;

                if (/^\[/.test(option.maximumHeights)) {
                    maximumHeight = option.maximumHeights.replace(/\[/, '').replace('/\]/', '');
                    maximumHeight = entity.properties[maximumHeight]._value;
                } else
                    maximumHeight = option.maximumHeights;
                minimumHeights.fill(minimumHeight);
                maximumHeights.fill(maximumHeight);
                defaultOptions.minimumHeights = minimumHeights;
                defaultOptions.maximumHeights = maximumHeights;

                //填充颜色设置
                var material = that._cesium.Color.WHITE;
                if (!that._core.isnull(option) && !that._core.isnull(option.material)) {
                    if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") {
                        material = option.material.replace(/\[/, '').replace('/\]/', '');
                    } else {
                        material = lodash.clone(option.material);
                    } {
                        if (that._core.isHtmlColor(material)) {
                            material = that._color.colorFromHtmlColor(option.material);
                        } else {
                            if (/^rgb/.test(material)) {
                                material = that._color.rgbaStringToRgbaObj(material);
                            }
                            if (material.r > 1) {
                                material.r = material.r / 255;
                            }
                            if (material.g > 1) {
                                material.g = material.g / 255;
                            }
                            if (material.b > 1) {
                                material.b = material.b / 255;
                            }
                            if (material.a > 1) {
                                material.a = material.a / 255;
                            }
                            material = that._color.createColor(material.r, material.g, material.b, material.a);
                        }
                    }
                }
                //图例
                var col = "material:" + material.red * 255 + "," + material.green * 255 + "," + material.blue * 255;
                that.Legend.push(col);
                var geometryInstance = new that._cesium.GeometryInstance({
                    id: entity,
                    geometry: new that._cesium.WallGeometry(defaultOptions),
                    attributes: {
                        color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(material),
                    }
                });
                geometries.push(geometryInstance);
            }
            var time;
            //添加时间段
            if (option && option.time) {
                time = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                    start: option.time.start ? that._cesium.JulianDate.fromDate(new Date(option.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                    stop: option.time.end ? that._cesium.JulianDate.fromDate(new Date(option.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
                })]);
            }
            var ps = that._viewer.scene.primitives.add(new that._cesium.Primitive({
                geometryInstances: geometries,
                appearance: new that._cesium.PerInstanceColorAppearance({
                    flat: true,
                    translucent: true,
                    faceForward: true,
                    closed: true
                }),
                // shadows: Cesium.ShadowMode.ENABLED
            }), time);
            that.item = ps;
            //if (options.show == false) {
            //    ps.show = false;
            //}
            if (checked) ; else {
                _this.setVisibility(false);
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        if (this._core.isnull(option.id)) {
            option.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建墙图层" + options.id;
        }
        //导出工程树
        var obj = {
            id: option.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineWallLayer',
            item: this,
            url: geojsonOrurl,
            style: options
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    /**
    * primivites加载wall数据矢量切片加载
    * @param {String} [name] 名称
    * @param {object} [geoOptions] 切片配置
    * example {
    *       url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
            layer: 'skyline:gouwu',
            upperLevelLimit: 16,
            lowerLevelLimit: 16,
            minx: 118.73577996,
            miny: 32.03315001,
            maxx: 118.801919985,
            maxy: 32.07363702
    * }
    * @param {Object} [styleOption] 显示样式
    * {
    *      granularity: undefined,
           maximumHeights: 0, 
           minimumHeights: 0, 
           vertexFormat: undefined,
           material:'#ff0000'
    * }
    * @param {Float} [GroupID] 组编号
    * @param {object} [disFnc] 回调函数
    */
    WallGeoFeatureLayer.prototype.createWallGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            positions: undefined,
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //optional The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
            maximumHeights: 0, //		optional An array parallel to positions that give the maximum height of the wall at positions. If undefined, the height of each position in used.
            minimumHeights: 0, //		optional An array parallel to positions that give the minimum height of the wall at positions. If undefined, the height at each position is 0.0.
            vertexFormat: this._cesium.VertexFormat.DEFAULT, //	optional The vertex attributes to be computed.om each light source.
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        // var options = this._core.extend(defaultOptions, styleOption, true);
        //this.options=options;
        /**
         * 请求矢量切片
         */
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        var that = this;
        geoJSONVectorTileProvider._loadTile = function (json) {
            //测试
            //图例
            that.Legend = [];
            var collection = new that._cesium.PrimitiveCollection();
            json.features.forEach(function (feature) {
                var newArr = [];
                var haveZ = false;

                function fun(arr) {
                    for (var i = 0; i < arr.length; i++) {
                        if (Array.isArray(arr[i])) {
                            fun(arr[i]);
                        } else {
                            newArr.push(arr[i]);
                            if (i === 2 && !haveZ) {
                                haveZ = true;
                            }
                        }
                    }
                }
                //fun(feature.geometry.coordinates);
                if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                    if (Array.isArray(feature.geometry.coordinates[0][0])) {
                        for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                            newArr = [];
                            fun(feature.geometry.coordinates[j]);
                            createobj(newArr);
                        }
                    } else {
                        fun(feature.geometry.coordinates);
                        createobj(newArr);
                    }
                }
                function createobj(newArr) {
                    if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                        var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                        options.material = feature.properties[material];
                        //填充颜色设置
                        if (that._core.isHtmlColor(options.material)) {
                            options.material = that._color.colorFromHtmlColor(options.material);
                        } else {
                            if (/^rgb/.test(options.material)) {
                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                            }
                            if (options.material.r > 1) {
                                options.material.r = options.material.r / 255;
                            }
                            if (options.material.g > 1) {
                                options.material.g = options.material.g / 255;
                            }
                            if (options.material.b > 1) {
                                options.material.b = options.material.b / 255;
                            }
                            if (options.material.a > 1) {
                                options.material.a = options.material.a / 255;
                            }
                            options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                        }
                    }
                    var pos = haveZ ?
                        that._cesium.Cartesian3.fromDegreesArrayHeights(newArr) :
                        that._cesium.Cartesian3.fromDegreesArray(newArr)
                        ;
                    defaultOptions.positions = pos;
                    feature.positions = pos;
                    var minimumHeights = new Array(defaultOptions.positions.length);
                    var maximumHeights = new Array(defaultOptions.positions.length);
                    var minimumHeight = undefined;
                    var maximumHeight = undefined;

                    if (/^\[/.test(styleOption.minimumHeights)) {
                        minimumHeight = styleOption.minimumHeights.replace(/\[/, '').replace('/\]/', '');
                        minimumHeight = entity.properties[minimumHeight]._value;
                    } else
                        minimumHeight = styleOption.minimumHeights;

                    if (/^\[/.test(styleOption.maximumHeights)) {
                        maximumHeight = styleOption.maximumHeights.replace(/\[/, '').replace('/\]/', '');
                        maximumHeight = entity.properties[maximumHeight]._value;
                    } else
                        maximumHeight = styleOption.maximumHeights;
                    minimumHeights.fill(minimumHeight);
                    maximumHeights.fill(maximumHeight);
                    defaultOptions.minimumHeights = minimumHeights;
                    defaultOptions.maximumHeights = maximumHeights;

                    //样式属性
                    feature.treeID = styleOption.id;
                    feature.VectorType = 'wall';
                    feature.VectorStyle = {
                        haveZ: haveZ,
                        minimumHeights: minimumHeights,
                        maximumHeights: maximumHeights,
                        positions: newArr,
                        material: styleOption.material
                    };

                    var geometryInstance = new that._cesium.GeometryInstance({
                        id: feature,
                        geometry: new that._cesium.WallGeometry(defaultOptions),
                        attributes: {
                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(styleOption.material),
                        }
                    });
                    //图例
                    var col = "material:" + styleOption.material.red * 255 + "," + styleOption.material.green * 255 + "," + styleOption.material.blue * 255;
                    that.Legend.push(col);
                    //geomInstances.push(geometryInstance);
                    var primitive = new that._cesium.Primitive({
                        geometryInstances: geometryInstance,
                        //appearance: new that._cesium.PerInstanceColorAppearance({
                        //    flat: true,
                        //    translucent: true,
                        //    faceForward: true,
                        //    closed: true
                        //}),
                        appearance: new that._cesium.MaterialAppearance({
                            material: new that._cesium.Material({
                                fabric: {
                                    type: 'Color',
                                    uniforms: {
                                        // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                        color: styleOption.material
                                    }
                                }
                            }),
                            faceForward: true,
                            flat: false
                        }),
                        vertexCacheOptimize: true,
                        interleave: true,
                        shadows: that._cesium.ShadowMode.ENABLED,
                    });
                    collection.add(primitive);
                }
            });
            return collection;
        };
        //添加时间段
        if (styleOption && styleOption.time) {
            geoJSONVectorTileProvider.availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建墙图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineWallLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this._Provider.treeID = styleOption.id;

        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        if (typeof disFnc == 'function')
            disFnc(this.item);
        return this;
    };
    //工程树添加
    WallGeoFeatureLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
    * 删除数据
    */
    WallGeoFeatureLayer.prototype.deleteObject = function () {
        this._viewer.scene.primitives.remove(this.item);
        try {
            this._Provider.remove();
        } catch (ex) { }
    };
    /**
    * 导出工程数据
    */
    WallGeoFeatureLayer.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url
            }
        };
    };
    /**
    * 返回图例
    * @returns {object} 
    */
    WallGeoFeatureLayer.prototype.getLegend = function () {
        var legend = [];
        if (this.Legend != null) {
            legend = this._core.unique(this.Legend);
        }
        return legend;
    };
    /**
    * 设置数据是否刷新
    */
    WallGeoFeatureLayer.prototype.setRefresh = function (b) {
        try {
            if (this._Provider) {
                this._Provider.setStatus(!b);
            }
        } catch (ex) {
        }
    };
    /**
     * 设置数据显示隐藏
     */
    WallGeoFeatureLayer.prototype.setVisibility = function (b) {
        this.item.show = b;
        if (this._Provider) {
            this._Provider.setStatus(!b);
        }
    };

    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    WallGeoFeatureLayer.prototype.edit = function (open, option) {
        this.isEditting = open;
        this.editoption = option;
        return this._Provider && this._Provider.edit && this._Provider.edit(open, option);
    };
    /**
        * 设置数据是否刷新
        */
    WallGeoFeatureLayer.prototype.forceRefresh = function () {
        try {
            // this._cache = true;
            // if (!this._forceRefreshPrvimitive)
            //     this._forceRefreshPrvimitive = loadsh.cloneDeep(this._primitive)
            // var temp = loadsh.cloneDeep(this._forceRefreshPrvimitive)
            // this._viewer.scene.primitives.remove(this._primitive);
            // this._viewer.scene.primitives.add(temp);
            // this._viewer.scene.primitivesQuadTrees.push(temp);
            // this.edit(this.isEditting, this.editoption);
            // temp._tileProvider.edit(this.isEditting, this.editoption);

            for (var i = 0; i < this._Provider.quadtree._levelZeroTiles.length; i++) {
                this._Provider.quadtree._levelZeroTiles[i].freeResources();
            }
        } catch (ex) {
        }
    };

    /**
     *
     * 简单图形
     *
     * @alias SimpleGraphic
     * @constructor
     *
     */
    function SimpleGraphic(viewer) {
        this._viewer = viewer;
        this._cesium = Cesium;
        this._core = new Core();
        this._tree = tree;
        this._getPosition = new getPosition(this._viewer, this._cesium);
        this._ModelEdit = new ModelEdit(this._viewer);
        this._popupmessage = new PopupMessage(this._viewer, this._cesium);

        this._createGroup = new createGroup(this._viewer, this._cesium);
        this._billboardGeoJsonFeatureLayer = new billboardGeoJsonFeatureLayer(this._viewer, this._cesium);
        this._GeoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        this._LabelGeoJsonFeatureLayercopy = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        this._VectorGeoJsonFeatureLayer = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        this._PolylineGeoJsonFeatureLayer = new PolylineGeoJsonFeatureLayer(this._viewer, this._cesium);
        this._PointModel = new PointModel(this._viewer, this._cesium);
        this._PolygonGeoJsonFeatureLayer = new PolygonGeoJsonFeatureLayer(this._viewer, this._cesium);
        this._PolygonVectorTileLayerArcgis = new PolygonVectorTileLayerArcgis(this._viewer, this._cesium);
        this._WallGeoFeatureLayer = new WallGeoFeatureLayer(this._viewer, this._cesium);

        this.tooltip = this._core.CreateTooltip();
        //需要排除的对象
        this.objectsToExclude = [];
        this.SimpleGraphicObj = [];
        !tree.editPointID && (tree.editPointID = {
            edit: [],   //编辑节点
            size: [],   //大小节点
            move: undefined,   //移动节点
            height: [],   //高度节点
            add: []     //新增节点
        });
        this.editProp = false;

        this.PrimitiveCollection = new Cesium.PrimitiveCollection();
        viewer.scene.primitives.add(this.PrimitiveCollection);

        this.SizeData = [];
    }

    /**
     * 创建简单图形
     * 
     * @param {String} [type] 类型
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createSimpleGraphic = function (type, option = {}, callback) {
        let Graphic = null;
        let _callback = (entity) => {
            if (this.SimpleGraphicObj.length && !this.editHandler) {
                this.edit(this.openEdit, this.editOption);
            } else if (!this.SimpleGraphicObj.length && this.editHandler) {
                this.edit(false);
            }
            callback && callback(entity);
        };
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        switch (type) {
            case "point":
                //基础点
                Graphic = this.createPoint(option, _callback);
                break;
            case "billboard":
                //图标点
                Graphic = this.createBillboard(option, _callback);
                break;
            case "label":
                //文本点
                Graphic = this.createLabel(option, _callback);
                break;
            case "model":
                //模型点
                Graphic = this.createModel(option, _callback);
                break;
            case "polyline":
                //线
                Graphic = this.createPolyline(option, _callback);
                break;
            case "polygon":
                //面
                Graphic = this.createPolygon(option, _callback);
                break;
            case "triangle":
                //三角形
                Graphic = this.createTriangle(option, _callback);
                break;
            case "polygon-rectangle":
                //面-矩形
                Graphic = this.createPolygonRectangle(option, _callback);
                break;
            case "rectangle":
                //矩形
                Graphic = this.createRectangle(option, _callback);
                break;
            case "circle":
                //圆
                Graphic = this.createCircle(option, _callback);
                break;
            case "ellipse":
                //椭圆
                Graphic = this.createEllipse(option, _callback);
                break;
            case "box":
                //立方体
                Graphic = this.createBox(option, _callback);
                break;
            case "cylinder":
                //圆柱体
                Graphic = this.createCylinder(option, _callback);
                break;
            case "cone":
                //圆锥体
                Graphic = this.createCone(option, _callback);
                break;
            case "sphere":
                //球体
                Graphic = this.createSphere(option, _callback);
                break;
            case "polyhedron":
                //球体
                Graphic = this.createPolyhedron(option, _callback);
                break;
        }
        return Graphic;
    };


    /**
     * 添加简单图形
     * 
     * @param {String} [type] 类型
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addSimpleGraphic = function (type, option = {}, treeobj) {
        let Graphic = null;
        //设置鼠标样式
        switch (type) {
            case "point":
                //基础点
                Graphic = this.addPoint(option);
                break;
            case "billboard":
                //图标点
                Graphic = this.addBillboard(option);
                break;
            case "label":
                //文本点
                Graphic = this.addLabel(option);
                break;
            case "model":
                //模型点
                Graphic = this.addModel(option);
                break;
            case "polyline":
                //线
                Graphic = this.addPolyline(option);
                break;
            case "polylinePrimitive":
                //线
                Graphic = this.addPolylinePrimitive(option);
                break;
            case "polygon":
                //面
                Graphic = this.addPolygon(option);
                break;
            case "polygonPrimitive":
                //面
                Graphic = this.addPolygonPrimitive(option);
                break;
            case "rectangle":
                //矩形
                Graphic = this.addRectangle(option);
                break;
            case "circle":
                //圆
                Graphic = this.addCircle(option);
                break;
            case "ellipse":
                //椭圆
                Graphic = this.addEllipse(option);
                break;
            case "box":
                //立方体
                Graphic = this.addBox(option);
                break;
            case "cylinder":
                //圆柱体
                Graphic = this.addCylinder(option);
                break;
            case "cone":
                //圆锥体
                Graphic = this.addCone(option);
                break;
            case "sphere":
                //球体
                Graphic = this.addSphere(option);
                break;
            case "ellipsoid":
                //椭球体
                Graphic = this.addSphere(option);
                break;
            case "polyhedron":
                //多边体
                Graphic = this.addPolyhedron(option);
                break;
        }
        if (this.SimpleGraphicObj.length && !this.editHandler) {
            this.edit(this.openEdit, this.editOption);
        }
        if (Graphic && option.removeEdit) {
            this.SimpleGraphicObj.pop();
        }
        Graphic.deleteObject = () => {
            this.remove(Graphic.id);
            this._viewer.entities.removeById(Graphic.id);
        };
        if (treeobj) {
            option.GroupID = treeobj.pId;
            option.id = treeobj.id;
            option.name = treeobj.name;
        }
        //添加工程树
        if (option.GroupID !== undefined) {
            let obj = {
                id: Graphic.id,
                name: Graphic.name,
                pId: option.GroupID,
                type: type,
                item: {
                    item: Graphic,
                    setVisibility: (show) => {
                        Graphic.show = show;
                    }
                }
            };
            if (type.indexOf('Primitive') > -1) {
                obj.id = option.id;
                obj.name = option.name;
            }
            tree.insertGroupId(obj, option.GroupID);
        }
        return Graphic;
    };

    /**
     * 创建基本点
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createPoint = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        this.drawHandler.setInputAction(event => {
            let position = that._getPosition.getMousePosition(event);
            if (position) {
                let point = viewer.entities.add({
                    id: that._core.getuid(),
                    name: 'Point',
                    position: position,
                    point: {
                        pixelSize: 16,
                        color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, '#0000ff')),
                        outlineWidth: that._core.defaultValue(option.outlineWidth, 2),
                        outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                        disableDepthTestDistance: that._core.defaultValue(option.disableDepthTestDistance, Number.POSITIVE_INFINITY),
                        distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
                    }
                });
                that.SimpleGraphicObj.push(point.id);

                that.drawHandler.destroy();
                that.drawHandler = undefined;
                that.tooltip.show(false);
                setTimeout(function () {
                    tree.states = 0;
                }, 100);
                //恢复鼠标样式
                that._core.mouse(that._viewer.container, 0, "0");
                //回调
                callBack && typeof callBack === 'function' && callBack(point);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            that.tooltip.showAt(event.endPosition, "点击绘制点");
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.drawHandler.setInputAction(event => {
            this.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = () => {
            this.end = undefined;
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");
        };
        return this;
    };

    /**
     * 添加基本点
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addPoint = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let point = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, 'Point'),
            position: option.position,
            point: {
                pixelSize: that._core.defaultValue(option.pixelSize, 16),
                color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, '#0000ff')),
                outlineWidth: that._core.defaultValue(option.outlineWidth, 2),
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                heightReference: that._core.defaultValue(option.heightReference, 1),
                scaleByDistance: that._core.defaultValue(option.scaleByDistance, undefined),
                disableDepthTestDistance: that._core.defaultValue(option.disableDepthTestDistance, Number.POSITIVE_INFINITY),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        that.SimpleGraphicObj.push(point.id);

        return point;
    };

    /**
     * 创建图标点
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createBillboard = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        this.drawHandler.setInputAction(event => {
            let position = that._getPosition.getMousePosition(event);
            if (position) {
                let Billboard = viewer.entities.add({
                    id: that._core.getuid(),
                    name: 'Billboard',
                    position: position,
                    billboard: {
                        horizontalOrigin: that._cesium.HorizontalOrigin.CENTER,
                        verticalOrigin: that._cesium.VerticalOrigin.BOTTOM,
                        scale: that._core.defaultValue(option.scale, 1),
                        width: that._core.defaultValue(option.width, option.image ? undefined : 32),
                        height: that._core.defaultValue(option.height, option.image ? undefined : 44),
                        image: that._core.defaultValue(option.image, window.SmartEarthRootUrl + configData$1.mark),
                        color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, '#ffffff')),
                        disableDepthTestDistance: that._core.defaultValue(option.disableDepthTestDistance, Number.POSITIVE_INFINITY),
                        distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
                    }
                });
                that.SimpleGraphicObj.push(Billboard.id);

                that.drawHandler.destroy();
                that.drawHandler = undefined;
                that.tooltip.show(false);
                setTimeout(function () {
                    tree.states = 0;
                }, 100);
                //恢复鼠标样式
                that._core.mouse(that._viewer.container, 0, "0");
                //回调
                callBack && typeof callBack === 'function' && callBack(Billboard);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            that.tooltip.showAt(event.endPosition, "点击绘制图标");
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.drawHandler.setInputAction(event => {
            this.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = () => {
            this.end = undefined;
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");
        };
        return this;
    };

    /**
     * 添加图标点
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addBillboard = function (option = {}) {
        let that = this;
        let viewer = this._viewer;


        let Billboard = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, 'Billboard'),
            position: option.position,
            billboard: {
                horizontalOrigin: that._core.defaultValue(option.horizontalOrigin, that._cesium.HorizontalOrigin.CENTER),
                verticalOrigin: that._core.defaultValue(option.verticalOrigin, that._cesium.VerticalOrigin.BOTTOM),
                scale: that._core.defaultValue(option.scale, 1.0),
                rotation: that._core.defaultValue(option.rotation, 0.0),
                width: that._core.defaultValue(option.width, undefined),
                height: that._core.defaultValue(option.height, undefined),
                image: that._core.defaultValue(option.image, window.SmartEarthRootUrl + configData$1.mark),
                color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, '#ffffff')),
                heightReference: that._core.defaultValue(option.heightReference, 1),
                scaleByDistance: that._core.defaultValue(option.scaleByDistance, undefined),
                disableDepthTestDistance: that._core.defaultValue(option.disableDepthTestDistance, Number.POSITIVE_INFINITY),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        that.SimpleGraphicObj.push(Billboard.id);

        return Billboard;
    };

    /**
     * 创建文本点
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createLabel = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        this.drawHandler.setInputAction(event => {
            let position = that._getPosition.getMousePosition(event);
            if (position) {
                let label = viewer.entities.add({
                    id: that._core.getuid(),
                    name: 'Label',
                    position: position,
                    label: {
                        text: '新建文本', //文本
                        font: "24px 宋体",
                        fillColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.fillColor, '#ffffff')),
                        scale: 1,
                        style: 2,
                        outlineColor: that._cesium.Color.BLACK,
                        outlineWidth: 0,
                        showBackground: false,
                        backgroundColor: new that._cesium.Color(0.165, 0.165, 0.165, 0.8),
                        horizontalOrigin: that._cesium.HorizontalOrigin.CENTER,
                        verticalOrigin: that._cesium.VerticalOrigin.CENTER,
                        distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000)),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY
                    }
                });
                that.SimpleGraphicObj.push(label.id);

                that.drawHandler.destroy();
                that.drawHandler = undefined;
                that.tooltip.show(false);
                setTimeout(function () {
                    tree.states = 0;
                }, 100);
                //恢复鼠标样式
                that._core.mouse(that._viewer.container, 0, "0");
                //回调
                callBack && typeof callBack === 'function' && callBack(label);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            that.tooltip.showAt(event.endPosition, "点击绘制文本");
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.drawHandler.setInputAction(event => {
            this.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = () => {
            this.end = undefined;
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");
        };
        return this;
    };

    /**
     * 添加文本点
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addLabel = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let label = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, 'Label'),
            position: option.position,
            label: {
                text: that._core.defaultValue(option.text, '新建文本'), //文本
                font: that._core.defaultValue(option.font, "24px 宋体"),
                scale: that._core.defaultValue(option.scale, 1),
                style: that._core.defaultValue(option.style, 2),
                fillColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.fillColor, '#ffffff')),
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, '#000000')),
                outlineWidth: that._core.defaultValue(option.outlineWidth, 0),
                showBackground: that._core.defaultValue(option.showBackground, false),
                backgroundColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.backgroundColor, 'rgba(42,42,42,0.8)')),
                heightReference: that._core.defaultValue(option.heightReference, 1),
                horizontalOrigin: that._core.defaultValue(option.horizontalOrigin, that._cesium.HorizontalOrigin.CENTER),
                verticalOrigin: that._core.defaultValue(option.verticalOrigin, that._cesium.VerticalOrigin.CENTER),
                scaleByDistance: that._core.defaultValue(option.scaleByDistance, undefined),
                pixelOffset: that._core.defaultValue(option.pixelOffset, undefined),
                disableDepthTestDistance: that._core.defaultValue(option.disableDepthTestDistance, Number.POSITIVE_INFINITY),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        that.SimpleGraphicObj.push(label.id);

        return label;
    };

    /**
     * 创建模型点
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createModel = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let model;
        let mx = Cesium.Matrix3.fromRotationX(
            Cesium.Math.toRadians(that._core.defaultValue(option.heading, 0))
        );
        let my = Cesium.Matrix3.fromRotationY(
            Cesium.Math.toRadians(that._core.defaultValue(option.pitch, 0))
        );
        let mz = Cesium.Matrix3.fromRotationZ(
            Cesium.Math.toRadians(that._core.defaultValue(option.roll, 0))
        );
        let rotationX = Cesium.Matrix4.fromRotationTranslation(mx);
        let rotationY = Cesium.Matrix4.fromRotationTranslation(my);
        let rotationZ = Cesium.Matrix4.fromRotationTranslation(mz);

        this.drawHandler.setInputAction(event => {
            let position = that._getPosition.getMousePosition(event);
            if (position) {
                model && viewer.scene.primitives.remove(model);
                model = viewer.entities.add({
                    id: that._core.getuid(),
                    name: 'Model',
                    position: position,
                    orientation: Cesium.Transforms.headingPitchRollQuaternion(
                        position,
                        new Cesium.HeadingPitchRoll(
                            Cesium.Math.toRadians(that._core.defaultValue(option.heading, 0)),
                            Cesium.Math.toRadians(that._core.defaultValue(option.pitch, 0)),
                            Cesium.Math.toRadians(that._core.defaultValue(option.roll, 0))
                        )
                    ),
                    model: {
                        uri: that._core.defaultValue(option.url, window.SmartEarthRootUrl + configData$1.testModel),
                        scale: that._core.defaultValue(option.scale, 1.0),
                        minimumPixelSize: 0,
                        runAnimations: true,
                        colorBlendMode: that._core.defaultValue(option.colorBlendMode, undefined),
                        color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, '#ffffff')),
                        distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
                    }
                });
                model.heading = that._core.defaultValue(option.heading, 0);
                model.pitch = that._core.defaultValue(option.pitch, 0);
                model.roll = that._core.defaultValue(option.roll, 0);
                that.SimpleGraphicObj.push(model.id);

                that.drawHandler.destroy();
                that.drawHandler = undefined;
                that.tooltip.show(false);
                setTimeout(function () {
                    tree.states = 0;
                }, 100);
                //恢复鼠标样式
                that._core.mouse(that._viewer.container, 0, "0");
                //回调
                callBack && typeof callBack === 'function' && callBack(model);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        let isReadyOver = false;
        this.drawHandler.setInputAction(event => {
            let position = that._getPosition.getMousePosition(event);
            if (!model) {
                if (position) {
                    let modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(position);

                    //旋转、平移矩阵相乘
                    Cesium.Matrix4.multiply(modelMatrix, rotationX, modelMatrix);
                    Cesium.Matrix4.multiply(modelMatrix, rotationY, modelMatrix);
                    Cesium.Matrix4.multiply(modelMatrix, rotationZ, modelMatrix);

                    model = viewer.scene.primitives.add(Cesium.Model.fromGltf({
                        modelMatrix: modelMatrix,
                        url: that._core.defaultValue(option.url, window.SmartEarthRootUrl + configData$1.testModel),
                        scale: that._core.defaultValue(option.scale, 1.0),
                        minimumPixelSize: 0,
                        colorBlendMode: that._core.defaultValue(option.colorBlendMode, undefined),
                        color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, '#ffffff')),
                        distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000)),
                        allowPicking: false, // 禁用拾取
                    }));

                    model.readyPromise.then(() => {
                        isReadyOver = true;
                    });
                }
            } else {
                let modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(position);

                //旋转、平移矩阵相乘
                Cesium.Matrix4.multiply(modelMatrix, rotationX, modelMatrix);
                Cesium.Matrix4.multiply(modelMatrix, rotationY, modelMatrix);
                Cesium.Matrix4.multiply(modelMatrix, rotationZ, modelMatrix);
                model.modelMatrix = modelMatrix;
            }

            if (isReadyOver) {
                that.tooltip.showAt(event.endPosition, "点击绘制模型");
            } else {
                that.tooltip.showAt(event.endPosition, "加载模型中...");
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.drawHandler.setInputAction(event => {
            this.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = () => {
            this.end = undefined;
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");
        };
        return this;
    };

    /**
     * 添加模型点
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addModel = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let model = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, 'Model'),
            position: option.position,
            orientation: Cesium.Transforms.headingPitchRollQuaternion(
                option.position,
                new Cesium.HeadingPitchRoll(
                    Cesium.Math.toRadians(that._core.defaultValue(option.heading, 0)),
                    Cesium.Math.toRadians(that._core.defaultValue(option.pitch, 0)),
                    Cesium.Math.toRadians(that._core.defaultValue(option.roll, 0))
                )
            ),
            model: {
                scale: that._core.defaultValue(option.scale, 1),
                uri: that._core.defaultValue(option.url, window.SmartEarthRootUrl + configData$1.testModel),
                minimumPixelSize: that._core.defaultValue(option.minimumPixelSize, 0),
                runAnimations: that._core.defaultValue(option.runAnimations, true),
                colorBlendMode: that._core.defaultValue(option.colorBlendMode, undefined),
                color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, '#ffffff')),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        model.heading = that._core.defaultValue(option.heading, 0);
        model.pitch = that._core.defaultValue(option.pitch, 0);
        model.roll = that._core.defaultValue(option.roll, 0);
        that.SimpleGraphicObj.push(model.id);

        return model;
    };

    /**
     * 创建线
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createPolyline = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let polyline;
        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (positions.length === 0) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);
            if (option.toPoint && positions.length === 3) {
                positions.pop();
                that.end();
            }

            if (!polyline) {
                polyline = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建线',
                    polyline: {
                        positions: new that._cesium.CallbackProperty(function () {
                            return positions
                        }, false),
                        clampToGround: that._core.defaultValue(option.clampToGround, true),
                        material: new Cesium.PolylineOutlineMaterialProperty({
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)')),
                            outlineWidth: 0,
                            outlineColor: that._cesium.Color.WHITE.withAlpha(0.6)
                        }),
                        depthFailMaterial: option.depthFailColor && new Cesium.PolylineOutlineMaterialProperty({
                            color: that._cesium.Color.fromCssColorString(option.depthFailColor),
                            outlineWidth: 0,
                            outlineColor: that._cesium.Color.WHITE.withAlpha(0.6)
                        }),
                        width: that._core.defaultValue(option.width, 3),
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000)
                    }
                });
                that.SimpleGraphicObj.push(polyline.id);
            }
            if (option.showSize) {
                that.showSizeData("polyline", [positions[positions.length - 2], positions[positions.length - 1]]);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length === 0) {
                that.tooltip.showAt(event.endPosition, "点击开始绘制");
            } else {
                that.tooltip.showAt(event.endPosition, "点击添加点，右键结束绘制");
                let cartesian = that._getPosition.getMousePosition(event);
                if (!cartesian) return;
                positions.pop();
                positions.push(cartesian);

                if (option.showSize) {
                    that.clearLastSizeData();
                    that.showSizeData("polyline", [positions[positions.length - 2], positions[positions.length - 1]]);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.end = function (type) {
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            that.clearAllSizeData();
            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0);

            that.end = undefined;
            if (type === 'cancel') {
                polyline && (viewer.entities.remove(polyline),
                    that.SimpleGraphicObj.pop());
                return;
            }
            //回调
            callBack && typeof callBack === 'function' && callBack(polyline, positions);
        };

        this.drawHandler.setInputAction(event => {
            that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        return this;
    };

    /**
     * 添加线-entity
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addPolyline = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let positions = option.positions;
        let polyline = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, '新建线'),
            polyline: {
                positions: positions,
                clampToGround: that._core.defaultValue(option.clampToGround, true),
                material: new Cesium.PolylineOutlineMaterialProperty({
                    color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)')),
                    outlineWidth: that._core.defaultValue(option.outlineWidth, 0),
                    outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                }),
                depthFailMaterial: option.depthFailColor && new Cesium.PolylineOutlineMaterialProperty({
                    color: that._cesium.Color.fromCssColorString(option.depthFailColor),
                    outlineWidth: 0,
                    outlineColor: that._cesium.Color.WHITE.withAlpha(0.6)
                }),
                width: that._core.defaultValue(option.width, 3),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        that.SimpleGraphicObj.push(polyline.id);

        return polyline;
    };

    /**
     * 添加线-primitive
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addPolylinePrimitive = function (option = {}) {
        let that = this;
        this._viewer;

        let positions = option.positions;

        let geometry;
        if (option.clampToGround) {
            geometry = new that._cesium.GroundPolylineGeometry({
                positions: positions,
                width: that._core.defaultValue(option.width, 3)
            });
        } else {
            let polyline = new Cesium.PolylineGeometry({
                positions: positions,
                width: that._core.defaultValue(option.width, 3)
            });
            geometry = Cesium.PolylineGeometry.createGeometry(polyline);
        }


        let color = that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'));
        let geometryInstance = new Cesium.GeometryInstance({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            geometry: geometry,
            attributes: {
                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(color),
            }
        });

        let Primitive;
        let PolylineColorAppearance = new that._cesium.PolylineColorAppearance({
            flat: true,
            translucent: true,
            faceForward: true,
            closed: true
        });
        if (option.clampToGround) {
            Primitive = new that._cesium.GroundPolylinePrimitive({
                geometryInstances: geometryInstance,
                appearance: PolylineColorAppearance
            });
        } else {
            Primitive = new that._cesium.Primitive({
                geometryInstances: geometryInstance,
                appearance: PolylineColorAppearance,
            });
        }
        this.PrimitiveCollection.add(Primitive);

        return Primitive;
    };

    /**
     * 创建面
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createPolygon = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let polygon, polyline;

        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (positions.length === 0) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);

            if (positions.length === 2 && !polyline) {
                option.clampToGround = that._core.defaultValue(option.clampToGround, true);
                polyline = viewer.entities.add({
                    name: '临时线',
                    polyline: {
                        positions: new that._cesium.CallbackProperty(function () {
                            return positions
                        }, false),
                        clampToGround: that._core.defaultValue(option.clampToGround, true),
                        material: new Cesium.PolylineOutlineMaterialProperty({
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)')),
                            outlineWidth: 0,
                            outlineColor: that._cesium.Color.WHITE.withAlpha(0.6)
                        }),
                        width: 3,
                    }
                });
            }


            if (positions.length === 3 && !polygon) {
                polyline && viewer.entities.remove(polyline);
                polygon = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建面',
                    polygon: {
                        hierarchy: new that._cesium.CallbackProperty(function () {
                            return new that._cesium.PolygonHierarchy(positions);
                        }, false),
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                        }),
                        perPositionHeight: !that._core.defaultValue(option.clampToGround, false),
                        heightReference: option.clampToGround ? 1 : 0,
                        outline: that._core.defaultValue(option.outline, false),
                        outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000)
                    }
                });
                that.SimpleGraphicObj.push(polygon.id);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length === 0) {
                that.tooltip.showAt(event.endPosition, "点击添加第一个点");
            } else if (positions.length === 1) {
                that.tooltip.showAt(event.endPosition, "点击添加第二个点");
                let cartesian = that._getPosition.getMousePosition(event);
                if (!cartesian) return;
                positions.pop();
                positions.push(cartesian);
            } else {
                that.tooltip.showAt(event.endPosition, "点击添加点，右键结束绘制");
                let cartesian = that._getPosition.getMousePosition(event);
                if (!cartesian) return;
                positions.pop();
                positions.push(cartesian);

                if (option.showSize) {
                    that.clearLastSizeData();
                    that.showSizeData("polygon", positions);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.end = function (type) {
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            polyline && viewer.entities.remove(polyline);

            that.clearAllSizeData();
            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");

            that.end = undefined;
            if (type === 'cancel') {
                polygon && (viewer.entities.remove(polygon),
                    that.SimpleGraphicObj.pop());
                return;
            }
            //回调
            callBack && typeof callBack === 'function' && callBack(polygon);
        };

        this.drawHandler.setInputAction(event => {
            that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        return this;
    };

    /**
     * 创建三角形
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createTriangle = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let firstPoint;
        let Triangle;
        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (!firstPoint) {
                firstPoint = cartesian;
                positions = [cartesian, cartesian, cartesian];
            } else {
                positions = createTriangleArr(firstPoint, cartesian);
                this.end();
            }


            if (positions.length && !Triangle) {
                option.clampToGround = that._core.defaultValue(option.clampToGround, true);
                Triangle = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建三角形',
                    polygon: {
                        hierarchy: new that._cesium.CallbackProperty(function () {
                            return new that._cesium.PolygonHierarchy(positions);
                        }, false),
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                        }),
                        perPositionHeight: !that._core.defaultValue(option.clampToGround, false),
                        heightReference: option.clampToGround ? 1 : 0,
                        outline: that._core.defaultValue(option.outline, false),
                        outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000)
                    }
                });
                that.SimpleGraphicObj.push(Triangle.id);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (!firstPoint) {
                that.tooltip.showAt(event.endPosition, "点击开始绘制");
            } else {
                that.tooltip.showAt(event.endPosition, "再次点击结束绘制");
                let cartesian = that._getPosition.getMousePosition(event);
                if (!cartesian) return;
                positions = createTriangleArr(firstPoint, cartesian);
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.end = function (type) {
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0);

            that.end = undefined;
            if (type === 'cancel') {
                Triangle && (viewer.entities.remove(Triangle),
                    that.SimpleGraphicObj.pop());
                return;
            }
            //回调
            callBack && typeof callBack === 'function' && callBack(Triangle);
        };

        this.drawHandler.setInputAction(event => {
            that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);


        //生成等边三角形顶点
        function createTriangleArr(point1, point2) {
            let triangleArr = [];
            //转换经纬度
            let degrees1 = that.toDegrees(point1);
            let degrees2 = that.toDegrees(point2);
            //获取角度和距离
            let data = getDistanceAndAngle(degrees1.lat, degrees1.lon, degrees2.lat, degrees2.lon);
            let angle = data.angle;
            let distance = data.distance;

            //获取另外两个顶点
            triangleArr.push(degrees2.lon, degrees2.lat);
            let p = GetPositionFromA_D(degrees1.lat, degrees1.lon, distance, angle + 120);
            triangleArr.push(p[0], p[1]);
            p = GetPositionFromA_D(degrees1.lat, degrees1.lon, distance, angle - 120);
            triangleArr.push(p[0], p[1]);

            return Cesium.Cartesian3.fromDegreesArray(triangleArr);
        }

        let Ea = 6378137.0;     //   赤道半径
        let Eb = 6356725.0;     //   极半径
        //通过角度和距离获取经纬度
        function GetPositionFromA_D(lat, lon, distance, angle) {
            let dx = distance * Math.sin(angle * Math.PI / 180.0);
            let dy = distance * Math.cos(angle * Math.PI / 180.0);

            let ec = Eb + (Ea - Eb) * (90.0 - lat) / 90.0;
            let ed = ec * Math.cos(lat * Math.PI / 180);

            let newLon = (dx / ed + lon * Math.PI / 180.0) * 180.0 / Math.PI;
            let newLat = (dy / ec + lat * Math.PI / 180.0) * 180.0 / Math.PI;

            return [newLon, newLat];
        }

        //根据两点经纬度测算距离和方位角
        function getDistanceAndAngle(lat1, lng1, lat2, lng2) {
            let radLat1 = getRad(lat1);
            let radLat2 = getRad(lat2);
            let a = getRad(lat2) - getRad(lat1);
            let b = getRad(lng2) - getRad(lng1);

            let distance = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) + Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
            distance = distance * Ea;
            distance = Math.round(distance * 10000) / 10000.0;

            return {
                angle: that._core.TwoPointAzimuth(lng1, lat1, lng2, lat2),
                distance: distance
            };
        }

        function getRad(d) {
            return d * Math.PI / 180.0;
        }
        return this;
    };

    /**
     * 创建面-矩形
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createPolygonRectangle = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let polygon;
        let start, end;
        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (!positions.length) {
                start = event.position;
                positions.push(cartesian.clone(), cartesian.clone(), cartesian.clone(), cartesian.clone());
            } else {
                that.end();
            }


            if (!polygon) {
                option.clampToGround = that._core.defaultValue(option.clampToGround, true);
                polygon = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建面',
                    polygon: {
                        hierarchy: new that._cesium.CallbackProperty(function () {
                            return new that._cesium.PolygonHierarchy(positions);
                        }, false),
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                        }),
                        perPositionHeight: !that._core.defaultValue(option.clampToGround, false),
                        heightReference: option.clampToGround ? 1 : 0,
                        outline: that._core.defaultValue(option.outline, false),
                        outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000)
                    }
                });
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length === 0) {
                that.tooltip.showAt(event.endPosition, "点击开始绘制");
            } else {
                that.tooltip.showAt(event.endPosition, "点击结束绘制");
                start = Viewer.scene.cartesianToCanvasCoordinates(positions[0]);
                end = event.endPosition;
                let p1 = {
                    x: start.x,
                    y: end.y
                };
                let p2 = {
                    x: end.x,
                    y: start.y
                };
                let cartesian = that._getPosition.getMousePosition(p1);
                if (cartesian) positions[1] = cartesian;
                cartesian = that._getPosition.getMousePosition(end);
                if (cartesian) positions[2] = cartesian;
                cartesian = that._getPosition.getMousePosition(p2);
                if (cartesian) positions[3] = cartesian;
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.end = function (type) {
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");

            that.end = undefined;
            if (type === 'cancel') {
                polygon && viewer.entities.remove(polygon);
                return;
            }
            //回调
            callBack && typeof callBack === 'function' && callBack(polygon, start, end);
        };
        return this;
    };

    /**
     * 添加面
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addPolygon = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let positions = option.positions;
        let hierarchy;
        if (option.hierarchy) {
            hierarchy = option.hierarchy;
        } else {
            hierarchy = new that._cesium.PolygonHierarchy(positions);
        }
        option.clampToGround = that._core.defaultValue(option.clampToGround, true);
        let polygon = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, '新建面'),
            polygon: {
                hierarchy: new that._cesium.CallbackProperty(function () {
                    return hierarchy;
                }, false),
                material: new that._cesium.ImageMaterialProperty({
                    image: that._core.defaultValue(option.image, null),
                    repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                    color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                }),
                outline: that._core.defaultValue(option.outline, false),
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                perPositionHeight: !that._core.defaultValue(option.clampToGround, false),
                heightReference: option.clampToGround ? 1 : 0,
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        that.SimpleGraphicObj.push(polygon.id);

        return polygon;
    };

    /**
     * 添加面-primitive
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addPolygonPrimitive = function (option = {}) {
        let that = this;
        this._viewer;

        let positions = option.positions;
        let hierarchy;
        if (option.hierarchy) {
            hierarchy = option.hierarchy;
        } else {
            hierarchy = new that._cesium.PolygonHierarchy(positions);
        }
        let collection;

        let polygon = new that._cesium.PolygonGeometry({
            height: that._core.defaultValue(option.height, undefined),
            extrudedHeight: that._core.defaultValue(option.extrudedHeight, undefined),
            polygonHierarchy: hierarchy,
            vertexFormat: option.water ? Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT : undefined
        });

        let geometry = that._cesium.PolygonGeometry.createGeometry(polygon);
        let color = that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'));
        let geometryInstance1 = new Cesium.GeometryInstance({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            geometry: geometry,
            attributes: !option.water ? {
                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(color),
            } : undefined
        });

        let Primitive;
        if (option.water) {
            Primitive = new Cesium.Primitive({
                geometryInstances: geometryInstance1,
                appearance: new Cesium.EllipsoidSurfaceAppearance({
                    material: new Cesium.Material({
                        fabric: {
                            type: 'Water',
                            uniforms: {
                                baseWaterColor: option.watherColor || Cesium.Color.SKYBLUE.withAlpha(0.6),
                                blendColor: option.watherColor || Cesium.Color.SKYBLUE.withAlpha(0.6),
                                normalMap: option.url,
                                frequency: option.frequency || 1000.0,
                                animationSpeed: option.watherSpeed || 0.01,
                                amplitude: option.amplitude || 10.0
                            }
                        }
                    })
                }),
                show: true
            });
        } else {
            Primitive = new that._cesium.Primitive({
                geometryInstances: geometryInstance1,
                appearance: new that._cesium.PerInstanceColorAppearance({
                    translucent: true,
                    // vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                    // fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                }),
                shadows: option.shadows
            });
            if (option.extrudedHeight) {
                collection = new Cesium.PrimitiveCollection();
                let OutlinePolygon = new Cesium.PolygonOutlineGeometry({
                    height: that._core.defaultValue(option.height, undefined),
                    polygonHierarchy: hierarchy,
                    extrudedHeight: option.extrudedHeight
                });
                let OutlineGeometry = Cesium.PolygonOutlineGeometry.createGeometry(OutlinePolygon);
                let outlineColor = that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)'));
                let geometryInstance2 = new Cesium.GeometryInstance({
                    id: that._core.defaultValue(option.id, that._core.getuid()),
                    geometry: OutlineGeometry,
                    attributes: {
                        color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(outlineColor),
                    }
                });
                let Primitive2 = new that._cesium.Primitive({
                    geometryInstances: geometryInstance2,
                    appearance: new that._cesium.PolylineColorAppearance({
                        flat: true,
                        translucent: true,
                        faceForward: true,
                        closed: true
                    }),
                });
                collection.add(Primitive);
                collection.add(Primitive2);
            }
        }
        !collection && (collection = Primitive);
        this.PrimitiveCollection.add(collection);

        return collection;
    };

    /**
     * 创建矩形
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createRectangle = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let rectangle;
        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (positions.length === 0) {
                positions.push(cartesian, cartesian);
            } else {
                positions.pop();
                positions.push(cartesian);
                that.end();
            }

            if (!rectangle) {
                let degrees = that.toDegrees(positions[0]);
                option.clampToGround = that._core.defaultValue(option.clampToGround, true);

                rectangle = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建矩形',
                    rectangle: {
                        coordinates: new that._cesium.CallbackProperty(function () {
                            return that._cesium.Rectangle.fromCartesianArray(positions);
                        }, false),
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                        }),
                        height: option.clampToGround ? undefined : degrees.height,
                        heightReference: option.clampToGround ? 1 : 0,
                        outline: true,
                        outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 1,
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000)
                    }
                });
                rectangle.thisHeight = degrees.height;
                that.SimpleGraphicObj.push(rectangle.id);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length > 0) {
                that.tooltip.showAt(event.endPosition, "再次点击结束绘制，右键取消");
                let cartesian = that._getPosition.getMousePosition(event);
                if (cartesian) {
                    positions.pop();
                    positions.push(cartesian);

                    if (option.showSize) {
                        that.clearLastSizeData();
                        that.showSizeData("rectangle", positions);
                    }
                }
            } else {
                that.tooltip.showAt(event.endPosition, "点击开始绘制");
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.drawHandler.setInputAction(event => {
            this.end('cancel');
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            this.end = undefined;
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            that.clearAllSizeData();

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");

            if (type === 'cancel') {
                rectangle && (viewer.entities.remove(rectangle),
                    that.SimpleGraphicObj.pop());
                return;
            }

            //回调
            callBack && typeof callBack === 'function' && callBack(rectangle);
        };
        return this;
    };

    /**
     * 添加矩形
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addRectangle = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let positions = option.positions;
        let coordinates;
        if (option.coordinates) {
            coordinates = option.coordinates;
        } else {
            coordinates = that._cesium.Rectangle.fromCartesianArray(positions);
        }
        let rectangle = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, '新建矩形'),
            rectangle: {
                coordinates: new that._cesium.CallbackProperty(function () {
                    return coordinates;
                }, false),
                material: new that._cesium.ImageMaterialProperty({
                    image: that._core.defaultValue(option.image, null),
                    repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                    color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                }),
                height: that._core.defaultValue(option.height, undefined),
                rotation: that._core.defaultValue(option.rotation, 0),
                heightReference: that._core.defaultValue(option.heightReference, 1),
                outline: that._core.defaultValue(option.outline, false),
                outlineWidth: 1,
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        that.SimpleGraphicObj.push(rectangle.id);

        return rectangle;
    };

    /**
     * 创建圆
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createCircle = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let circle, distance = 0;
        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (positions.length === 0) {
                positions.push(cartesian, cartesian);
            } else {
                positions[0] = cartesian;
                distance = that._cesium.Cartesian3.distance(positions[0], positions[1]);

                that.end();
            }

            if (!circle) {
                let degrees = that.toDegrees(positions[1]);
                option.clampToGround = that._core.defaultValue(option.clampToGround, true);

                circle = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建圆',
                    position: positions[1],
                    ellipse: {
                        semiMajorAxis: new that._cesium.CallbackProperty(function () {
                            return distance;
                        }, false),
                        semiMinorAxis: new that._cesium.CallbackProperty(function () {
                            return distance;
                        }, false),
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                        }),
                        height: option.clampToGround ? undefined : degrees.height,
                        heightReference: option.clampToGround ? 1 : 0,
                        outline: true,
                        outlineWidth: 1,
                        outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000)
                    }
                });
                circle.thisHeight = degrees.height;
                that.SimpleGraphicObj.push(circle.id);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length > 0) {
                that.tooltip.showAt(event.endPosition, "再次点击结束绘制，右键取消");
                let cartesian = that._getPosition.getMousePosition(event);
                if (cartesian) {
                    positions[0] = cartesian;
                    distance = that._cesium.Cartesian3.distance(positions[0], positions[1]);

                    if (option.showSize) {
                        that.clearLastSizeData();
                        that.showSizeData("circle", positions[1], distance);
                    }
                }
            } else {
                that.tooltip.showAt(event.endPosition, "点击开始绘制");
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.drawHandler.setInputAction(event => {
            this.end('cancel');
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            this.end = undefined;
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            that.clearAllSizeData();

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");

            if (type === 'cancel') {
                circle && (viewer.entities.remove(circle),
                    that.SimpleGraphicObj.pop());
                return;
            }

            //回调
            callBack && typeof callBack === 'function' && callBack(circle, { distance, positions });
        };
        return this;
    };

    /**
     * 添加圆
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addCircle = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let distance = option.radius;
        let circle = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, '新建圆'),
            position: option.position,
            ellipse: {
                semiMajorAxis: new that._cesium.CallbackProperty(function () {
                    return distance;
                }, false),
                semiMinorAxis: new that._cesium.CallbackProperty(function () {
                    return distance;
                }, false),
                material: new that._cesium.ImageMaterialProperty({
                    image: that._core.defaultValue(option.image, null),
                    repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                    transparent: true,
                    color: that._cesium.Color.fromCssColorString(that._core.defaultValue(
                        option.color,
                        option.image ? '#ffffff' : 'rgba(0,255,0,0.6)')
                    )
                }),
                height: that._core.defaultValue(option.height, undefined),
                heightReference: that._core.defaultValue(option.heightReference, option.height ? 0 : 1),
                outline: that._core.defaultValue(option.outline, false),
                outlineWidth: 1,
                rotation: option.rotation,
                stRotation: option.outline,
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        that.SimpleGraphicObj.push(circle.id);

        return circle;
    };

    /**
     * 创建椭圆
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createEllipse = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let ellipse, distance = 0;
        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (positions.length === 0) {
                positions.push(cartesian, cartesian);
            } else {
                positions[0] = cartesian;
                distance = that._cesium.Cartesian3.distance(positions[0], positions[1]);

                that.end();
            }

            if (!ellipse) {
                let degrees = that.toDegrees(positions[1]);
                option.clampToGround = that._core.defaultValue(option.clampToGround, true);

                ellipse = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建椭圆',
                    position: positions[1],
                    ellipse: {
                        semiMajorAxis: new that._cesium.CallbackProperty(function () {
                            return distance;
                        }, false),
                        semiMinorAxis: new that._cesium.CallbackProperty(function () {
                            return distance / 2;
                        }, false),
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                        }),
                        height: option.clampToGround ? undefined : degrees.height,
                        heightReference: option.clampToGround ? 1 : 0,
                        outline: true,
                        outlineWidth: 1,
                        outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000)
                    }
                });
                ellipse.thisHeight = degrees.height;
                that.SimpleGraphicObj.push(ellipse.id);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length > 0) {
                that.tooltip.showAt(event.endPosition, "再次点击结束绘制，右键取消");
                let cartesian = that._getPosition.getMousePosition(event);
                if (cartesian) {
                    positions[0] = cartesian;
                    distance = that._cesium.Cartesian3.distance(positions[0], positions[1]);
                }
            } else {
                that.tooltip.showAt(event.endPosition, "点击开始绘制");
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.drawHandler.setInputAction(event => {
            this.end('cancel');
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            this.end = undefined;
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            that.clearAllSizeData();

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");

            if (type === 'cancel') {
                ellipse && (viewer.entities.remove(ellipse),
                    that.SimpleGraphicObj.pop());
                return;
            }

            //回调
            callBack && typeof callBack === 'function' && callBack(ellipse);
        };
        return this;
    };

    /**
     * 添加圆
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addEllipse = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let semiMajorAxis = option.semiMajorAxis;
        let semiMinorAxis = option.semiMinorAxis;
        let ellipse = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, '新建圆'),
            position: option.position,
            ellipse: {
                semiMajorAxis: new that._cesium.CallbackProperty(function () {
                    return semiMajorAxis;
                }, false),
                semiMinorAxis: new that._cesium.CallbackProperty(function () {
                    return semiMinorAxis;
                }, false),
                material: new that._cesium.ImageMaterialProperty({
                    image: that._core.defaultValue(option.image, null),
                    repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                    color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                }),
                height: that._core.defaultValue(option.height, undefined),
                heightReference: that._core.defaultValue(option.heightReference, 1),
                outline: that._core.defaultValue(option.outline, false),
                outlineWidth: 1,
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        that.SimpleGraphicObj.push(ellipse.id);

        return ellipse;
    };

    /**
     * 创建立方体
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createBox = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let box, size = [0, 0, 200];
        this.drawHandler.setInputAction(event => {
            let degrees = that._getPosition.getMouseDegrees(event);
            if (!degrees) return;

            if (positions.length === 0) {
                positions.push(degrees, degrees);
            } else {
                degrees.height = positions[0].height;
                positions[1] = degrees;
                let long = that.Cdcl(positions[0].lat, positions[0].lon, positions[0].lat, positions[1].lon);
                let width = that.Cdcl(positions[0].lat, positions[0].lon, positions[1].lat, positions[0].lon);
                let center = {
                    lon: (positions[0].lon + positions[1].lon) / 2,
                    lat: (positions[0].lat + positions[1].lat) / 2
                };
                if (size) {
                    size[0] = long;
                    size[1] = width;
                }
                box.position = Cesium.Cartesian3.fromDegrees(center.lon, center.lat, positions[0].height + size[2] / 2);

                that.end();
            }

            if (!box) {
                box = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建立方体',
                    position: that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                    box: {
                        dimensions: new that._cesium.CallbackProperty(function () {
                            return that._cesium.Cartesian3.fromArray(size);
                        }, false),
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                        }),
                        fill: true,
                        outline: true,
                        outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                        shadows: that._cesium.ShadowMode.ENABLED,
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000)
                    }
                });
                that.SimpleGraphicObj.push(box.id);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length > 0) {
                that.tooltip.showAt(event.endPosition, "再次点击结束绘制，右键取消");
                let degrees = that._getPosition.getMouseDegrees(event);
                if (degrees) {
                    degrees.height = positions[0].height;
                    positions[1] = degrees;
                    let long = that.Cdcl(positions[0].lat, positions[0].lon, positions[0].lat, positions[1].lon);
                    let width = that.Cdcl(positions[0].lat, positions[0].lon, positions[1].lat, positions[0].lon);
                    let center = {
                        lon: (positions[0].lon + positions[1].lon) / 2,
                        lat: (positions[0].lat + positions[1].lat) / 2
                    };
                    if (size) {
                        size[0] = long;
                        size[1] = width;
                    }
                    box.position = Cesium.Cartesian3.fromDegrees(center.lon, center.lat, positions[0].height + size[2] / 2);

                    if (option.showSize) {
                        that.clearLastSizeData();
                        that.showSizeData("box", box.position, size);
                    }
                }
            } else {
                that.tooltip.showAt(event.endPosition, "点击开始绘制");
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.drawHandler.setInputAction(event => {
            this.end('cancel');
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            this.end = undefined;
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            that.clearAllSizeData();

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");

            if (type === 'cancel') {
                box && (viewer.entities.remove(box),
                    that.SimpleGraphicObj.pop());
                return;
            }

            //回调
            callBack && typeof callBack === 'function' && callBack(box);
        };
        return this;
    };

    /**
     * 添加立方体
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addBox = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let dimensions = option.dimensions;
        let box = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, '新建立方体'),
            position: option.position,
            box: {
                dimensions: new that._cesium.CallbackProperty(function () {
                    return dimensions;
                }, false),
                material: new that._cesium.ImageMaterialProperty({
                    image: that._core.defaultValue(option.image, null),
                    repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                    color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                }),
                fill: true,
                outline: that._core.defaultValue(option.outline, true),
                shadows: that._cesium.ShadowMode.ENABLED,
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        that.SimpleGraphicObj.push(box.id);

        return box;
    };

    /**
     * 创建圆柱体
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createCylinder = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let cylinder, distance = 0;
        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (positions.length === 0) {
                positions.push(cartesian, cartesian);
            } else {
                positions[0] = cartesian;
                distance = that._cesium.Cartesian3.distance(positions[0], positions[1]);

                that.end();
            }

            if (!cylinder) {
                let degrees = that.toDegrees(cartesian);
                cylinder = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建圆柱体',
                    position: that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + 100),
                    cylinder: {
                        length: 200,
                        topRadius: new that._cesium.CallbackProperty(function () {
                            return distance;
                        }, false),
                        bottomRadius: new that._cesium.CallbackProperty(function () {
                            return distance;
                        }, false),
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                        }),
                        fill: true,
                        shadows: that._cesium.ShadowMode.ENABLED,
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000),
                        outline: true,
                        outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)'))
                    }
                });
                cylinder.changeTop = true;
                that.SimpleGraphicObj.push(cylinder.id);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length > 0) {
                that.tooltip.showAt(event.endPosition, "再次点击结束绘制，右键取消");
                let cartesian = that._getPosition.getMousePosition(event);
                if (cartesian) {
                    positions[0] = cartesian;
                    distance = that._cesium.Cartesian3.distance(positions[0], positions[1]);

                    if (option.showSize) {
                        that.clearLastSizeData();
                        that.showSizeData("cylinder", positions[1], distance, 200);
                    }
                }
            } else {
                that.tooltip.showAt(event.endPosition, "点击开始绘制");
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.drawHandler.setInputAction(event => {
            this.end('cancel');
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            this.end = undefined;
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            that.clearAllSizeData();

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");

            if (type === 'cancel') {
                cylinder && (viewer.entities.remove(cylinder),
                    that.SimpleGraphicObj.pop());
                return;
            }

            //回调
            callBack && typeof callBack === 'function' && callBack(cylinder);
        };
        return this;
    };

    /**
     * 添加圆柱体
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addCylinder = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let distance = option.radius;
        let cylinder = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, '新建圆柱体'),
            position: option.position,
            cylinder: {
                length: that._core.defaultValue(option.length, 200),
                topRadius: new that._cesium.CallbackProperty(function () {
                    return distance;
                }, false),
                bottomRadius: new that._cesium.CallbackProperty(function () {
                    return distance;
                }, false),
                material: new that._cesium.ImageMaterialProperty({
                    image: that._core.defaultValue(option.image, null),
                    repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                    color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                }),
                fill: true,
                outline: that._core.defaultValue(option.outline, true),
                shadows: that._cesium.ShadowMode.ENABLED,
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        cylinder.changeTop = true;
        that.SimpleGraphicObj.push(cylinder.id);

        return cylinder;
    };

    /**
     * 创建圆锥体
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createCone = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let cone, distance = 0;
        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (positions.length === 0) {
                positions.push(cartesian, cartesian);
            } else {
                positions[0] = cartesian;
                distance = that._cesium.Cartesian3.distance(positions[0], positions[1]);

                that.end();
            }

            if (!cone) {
                let degrees = that.toDegrees(cartesian);
                cone = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建圆锥体',
                    position: that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + 100),
                    cylinder: {
                        length: 200,
                        topRadius: 0,
                        bottomRadius: new that._cesium.CallbackProperty(function () {
                            return distance;
                        }, false),
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                        }),
                        fill: true,
                        shadows: that._cesium.ShadowMode.ENABLED,
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000),
                        outline: true,
                        outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)'))
                    }
                });
                cone.changeTop = false;
                that.SimpleGraphicObj.push(cone.id);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length > 0) {
                that.tooltip.showAt(event.endPosition, "再次点击结束绘制，右键取消");
                let cartesian = that._getPosition.getMousePosition(event);
                if (cartesian) {
                    positions[0] = cartesian;
                    distance = that._cesium.Cartesian3.distance(positions[0], positions[1]);

                    if (option.showSize) {
                        that.clearLastSizeData();
                        that.showSizeData("cone", positions[1], distance, 200);
                    }
                }
            } else {
                that.tooltip.showAt(event.endPosition, "点击开始绘制");
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.drawHandler.setInputAction(event => {
            this.end('cancel');
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            this.end = undefined;
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            that.clearAllSizeData();

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");

            if (type === 'cancel') {
                cone && (viewer.entities.remove(cone),
                    that.SimpleGraphicObj.pop());
                return;
            }

            //回调
            callBack && typeof callBack === 'function' && callBack(cone);
        };
        return this;
    };

    /**
     * 添加圆锥体
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addCone = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let bottomRadius = option.bottomRadius;
        let cone = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, '新建圆锥体'),
            position: option.position,
            cylinder: {
                length: that._core.defaultValue(option.length, 200),
                topRadius: that._core.defaultValue(option.topRadius, 0),
                bottomRadius: new that._cesium.CallbackProperty(function () {
                    return bottomRadius;
                }, false),
                material: new that._cesium.ImageMaterialProperty({
                    image: that._core.defaultValue(option.image, null),
                    repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                    color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                }),
                fill: true,
                outline: that._core.defaultValue(option.outline, true),
                shadows: that._cesium.ShadowMode.ENABLED,
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        cone.changeTop = false;
        that.SimpleGraphicObj.push(cone.id);

        return cone;
    };

    /**
     * 创建球体
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createSphere = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let Sphere, distance = 0;
        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (positions.length === 0) {
                positions.push(cartesian, cartesian);
            } else {
                positions[0] = cartesian;
                distance = that._cesium.Cartesian3.distance(positions[0], positions[1]);

                that.end();
            }

            if (!Sphere) {
                Sphere = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建球体',
                    position: cartesian.clone(),
                    ellipsoid: {
                        radii: new that._cesium.CallbackProperty(function () {
                            return new Cesium.Cartesian3(distance, distance, distance);
                        }, false),
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                        }),
                        fill: true,
                        shadows: that._cesium.ShadowMode.ENABLED,
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000),
                        outline: true,
                        outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)'))
                    }
                });
                Sphere.isSphere = true; //球体，编辑只能更改半径
                that.SimpleGraphicObj.push(Sphere.id);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length > 0) {
                that.tooltip.showAt(event.endPosition, "再次点击结束绘制，右键取消");
                let cartesian = that._getPosition.getMousePosition(event);
                if (cartesian) {
                    positions[0] = cartesian;
                    distance = that._cesium.Cartesian3.distance(positions[0], positions[1]);

                    if (option.showSize) {
                        that.clearLastSizeData();
                        that.showSizeData("sphere", positions[1], distance);
                    }
                }
            } else {
                that.tooltip.showAt(event.endPosition, "点击开始绘制");
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.drawHandler.setInputAction(event => {
            this.end('cancel');
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            this.end = undefined;
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            that.clearAllSizeData();

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");

            if (type === 'cancel') {
                Sphere && (viewer.entities.remove(Sphere),
                    that.SimpleGraphicObj.pop());
                return;
            }

            let point0 = that.toDegrees(positions[0]);
            let point1 = that.toDegrees(positions[1]);
            point0.height = point1.height;
            positions[0] = Cesium.Cartesian3.fromDegrees(point0.lon, point0.lat, point0.height);

            //回调
            callBack && typeof callBack === 'function' && callBack(Sphere);
        };
        return this;
    };

    /**
     * 添加球体
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addSphere = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let distance = option.radius;
        let radii;
        if (option.radii) {
            radii = option.radii;
        } else {
            radii = new Cesium.Cartesian3(distance, distance, distance);
        }
        let Sphere = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, '新建球体'),
            position: option.position,
            ellipsoid: {
                radii: new that._cesium.CallbackProperty(function () {
                    return radii;
                }, false),
                material: new that._cesium.ImageMaterialProperty({
                    image: that._core.defaultValue(option.image, null),
                    repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                    color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                }),
                fill: true,
                outline: that._core.defaultValue(option.outline, true),
                shadows: that._cesium.ShadowMode.ENABLED,
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        Sphere.isSphere = true; //球体，编辑只能更改半径
        that.SimpleGraphicObj.push(Sphere.id);

        return Sphere;
    };

    /**
     * 创建多边体
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SimpleGraphic.prototype.createPolyhedron = function (option = {}, callBack) {
        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        let Polyhedron;
        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (positions.length === 1) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);

            if (positions.length === 3 && !Polyhedron) {
                let degrees = that.toDegrees(positions[0]);
                Polyhedron = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建多边体',
                    polygon: {
                        hierarchy: new that._cesium.CallbackProperty(function () {
                            return new that._cesium.PolygonHierarchy(positions);
                        }, false),
                        extrudedHeight: degrees.height + 200,
                        height: degrees.height,
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                        }),
                        fill: true,
                        shadows: that._cesium.ShadowMode.ENABLED,
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000),
                        outline: true,
                        outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)'))
                    }
                });
                that.SimpleGraphicObj.push(Polyhedron.id);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length === 0) {
                that.tooltip.showAt(event.endPosition, "点击添加第一个点");
            } else if (positions.length === 1) {
                that.tooltip.showAt(event.endPosition, "点击添加第二个点");
            } else {
                that.tooltip.showAt(event.endPosition, "点击添加点，右键结束绘制");
                let cartesian = that._getPosition.getMousePosition(event);
                if (!cartesian) return;
                positions.pop();
                positions.push(cartesian);

                if (option.showSize) {
                    that.clearLastSizeData();
                    that.showSizeData("polyhedron", positions, 0, 200);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.end = function (type) {
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            that.clearAllSizeData();

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");

            that.end = undefined;
            if (type === 'cancel') {
                Polyhedron && (viewer.entities.remove(Polyhedron),
                    that.SimpleGraphicObj.pop());
                return;
            }
            //回调
            callBack && typeof callBack === 'function' && callBack(Polyhedron);
        };

        this.drawHandler.setInputAction(event => {
            that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        return this;
    };

    /**
     * 添加多边体
     * 
     * @param {Object} [option] 参数
     */
    SimpleGraphic.prototype.addPolyhedron = function (option = {}) {
        let that = this;
        let viewer = this._viewer;

        let positions = option.positions;
        let height = that._core.defaultValue(option.height, 0);
        let hierarchy;
        if (option.hierarchy) {
            hierarchy = option.hierarchy;
        } else {
            hierarchy = new that._cesium.PolygonHierarchy(positions);
        }
        let Polyhedron = viewer.entities.add({
            id: that._core.defaultValue(option.id, that._core.getuid()),
            name: that._core.defaultValue(option.name, '新建多边体'),
            polygon: {
                hierarchy: new that._cesium.CallbackProperty(function () {
                    return hierarchy;
                }, false),
                extrudedHeight: that._core.defaultValue(option.extrudedHeight, height + 200),
                height: height,
                material: new that._cesium.ImageMaterialProperty({
                    image: that._core.defaultValue(option.image, null),
                    repeat: that._core.defaultValue(option.repeat, new that._cesium.Cartesian2(1, 1)),
                    color: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(0,255,0,0.6)'))
                }),
                shadows: that._cesium.ShadowMode.ENABLED,
                fill: true,
                outline: that._core.defaultValue(option.outline, true),
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,255,255,0.6)')),
                distanceDisplayCondition: that._core.defaultValue(option.distanceDisplayCondition, new that._cesium.DistanceDisplayCondition(0, 100000000))
            }
        });
        that.SimpleGraphicObj.push(Polyhedron.id);

        return Polyhedron;
    };

    /**
    * 
    * 世界坐标转经纬度
    * 
    */
    SimpleGraphic.prototype.toDegrees = function (cartesian) {
        let cartographic = this._cesium.Cartographic.fromCartesian(cartesian);
        return {
            lon: this._cesium.Math.toDegrees(cartographic.longitude),
            lat: this._cesium.Math.toDegrees(cartographic.latitude),
            height: cartographic.height
        };
    };

    /**
    * 
    * 显示图形大小信息（面积体积）
    * 
    */
    SimpleGraphic.prototype.showSizeData = function (type, positions, radius, height) {
        let labelText = '';
        let position;
        switch (type) {
            case 'polyline':
                let distance = Cesium.Cartesian3.distance(positions[0], positions[1]);
                if (distance >= 1000) {
                    distance /= 1000;
                    labelText = distance.toFixed(2) + '千米';
                } else {
                    labelText = distance.toFixed(2) + '米';
                }
                position = Cesium.Cartesian3.midpoint(positions[0], positions[1], new Cesium.Cartesian3());
                break;
            case 'polygon':
                var degreesArr = [];
                position = new Cesium.Cartesian3();
                positions.forEach(item => {
                    position = Cesium.Cartesian3.add(item, position, new Cesium.Cartesian3());
                    degreesArr.push(this.toDegrees(item));
                });

                position = Cesium.Cartesian3.divideByScalar(position, positions.length, new Cesium.Cartesian3());
                labelText = this._core.getArea(degreesArr, positions, Cesium);
                break;
            case 'rectangle':
                let p1 = this.toDegrees(positions[0]);
                let p2 = this.toDegrees(positions[1]);
                let long = Cesium.Cartesian3.distance(positions[0], Cesium.Cartesian3.fromDegrees(p1.lon, p2.lat, p1.height));
                let width = Cesium.Cartesian3.distance(positions[1], Cesium.Cartesian3.fromDegrees(p1.lon, p2.lat, p1.height));

                var area = long * width;
                if (area >= 1000000) {
                    area /= 1000000;
                    labelText = area.toFixed(2) + '平方千米';
                } else {
                    labelText = area.toFixed(2) + '平方米';
                }
                position = Cesium.Cartesian3.midpoint(positions[0], positions[1], new Cesium.Cartesian3());
                break;
            case 'circle':
                position = positions;
                // var area = Math.PI * radius * radius;
                // if (area >= 1000000) {
                //     area /= 1000000;
                //     labelText = area.toFixed(2) + '平方千米';
                // } else {
                //     labelText = area.toFixed(2) + '平方米';
                // }
                if (radius >= 1000) {
                    radius /= 1000;
                    labelText = '半径：' + radius.toFixed(2) + '千米';
                } else {
                    labelText = '半径：' + radius.toFixed(2) + '米';
                }
                break;
            case 'box':
                let boxSize = [];
                if (radius[0] < radius[1]) {
                    boxSize.push(radius[1]);
                    boxSize.push(radius[0]);
                } else {
                    boxSize.push(radius[0]);
                    boxSize.push(radius[1]);
                }
                boxSize.push(radius[2]);

                let size = ['长：', '\n宽：', '\n高：'];
                boxSize.forEach((item, index) => {
                    if (item >= 1000) {
                        item /= 1000;
                        labelText += size[index] + item.toFixed(2) + '千米';
                    } else {
                        labelText += size[index] + item.toFixed(2) + '米';
                    }
                });

                position = positions;
                break;
            case 'cylinder':
                position = positions;
                // var data = Math.PI * radius * radius * height;
                // if (data >= 1000000000) {
                //     data /= 1000000000;
                //     labelText = data.toFixed(2) + '立方千米';
                // } else {
                //     labelText = data.toFixed(2) + '立方米';
                // }
                if (radius >= 1000) {
                    radius /= 1000;
                    labelText = '半径：' + radius.toFixed(2) + '千米\n';
                } else {
                    labelText = '半径：' + radius.toFixed(2) + '米\n';
                }
                if (height >= 1000) {
                    height /= 1000;
                    labelText += '高度：' + height.toFixed(2) + '千米';
                } else {
                    labelText += '高度：' + height.toFixed(2) + '米';
                }
                break;
            case 'cone':
                position = positions;
                // var data = Math.PI * radius * radius * height / 3;
                // if (data >= 1000000000) {
                //     data /= 1000000000;
                //     labelText = data.toFixed(2) + '立方千米';
                // } else {
                //     labelText = data.toFixed(2) + '立方米';
                // }
                if (radius >= 1000) {
                    radius /= 1000;
                    labelText = '半径：' + radius.toFixed(2) + '千米\n';
                } else {
                    labelText = '半径：' + radius.toFixed(2) + '米\n';
                }
                if (height >= 1000) {
                    height /= 1000;
                    labelText += '高度：' + height.toFixed(2) + '千米';
                } else {
                    labelText += '高度：' + height.toFixed(2) + '米';
                }
                break;
            case 'sphere':
                position = positions;
                // var data = Math.PI * radius * radius * radius * 4 / 3;
                // if (data >= 1000000000) {
                //     data /= 1000000000;
                //     labelText = data.toFixed(2) + '立方千米';
                // } else {
                //     labelText = data.toFixed(2) + '立方米';
                // }
                if (radius >= 1000) {
                    radius /= 1000;
                    labelText = '半径：' + radius.toFixed(2) + '千米';
                } else {
                    labelText = '半径：' + radius.toFixed(2) + '米';
                }
                break;
            case 'polyhedron':
                var degreesArr = [];
                position = new Cesium.Cartesian3();
                positions.forEach(item => {
                    position = Cesium.Cartesian3.add(item, position, new Cesium.Cartesian3());
                    degreesArr.push(this.toDegrees(item));
                });

                position = Cesium.Cartesian3.divideByScalar(position, positions.length, new Cesium.Cartesian3());

                if (height >= 1000) {
                    height /= 1000;
                    labelText = '高度：' + height.toFixed(2) + '千米';
                } else {
                    labelText = '高度：' + height.toFixed(2) + '米';
                }

                labelText += '\n面积：' + this._core.getArea(degreesArr, positions, Cesium);
                break;
        }
        let label = this._viewer.entities.add({
            position: position,
            label: {
                text: labelText,
                font: '16px 宋体',
                fillColor: Cesium.Color.GOLD,
                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                showBackground: true,
                disableDepthTestDistance: Number.POSITIVE_INFINITY,
            }
        });
        this.SizeData.push(label.id);
    };

    /**
    * 
    * 清除最后一个图形大小信息（面积体积）
    * 
    */
    SimpleGraphic.prototype.clearLastSizeData = function () {
        if (this.SizeData.length) {
            let id = this.SizeData.pop();
            this._viewer.entities.removeById(id);
        }
    };

    /**
    * 
    * 清除所有图形大小信息（面积体积）
    * 
    */
    SimpleGraphic.prototype.clearAllSizeData = function () {
        this.SizeData.forEach(id => {
            this._viewer.entities.removeById(id);
        });
        this.SizeData = [];
    };


    /**
     * 
    * 根据经纬度求距离
    * 
    */
    SimpleGraphic.prototype.Cdcl = function (lat1, lng1, lat2, lng2) {
        let cdcl = 0.0;
        let EARTH_RADIUS = 6378137.0;    //单位M
        let PI = Math.PI;

        function getRad(d) {
            return d * PI / 180.0;
        }
        let f = getRad((lat1 + lat2) / 2);
        let g = getRad((lat1 - lat2) / 2);
        let l = getRad((lng1 - lng2) / 2);

        let sg = Math.sin(g);
        let sl = Math.sin(l);
        let sf = Math.sin(f);

        let s, c, w, r, d, h1, h2;
        let a = EARTH_RADIUS;
        let fl = 1 / 298.257;

        sg = sg * sg;
        sl = sl * sl;
        sf = sf * sf;

        s = sg * (1 - sl) + (1 - sf) * sl;
        c = (1 - sg) * (1 - sl) + sf * sl;

        w = Math.atan(Math.sqrt(s / c));
        r = Math.sqrt(s * c) / w;
        d = 2 * w * a;
        h1 = (3 * r - 1) / 2 / c;
        h2 = (3 * r + 1) / 2 / s;
        cdcl = d * (1 + fl * (h1 * sf * (1 - sg) - h2 * (1 - sf) * sg));
        return cdcl;
    };

    /**
    * 设置编辑状态编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    SimpleGraphic.prototype.setEdit = function (open, option = {}) {
        open === undefined && (open = true);
        !option && (option = {});
        this.editOption = option;
        this.openEdit = open;
    };
    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    SimpleGraphic.prototype.edit = function (open, option = {}) {
        let that = this;
        let viewer = this._viewer;
        !option && (option = {});
        //是否开启属性弹框
        option.editProp !== undefined && (this.editProp = option.editProp);

        if (this.editHandler) {
            this.editHandler.destroy();
            this.editHandler = undefined;
        }
        open === undefined && (open = true);
        if (!open) {
            endThisEdit();
            return;
        }


        // 创建监听的handler
        this.editHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        //当前编辑的实体对象、当前的编辑点、当前的编辑点位置和当前编辑类型
        var geo, currentPoint, currentPointpos, type;
        // 判断是否处于编辑状态
        this.isEditting = false;
        //移动点（拖拽可移动当前图形）和选中编辑点的类型
        let pointType;

        // 对鼠标按下事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            if (tree.editVector) return;
            // 获取屏幕坐标
            let windowPosition = event.position;
            // 通过屏幕坐标获取当前位置的实体
            let pickedObject = viewer.scene.pick(windowPosition);
            if (that._cesium.defined(pickedObject) && pickedObject.id instanceof Cesium.Entity) {
                // 获取当前点的实体
                let entity = pickedObject.id;
                if (!that.isEditting && tree.states == 0) {
                    if (that.SimpleGraphicObj.indexOf(entity.id) === -1) {
                        return;
                    }
                    geo = entity;
                    if (geo.GeoType === undefined) {
                        let entityData = that.getEntityTypeAndObject(geo);
                        geo.GeoType = entityData.type;
                    }
                    type = geo.GeoType;

                    //获取简单图形数据
                    that.getSimpleGraphicData(type, geo);

                    if (type === 'point' || type === 'billboard' || type === 'label' || type === 'model') {
                        // 设置编辑状态为true 
                        that.isEditting = true;
                        if (type === 'model') {
                            that._ModelEdit.start(geo);
                        } else {
                            that.tooltip.showAt(event.position, '拖拽修改位置');
                        }
                    } else {
                        // 设置编辑状态为true 
                        that.isEditting = true;
                        SmartEarthPopupData.editGraphic.updataEditPoint();
                    }

                    if (this.editProp) {
                        !option.editPropData && (option.editPropData = {});
                        that._popupmessage.createPopupProp('属性编辑', {
                            width: option.editPropData.width || 360,
                            height: option.editPropData.height || '90%',
                            url: 'Workers/prop/jdtx_prop.html',
                            shade: option.editPropData.shade,
                            offset: option.editPropData.offset,
                            type: type,
                            fn: {
                                success: function (layero, index) {
                                    option.editPropData.success && option.editPropData.success(layero, index);
                                    SmartEarthPopupData.layerIndex = index;
                                    SmartEarthPopupData.window = layero.find('iframe')[0].contentWindow;
                                },
                                end: function () {
                                    option.editPropData.end && option.editPropData.end();
                                    endThisEdit();
                                    SmartEarthPopupData.layerIndex = undefined;
                                    SmartEarthPopupData.window = undefined;
                                }
                            }
                        });
                    }

                } else if ((entity == geo && (entity.GeoType === 'point' || entity.GeoType === 'billboard' || entity.GeoType === 'label')) ||
                    entity.name == "height_point" || entity.name == "edit_point" || entity.name == "move_point" || entity.name == "add_point" || entity.name == "size_point") {
                    viewer.container.style.cursor = 'crosshair';
                    // 禁止地球旋转和缩放，地球的旋转会对鼠标移动监听有影响，所以需要禁止
                    that.defaultEvent(false);
                    if (entity.name == "height_point") {
                        //获取当前高度点位置
                        currentPointpos = {
                            windowPosition: windowPosition,
                            originHeight: that._cesium.Cartographic.fromCartesian(entity.position.getValue()).height
                        };
                        pointType = "height_point";
                    } else if (entity.name == "move_point") {
                        pointType = "move_point";
                    } else if (entity.GeoType === 'point' || entity.GeoType === 'billboard' || entity.GeoType === 'label') {
                        that.tooltip.showAt(event.position, '释放后完成修改');
                        pointType = "move_point";
                    } else if (entity.name == "edit_point") {
                        pointType = "edit_point";
                    } else if (entity.name == "add_point") {
                        pointType = "add_point";
                    } else if (entity.name == "size_point") {
                        pointType = "size_point";
                    }
                    // 如果实体为编辑点，那么设置当前编辑点为该点
                    currentPoint = entity;
                } else {
                    if (geo && entity.id === geo.id) {
                        return;
                    }
                    endThisEdit();
                }
            } else {
                if (pickedObject && pickedObject.id === 'modeEditAxis') return
                endThisEdit();
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);

        //// 对鼠标移动事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            if (tree.editVector) return;
            let pickedObject = viewer.scene.pick(event.endPosition);
            if (that._cesium.defined(pickedObject)) {
                if (that.isEditting && !currentPoint) {
                    //兼容地下模式
                    if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                        that.isEditting && (endThisEdit(), that.defaultEvent(false));
                        return;
                    }
                    if ((type === 'point' || type === 'billboard' || type === 'label' || type === 'model') && pickedObject.id == geo) {
                        //点类
                        that.tooltip.showAt(event.endPosition, type === 'model' ? '右键删除' : '拖拽修改位置，右键删除');
                    } else if (pickedObject.id && pickedObject.id.name === "edit_point" && geo.pottingPoint) {
                        //编辑节点
                        if (type === 'polyline' && geo.pottingPoint.length > 2) {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置，右键删除点');
                        } else if (type === 'polygon' && geo.pottingPoint.length > 3) {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置，右键删除点');
                        } else {
                            that.tooltip.showAt(event.endPosition, '拖拽修改位置');
                        }
                    } else if (pickedObject.id && (pickedObject.id.name === "move_point" || pickedObject.id.name === "size_point")) {
                        that.tooltip.showAt(event.endPosition, '拖拽修改位置');
                    } else if (pickedObject.id && pickedObject.id.name === "add_point") {
                        that.tooltip.showAt(event.endPosition, '拖拽增加节点');
                    } else if (pickedObject.id && pickedObject.id.name === "height_point") {
                        that.tooltip.showAt(event.endPosition, '拖拽修改高度');
                    } else if (pickedObject.id == geo || pickedObject.id === 'modeEditAxis') {
                        that.tooltip.show(false);
                    }
                } else if (!that.isEditting && tree.states === 0) {
                    if (pickedObject.id && that.SimpleGraphicObj.indexOf(pickedObject.id.id) > -1) {
                        that.tooltip.showAt(event.endPosition, '点击激活编辑，右键删除');
                    } else {
                        that.tooltip.show(false);
                    }
                }
            } else if (tree.states == 0 && !currentPoint) {
                that.tooltip.show(false);
            }

            // 如果处于编辑状态且编辑点已定义，那么开始拖拽编辑
            if (that.isEditting && currentPoint) {
                that.tooltip.showAt(event.endPosition, '释放后完成修改');
                let cartesian = that._getPosition.getMousePosition(event);
                //拉伸节点不需要获取当前位置坐标
                if (!cartesian && pointType !== "height_point") {
                    return;
                }            ///地面上点
                if (pointType === "edit_point") {
                    // 更新编辑点的位置
                    currentPoint.position = cartesian;
                    let pointIndex = tree.editPointID.edit.indexOf(currentPoint.id);

                    //修改对应坐标数据
                    if (geo[type].height !== undefined) {
                        let degrees = that.toDegrees(cartesian);
                        geo.pottingPoint[pointIndex] = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, geo[type].height.getValue());
                        currentPoint.position = geo.pottingPoint[pointIndex];
                    } else {
                        geo.pottingPoint[pointIndex] = cartesian;
                    }

                    //修改对应的拉伸节点
                    if (tree.editPointID.height.length > 0) {
                        let thisHeightPoint = viewer.entities.getById(tree.editPointID.height[pointIndex]);
                        if (thisHeightPoint) {
                            let degrees = that.toDegrees(cartesian);
                            //修改拉伸节点位置
                            let expiontcart = that._cesium.Cartographic.fromCartesian(thisHeightPoint.position.getValue());
                            thisHeightPoint.position = that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, expiontcart.height);
                        }
                    }

                    //修改边上的新增节点
                    if (tree.editPointID.add.length > 0) {
                        //上一个新增节点
                        if (pointIndex > 0) {
                            let thisAddPoint1 = viewer.entities.getById(tree.editPointID.add[pointIndex - 1]);
                            if (thisAddPoint1) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[pointIndex - 1]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                                thisAddPoint1.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                        //下一个新增节点
                        if (pointIndex < geo.pottingPoint.length - 1) {
                            let thisAddPoint2 = viewer.entities.getById(tree.editPointID.add[pointIndex]);
                            if (thisAddPoint2) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[pointIndex + 1]);
                                thisAddPoint2.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                        //面的起点和终点之间的节点
                        if (type === 'polygon' && (pointIndex === 0 || pointIndex === geo.pottingPoint.length - 1)) {
                            let thisAddPoint3 = viewer.entities.getById(tree.editPointID.add[tree.editPointID.add.length - 1]);
                            if (thisAddPoint3) {
                                let point1 = viewer.entities.getById(tree.editPointID.edit[0]);
                                let point2 = viewer.entities.getById(tree.editPointID.edit[geo.pottingPoint.length - 1]);
                                thisAddPoint3.position = Cesium.Cartesian3.midpoint(point1.position.getValue(), point2.position.getValue(), new Cesium.Cartesian3());
                            }
                        }
                    }

                    let positions = geo.pottingPoint.concat([]);
                    //修改移动节点位置
                    let _center = new that._cesium.Cartesian3();
                    let pointLength = positions.length;
                    positions.forEach(item => {
                        _center.x += item.x;
                        _center.y += item.y;
                        _center.z += item.z;
                    });
                    _center.x /= pointLength;
                    _center.y /= pointLength;
                    _center.z /= pointLength;
                    tree.editPointID.move && (tree.editPointID.move.position = _center);

                    //修改实体对象坐标
                    if (type === 'polyline' || type === 'polygon' || type === 'rectangle') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    }
                } else if (pointType === "height_point") {////拉伸高度点
                    let pointIndex = tree.editPointID.height.indexOf(currentPoint.id);
                    let e_point = viewer.entities.getById(tree.editPointID.edit[pointIndex]);
                    if (type === 'ellipse' || type === 'cylinder' || type === 'box') {
                        //圆和圆柱、圆锥、立方体没有对应的编辑节点，对应移动节点
                        e_point = tree.editPointID.move;
                    }
                    let e_degrees = that.toDegrees(e_point.position.getValue());
                    let originHeight = currentPointpos.originHeight - e_degrees.height;
                    let e_winPosition = viewer.scene.cartesianToCanvasCoordinates(e_point.position.getValue());

                    //移动后高度变化
                    let _height = (currentPointpos.windowPosition.y - event.endPosition.y) * originHeight / Math.abs(e_winPosition.y - currentPointpos.windowPosition.y);

                    let h = Math.abs(originHeight + _height);
                    tree.editPointID.height.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            let e_p = e.position.getValue();
                            let e_d = that.toDegrees(e_p);
                            e.position = that._cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, h + e_degrees.height);
                        }
                    });

                    if (geo[type].extrudedHeight) {
                        geo[type].extrudedHeight = new that._cesium.CallbackProperty(function () {
                            return h + e_degrees.height;
                        }, false);
                    } else if (type === 'box') {
                        SmartEarthPopupData.editGraphic.setValue('height', h);
                    } else if (type === 'cylinder') {
                        SmartEarthPopupData.editGraphic.setValue('length', h);
                    }

                    if (SmartEarthPopupData.window) {
                        SmartEarthPopupData.window.document.querySelector('.ExtrudedPolygon input[name="extrudedHeight"]') && (SmartEarthPopupData.window.document.querySelector('.ExtrudedPolygon input[name="extrudedHeight"]').value = parseFloat(h).toFixed(2));
                        SmartEarthPopupData.window.document.querySelector('.box input[name="height"]') && (SmartEarthPopupData.window.document.querySelector('.box input[name="height"]').value = parseFloat(h).toFixed(2));
                        SmartEarthPopupData.window.document.querySelector('.cylinder input[name="height"]') && (SmartEarthPopupData.window.document.querySelector('.cylinder input[name="height"]').value = parseFloat(h).toFixed(2));
                        SmartEarthPopupData.window.document.querySelector('.cone input[name="height"]') && (SmartEarthPopupData.window.document.querySelector('.cone input[name="height"]').value = parseFloat(h).toFixed(2));
                    }
                } else if (pointType === "add_point") {////新增节点
                    let addIndex = tree.editPointID.add.indexOf(currentPoint.id);
                    //移除旧新增节点
                    viewer.entities.remove(currentPoint);
                    //添加新的编辑节点
                    let new_edit_point = viewer.entities.add({
                        name: "edit_point",
                        position: cartesian,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    tree.editPointID.edit.splice(addIndex + 1, 0, new_edit_point.id);
                    geo.pottingPoint.splice(addIndex + 1, 0, cartesian.clone());

                    //添加新的拉伸节点
                    if (tree.editPointID.height.length > 0) {
                        //拉伸节点
                        let degrees = that.toDegrees(cartesian);
                        degrees.height = geo[type].extrudedHeight.getValue();

                        let new_heightpoint = viewer.entities.add({
                            name: "height_point",
                            position: that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                            point: {
                                color: that._cesium.Color.YELLOW,
                                pixelSize: 12,
                                outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                                outlineWidth: 2,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            }
                        });
                        tree.editPointID.height.splice(addIndex + 1, 0, new_heightpoint.id);
                    }

                    //添加两个新的新增节点
                    let add_position1 = Cesium.Cartesian3.midpoint(geo.pottingPoint[addIndex], geo.pottingPoint[addIndex + 1], new Cesium.Cartesian3());
                    //添加节点1
                    let add_point1 = viewer.entities.add({
                        name: "add_point",
                        position: add_position1,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    let add_position2 = Cesium.Cartesian3.midpoint(geo.pottingPoint[addIndex + 1], geo.pottingPoint[addIndex + 2 === geo.pottingPoint.length ? 0 : addIndex + 2], new Cesium.Cartesian3());
                    //添加节点2
                    let add_point2 = viewer.entities.add({
                        name: "add_point",
                        position: add_position2,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    tree.editPointID.add.splice(addIndex, 1, add_point1.id, add_point2.id);

                    //转为编辑节点状态
                    currentPoint = new_edit_point;
                    pointType = 'edit_point';

                    //修改实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'polygon') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    }
                } else if (pointType === "size_point") {    //大小节点
                    let center = tree.editPointID.move.position.getValue();
                    let distance = that._cesium.Cartesian3.distance(center, cartesian);

                    //修改实体对象坐标
                    if (type === 'ellipse' || type === 'cylinder' || (type === 'ellipsoid' && geo.isSphere)) {
                        SmartEarthPopupData.editGraphic.setValue('radius', distance);
                        if (SmartEarthPopupData.window) {
                            SmartEarthPopupData.window.document.querySelector('.' + type + ' input[name="radius"]') && (SmartEarthPopupData.window.document.querySelector('.' + type + ' input[name="radius"]').value = parseFloat(distance).toFixed(2));
                        }
                    } else if (type === 'box') {
                        let s = currentPoint.angle === 90 ? 'long' : 'width';
                        SmartEarthPopupData.editGraphic.setValue(s, distance * 2);
                        if (SmartEarthPopupData.window) {
                            SmartEarthPopupData.window.document.querySelector('.box input[name="' + s + '"]') && (SmartEarthPopupData.window.document.querySelector('.box input[name="' + s + '"]').value = parseFloat(distance * 2).toFixed(2));
                        }
                    }
                } else {
                    //点类移动
                    if (type === 'model') return
                    if (type === 'point' || type === 'billboard' || type === 'label') {
                        currentPoint.position = cartesian;
                        if (SmartEarthPopupData.window) {
                            SmartEarthPopupData.window.document.querySelector('.' + type + ' input[name="height"]') && (SmartEarthPopupData.window.document.querySelector('.' + type + ' input[name="height"]').value = SmartEarthPopupData.editGraphic.getValue('pHeight').toFixed(2));
                        }
                        return;
                    }

                    ///移动后变化
                    let degrees1 = that.toDegrees(cartesian);
                    ///移动前经纬度
                    currentPointpos = currentPoint.position.getValue();
                    let degrees2 = that.toDegrees(currentPointpos);
                    //计算差值
                    let _x = degrees1.lon - degrees2.lon, _y = degrees1.lat - degrees2.lat, _z = degrees1.height - degrees2.height;

                    //修改移动节点位置
                    currentPoint.position = cartesian;
                    if (geo[type].height) {
                        let height = that.toDegrees(cartesian).height;
                        geo[type].height = height;
                        geo.thisHeight = height;
                    }

                    //修改所有节点位置
                    geo.pottingPoint.forEach((item, index) => {
                        let oldPosition, oldCartographic, newPosition;

                        //对应的编辑节点
                        let _edit = viewer.entities.getById(tree.editPointID.edit[index]);
                        if (!_edit) {
                            //对应的大小节点
                            _edit = viewer.entities.getById(tree.editPointID.size[index]);
                        }

                        if (_edit) {
                            oldPosition = that.toDegrees(_edit.position.getValue());
                        } else {
                            oldPosition = that.toDegrees(item);
                        }

                        // if (geo[type].height) {
                        //     oldPosition.height = geo[type].height.getValue ? geo[type].height.getValue() : geo[type].height;
                        // }

                        newPosition = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                        item.x = newPosition.x;
                        item.y = newPosition.y;
                        item.z = newPosition.z;
                        //修改编辑节点坐标
                        _edit && (_edit.position = newPosition);

                        //修改拉伸节点坐标
                        if (tree.editPointID.height.length > 0) {
                            let _heightPoint = viewer.entities.getById(tree.editPointID.height[index]);
                            if (_heightPoint) {
                                oldPosition = _heightPoint.position.getValue();
                                oldCartographic = that._cesium.Cartographic.fromCartesian(oldPosition);
                                oldPosition = {
                                    lon: that._cesium.Math.toDegrees(oldCartographic.longitude),
                                    lat: that._cesium.Math.toDegrees(oldCartographic.latitude),
                                    height: oldCartographic.height
                                };
                                _heightPoint.position = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                            }
                        }

                        //修改新增节点坐标
                        if (tree.editPointID.add.length > 0 && tree.editPointID.add[index]) {
                            let _addPoint = viewer.entities.getById(tree.editPointID.add[index]);
                            if (_addPoint) {
                                oldPosition = that.toDegrees(_addPoint.position.getValue());
                                // if (geo[type].height) {
                                //     oldPosition.height = geo[type].height.getValue ? geo[type].height.getValue() : geo[type].height;
                                // }
                                _addPoint.position = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height + _z);
                            }
                        }
                    });

                    //修改实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'polygon' || type === 'rectangle') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                        if (tree.editPointID.height.length > 0) {
                            SmartEarthPopupData.editGraphic.setValue('extrudedHeight', SmartEarthPopupData.editGraphic.getValue('extrudedHeight') + _z);
                            if (SmartEarthPopupData.window) {
                                SmartEarthPopupData.window.document.querySelector('.ExtrudedPolygon input[name="height"]') && (SmartEarthPopupData.window.document.querySelector('.ExtrudedPolygon input[name="height"]').value = parseFloat(geo[type].height.getValue()).toFixed(2));
                            }
                        }
                        if (SmartEarthPopupData.window) {
                            SmartEarthPopupData.window.document.querySelector('.rectangle input[name="height"]') && (SmartEarthPopupData.window.document.querySelector('.rectangle input[name="height"]').value = parseFloat(geo[type].height.getValue()).toFixed(2));
                        }
                    } else if (type === 'ellipse') {
                        geo.pottingPoint[1] = cartesian;
                        geo.position = cartesian.clone();
                        if (SmartEarthPopupData.window) {
                            SmartEarthPopupData.window.document.querySelector('.ellipse input[name="height"]') && (SmartEarthPopupData.window.document.querySelector('.ellipse input[name="height"]').value = parseFloat(geo[type].height.getValue()).toFixed(2));
                        }
                    } else if (type === 'box') {
                        geo.pottingPoint[2] = cartesian;
                        let size = geo.box.dimensions.getValue();
                        let center = that.toDegrees(cartesian);
                        geo.position = Cesium.Cartesian3.fromDegrees(center.lon, center.lat, center.height + size.z / 2);
                    } else if (type === 'cylinder') {
                        geo.pottingPoint[1] = cartesian;
                        let length = geo.cylinder.length.getValue();
                        let degrees = that.toDegrees(geo.pottingPoint[1]);
                        geo.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + length / 2);
                    } else if (type === 'ellipsoid') {
                        geo.pottingPoint[geo.pottingPoint.length - 1] = cartesian;
                        geo.position = cartesian.clone();
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //// 对鼠标抬起事件的监听
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            if (tree.editVector) return;
            if (currentPoint) {
                option.callBack && option.callBack.updata && option.callBack.updata(currentPoint.name, geo);
            }
            viewer.container.style.cursor = 'default';
            // 移除当前编辑点
            currentPoint = undefined;
            // 恢复地球的旋转和缩放
            that.defaultEvent(true);
        }, this._cesium.ScreenSpaceEventType.LEFT_UP);
        this.editHandler.setInputAction(event => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            if (tree.editVector) return;
            // 通过屏幕坐标获取当前位置的实体信息
            let pickedObject = viewer.scene.pick(event.position);
            // 如果实体信息存在则说明该位置存在实体
            if (that._cesium.defined(pickedObject) && tree.states == 0) {
                // 获取当前点的实体
                let entity = pickedObject.id;
                if (that.SimpleGraphicObj.indexOf(entity.id) > -1) {
                    that.tooltip.show(false);
                    that.delButton(true, event.position, function () {
                        if (entity.treeobj) {
                            tree.delete(entity.treeobj.id, viewer, that._cesium);
                        }
                        viewer.entities.removeById(entity.id);
                        let index = that.SimpleGraphicObj.indexOf(entity.id);
                        that.SimpleGraphicObj.splice(index, 1);
                        that.delButton(false);
                        that.tooltip.show(false);
                        endThisEdit();
                        if (!that.SimpleGraphicObj.length && that.editHandler) {
                            that.edit(false);
                        }
                        option.callBack && option.callBack.delete && option.callBack.delete(entity);
                    });
                } else if (tree.editPointID.edit.indexOf(entity.id) > -1 &&
                    ((type === 'polyline' && tree.editPointID.edit.length > 2) || (type === 'polygon' && tree.editPointID.edit.length > 3))) {
                    let thisPointIndex = tree.editPointID.edit.indexOf(entity.id);

                    //移除编辑节点
                    viewer.entities.removeById(entity.id);
                    tree.editPointID.edit.splice(thisPointIndex, 1);

                    //移除拉伸节点
                    if (tree.editPointID.height.length > 0) {
                        viewer.entities.removeById(tree.editPointID.height[thisPointIndex]);
                        tree.editPointID.height.splice(thisPointIndex, 1);
                    }

                    //移除实体对象节点
                    geo.pottingPoint.splice(thisPointIndex, 1);

                    //移除并更新新增节点
                    if (tree.editPointID.add.length > 0) {
                        //删除下一个新增节点
                        if (tree.editPointID.add[thisPointIndex]) {
                            viewer.entities.removeById(tree.editPointID.add[thisPointIndex]);
                            tree.editPointID.add.splice(thisPointIndex, 1);
                            //更新上一个新增节点
                            if (thisPointIndex - 1 >= 0) {
                                let updataAddPoint = viewer.entities.getById(tree.editPointID.add[thisPointIndex - 1]);
                                if (updataAddPoint) {
                                    //删除的是面的最后一个节点的话就计算第一个节点（索引0）和最后一个节点的中点
                                    updataAddPoint.position = Cesium.Cartesian3.midpoint(
                                        geo.pottingPoint[thisPointIndex - 1],
                                        geo.pottingPoint[thisPointIndex === geo.pottingPoint.length ? 0 : thisPointIndex],
                                        new Cesium.Cartesian3());
                                }
                            } else if (thisPointIndex - 1 === -1 && type === 'polygon') {
                                //删除的是面的第一个节点
                                let updataAddPoint = viewer.entities.getById(tree.editPointID.add[tree.editPointID.add.length - 1]);
                                if (updataAddPoint) {
                                    updataAddPoint.position = Cesium.Cartesian3.midpoint(geo.pottingPoint[0], geo.pottingPoint[geo.pottingPoint.length - 1], new Cesium.Cartesian3());
                                }
                            }
                        } else {
                            //直接移除上一个新增节点
                            viewer.entities.removeById(tree.editPointID.add[thisPointIndex - 1]);
                            tree.editPointID.add.pop();
                        }
                    }

                    //修改移动节点位置
                    let _center = new that._cesium.Cartesian3();
                    let pointLength = geo.pottingPoint.length;
                    geo.pottingPoint.forEach(item => {
                        _center.x += item.x;
                        _center.y += item.y;
                        _center.z += item.z;
                    });
                    _center.x /= pointLength;
                    _center.y /= pointLength;
                    _center.z /= pointLength;
                    tree.editPointID.move && (tree.editPointID.move.position = _center);

                    //更新实体对象坐标
                    let positions = geo.pottingPoint.concat([]);
                    if (type === 'polyline' || type === 'polygon') {
                        SmartEarthPopupData.editGraphic.setValue('positions', positions);
                    }
                    that.tooltip.show(false);
                    option.callBack && option.callBack.updata && option.callBack.updata(currentPoint && currentPoint.name, geo);
                }
            }
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        endThisEdit();

        function endThisEdit() {
            // 恢复地球的旋转和缩放
            that.defaultEvent(true);

            // 移除编辑点，清空编辑点数组
            tree.editPointID.edit.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.edit = [];

            tree.editPointID.height.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.height = [];

            tree.editPointID.add.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.add = [];

            tree.editPointID.size.forEach(item => {
                viewer.entities.removeById(item);
            });
            tree.editPointID.size = [];

            tree.editPointID.move && viewer.entities.remove(tree.editPointID.move);
            tree.editPointID.move = undefined;

            geo = undefined;
            type = undefined;

            //关闭原先窗口
            window.layuiLayer.close(SmartEarthPopupData.layerIndex);
            SmartEarthPopupData.editGraphic = {};

            that.isEditting = false;

            that.delButton(false);
            that._ModelEdit.end();
        }
    };

    //删除按钮
    SimpleGraphic.prototype.delButton = function (show, position, even) {
        if (show) {
            let del = document.getElementById('DeleteMilitaryStandardDelete');
            if (!del) {
                del = document.createElement('button');
                del.id = 'DeleteMilitaryStandardDelete';
                del.innerText = '删除对象';
                del.style.cssText = `height: 38px;
                                    line-height: 38px;
                                    padding: 0 18px;
                                    background-color: #052355;
                                    color: #fff;
                                    white-space: nowrap;
                                    text-align: center;
                                    font-size: 14px;
                                    border: none;
                                    border-radius: 2px;
                                    cursor: pointer;
                                    position: absolute;`;
                this._viewer.container.appendChild(del);
            }
            del.style.display = 'block';
            del.style.top = position.y + 'px';
            del.style.left = position.x + 'px';
            del.onclick = even;
        } else {
            let del = document.getElementById('DeleteMilitaryStandardDelete');
            if (del) {
                del.style.display = 'none';
                del.onclick = null;
            }
        }
    };

    //默认鼠标事件
    SimpleGraphic.prototype.defaultEvent = function (isOpen) {
        let scene = this._viewer.scene;
        scene.screenSpaceCameraController.enableRotate = isOpen;
        scene.screenSpaceCameraController.enableTranslate = isOpen;
        scene.screenSpaceCameraController.enableZoom = isOpen;
        scene.screenSpaceCameraController.enableTilt = isOpen;
        scene.screenSpaceCameraController.enableLook = isOpen;
    };

    //通过角度和距离获取经纬度
    SimpleGraphic.prototype.GetDegreesFromA_D = function (lon, lat, distance, angle) {
        let Ea = 6378137.0;     //   赤道半径
        let Eb = 6356725.0;     //   极半径
        let dx = distance * Math.sin(angle * Math.PI / 180.0);
        let dy = distance * Math.cos(angle * Math.PI / 180.0);

        let ec = Eb + (Ea - Eb) * (90.0 - lat) / 90.0;
        let ed = ec * Math.cos(lat * Math.PI / 180);

        let newLon = (dx / ed + lon * Math.PI / 180.0) * 180.0 / Math.PI;
        let newLat = (dy / ec + lat * Math.PI / 180.0) * 180.0 / Math.PI;

        return [newLon, newLat];
    };

    //通过角度和距离获取经纬度
    SimpleGraphic.prototype.GetPositionFromA_D = function (position, distance, angle) {
        let degrees = this.toDegrees(position);
        let newDegrees = this.GetDegreesFromA_D(degrees.lon, degrees.lat, distance, angle);

        return this._cesium.Cartesian3.fromDegrees(newDegrees[0], newDegrees[1], degrees.height);
    };

    //获取entity对象的类型和关联的对象
    SimpleGraphic.prototype.getEntityTypeAndObject = function (entity) {
        let data = {
            type: '',
            object: null
        };
        if (entity) {
            if (entity.billboard) {
                data.type = 'billboard';
                data.object = entity.billboard;
            } else if (entity.box) {
                data.type = 'box';
                data.object = entity.box;
            } else if (entity.corridor) {
                data.type = 'corridor';
                data.object = entity.corridor;
            } else if (entity.cylinder) {
                data.type = 'cylinder';
                data.object = entity.cylinder;
            } else if (entity.ellipse) {
                data.type = 'ellipse';
                data.object = entity.ellipse;
            } else if (entity.ellipsoid) {
                data.type = 'ellipsoid';
                data.object = entity.ellipsoid;
            } else if (entity.label) {
                data.type = 'label';
                data.object = entity.label;
            } else if (entity.model) {
                data.type = 'model';
                data.object = entity.model;
            } else if (entity.path) {
                data.type = 'path';
                data.object = entity.path;
            } else if (entity.plane) {
                data.type = 'plane';
                data.object = entity.plane;
            } else if (entity.point) {
                data.type = 'point';
                data.object = entity.point;
            } else if (entity.polygon) {
                data.type = 'polygon';
                data.object = entity.polygon;
            } else if (entity.polyline) {
                data.type = 'polyline';
                data.object = entity.polyline;
            } else if (entity.polylineVolume) {
                data.type = 'polylineVolume';
                data.object = entity.polylineVolume;
            } else if (entity.rectangle) {
                data.type = 'rectangle';
                data.object = entity.rectangle;
            } else if (entity.wall) {
                data.type = 'wall';
                data.object = entity.wall;
            }
        }
        return data;
    };

    SimpleGraphic.prototype.getSimpleGraphicData = function (type, geo) {
        let that = this;
        let viewer = this._viewer;
        SmartEarthPopupData.editGraphic = {
            entity: geo,
            type: type,
            graphic: geo[type],
            getValue: function (attr) {
                if (attr === 'position' || attr === 'name' || attr === 'id' || attr === 'orientation' || attr === 'heading' || attr === 'pitch' || attr === 'roll') {
                    return this.entity[attr] && (this.entity[attr].getValue ? this.entity[attr].getValue() : this.entity[attr]);
                } else if (attr === 'radius') {
                    if (this.type === 'ellipse') {
                        return this.graphic.semiMajorAxis.getValue();
                    } else if (this.type === 'ellipsoid') {
                        return this.graphic.radii.getValue().x;
                    } else if (this.type === 'cylinder') {
                        return this.graphic.bottomRadius.getValue();
                    }
                } else if (attr === 'pHeight') {
                    if (this.getValue('position')) {
                        let position = this.getValue('position');
                        let Cartographic = Cesium.Cartographic.fromCartesian(position);
                        return Cartographic.height;
                    }
                } else if (attr === 'repeat') {
                    return this.graphic.material[attr] && (this.graphic.material[attr].getValue ? this.graphic.material[attr].getValue() : this.graphic.material[attr]);
                } else {
                    return this.graphic[attr] && (this.graphic[attr].getValue ? this.graphic[attr].getValue() : this.graphic[attr]);
                }
            },
            changeHeightPoint: function (height) {
                if (tree.editPointID.height.length > 0) {
                    tree.editPointID.height.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            let e_p = e.position.getValue();
                            let e_d = that.toDegrees(e_p);
                            e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                        }
                    });
                }
            },
            changeEditPoint: function (height) {
                if (tree.editPointID.edit.length > 0) {
                    tree.editPointID.edit.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                if (tree.editPointID.size.length > 0) {
                    tree.editPointID.size.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                if (tree.editPointID.add.length > 0) {
                    tree.editPointID.add.forEach(item => {
                        let e = viewer.entities.getById(item);
                        if (e) {
                            if (height === 'clampToGround') {
                                e.point.heightReference = 1;
                            } else {
                                e.point.heightReference = 0;
                                let e_p = e.position.getValue();
                                let e_d = that.toDegrees(e_p);
                                e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                            }
                        }
                    });
                }
                let e = tree.editPointID.move;
                if (e) {
                    if (height === 'clampToGround') {
                        e.point.heightReference = 1;
                    } else {
                        e.point.heightReference = 0;
                        let e_p = e.position.getValue();
                        let e_d = that.toDegrees(e_p);
                        e.position = Cesium.Cartesian3.fromDegrees(e_d.lon, e_d.lat, height);
                    }
                }
            },
            clearAllEditPoint: function () {
                // 移除编辑点，清空编辑点数组
                tree.editPointID.edit.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.edit = [];

                tree.editPointID.height.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.height = [];

                tree.editPointID.add.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.add = [];

                tree.editPointID.size.forEach(item => {
                    viewer.entities.removeById(item);
                });
                tree.editPointID.size = [];

                tree.editPointID.move && viewer.entities.remove(tree.editPointID.move);
                tree.editPointID.move = undefined;
            }
        };
        if (type === 'billboard' || type === 'point' || type === 'label' || type === 'model') {
            //获取颜色值
            let color = SmartEarthPopupData.editGraphic.getValue('color') || SmartEarthPopupData.editGraphic.getValue('fillColor');
            if (color) {
                getFillColor(color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            if (type === 'label') {
                let backgroundColor = SmartEarthPopupData.editGraphic.getValue('backgroundColor');
                if (backgroundColor) {
                    getBackgroundColor(backgroundColor);
                } else {
                    SmartEarthPopupData.editGraphic.backgroundColor = '#000000';
                    SmartEarthPopupData.editGraphic.backgroundAlpha = 80;
                }
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'position' && this.entity.offset) {
                    this.entity.oP = value;
                    let frompoint_to_world_matrix = Cesium.Transforms.eastNorthUpToFixedFrame(this.entity.oP);
                    let result = new Cesium.Cartesian3(0, 0, 0);
                    Cesium.Matrix4.multiplyByPoint(frompoint_to_world_matrix, this.entity.offset, result);
                    value = result;
                } else if (attr === 'offset') {
                    !this.entity.oP && (this.entity.oP = this.getValue('position'));
                    this.entity.offset = value;
                    let frompoint_to_world_matrix = Cesium.Transforms.eastNorthUpToFixedFrame(this.entity.oP);
                    let result = new Cesium.Cartesian3(0, 0, 0);
                    Cesium.Matrix4.multiplyByPoint(frompoint_to_world_matrix, this.entity.offset, result);
                    value = result;
                    attr = 'position';
                }

                if (attr === 'position' || attr === 'name') {
                    this.entity[attr] = value;
                } else if (attr === 'autoRotate' && this.type === 'model') {
                    if (this.entity.heading === undefined) {
                        this.entity.heading = 0;
                        this.entity.pitch = 0;
                        this.entity.roll = 0;
                    }

                    if (typeof value === 'number') {
                        this.entity['orientation'] = new Cesium.CallbackProperty(() => {
                            this.entity.heading += value;
                            this.entity.heading > 360 && (this.entity.heading -= 360);
                            if (SmartEarthPopupData.window) {
                                SmartEarthPopupData.window.document.querySelector('.model input[name="heading"]') && (SmartEarthPopupData.window.document.querySelector('.model input[name="heading"]').value = this.entity.heading);
                            }
                            return Cesium.Transforms.headingPitchRollQuaternion(
                                this.getValue('position'),
                                new Cesium.HeadingPitchRoll(
                                    Cesium.Math.toRadians(this.entity.heading),
                                    Cesium.Math.toRadians(this.entity.pitch),
                                    Cesium.Math.toRadians(this.entity.roll)
                                )
                            );
                        }, false);
                        if (SmartEarthPopupData.window) {
                            SmartEarthPopupData.window.document.querySelector('.model input[name="heading"]') && (SmartEarthPopupData.window.document.querySelector('.model input[name="heading"]').disabled = true);
                            SmartEarthPopupData.window.document.querySelector('.model input[name="pitch"]') && (SmartEarthPopupData.window.document.querySelector('.model input[name="pitch"]').disabled = true);
                            SmartEarthPopupData.window.document.querySelector('.model input[name="roll"]') && (SmartEarthPopupData.window.document.querySelector('.model input[name="roll"]').disabled = true);
                        }
                    } else if (value === false) {
                        this.entity['orientation'] = Cesium.Transforms.headingPitchRollQuaternion(
                            this.getValue('position'),
                            new Cesium.HeadingPitchRoll(
                                Cesium.Math.toRadians(this.entity.heading),
                                Cesium.Math.toRadians(this.entity.pitch),
                                Cesium.Math.toRadians(this.entity.roll)
                            )
                        );
                        if (SmartEarthPopupData.window) {
                            SmartEarthPopupData.window.document.querySelector('.model input[name="heading"]') && (SmartEarthPopupData.window.document.querySelector('.model input[name="heading"]').disabled = false);
                            SmartEarthPopupData.window.document.querySelector('.model input[name="pitch"]') && (SmartEarthPopupData.window.document.querySelector('.model input[name="pitch"]').disabled = false);
                            SmartEarthPopupData.window.document.querySelector('.model input[name="roll"]') && (SmartEarthPopupData.window.document.querySelector('.model input[name="roll"]').disabled = false);
                        }
                    }
                } else if ((attr === 'heading' || attr === 'pitch' || attr === 'roll') && this.type === 'model') {
                    this.entity[attr] = value;
                    this.entity['orientation'] = Cesium.Transforms.headingPitchRollQuaternion(
                        this.getValue('position'),
                        new Cesium.HeadingPitchRoll(
                            Cesium.Math.toRadians(this.entity.heading),
                            Cesium.Math.toRadians(this.entity.pitch),
                            Cesium.Math.toRadians(this.entity.roll)
                        )
                    );
                } else {
                    if (attr === 'color' || attr === 'outlineColor' || attr === 'backgroundColor' || attr === 'fillColor') {
                        value = Cesium.Color.fromCssColorString(value);
                    } else if (attr === 'fontSize') {
                        let font = this.getValue('font');
                        font = font.split(' ');
                        font[0] = value;
                        value = font.join(' ');
                    } else if (attr === 'alpha') {
                        if (this.type === 'label') {
                            this.graphic.fillColor._value.alpha = value;
                        } else {
                            this.graphic.color._value.alpha = value;
                        }
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'backgroundAlpha') {
                        this.graphic.backgroundColor._value.alpha = value;
                        return;
                    } else if (attr === 'pHeight') {
                        if (this.getValue('position')) {
                            let position = this.getValue('position');
                            let Cartographic = Cesium.Cartographic.fromCartesian(position);
                            Cartographic.height = value;
                            this.entity.position = Cesium.Cartographic.toCartesian(Cartographic);
                            return;
                        }
                    }
                    this.graphic[attr] = value;
                }
            };
        } else if (type === 'polyline') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            if (material.outlineColor) {
                getOutlineColor(material.outlineColor);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'outlineWidth') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.material.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic[attr] = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let pottingPoint = this.getValue('positions');
                this.entity.pottingPoint = pottingPoint;
                return pottingPoint;
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    if (this.getValue('extrudedHeight') !== undefined) {
                        let cartographic = Cesium.Cartographic.fromCartesian(item);
                        let degrees = {
                            lon: Cesium.Math.toDegrees(cartographic.longitude),
                            lat: Cesium.Math.toDegrees(cartographic.latitude),
                            height: this.getValue('extrudedHeight')
                        };

                        if (this.getValue('height')) {
                            let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                            item.x = e_p.x;
                            item.y = e_p.y;
                            item.z = e_p.z;
                            edit_point.position = e_p;
                            this.entity.pottingPoint[index] = e_p.clone();
                        }

                        let heightpoint = viewer.entities.add({
                            name: "height_point",
                            position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                            point: {
                                color: Cesium.Color.YELLOW,
                                pixelSize: 12,
                                outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                                outlineWidth: 2,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            }
                        });
                        tree.editPointID.height.push(heightpoint.id);
                    }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                tree.editPointID.move = viewer.entities.add({
                    name: "move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });

                for (let i = 0; i < points.length - 1; i++) {
                    let add_position = Cesium.Cartesian3.midpoint(points[i], points[i + 1], new Cesium.Cartesian3());
                    //添加节点
                    let add_point = viewer.entities.add({
                        name: "add_point",
                        position: add_position,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.add.push(add_point.id);
                }
            };
        } else if (type === 'polygon') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic.hierarchy = new Cesium.CallbackProperty(function () {
                            return new Cesium.PolygonHierarchy(value);
                        }, false);
                        return;
                    } else if (attr === 'hierarchy') {
                        this.graphic.hierarchy = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'clampToGround') {
                        if (this.graphic.hierarchy instanceof Cesium.CallbackProperty) {
                            this.graphic.hierarchy = this.graphic.hierarchy.getValue();
                            setTimeout(() => {
                                changeGround(this.graphic, this.entity.pottingPoint, value);
                            }, 100);
                        } else {
                            changeGround(this.graphic, this.entity.pottingPoint, value);
                        }
                        //更新新增节点贴地状态
                        if (tree.editPointID.add.length > 0) {
                            tree.editPointID.add.forEach(item => {
                                let updataAddPoint = viewer.entities.getById(item);
                                if (updataAddPoint) {
                                    if (value) {
                                        updataAddPoint.point.heightReference = 1;
                                    } else {
                                        updataAddPoint.point.heightReference = 0;
                                    }
                                }
                            });
                        }

                        function changeGround(graphic, points, checked) {
                            if (checked) {
                                graphic.perPositionHeight = false;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.perPositionHeight = true;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            //更新节点高度
                            if (tree.editPointID.edit.length > 0 && !checked) {
                                points.forEach((item, index) => {
                                    let _editPoint = viewer.entities.getById(tree.editPointID.edit[index]);
                                    if (_editPoint) {
                                        let p = _editPoint.position.getValue();
                                        item.x = p.x;
                                        item.y = p.y;
                                        item.z = p.z;
                                    }
                                });
                            }
                            graphic.hierarchy = new Cesium.CallbackProperty(function () {
                                return new Cesium.PolygonHierarchy(points);
                            }, false);
                        }
                        return;
                    } else if (attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (attr === 'height') {
                        this.changeEditPoint(value);
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let hierarchy = this.getValue('hierarchy');
                let positions = hierarchy.positions.concat([]);
                if (this.getValue('height') !== undefined) {
                    let height = this.getValue('height');
                    positions.forEach(item => {
                        let degree = that.toDegrees(item);
                        let cartesian = Cesium.Cartesian3.fromDegrees(degree.lon, degree.lat, height);
                        item.x = cartesian.x;
                        item.y = cartesian.y;
                        item.z = cartesian.z;
                    });
                }
                this.entity.pottingPoint = positions;
                return positions;
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    if (this.getValue('extrudedHeight') !== undefined) {
                        let cartographic = Cesium.Cartographic.fromCartesian(item);
                        let degrees = {
                            lon: Cesium.Math.toDegrees(cartographic.longitude),
                            lat: Cesium.Math.toDegrees(cartographic.latitude),
                            height: this.getValue('extrudedHeight')
                        };

                        if (this.getValue('height')) {
                            let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                            item.x = e_p.x;
                            item.y = e_p.y;
                            item.z = e_p.z;
                            edit_point.position = e_p;
                            this.entity.pottingPoint[index] = e_p.clone();
                        }

                        let heightpoint = viewer.entities.add({
                            name: "height_point",
                            position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                            point: {
                                color: Cesium.Color.YELLOW,
                                pixelSize: 12,
                                outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                                outlineWidth: 2,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            }
                        });
                        tree.editPointID.height.push(heightpoint.id);
                    }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                //移动节点
                tree.editPointID.move = viewer.entities.add({
                    name: "move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });

                for (let i = 0; i < points.length - 1; i++) {
                    let add_position = Cesium.Cartesian3.midpoint(points[i], points[i + 1], new Cesium.Cartesian3());
                    //添加节点
                    let add_point = viewer.entities.add({
                        name: "add_point",
                        position: add_position,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.add.push(add_point.id);
                }

                //首尾间的添加节点
                let add_position = Cesium.Cartesian3.midpoint(points[0], points[points.length - 1], new Cesium.Cartesian3());
                let add_point = viewer.entities.add({
                    name: "add_point",
                    position: add_position,
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE.withAlpha(0.4),
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.4),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
                tree.editPointID.add.push(add_point.id);
            };
        } else if (type === 'ellipse' || type === 'cylinder' || geo.isSphere) {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'semiMajorAxis') {
                        this.graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'semiMinorAxis') {
                        this.graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'radii') {
                        this.graphic.radii = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'topRadius') {
                        this.graphic.topRadius = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'bottomRadius') {
                        this.graphic.bottomRadius = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'radius') {
                        if (this.type === 'ellipse') {
                            this.graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                            this.graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                        } else if (this.type === 'ellipsoid') {
                            if (this.graphic.material.image.getValue() !== null) {
                                this.graphic.radii = new Cesium.Cartesian3(value, value, value);
                            } else {
                                this.graphic.radii = new Cesium.CallbackProperty(function () {
                                    return new Cesium.Cartesian3(value, value, value);
                                }, false);
                            }
                        } else if (this.type === 'cylinder') {
                            this.graphic.bottomRadius = new Cesium.CallbackProperty(function () {
                                return value;
                            }, false);
                            if (this.entity.changeTop) {
                                this.graphic.topRadius = new Cesium.CallbackProperty(function () {
                                    return value;
                                }, false);
                            }
                        }
                        let center = tree.editPointID.move.position.getValue();
                        let newPosition = that.GetPositionFromA_D(center, value, 90);

                        // 更新编辑点的位置
                        let _sizePoint = viewer.entities.getById(tree.editPointID.size[0]);
                        _sizePoint.position = newPosition;
                        geo.pottingPoint[0] = newPosition;
                        geo.pottingPoint[geo.pottingPoint.length - 1] = center;

                        //修改对应的拉伸节点
                        let thisHeightPoint = viewer.entities.getById(tree.editPointID.height[0]);
                        if (thisHeightPoint) {
                            let degrees = that.toDegrees(newPosition);
                            //修改拉伸节点位置
                            let expiontcart = that._cesium.Cartographic.fromCartesian(thisHeightPoint.position.getValue());
                            thisHeightPoint.position = that._cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, expiontcart.height);
                        }
                        return;
                    } else if (this.type === 'cylinder' && attr === 'length') {
                        this.graphic.length = value;
                        let degrees = that.toDegrees(this.entity.pottingPoint[1]);
                        this.entity.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + value / 2);
                        this.changeHeightPoint(degrees.height + value);
                        return;
                    } else if (this.type === 'ellipse' && attr === 'clampToGround') {
                        if (this.graphic.semiMinorAxis instanceof Cesium.CallbackProperty) {
                            this.graphic.semiMinorAxis = this.graphic.semiMinorAxis.getValue();
                            this.graphic.semiMajorAxis = this.graphic.semiMajorAxis.getValue();
                            setTimeout(() => {
                                changeGround(this.entity, this.graphic, value);
                            }, 100);
                        } else {
                            changeGround(this.entity, this.graphic, value);
                        }

                        if (!value) {
                            this.changeEditPoint(this.entity.thisHeight);
                        } else {
                            this.changeEditPoint('clampToGround');
                        }

                        function changeGround(entity, graphic, checked) {
                            if (checked) {
                                if (entity.thisHeight === undefined) {
                                    entity.thisHeight = graphic.height && graphic.height.getValue();
                                }
                                graphic.height = undefined;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.height = entity.thisHeight;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            let radius = graphic.semiMinorAxis.getValue();
                            graphic.semiMinorAxis = new Cesium.CallbackProperty(function () {
                                return radius;
                            }, false);
                            graphic.semiMajorAxis = new Cesium.CallbackProperty(function () {
                                return radius;
                            }, false);
                        }
                        return;
                    } else if (this.type === 'ellipse' && attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (this.type === 'ellipse' && attr === 'height') {
                        this.changeEditPoint(value);
                        this.entity.thisHeight = value;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let radius = this.getValue('radius');
                let position = this.getValue('position');
                if (this.type === 'ellipse' || this.entity.isSphere) {
                    if (this.type === 'ellipse' && this.getValue('height') !== undefined) {
                        let height = this.getValue('height');
                        let degree = that.toDegrees(position);
                        position = Cesium.Cartesian3.fromDegrees(degree.lon, degree.lat, height);
                    }
                    let position0 = that.GetPositionFromA_D(position, radius, 90);
                    this.entity.pottingPoint = [position0, position];
                    return [position0, position];
                } else {
                    let degrees = that.toDegrees(position);
                    //求cylinder底部点位置
                    position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height - this.getValue('length') / 2);
                    let position0 = that.GetPositionFromA_D(position, radius, 90);
                    this.entity.pottingPoint = [position0, position];
                    return [position0, position];
                }
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;
                //大小节点
                let size_point = viewer.entities.add({
                    name: "size_point",
                    position: points[0],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
                size_point.angle = 90;
                tree.editPointID.size.push(size_point.id);

                //拉伸节点
                if (this.getValue('extrudedHeight') !== undefined) {
                    let degrees = that.toDegrees(points[1]);
                    degrees.height = this.getValue('extrudedHeight');

                    let heightpoint = viewer.entities.add({
                        name: "height_point",
                        position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                        point: {
                            color: Cesium.Color.YELLOW,
                            pixelSize: 12,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            outlineWidth: 2,
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        }
                    });
                    tree.editPointID.height.push(heightpoint.id);
                } else if (type === 'cylinder') {
                    let degrees = that.toDegrees(points[1]);
                    let length = this.getValue('length');
                    let heightpoint = viewer.entities.add({
                        name: "height_point",
                        position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + length),
                        point: {
                            color: Cesium.Color.YELLOW,
                            pixelSize: 12,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            outlineWidth: 2,
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        }
                    });
                    tree.editPointID.height.push(undefined, heightpoint.id);
                }

                tree.editPointID.move = viewer.entities.add({
                    name: "move_point",
                    position: points[1],
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'rectangle') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'positions') {
                        this.graphic.coordinates = new Cesium.CallbackProperty(function () {
                            return Cesium.Rectangle.fromCartesianArray(value);
                        }, false);
                        return;
                    } else if (attr === 'coordinates') {
                        this.graphic.coordinates = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    } else if (attr === 'clampToGround') {
                        if (this.graphic.coordinates instanceof Cesium.CallbackProperty) {
                            this.graphic.coordinates = this.graphic.coordinates.getValue();
                            setTimeout(() => {
                                changeGround(this.entity, this.graphic, value);
                            }, 100);
                        } else {
                            changeGround(this.entity, this.graphic, value);
                        }

                        if (!value) {
                            this.changeEditPoint(this.entity.thisHeight);
                        } else {
                            this.changeEditPoint('clampToGround');
                        }

                        function changeGround(entity, graphic, checked) {
                            if (checked) {
                                if (entity.thisHeight === undefined) {
                                    entity.thisHeight = graphic.height && graphic.height.getValue();
                                }
                                graphic.height = undefined;
                                graphic.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
                            } else {
                                graphic.height = entity.thisHeight;
                                graphic.heightReference = Cesium.HeightReference.NONE;
                            }
                            let coordinates = graphic.coordinates.getValue();
                            graphic.coordinates = new Cesium.CallbackProperty(function () {
                                return coordinates;
                            }, false);
                        }
                        return;
                    } else if (attr === 'extrudedHeight') {
                        this.changeHeightPoint(value);
                    } else if (attr === 'height') {
                        this.changeEditPoint(value);
                        this.entity.thisHeight = value;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let coordinates = this.getValue('coordinates');
                let position0, position1;
                let height = this.getValue('height');
                if (height !== undefined) {
                    position0 = Cesium.Cartesian3.fromRadians(coordinates.west, coordinates.north, height);
                    position1 = Cesium.Cartesian3.fromRadians(coordinates.east, coordinates.south, height);
                } else {
                    height = viewer.scene.sampleHeight(new Cesium.Cartographic(coordinates.west, coordinates.north, 0), [this.entity]);
                    position0 = Cesium.Cartesian3.fromRadians(coordinates.west, coordinates.north, height);
                    height = viewer.scene.sampleHeight(new Cesium.Cartographic(coordinates.east, coordinates.south, 0), [this.entity]);
                    position1 = Cesium.Cartesian3.fromRadians(coordinates.east, coordinates.south, height);
                }
                this.entity.pottingPoint = [position0, position1];
                return [position0, position1];
            };
            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;

                let centerPoint = new Cesium.Cartesian3();
                points.forEach((item, index) => {
                    //编辑节点
                    let edit_point = viewer.entities.add({
                        name: "edit_point",
                        position: item,
                        point: {
                            pixelSize: 10,
                            color: Cesium.Color.ROYALBLUE,
                            outlineWidth: 2,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                        }
                    });
                    tree.editPointID.edit.push(edit_point.id);

                    //拉伸节点
                    if (this.getValue('extrudedHeight') !== undefined) {
                        let cartographic = Cesium.Cartographic.fromCartesian(item);
                        let degrees = {
                            lon: Cesium.Math.toDegrees(cartographic.longitude),
                            lat: Cesium.Math.toDegrees(cartographic.latitude),
                            height: this.getValue('extrudedHeight')
                        };

                        if (this.getValue('height')) {
                            let e_p = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, this.getValue('height'));
                            item.x = e_p.x;
                            item.y = e_p.y;
                            item.z = e_p.z;
                            edit_point.position = e_p;
                            this.entity.pottingPoint[index] = e_p.clone();
                        }

                        let heightpoint = viewer.entities.add({
                            name: "height_point",
                            position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height),
                            point: {
                                color: Cesium.Color.YELLOW,
                                pixelSize: 12,
                                outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                                outlineWidth: 2,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            }
                        });
                        tree.editPointID.height.push(heightpoint.id);
                    }

                    centerPoint.x += item.x;
                    centerPoint.y += item.y;
                    centerPoint.z += item.z;
                });
                centerPoint.x /= points.length;
                centerPoint.y /= points.length;
                centerPoint.z /= points.length;

                //移动节点
                tree.editPointID.move = viewer.entities.add({
                    name: "move_point",
                    position: centerPoint,
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'box') {
            //获取颜色值
            let material = SmartEarthPopupData.editGraphic.getValue('material');
            if (material.color) {
                getFillColor(material.color);
            } else {
                SmartEarthPopupData.editGraphic.fillColor = '#00ff00';
                SmartEarthPopupData.editGraphic.alpha = 60;
            }
            let outline = SmartEarthPopupData.editGraphic.getValue('outlineColor');
            if (outline) {
                getOutlineColor(outline);
            } else {
                SmartEarthPopupData.editGraphic.outlineColor = '#ffffff';
                SmartEarthPopupData.editGraphic.outlineAlpha = 60;
            }

            SmartEarthPopupData.editGraphic.setValue = function (attr, value) {
                if (attr === 'name') {
                    this.entity[attr] = value;
                } else {
                    if (attr === 'color' || attr === 'outlineColor') {
                        value = Cesium.Color.fromCssColorString(value);
                        if (attr === 'color') {
                            this.graphic.material.color = value;
                            return;
                        }
                    } else if (attr === 'image' || attr === 'repeat') {
                        this.graphic.material[attr] = value;
                        return;
                    } else if (attr === 'alpha') {
                        this.graphic.material.color._value.alpha = value;
                        return;
                    } else if (attr === 'outlineAlpha') {
                        this.graphic.outlineColor._value.alpha = value;
                        return;
                    } else if (attr === 'long' || attr === 'width' || attr === 'height') {
                        let dimensions = this.getValue('dimensions');
                        if (attr === 'long') {
                            dimensions.x = value;
                        } else if (attr === 'width') {
                            dimensions.y = value;
                        } else {
                            dimensions.z = value;
                        }
                        this.graphic.dimensions = new Cesium.CallbackProperty(function () {
                            return dimensions;
                        }, false);

                        if (attr === 'long' || attr === 'width') {
                            let angle = attr === 'long' ? 90 : 180;
                            let pointIndex = attr === 'long' ? 0 : 1;
                            let center = tree.editPointID.move.position.getValue();
                            let newPosition = that.GetPositionFromA_D(center, value / 2, angle);

                            // 更新编辑点的位置
                            let _sizePoint = viewer.entities.getById(tree.editPointID.size[pointIndex]);
                            _sizePoint.position = newPosition;
                            this.entity.pottingPoint[pointIndex] = newPosition;
                            this.entity.pottingPoint[this.entity.pottingPoint.length - 1] = center;
                        } else {
                            let degrees = that.toDegrees(tree.editPointID.move.position.getValue());
                            this.entity.position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + value / 2);
                            this.changeHeightPoint(degrees.height + value);
                        }
                        return;
                    } else if (attr === 'dimensions') {
                        this.graphic.dimensions = new Cesium.CallbackProperty(function () {
                            return value;
                        }, false);
                        return;
                    }
                    this.graphic[attr] = value;
                }
            };
            SmartEarthPopupData.editGraphic.getPottingPoint = function () {
                let dimensions = this.getValue('dimensions');
                let position = this.getValue('position');
                let degrees = that.toDegrees(position);
                //求box底部点位置
                position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height - dimensions.z / 2);
                let position0 = that.GetPositionFromA_D(position, dimensions.x / 2, 90);
                let position1 = that.GetPositionFromA_D(position, dimensions.y / 2, 180);
                this.entity.pottingPoint = [position0, position1, position];
                return [position0, position1, position];
            };

            //更新编辑点
            SmartEarthPopupData.editGraphic.updataEditPoint = function () {
                this.clearAllEditPoint();

                // 生成编辑点
                let points = this.getPottingPoint();
                if (!points) return;
                //大小节点
                let size_point1 = viewer.entities.add({
                    name: "size_point",
                    position: points[0],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY
                    }
                });
                size_point1.angle = 90;

                let size_point2 = viewer.entities.add({
                    name: "size_point",
                    position: points[1],
                    point: {
                        pixelSize: 10,
                        color: Cesium.Color.ROYALBLUE,
                        outlineWidth: 2,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        disableDepthTestDistance: Number.POSITIVE_INFINITY
                    }
                });
                size_point2.angle = 180;
                tree.editPointID.size.push(size_point1.id);
                tree.editPointID.size.push(size_point2.id);

                //拉伸节点
                let degrees = that.toDegrees(points[2]);
                let dimensions = this.getValue('dimensions');
                let heightpoint = viewer.entities.add({
                    name: "height_point",
                    position: Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + dimensions.z),
                    point: {
                        color: Cesium.Color.YELLOW,
                        pixelSize: 12,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                });
                tree.editPointID.height.push(undefined, undefined, heightpoint.id);

                tree.editPointID.move = viewer.entities.add({
                    name: "move_point",
                    position: points[2],
                    point: {
                        color: Cesium.Color.PURPLE,
                        pixelSize: 10,
                        outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                        outlineWidth: 2,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: this.graphic.heightReference && this.graphic.heightReference.getValue()
                    }
                });
            };
        } else if (type === 'corridor') ; else if (type === 'ellipsoid' && !geo.isSphere) ; else ;

        function getFillColor(rgba) {
            SmartEarthPopupData.editGraphic.fillColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.alpha = rgba.alpha * 100;
        }

        function getOutlineColor(rgba) {
            SmartEarthPopupData.editGraphic.outlineColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.outlineAlpha = rgba.alpha * 100;
        }

        function getBackgroundColor(rgba) {
            SmartEarthPopupData.editGraphic.backgroundColor = colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')');
            SmartEarthPopupData.editGraphic.backgroundAlpha = rgba.alpha * 100;
        }

        function colorHex(rgb) {
            let _this = rgb;
            let reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;
            if (/^(rgb|RGB)/.test(_this)) {
                let str = _this.replace(/(rgb|RGB)*/g, "");
                str = str.replace("(", "").replace(")", "");
                let aColor = str.split(",");
                let strHex = "#";
                for (let i = 0; i < aColor.length; i++) {
                    let hex = Number(aColor[i]).toString(16);
                    hex = hex.length === 1 ? 0 + '' + hex : hex;// 保证每个rgb的值为2位
                    if (hex === "0") {
                        hex += hex;
                    }
                    strHex += hex;
                }
                if (strHex.length !== 7) {
                    strHex = _this;
                }
                return strHex;
            } else if (reg.test(_this)) {
                let aNum = _this.replace(/#/, "").split("");
                if (aNum.length === 6) {
                    return _this;
                } else if (aNum.length === 3) {
                    let numHex = "#";
                    for (let i = 0; i < aNum.length; i += 1) {
                        numHex += (aNum[i] + aNum[i]);
                    }
                    return numHex;
                }
            } else {
                return _this;
            }
        }
    };

    //获取样式
    SimpleGraphic.prototype.getStyle = function (entity) {
        let style, type;

        //获取entity类型
        type = this.getEntityTypeAndObject(entity).type;

        let distanceDisplayCondition = getValue('distanceDisplayCondition');
        if (type === 'point') {
            style = {
                id: getValue('id'),
                name: getValue('name'),
                position: getValue('position'),
                pixelSize: getValue('pixelSize'),
                scaleByDistance: getValue('scaleByDistance'),
                color: getValue('color') && getValue('color').toCssColorString(),
                outlineWidth: getValue('outlineWidth'),
                outlineColor: getValue('outlineColor') && getValue('outlineColor').toCssColorString(),
                heightReference: getValue('heightReference'),
                distanceDisplayCondition: distanceDisplayCondition && {
                    near: distanceDisplayCondition.near,
                    far: distanceDisplayCondition.far
                }
            };
        } else if (type === 'billboard') {
            style = {
                id: getValue('id'),
                name: getValue('name'),
                position: getValue('position'),
                image: getValue('image'),
                scale: getValue('scale'),
                scaleByDistance: getValue('scaleByDistance'),
                rotation: getValue('rotation'),
                width: getValue('width'),
                height: getValue('height'),
                color: getValue('color') && getValue('color').toCssColorString(),
                horizontalOrigin: getValue('horizontalOrigin'),
                verticalOrigin: getValue('verticalOrigin'),
                heightReference: getValue('heightReference'),
                distanceDisplayCondition: distanceDisplayCondition && {
                    near: distanceDisplayCondition.near,
                    far: distanceDisplayCondition.far
                }
            };
        } else if (type === 'label') {
            style = {
                id: getValue('id'),
                name: getValue('name'),
                position: getValue('position'),
                text: getValue('text'),
                font: getValue('font'),
                style: getValue('style'),
                scale: getValue('scale'),
                scaleByDistance: getValue('scaleByDistance'),
                fillColor: getValue('fillColor') && getValue('fillColor').toCssColorString(),
                outlineColor: getValue('outlineColor') && getValue('outlineColor').toCssColorString(),
                outlineWidth: getValue('outlineWidth'),
                showBackground: getValue('showBackground'),
                backgroundColor: getValue('backgroundColor') && getValue('backgroundColor').toCssColorString(),
                horizontalOrigin: getValue('horizontalOrigin'),
                verticalOrigin: getValue('verticalOrigin'),
                heightReference: getValue('heightReference'),
                distanceDisplayCondition: distanceDisplayCondition && {
                    near: distanceDisplayCondition.near,
                    far: distanceDisplayCondition.far
                }
            };
        } else if (type === 'model') {
            style = {
                id: getValue('id'),
                name: getValue('name'),
                position: getValue('position'),
                url: getValue('uri'),
                minimumPixelSize: getValue('minimumPixelSize'),
                runAnimations: getValue('runAnimations'),
                scale: getValue('scale'),
                color: getValue('color') && getValue('color').toCssColorString(),
                heightReference: getValue('heightReference'),
                distanceDisplayCondition: distanceDisplayCondition && {
                    near: distanceDisplayCondition.near,
                    far: distanceDisplayCondition.far
                }
            };
        } else if (type === 'polyline') {
            style = {
                id: getValue('id'),
                name: getValue('name'),
                positions: getValue('positions'),
                clampToGround: getValue('clampToGround'),
                color: getValue('material') && getValue('material').color.toCssColorString(),
                outlineWidth: getValue('material') && getValue('material').outlineWidth,
                outlineColor: getValue('material') && getValue('material').outlineColor.toCssColorString(),
                width: getValue('width'),
                distanceDisplayCondition: distanceDisplayCondition && {
                    near: distanceDisplayCondition.near,
                    far: distanceDisplayCondition.far
                }
            };
        } else if (type === 'polylineVolume') ; else if (type === 'corridor') ; else if (type === 'wall') ; else if (type === 'path') ; else if (type === 'plane') ; else if (type === 'polygon') {
            style = {
                id: getValue('id'),
                name: getValue('name'),
                positions: getValue('hierarchy').positions,
                color: getValue('material') && getValue('material').color.toCssColorString(),
                image: getValue('material') && getValue('material').image,
                repeat: getValue('material') && getValue('material').repeat,
                outlineColor: getValue('outlineColor') && getValue('outlineColor').toCssColorString(),
                outline: getValue('outline'),
                perPositionHeight: getValue('perPositionHeight'),
                height: getValue('height'),
                extrudedHeight: getValue('extrudedHeight'),
                distanceDisplayCondition: distanceDisplayCondition && {
                    near: distanceDisplayCondition.near,
                    far: distanceDisplayCondition.far
                }
            };
        } else if (type === 'ellipse') {
            style = {
                id: getValue('id'),
                name: getValue('name'),
                position: getValue('position'),
                radius: getValue('radius'),
                semiMajorAxis: getValue('semiMajorAxis'),
                semiMinorAxis: getValue('semiMinorAxis'),
                color: getValue('material') && getValue('material').color.toCssColorString(),
                image: getValue('material') && getValue('material').image,
                repeat: getValue('material') && getValue('material').repeat,
                outlineColor: getValue('outlineColor') && getValue('outlineColor').toCssColorString(),
                outline: getValue('outline'),
                height: getValue('height'),
                heightReference: getValue('heightReference'),
                distanceDisplayCondition: distanceDisplayCondition && {
                    near: distanceDisplayCondition.near,
                    far: distanceDisplayCondition.far
                }
            };
            type = 'circle';
        } else if (type === 'rectangle') {
            style = {
                id: getValue('id'),
                name: getValue('name'),
                coordinates: getValue('coordinates'),
                color: getValue('material') && getValue('material').color.toCssColorString(),
                image: getValue('material') && getValue('material').image,
                repeat: getValue('material') && getValue('material').repeat,
                outlineColor: getValue('outlineColor') && getValue('outlineColor').toCssColorString(),
                outline: getValue('outline'),
                height: getValue('height'),
                rotation: getValue('rotation'),
                heightReference: getValue('heightReference'),
                distanceDisplayCondition: distanceDisplayCondition && {
                    near: distanceDisplayCondition.near,
                    far: distanceDisplayCondition.far
                }
            };
        } else if (type === 'box') {
            style = {
                id: getValue('id'),
                name: getValue('name'),
                position: getValue('position'),
                dimensions: getValue('dimensions'),
                color: getValue('material') && getValue('material').color.toCssColorString(),
                image: getValue('material') && getValue('material').image,
                repeat: getValue('material') && getValue('material').repeat,
                outlineColor: getValue('outlineColor') && getValue('outlineColor').toCssColorString(),
                outline: getValue('outline'),
                distanceDisplayCondition: distanceDisplayCondition && {
                    near: distanceDisplayCondition.near,
                    far: distanceDisplayCondition.far
                }
            };
        } else if (type === 'cylinder') {
            style = {
                id: getValue('id'),
                name: getValue('name'),
                position: getValue('position'),
                radius: getValue('radius'),
                topRadius: getValue('topRadius'),
                bottomRadius: getValue('bottomRadius'),
                length: getValue('length'),
                color: getValue('material') && getValue('material').color.toCssColorString(),
                image: getValue('material') && getValue('material').image,
                repeat: getValue('material') && getValue('material').repeat,
                outlineColor: getValue('outlineColor') && getValue('outlineColor').toCssColorString(),
                outline: getValue('outline'),
                distanceDisplayCondition: distanceDisplayCondition && {
                    near: distanceDisplayCondition.near,
                    far: distanceDisplayCondition.far
                },
                changeTop: entity.changeTop
            };
        } else if (type === 'ellipsoid') {
            style = {
                id: getValue('id'),
                name: getValue('name'),
                position: getValue('position'),
                radius: getValue('radius'),
                radii: getValue('radii'),
                color: getValue('material') && getValue('material').color.toCssColorString(),
                image: getValue('material') && getValue('material').image,
                repeat: getValue('material') && getValue('material').repeat,
                outlineColor: getValue('outlineColor') && getValue('outlineColor').toCssColorString(),
                outline: getValue('outline'),
                distanceDisplayCondition: distanceDisplayCondition && {
                    near: distanceDisplayCondition.near,
                    far: distanceDisplayCondition.far
                },
                isSphere: entity.isSphere
            };
        }

        function getValue(attr) {
            if (attr === 'position' || attr === 'name' || attr === 'id') {
                return entity[attr] && (entity[attr].getValue ? entity[attr].getValue() : entity[attr]);
            } else if (attr === 'radius') {
                if (type === 'ellipse') {
                    return entity[type].semiMajorAxis.getValue();
                } else if (type === 'ellipsoid') {
                    return entity[type].radii.getValue().x;
                } else if (type === 'cylinder') {
                    return entity[type].bottomRadius.getValue();
                }
            } else if (attr === 'repeat') {
                return entity[type].material[attr] && (entity[type].material[attr].getValue ? entity[type].material[attr].getValue() : entity[type].material[attr]);
            } else {
                return entity[type][attr] && (entity[type][attr].getValue ? entity[type][attr].getValue() : entity[type][attr]);
            }
        }
        style.type = type;

        return style;
    };
    SimpleGraphic.prototype.addPlotting = function (item) {
        let that = this;
        let collection = new that._cesium.EntityCollection();
        if (item.type === 'polygon' && item.style.extrudedHeight !== undefined) {
            item.type === 'polyhedron';
        } else if (item.type === 'cylinder' && !item.style.changeTop) {
            item.type === 'cone';
        } else if (item.type === 'ellipsoid' && item.style.isSphere) {
            item.type === 'sphere';
        }
        if (item.style && item.style.id && that.SimpleGraphicObj.indexOf(item.style.id) > -1) ; else {
            let entity = that.addSimpleGraphic(item.type, item.style, item.treeobj);
            that.SimpleGraphicObj.push(entity.id);
            collection.add(entity);
        }
    };
    SimpleGraphic.prototype.addFeatures = function (features) {
        let that = this;
        let collection = new that._cesium.EntityCollection();
        features.forEach(item => {
            if (item.type === 'polygon' && item.style.extrudedHeight !== undefined) {
                item.type === 'polyhedron';
            } else if (item.type === 'cylinder' && !item.style.changeTop) {
                item.type === 'cone';
            } else if (item.type === 'ellipsoid' && item.style.isSphere) {
                item.type === 'sphere';
            }
            if (item.style && item.style.id && that.SimpleGraphicObj.indexOf(item.style.id) > -1) ; else {
                let entity = that.addSimpleGraphic(item.type, item.style);
                that.SimpleGraphicObj.push(entity.id);
                collection.add(entity);
            }
        });
        return collection;
    };

    //打开
    SimpleGraphic.prototype.open = function (file, callback) {
        debugger
        let that = this;
        this._viewer;
        let reader = new FileReader();//读取操作就是由它完成的。
        reader.readAsText(file);//读取文件的内容
        reader.onload = function () {
            debugger
            //当读取完成之后会回调这个函数，然后此时文件的内容存储到了result中。直接操作即可。
            let data = JSON.parse(this.result);
            that.analysisJson(data);
            // let features = data.features;
            // let collection = that.addFeatures(features);
            // viewer.flyTo(collection);
            // callback && typeof callback === 'function' && callback(collection);
        };
    };
    //解析json
    SimpleGraphic.prototype.analysisJson = function (obj) {
        for (let i = 0; i < obj.length; i++) {
            if (obj[i] instanceof Array) {
                this.analysisJson(obj[i]);
            } else {
                this.createsj(obj[i]);
            }
        }

    };
    //工程树数据
    var EngineeringTree = [];
    //添加数据
    SimpleGraphic.prototype.createsj = function (obj) {
        let pid = 0;
        let id = "";
        if (obj.style.pId != 0) {
            for (let i = 0; i < EngineeringTree.length; i++) {
                if (EngineeringTree[i].id === obj.style.pId) {
                    pid = EngineeringTree[i].real;
                }
            }
        }
        if (obj.type === "group") {
            id = this._createGroup.createGroup(obj.style.name, false, pid);
        } else {
            if (obj.treeData) {
                obj.treeData.GroupID = pid;
                this.CreateLayer(obj);
            } else {
                this.addPlotting(obj);
            }
        }
        let objp = {
            pid: pid,
            real: id,
            id: obj.style.id
        };
        EngineeringTree.push(objp);
    };
    //添加图层billboardGeoJsonFeatureLayer
    SimpleGraphic.prototype.CreateLayer = function (obj) {
        let styletype = obj.treeData.geoOptions.styletype;
        let servertype = obj.treeData.geoOptions.servertype;
        if (styletype === undefined) {
            styletype = 'polygonbase';
        }
        if (servertype === undefined) {
            servertype = 'geojson';
        }
        if (obj.treeobj.pId) {
            obj.treeData.GroupID = obj.treeobj.pId;
        }
        if (styletype == 'billboardlayer') {
            if (servertype == "vector") {
                this._billboardGeoJsonFeatureLayer.createBillboardGeoJsonFeatureLayerProvider(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            } else {
                this._GeoJsonFeatureLayer.createBillboardGeoJsonFeature(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            }
        } else if (styletype == 'labellayer') {
            if (servertype == "vector") {
                if (obj.treeData.styleOption.textType == "rich") ; else {
                    obj.treeData.styleOption.heightReference == 1 && (obj.treeData.styleOption.heightReference = undefined);

                    this._LabelGeoJsonFeatureLayercopy.createPrimitiveLabelGeoJsonFeatureLayerProvider(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                }
            } else {
                if (obj.treeData.styleOption.collect) {
                    this._LabelGeoJsonFeatureLayercopy.createLabelPolymerizationGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                } else {
                    if (obj.treeData.styleOption.textType == "rich") {
                        this._LabelGeoJsonFeatureLayercopy.createLabelRichtextGeoJsonFeatureLayerProvider(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                    } else {
                        this._LabelGeoJsonFeatureLayercopy.createLabelPointGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                    }
                }
            }
        } else if (styletype == 'SXTLabellayer') {
            if (servertype == "vector") {
                if (obj.treeData.styleOption.textType == "rich") ; else {
                    this._LabelGeoJsonFeatureLayercopy.createSXTLabelGeoJsonFeatureLayerProvider(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                }
            }
        } else if (styletype == 'pointlayer') { //基础点
            if (servertype == "vector") {
                this._VectorGeoJsonFeatureLayer.createPointGeoJsonFeatureLayerProvider(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            } else {
                if (obj.treeData.styleOption.collect) {
                    this._LabelGeoJsonFeatureLayercopy.createPointPolymerizationGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                } else {
                    this._GeoJsonFeatureLayer.createPointGeojsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                }
            }
        } else if (styletype == 'Streetscape') {
            //街景完善
            if (servertype == "vector") {
                this._PolylineGeoJsonFeatureLayer.createPrimitivePolylineVectorGeoJsonFeatureLayerProvider(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            } else {
                if (obj.treeData.styleOption.opacity && obj.treeData.styleOption.material && obj.treeData.styleOption.material.indexOf("#") > -1 && !obj.treeData.styleOption.opacity == 1) {
                    obj.treeData.styleOption.material += obj.treeData.styleOption.opacity * 100;
                }
                this._GeoJsonFeatureLayer.createStreetscapeGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);

            }
        } else if (styletype == 'polylinelayer') {
            if (servertype == "vector") {
                this._PolylineGeoJsonFeatureLayer.createPrimitivePolylineVectorGeoJsonFeatureLayerProvider(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            } else {
                this._GeoJsonFeatureLayer.createStreetscapeGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            }
        } else if (styletype == 'polylinemodellayer') {
            if (servertype == "vector") {
                this._PolylineGeoJsonFeatureLayer.createPolylineVectorGeoJsonFeatureLayerProviderModel(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            } else {
                this._PointModel.exectPointModel(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            }
        } else if (styletype == 'polygonmodellayer') {
            if (servertype == "vector") {
                this._PolygonGeoJsonFeatureLayer.createPolygonVectorGeoJsonFeatureLayerProviderModel(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            } else {
                this._PointModel.createPolygonModel(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            }
        } else if (styletype == 'polygonbase') {
            //贴地面
            if (servertype == "vector") {
                if (obj.treeData.styleOption.ground == "1") {
                    obj.treeData.styleOption.extrudedHeightReference = 1;
                    this._VectorGeoJsonFeatureLayer.createGeoJsonFeatureLayerProviderOptimization(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                } else {
                    this._VectorGeoJsonFeatureLayer.VolumeVectorGeoJsonFeatureLayerOptimizationGroundtest(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                }
            } else {
                if (obj.treeData.styleOption.material && obj.treeData.styleOption.material.indexOf(".jpg") != -1) {
                    //水面
                    this._GeoJsonFeatureLayer.createPolygonMapGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                } else {
                    this._GeoJsonFeatureLayer.createPolygonGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                }
            }
        } else if (styletype == 'polygonlayer') {
            //拉伸面
            if (servertype == "vector") {
                obj.treeData.styleOption.classificationType = 0;
                if (obj.treeData.styleOption.classificationType == 0) {
                    this._VectorGeoJsonFeatureLayer.createGeoJsonFeatureLayerProviderOptimization(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                } else {
                    obj.treeData.styleOption.classificationType = 2;
                    obj.treeData.styleOption.ground = "1";
                    this._VectorGeoJsonFeatureLayer.createGeoJsonFeatureLayerProviderClassOptimization(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                }
            } else {
                if (obj.treeData.styleOption.material && obj.treeData.styleOption.material.indexOf(".jpg") != -1) {
                    //水面
                    this._PolygonVectorTileLayerArcgis.createPolygonMapGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                } else {
                    this._GeoJsonFeatureLayer.createPolygonGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
                }
            }
        } else if (styletype == 'modellayer') {
            if (servertype == "vector") {
                //模型点
                this._VectorGeoJsonFeatureLayer.createModelGeoJsonFeatureLayerProvider(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            } else {
                this._GeoJsonFeatureLayer.createModelPointGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            }
        } else if (styletype == "polylinevolumelayer") {
            if (servertype == "vector") {
                this._VolumeGeoJsonFeatureLayer.createVolumeGeoJsonFeatureLayerProvider(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            } else {
                this._GeoJsonFeatureLayer.createpolylineVolumeGeojsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            }
        } else if (styletype == "polylineWallLayer") { //墙类型样式加载entity
            if (servertype == "vector") {
                this._WallGeoFeatureLayer.createWallGeoJsonFeatureLayerProvider(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            } else {
                this._GeoJsonFeatureLayer.createWallGeoFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            }
        } else if (styletype == "primiviteModels") { //切片box全部加载
            this._PolygonVectorGeoJsonFeatureLayer.createPolygonVectorGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.styleOption.level_max, obj.treeData.styleOption.level_min, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
        } else if (styletype == "primiviteWall") { //墙全加载Primitive
            if (servertype == "vector") ; else {
                this._WallGeoFeatureLayer.createWallPrimitiveGeoFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
            }
        } else if (styletype == "model") ; else if (styletype == "pointcloudmodel") ; else if (styletype == "rasterlayer") ; else {
            this._GeoJsonFeatureLayer.createGeoJsonFeatureLayer(obj.treeData.name, obj.treeData.geoOptions, obj.treeData.styleOption, obj.treeData.GroupID, obj.treeData.checked, obj.treeData.disFnc);
        }
    };
    //移除
    SimpleGraphic.prototype.remove = function (id) {
        let viewer = this._viewer;
        let index = this.SimpleGraphicObj.indexOf(id);
        if (index > -1) {
            viewer.entities.removeById(id);
            this.SimpleGraphicObj.splice(index, 1);

            if (SmartEarthPopupData && SmartEarthPopupData.editGraphic && SmartEarthPopupData.editGraphic.getValue) {
                if (SmartEarthPopupData.editGraphic.getValue("id") === id) {
                    // 移除编辑点，清空编辑点数组
                    tree.editPointID.edit.forEach(item => {
                        viewer.entities.removeById(item);
                    });
                    tree.editPointID.edit = [];

                    tree.editPointID.height.forEach(item => {
                        viewer.entities.removeById(item);
                    });
                    tree.editPointID.height = [];

                    tree.editPointID.add.forEach(item => {
                        viewer.entities.removeById(item);
                    });
                    tree.editPointID.add = [];

                    tree.editPointID.size.forEach(item => {
                        viewer.entities.removeById(item);
                    });
                    tree.editPointID.size = [];

                    tree.editPointID.move && viewer.entities.remove(tree.editPointID.move);
                    tree.editPointID.move = undefined;

                    //关闭原先窗口
                    window.layuiLayer.close(SmartEarthPopupData.layerIndex);
                    SmartEarthPopupData.editGraphic = {};
                }
            }
        }
        if (!this.SimpleGraphicObj.length && this.editHandler) {
            this.edit(false);
        }
    };

    //清空
    SimpleGraphic.prototype.clear = function () {
        let viewer = this._viewer;
        this.SimpleGraphicObj.forEach(id => {
            viewer.entities.removeById(id);
        });
        this.SimpleGraphicObj = [];
        this.PrimitiveCollection.removeAll();

        // 移除编辑点，清空编辑点数组
        tree.editPointID.edit.forEach(item => {
            viewer.entities.removeById(item);
        });
        tree.editPointID.edit = [];

        tree.editPointID.height.forEach(item => {
            viewer.entities.removeById(item);
        });
        tree.editPointID.height = [];

        tree.editPointID.add.forEach(item => {
            viewer.entities.removeById(item);
        });
        tree.editPointID.add = [];

        tree.editPointID.size.forEach(item => {
            viewer.entities.removeById(item);
        });
        tree.editPointID.size = [];

        tree.editPointID.move && viewer.entities.remove(tree.editPointID.move);
        tree.editPointID.move = undefined;

        //关闭原先窗口
        window.layuiLayer.close(SmartEarthPopupData.layerIndex);
        SmartEarthPopupData.editGraphic = {};
        if (!this.SimpleGraphicObj.length && this.editHandler) {
            this.edit(false);
        }
    };
    //保存
    SimpleGraphic.prototype.save = function (fileName) {
        let viewer = this._viewer;
        let data = {
            "type": "FeatureCollection",
            "features": []
        };
        let feature;
        let that = this;

        this.SimpleGraphicObj.forEach(id => {
            let item = viewer.entities.getById(id);
            if (item) {
                let style = that.getStyle(item);
                feature = {
                    id: item.id,
                    name: item.name,
                    type: style.type,
                    style: style
                };
            }
            data.features.push(feature);
        });
        let content = JSON.stringify(data);
        let blob = new Blob([content], { type: "text/plain;charset=utf-8" });

        this._core.saveAs(blob, fileName ? fileName + '.json' : "标绘.json");
    };

    /**
     * 设置富文本
     */
    SimpleGraphic.prototype.setRichtext = function (entity, html) {
        let position = entity.position.getValue();
        this._viewer.entities.removeById(entity.id);

        let GroupID = '0';
        if (entity.treeobj) {
            tree.delete(entity.treeobj.id, this._viewer, this._cesium);
            GroupID = entity.treeobj.pId;
        }

        let divPoint = new DivPoint(this._viewer);
        divPoint.createDivPoint(entity.name, position, {
            id: entity.id,
            description: html,
            GroupID
        });
        return divPoint;
    };

    /**
     * 
     */
    SimpleGraphic.prototype.forceEndHanlder = function () {
        if (this.editHandler) {
            try {
                this.editHandler.destroy();
                this.editHandler = undefined;
            }
            catch (ex) { }
        }
        if (this.drawHandler) {
            try {
                this.drawHandler.destroy();
                this.drawHandler = undefined;
            }
            catch (ex) { }
        }
    };

    /**
     * 通视分析
     *
     * @alias SightLine
     * @constructor
     * 
     * @param {Viewer} Viewer 地图视图
     */
    function SightLine(Viewer) {
        this._viewer = Viewer;
        this._core = new Core();
        this.points = [];

        this._SimpleGraphic = new SimpleGraphic(this._viewer);
        // 禁用编辑
        this._SimpleGraphic.setEdit(false);
    }

    /**
     * 创建通视分析
     * 
     * @param {Object} [option] 参数
     * @param {Object} [option.type='default'] 类型【default|circle】
     * @param {Number} [option.height=1.8] 观察位置相对高度
     * @param {Number} [option.steps=64] 圆形通视分析的精细度
     */
    SightLine.prototype.createSightLine = function (option = {}) {
        if (option.type === 'circle') {
            this._SimpleGraphic.createCircle({}, (entity, data) => {
                let { distance, positions } = data;
                this._SimpleGraphic.remove(entity.id);

                let degrees = this._core.toDegrees(positions[1]);
                positions[1] = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + (option.height || 1.8));
                this.createPoint(positions[1], '观察点');

                let center = [degrees.lon, degrees.lat];
                let circle = Cesium.turf.circle(center, distance, { steps: option.steps || 64, units: 'meters' });
                circle.geometry.coordinates[0].forEach(coordinate => {
                    let height = this._viewer.scene.globe.getHeight(Cesium.Cartographic.fromDegrees(coordinate[0], coordinate[1]));
                    let position = Cesium.Cartesian3.fromDegrees(coordinate[0], coordinate[1], height);
                    let _position = this._viewer.scene.clampToHeight(position);
                    this.createLine([positions[1], _position || position]);
                });
            });
        } else {
            this._SimpleGraphic.createPolyline({
                toPoint: true,
                clampToGround: false
            }, (entity, positions) => {
                this._SimpleGraphic.remove(entity.id);

                let degrees = this._core.toDegrees(positions[0]);
                positions[0] = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height + (option.height || 1.8));
                this.createLine(positions);

                this.createPoint(positions[0], '观察点');
                this.createPoint(positions[1], '目标点');
            });
        }
        return this
    };

    /**
     * 创建视线
     * 
     * @param {Array} positions 坐标
      * @param {Array} objectsToExclude 排除的对象
     */
    SightLine.prototype.createLine = async function (positions, objectsToExclude) {
        // 射线求交
        let result = this._core.pickFromRay(this._viewer, positions[0], positions[1], objectsToExclude);
        if (result && result.position) {
            // 可视
            this._SimpleGraphic.addPolyline({
                positions: [positions[0], result.position],
                color: '#00ff00',
                clampToGround: false
            });
            // 不可视
            this._SimpleGraphic.addPolyline({
                positions: [result.position, positions[1]],
                color: '#ff0000',
                depthFailColor: '#ff00c6',
                clampToGround: false
            });
        } else {
            // 可视
            this._SimpleGraphic.addPolyline({
                positions: positions,
                color: '#00ff00',
                clampToGround: false
            });
        }
    };

    /**
     * 创建视点
     * 
     * @param {Cesium.Cartesian3} position 坐标
      * @param {String} text 文本
     */
    SightLine.prototype.createPoint = function (position, text) {
        this._SimpleGraphic.addPoint({
            position: position,
            pixelSize: 8,
            heightReference: 0
        });
        if (text) {
            this._SimpleGraphic.addLabel({
                text: text,
                position: position,
                font: 'bold 18px 宋体',
                outlineWidth: 2,
                verticalOrigin: 1,
                pixelOffset: new Cesium.Cartesian2(0, -18),
                heightReference: 0
            });
        }
    };

    /**
     * 设置显示隐藏
     * 
     * @param {Boolean} show 是否显示
     */
    SightLine.prototype.setVisibility = function (show) {

    };

    /**
     * 删除
     */
    SightLine.prototype.deleteObject = function () {
        this._SimpleGraphic.clear();
    };

    /**
    *
    * 地形夸张
    *
    * @alias terrainExaggeration 
    * @constructor
    *
    */
    function terrainExaggeration(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }
    /**
    * 地形夸张
    * @param {number} [numb] 数字类型。
    */
    terrainExaggeration.prototype.createterrainExaggeration = function (numb) {
        this._viewer.scene.globe.terrainExaggeration = numb;
        //window.location.reload();
    };

    /**
     *
     * 卷帘对比
     *
     * @alias curtaincontrast
     * @constructor
     *
     */
    function curtaincontrast(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this.leftIndex = undefined;
        this.rightIndex = undefined;
    }

    /**
     * 这个方法用于开启卷帘对比
     * @param {number} [leftIndex] 左侧图层索引。
     * @param {number} [rightIndex] 右侧图层索引。
     */
    curtaincontrast.prototype.curtainContrast = function (leftIndex, rightIndex) {
        var obj = document.getElementById("slider");
        if (obj) {
            this.clear();
        }
        var layers = this._viewer.imageryLayers;
        var scene = this._viewer.scene;
        curtainContrast_Data._scene = scene;

        var add = this._viewer.container;
        var div = document.createElement("div");
        div.id = "slider";
        div.style.position = 'absolute';
        div.style.cursor = 'e-resize';
        div.style.top = 0;
        div.style.backgroundColor = '#D3D3D3';
        div.style.width = '8px';
        div.style.height = '100%';
        div.style.zIndex = '1000';
        add.appendChild(div);
        //实现代码
        var leftLayer = layers.get(leftIndex);
        var rightLayer = layers.get(rightIndex);
        this.leftIndex = leftIndex;
        this.rightIndex = rightIndex;

        leftLayer.splitDirection = this._cesium.ImagerySplitDirection.LEFT;
        rightLayer.splitDirection = this._cesium.ImagerySplitDirection.RIGHT;

        var slider = document.getElementById('slider');
        scene.imagerySplitPosition = (slider.offsetLeft) / slider.parentElement.offsetWidth;
        slider.addEventListener('mousedown', mouseDown, false);
        window.addEventListener('mouseup', mouseUp, false);

        slider.style.left = '50%';
        curtainContrast_Data._scene.imagerySplitPosition = 0.5;
    };

    var curtainContrast_Data = {
        dragStartX: 0,
        _scene: undefined
    };

    function mouseUp() {
        window.removeEventListener('mousemove', sliderMove, false);
    }

    function mouseDown(e) {
        var slider = document.getElementById('slider');
        curtainContrast_Data.dragStartX = e.clientX - slider.offsetLeft;
        window.addEventListener('mousemove', sliderMove, false);
    }

    function sliderMove(e) {
        var slider = document.getElementById('slider');
        var splitPosition = (e.clientX - curtainContrast_Data.dragStartX) / slider.parentElement.offsetWidth;
        slider.style.left = 100.0 * splitPosition + '%';
        curtainContrast_Data._scene.imagerySplitPosition = splitPosition;
    }

    /**
     * 这个方法用于关闭卷帘对比
     *
     */
    curtaincontrast.prototype.close = function () {
        //修改页面分屏
        var obj = document.getElementById("slider");
        if (obj) {
            curtainContrast_Data._scene.imagerySplitPosition = "0%";
            obj.removeEventListener('mousedown', mouseDown, false);
            window.removeEventListener('mouseup', mouseUp, false);
            window.removeEventListener('mousemove', sliderMove, false);
            obj.remove();

            var layers = this._viewer.imageryLayers;
            var leftLayer = layers.get(this.leftIndex);
            var rightLayer = layers.get(this.rightIndex);
            leftLayer.splitDirection = this._cesium.ImagerySplitDirection.NONE;
            rightLayer.splitDirection = this._cesium.ImagerySplitDirection.NONE;
            curtainContrast_Data._scene = undefined;
        }
    };

    /**
     *
     * 室内模式
     *
     * @alias Indoormode
     * @constructor
     *
     */
    function Indoormode(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._handler = null;
        this.setPointerLocker = false;
    }

    /**
     * 室内模式
     */
    Indoormode.prototype.createIndoormode = function (option) {
        var _this = this;
        if (_this._handler != null) {
            return;
        }
        if (option && option.undergroundMode) {
            this.undergroundMode = option.undergroundMode;
        }
        var scene = _this._viewer.scene;
        var canvas = _this._viewer.canvas;
        canvas.setAttribute('tabindex', '0'); // needed to put focus on the canvas
        canvas.focus();
        canvas.onclick = function () {
            canvas.focus();
        };
        this.ellipsoid = scene.globe.ellipsoid;
        // disable the default event handlers
        scene.screenSpaceCameraController.enableRotate = false;
        scene.screenSpaceCameraController.enableTranslate = false;
        scene.screenSpaceCameraController.enableZoom = false;
        scene.screenSpaceCameraController.enableTilt = false;
        scene.screenSpaceCameraController.enableLook = false;
        _this._handler = new _this._cesium.ScreenSpaceEventHandler(canvas);
        // _this._handler.setInputAction(function (movement) {
        //     startMousePosition = movement.startPosition;
        //     mousePosition = movement.endPosition;
        //     indoor_mouseMove();
        // }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        // _this._handler.setInputAction(function (movement) {
        //     flags.looking = true;
        //     mousePosition = startMousePosition = _this._cesium.Cartesian3.clone(movement.position);
        // }, _this._cesium.ScreenSpaceEventType.LEFT_DOWN);

        // _this._handler.setInputAction(function (movement) {
        //     mousePosition = movement.endPosition;
        // }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        // _this._handler.setInputAction(function (position) {
        //     flags.looking = false;
        // }, _this._cesium.ScreenSpaceEventType.LEFT_UP);

        indoor_data._this = this;
        indoor_data.Viewer = _this._viewer;
        indoor_data.camera = _this._viewer.camera;
        document.addEventListener("pointerlockchange", pointerlockchange, false);

        document.addEventListener("mousemove", indoor_mouseMove, false);

        document.addEventListener('keydown', keydown, false);
        document.addEventListener('keyup', keyup, false);
        document.addEventListener("click", middleClick, false);

        _this._viewer.clock.onTick.addEventListener(onTick, _this);
        _this._viewer.container.requestPointerLock();

        return this;
    };

    var indoor_data = {
        _this: null,
        X_speedScale: 1.0,
        Y_speedScale: 0.8,
        moveRate: 0.1,
        moveRates: [0.1, 0.5, 1],
        clickNum: 1,
        movementX: 0,
        movementY: 0,
        moveFactor: 0,
        enable_looking: false,
        Viewer: null,
        camera: null
    };

    var flags$1 = {
        looking: false,
        moveForward: false,
        moveBackward: false,
        moveUp: false,
        moveDown: false,
        moveLeft: false,
        moveRight: false
    };

    function middleClick(e) {
        if (e.button === 1 && indoor_data.moveFactor < 100) {
            indoor_data.moveRate = indoor_data.moveRates[indoor_data.clickNum++];
            if (indoor_data.clickNum > 2) {
                indoor_data.clickNum = 0;
            }
        }
    }

    //鼠标移动
    function indoor_mouseMove(e) {
        if (indoor_data.enable_looking) {
            indoor_data.movementX = e.movementX;
            indoor_data.movementY = e.movementY;
            var width = indoor_data.Viewer.canvas.clientWidth;
            var height = indoor_data.Viewer.canvas.clientHeight;
            var x = indoor_data.movementX / width;
            var y = -indoor_data.movementY / height;
            if (!indoor_data.camera.roll && indoor_data.camera.pitch < 0 && y < 0) {
                y = 0;
            } else if (!indoor_data.camera.roll && indoor_data.camera.pitch > 0 && y > 0) {
                y = 0;
            }
            indoor_data.camera.rotate(indoor_data.camera.position, x * indoor_data.X_speedScale);
            indoor_data.camera.lookUp(y * indoor_data.Y_speedScale);
        }
    }

    function onTick(clock) {
        var camera = this._viewer.camera;
        // if (flags.looking) {
        //     var width = canvas.clientWidth;
        //     var height = canvas.clientHeight;
        //     var x = (mousePosition.x - startMousePosition.x) / width;
        //     var y = -(mousePosition.y - startMousePosition.y) / height;
        //     var lookFactor = 0.5;
        //     //camera.lookRight(x * lookFactor);
        //     if (!camera.roll && camera.pitch > 0 && y > 0) {
        //         y = 0;
        //     } else if (!camera.roll && camera.pitch < 0 && y < 0) {
        //         y = 0;
        //     }
        //     camera.rotate(camera.position, x * lookFactor);
        //     camera.lookUp(y * lookFactor);
        // }

        var groundHeightAtCameraPosition = this._viewer.scene.globe.getHeight(camera.positionCartographic);
        var cameraHeight = this.ellipsoid.cartesianToCartographic(camera.position).height;
        indoor_data.moveFactor = cameraHeight - groundHeightAtCameraPosition;
        var moveRate = indoor_data.moveFactor > 100 ? indoor_data.moveFactor / 100.0 : indoor_data.moveRate;
        if (flags$1.moveForward) {
            camera.moveForward(moveRate);
        }
        if (flags$1.moveBackward) {
            camera.moveBackward(moveRate);
        }
        if (flags$1.moveUp) {
            camera.moveUp(moveRate);
        }
        if (flags$1.moveDown) {
            camera.moveDown(moveRate);
        }
        if (flags$1.moveLeft) {
            camera.moveLeft(moveRate);
        }
        if (flags$1.moveRight) {
            camera.moveRight(moveRate);
        }
    }

    function pointerlockchange() {
        if (document.pointerLockElement) {
            indoor_data.enable_looking = true;
        } else if (indoor_data.enable_looking) {
            indoor_data._this.Indoormodeclose();
        }
    }


    function keydown(e) {
        var flagName = getFlagForKeyCode(e.keyCode);
        if (typeof flagName !== 'undefined') {
            flags$1[flagName] = true;
        }
    }

    function keyup(e) {
        var flagName = getFlagForKeyCode(e.keyCode);
        if (typeof flagName !== 'undefined') {
            flags$1[flagName] = false;
        }
    }

    function getFlagForKeyCode(keyCode) {
        switch (keyCode) {
            case 'W'.charCodeAt(0):
                return 'moveForward';
            case 'S'.charCodeAt(0):
                return 'moveBackward';
            case 'Q'.charCodeAt(0):
                return 'moveUp';
            case 'E'.charCodeAt(0):
                return 'moveDown';
            case 'D'.charCodeAt(0):
                return 'moveRight';
            case 'A'.charCodeAt(0):
                return 'moveLeft';
            default:
                return undefined;
        }
    }

    //关闭室内模式
    Indoormode.prototype.Indoormodeclose = function () {
        var _this = this;
        _this._handler.destroy();
        _this._handler = null;
        document.removeEventListener('keydown', keydown, false);
        document.removeEventListener('keyup', keyup, false);
        document.removeEventListener("pointerlockchange", pointerlockchange, false);
        document.removeEventListener("mousemove", indoor_mouseMove, false);
        document.removeEventListener("click", middleClick, false);
        _this._viewer.clock.onTick.removeEventListener(onTick, _this);
        document.exitPointerLock();
        indoor_data.enable_looking = false;

        document.body.style.cursor = 'default';
        if (this.undergroundMode) {
            this.undergroundMode.isIndoor = false;
            this.undergroundMode.attachMouseEvent();
            this.undergroundMode = undefined;
        } else {
            var scenes = _this._viewer.scene;
            scenes.screenSpaceCameraController.enableRotate = true;
            scenes.screenSpaceCameraController.enableTranslate = true;
            scenes.screenSpaceCameraController.enableZoom = true;
            scenes.screenSpaceCameraController.enableTilt = true;
            scenes.screenSpaceCameraController.enableLook = true;
        }
    };

    /**
     *
     * 添加雨雪雾
     *
     * @alias weather
     * @constructor
     *
     */
    function weather(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    /**
     * 这个方法用于添加雨雪雾
     *@param {string} [type] 类型（雨雪雾）。(rain/snow/fog)
     *@param {bool} [isOpen] 是否开启。
     *@param {Object} [value] 雨雪雾设置的参数。{
     *     test1:雨0—10，雪0—10，雾0—1
     *     test2:雨0—1，雪0—10，雾0—1
     *     test3:雨-1—1，雪0—1
     *     test4:雨0—1，雪0—1
     *}
     * @returns {Promise.<Number>} 。
     */
    weather.prototype.createWeather = function (type, isOpen, value) {
        var collection = this._viewer.scene.postProcessStages;
        var rainValue = null;
        var thisValue = null;
        var snowValue = null;
        var fogValue = null;
        var rainRange = {
            test1: { min: 10, max: 160 },
            test2: { min: 0.5, max: 3 },
            test3: { min: -1, max: 1 },
            test4: { min: 0, max: 1 },
        };
        var snowRange = {
            test1: { min: 10, max: 160 },
            test2: { min: 0, max: 1 },
            test3: { min: 0, max: 0.7 },
            test4: { min: 0.1, max: 0.9 },
        };
        switch (type) {
            case 'rain':
                rainValue = value;
                if (this._viewer.scene.postProcessStages._stages.length) {
                    this._viewer.scene.postProcessStages._stages.forEach(function (item) {
                        if (item && item.name === 'rain') {
                            collection.remove(item);
                        }
                    });
                }
                if (isOpen) {
                    if (!rainValue) {
                        thisValue = {
                            test1: 7.0,
                            test2: 0.3,
                            test3: -0.4,
                            test4: 1.0,
                        };
                        rainValue = {
                            test1: 7.0,
                            test2: 0.3,
                            test3: -0.4,
                            test4: 1.0,
                        };
                    } else {
                        thisValue = {
                            test1: value.test1,
                            test2: value.test2,
                            test3: value.test3,
                            test4: value.test4
                        };
                    }
                    thisValue.test1 = (10 - parseFloat(thisValue.test1)) * 15 + 10;
                    thisValue.test2 = parseFloat(thisValue.test2) * 2.5 + 0.5;
                    if (thisValue.test1 > rainRange.test1.max || thisValue.test1 < rainRange.test1.min) {
                        return;
                    }
                    if (thisValue.test2 > rainRange.test2.max || thisValue.test2 < rainRange.test2.min) {
                        return;
                    }
                    if (thisValue.test3 > rainRange.test3.max || thisValue.test3 < rainRange.test3.min) {
                        return;
                    }
                    if (thisValue.test4 > rainRange.test4.max || thisValue.test4 < rainRange.test4.min) {
                        return;
                    }
                    thisValue.test1 = this.getValue(thisValue.test1 + '');
                    thisValue.test2 = this.getValue(thisValue.test2 + '');
                    thisValue.test3 = this.getValue(thisValue.test3 + '');
                    thisValue.test4 = this.getValue(thisValue.test4 + '');
                    var rain = new this._cesium.PostProcessStage({
                        "name": "rain",
                        fragmentShader: "uniform sampler2D colorTexture; \n" +
                            "varying vec2 v_textureCoordinates;\n\n" +
                            "float hash(float x){\n" +
                            "return fract(sin(x*133.3)*13.13);\n}\n\n" +
                            "void main(void){\n" +
                            "float time = czm_frameNumber / " + thisValue.test1 + ";\n" +
                            "vec2 resolution = czm_viewport.zw; \n" +
                            "vec2 uv=(gl_FragCoord.xy*" + thisValue.test2 + "-resolution.xy)/min(resolution.x,resolution.y); \n" +
                            "vec3 c=vec3(.6,.7,.8);\n" +
                            "float a=" + thisValue.test3 + ";\n" +
                            "float si=sin(a),co=cos(a);\n" +
                            "uv*=mat2(co,-si,si,co);\n" +
                            "uv*=length(uv+vec2(0,4.9))*.3+" + thisValue.test4 + ";\n" +
                            "float v=1.-sin(hash(floor(uv.x*100.))*2.);\n" +
                            "float b=clamp(abs(sin(20.*time*v+uv.y*(5./(2.+v))))-.95,0.,1.)*20.;\n" +
                            "c*=v*b; //屏幕上雨的颜色\n" +
                            "gl_FragColor = mix(texture2D(colorTexture, v_textureCoordinates), vec4(c,1), 0.5); \n }"
                    });
                    collection.add(rain);
                }
                break;
            case 'snow':
                snowValue = value;
                if (this._viewer.scene.postProcessStages._stages.length) {
                    this._viewer.scene.postProcessStages._stages.forEach(function (item) {
                        if (item && item.name === 'snow') {
                            collection.remove(item);
                        }
                    });
                }
                if (isOpen) {
                    if (!snowValue) {
                        thisValue = {
                            test1: 7.0,
                            test2: 0.1,
                            test3: 0.5,
                            test4: 0.5,
                        };
                        snowValue = {
                            test1: 7.0,
                            test2: 0.1,
                            test3: 0.5,
                            test4: 0.5,
                        };
                    } else {
                        thisValue = {
                            test1: value.test1,
                            test2: value.test2,
                            test3: value.test3,
                            test4: value.test4
                        };
                    }
                    thisValue.test1 = (10 - parseFloat(thisValue.test1)) * 15 + 10;
                    thisValue.test2 = parseFloat(thisValue.test2) / 10;
                    thisValue.test3 = parseFloat(thisValue.test3) * 0.7;
                    thisValue.test4 = (1 - parseFloat(thisValue.test4)) * 0.8 + 0.1;
                    if (parseFloat(thisValue.test1) > snowRange.test1.max || parseFloat(thisValue.test1) < snowRange.test1.min) {
                        return;
                    }
                    if (parseFloat(thisValue.test2) > snowRange.test2.max || parseFloat(thisValue.test2) < snowRange.test2.min) {
                        return;
                    }
                    if (parseFloat(thisValue.test3) > snowRange.test3.max || parseFloat(thisValue.test3) < snowRange.test3.min) {
                        return;
                    }
                    if (parseFloat(thisValue.test4) > snowRange.test4.max || parseFloat(thisValue.test4) < snowRange.test4.min) {
                        return;
                    }
                    thisValue.test1 = this.getValue(thisValue.test1 + '');
                    thisValue.test2 = this.getValue(thisValue.test2 + '');
                    thisValue.test3 = this.getValue(thisValue.test3 + '');
                    thisValue.test4 = this.getValue(thisValue.test4 + '');
                    var snow = new this._cesium.PostProcessStage({
                        "name": "snow",
                        fragmentShader: "uniform sampler2D colorTexture;\n" +
                            "varying vec2 v_textureCoordinates;\n" +
                            "float snow(vec2 uv,float scale){\n" +
                            "float time = czm_frameNumber / " + thisValue.test1 + ";\n" +
                            "float w=smoothstep(1.0,0.,-uv.y*(scale/10.0));if(w<" + thisValue.test2 + ")return 0.;\n" +
                            "uv+=time/scale;uv.y+=time*2./scale;uv.x+=sin(uv.y+time*.5)/scale;\n" +
                            "uv*=scale;vec2 s=floor(uv),f=fract(uv),p;float k=3.,d;\n" +
                            "p=" + thisValue.test3 + "+.35*sin(11.*fract(sin((s+p+scale)*mat2(7,3,6,5))*5.))-f;d=length(p);k=min(d,k);\n" +
                            "k=smoothstep(0.,k,sin(f.x+f.y)*0.01);\n" +
                            "return k*w;\n" +
                            "}\n" +

                            "void main(void){\n" +
                            "vec2 resolution = czm_viewport.zw;\n" +
                            "vec2 uv=(gl_FragCoord.xy*2.-resolution.xy)/min(resolution.x,resolution.y);\n" +
                            "vec3 finalColor=vec3(0);\n" +
                            "float c = 0.0;\n" +
                            "c+=snow(uv,30.)*.0;\n" +
                            "c+=snow(uv,20.)*.0;\n" +
                            "c+=snow(uv,15.)*.0;\n" +
                            "c+=snow(uv,10.);\n" +
                            "c+=snow(uv,8.);\n" +
                            "c+=snow(uv,6.);\n" +
                            "c+=snow(uv,5.);\n" +
                            "finalColor=(vec3(c)); //屏幕上雪的颜色\n" +
                            "gl_FragColor = mix(texture2D(colorTexture, v_textureCoordinates), vec4(finalColor,1), " + thisValue.test4 + ");  //将雪和三维场景融合\n" +
                            "}"
                    });
                    collection.add(snow);
                }
                break;
            case 'fog':
                fogValue = value;
                if (this._viewer.scene.postProcessStages._stages.length) {
                    this._viewer.scene.postProcessStages._stages.forEach(function (item) {
                        if (item && item.name === 'fog') {
                            collection.remove(item);
                        }
                    });
                }
                if (isOpen) {
                    if (!fogValue) {
                        thisValue = {
                            distance: 200,
                            color: '#ffffff',
                        };
                        fogValue = {
                            distance: 200,
                            color: '#ffffff',
                        };
                    } else {
                        thisValue = {
                            distance: value.distance,
                            color: value.color && Cesium.Color.fromCssColorString(value.color)
                        };
                    }
                    if (thisValue.distance < 10) {
                        return;
                    }
                    let fog = new Cesium.PostProcessStage({
                        "name": "fog",
                        fragmentShader: "float getDistance(sampler2D depthTexture, vec2 texCoords) \n" +
                            "{ \n" +
                            "    float depth = czm_unpackDepth(texture2D(depthTexture, texCoords)); \n" +
                            "    if (depth == 0.0) { \n" +
                            "        return czm_infinity; \n" +
                            "    } \n" +
                            "    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, depth); \n" +
                            "    return -eyeCoordinate.z / eyeCoordinate.w; \n" +
                            "} \n" +
                            "float interpolateByDistance(vec4 nearFarScalar, float distance) \n" +
                            "{ \n" +
                            "    float startDistance = nearFarScalar.x; \n" +
                            "    float startValue = nearFarScalar.y; \n" +
                            "    float endDistance = nearFarScalar.z; \n" +
                            "    float endValue = nearFarScalar.w; \n" +
                            "    float t = clamp((distance - startDistance) / (endDistance - startDistance), 0.0, 1.0); \n" +
                            "    return mix(startValue, endValue, t); \n" +
                            "} \n" +
                            "vec4 alphaBlend(vec4 sourceColor, vec4 destinationColor) \n" +
                            "{ \n" +
                            "    return sourceColor * vec4(sourceColor.aaa, 1.0) + destinationColor * (1.0 - sourceColor.a); \n" +
                            "} \n" +
                            "uniform sampler2D colorTexture; \n" +
                            "uniform sampler2D depthTexture; \n" +
                            "uniform vec4 fogByDistance; \n" +
                            "uniform vec4 fogColor; \n" +
                            "varying vec2 v_textureCoordinates; \n" +
                            "void main(void) \n" +
                            "{ \n" +
                            "    float distance = getDistance(depthTexture, v_textureCoordinates); \n" +
                            "    vec4 sceneColor = texture2D(colorTexture, v_textureCoordinates); \n" +
                            "    float blendAmount = interpolateByDistance(fogByDistance, distance); \n" +
                            "    vec4 finalFogColor = vec4(fogColor.rgb, fogColor.a * blendAmount); \n" +
                            "    gl_FragColor = alphaBlend(finalFogColor, sceneColor); \n" +
                            "} \n",
                        uniforms: {
                            fogByDistance: new Cesium.Cartesian4(10, 0.0, thisValue.distance || 200, 1.0),
                            fogColor: thisValue.color || Cesium.Color.WHITE,
                        },
                    });
                    collection.add(fog);
                }
                break;
        }
    };
    weather.prototype.getValue = function (str) {
        if (str === '' || str === '-' || str === '.' || str === undefined) {
            return '0.0';
        }
        if (str[str.length - 1] === '-') {
            str = str.substr(0, str.length - 1);
        }
        if (str.split(".").length > 2) {
            return '0.0';
        }
        var num = str.split(".")[1] && str.split(".")[1].length;
        if (!num) {
            return parseFloat(str).toFixed(1);
        } else {
            return str;
        }
    };

    /**
     *
     * 这个方法用于实现粒子特效
     *
     * @alias particle
     * @constructor
     *
     */
    function particle(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this.Fireworks = [];
        this.Smog = [];
        this.Fountain = [];
        this.Flame = [];
    }

    /**
     * 这个方法用于添加粒子特效
     *@param {string} [type] 类型（烟花/烟雾/喷泉/火焰）。(fireworks/smog/fountain/flame)
     *@param {Object} [PositionOrEntity] 位置或entity。
     *@param {Object} [option] 参数。
     *@param {function} [callback] 回调。
     */
    particle.prototype.createParticleEffect = function (type, PositionOrEntity, option, callback) {
        if (!this._viewer.clockViewModel.shouldAnimate) {
            this._viewer.clockViewModel.shouldAnimate = true;
        }

        switch (type) {
            case 'fireworks':
                this.createFireworks(PositionOrEntity, option, callback);
                break;
            case 'smog':
                this.createSmog(PositionOrEntity, option, callback);
                break;
            case 'fountain':
                this.createFountain(PositionOrEntity, option, callback);
                break;
            case 'flame':
                this.createFlame(PositionOrEntity, option, callback);
                break;
        }
    };

    /**
     * 这个方法用于移除粒子特效
     *@param {string} [type] 类型（烟花/烟雾/喷泉/火焰）。(fireworks/smog/fountain/flame)
     */
    particle.prototype.removeParticleEffect = function (type) {
        var scene = this._viewer.scene;
        switch (type) {
            case 'fireworks':
                if (this.Fireworks.length > 0) {
                    this.Fireworks.forEach(function (item) {
                        scene.primitives.remove(item);
                    });
                    this.Fireworks = [];
                }
                break;
            case 'smog':
                if (this.Smog.length > 0) {
                    this.Smog.forEach(function (item) {
                        scene.primitives.remove(item);
                    });
                    this.Smog = [];
                }
                break;
            case 'fountain':
                if (this.Fountain.length > 0) {
                    this.Fountain.forEach(function (item) {
                        scene.primitives.remove(item);
                    });
                    this.Fountain = [];
                }
                break;
            case 'flame':
                if (this.Flame.length > 0) {
                    this.Flame.forEach(function (item) {
                        scene.primitives.remove(item);
                    });
                    this.Flame = [];
                }
                break;
        }
    };

    /*烟花
    *@param {Object} [position] 位置。
    *@param {Object} [option] 参数。{
    * minSize:最小爆炸尺寸
    * maxSize:最大爆炸尺寸
    * size:粒子大小
    * num:烟花数量
    *}
     *@param {function} [callback] 回调。
    */
    particle.prototype.createFireworks = function (position, option, callback) {
        var scene = this._viewer.scene;
        var Viewer = this._viewer;
        var Cesium = this._cesium;

        if (!option) {
            option = {};
        }
        Cesium.Math.setRandomNumberSeed(315);

        //发射初始位置
        var modelMatrix = this.computeModelMatrix(position);
        var emitterInitialLocation = new Cesium.Cartesian3(0.0, 0.0, 100.0);

        var particleCanvas;

        //获取粒子画布
        function getImage() {
            if (!Cesium.defined(particleCanvas)) {
                particleCanvas = document.createElement('canvas');
                particleCanvas.width = 20;
                particleCanvas.height = 20;
                var context2D = particleCanvas.getContext('2d');
                context2D.beginPath();
                context2D.arc(8, 8, 8, 0, Cesium.Math.TWO_PI, true);
                context2D.closePath();
                context2D.fillStyle = 'rgb(255, 255, 255)';
                context2D.fill();
            }
            return particleCanvas;
        }

        var minimumExplosionSize = Cesium.defaultValue(option.minSize, 30.0);  //最小爆炸尺寸
        var maximumExplosionSize = Cesium.defaultValue(option.maxSize, 100.0);  //最大爆炸尺寸
        var size = Cesium.defaultValue(option.size, 7.0);
        var particlePixelSize = new Cesium.Cartesian2(size, size);  //粒子大小
        var burstSize = 400.0;
        var lifetime = 10.0;
        var numberOfFireworks = Cesium.defaultValue(option.num, 20.0);  //烟花数量

        var emitterModelMatrixScratch = new Cesium.Matrix4();

        //创建烟花
        function createFirework(offset, color, bursts) {
            var position = Cesium.Cartesian3.add(emitterInitialLocation, offset, new Cesium.Cartesian3());
            var emitterModelMatrix = Cesium.Matrix4.fromTranslation(position, emitterModelMatrixScratch);
            var particleToWorld = Cesium.Matrix4.multiply(modelMatrix, emitterModelMatrix, new Cesium.Matrix4());
            var worldToParticle = Cesium.Matrix4.inverseTransformation(particleToWorld, particleToWorld);

            //随机爆炸大小
            var size = Cesium.Math.randomBetween(minimumExplosionSize, maximumExplosionSize);
            var particlePositionScratch = new Cesium.Cartesian3();
            var force = function (particle) {
                var position = Cesium.Matrix4.multiplyByPoint(worldToParticle, particle.position, particlePositionScratch);
                if (Cesium.Cartesian3.magnitudeSquared(position) >= size * size) {
                    Cesium.Cartesian3.clone(Cesium.Cartesian3.ZERO, particle.velocity);
                }
            };

            var normalSize = (size - minimumExplosionSize) / (maximumExplosionSize - minimumExplosionSize);
            var minLife = 0.3;
            var maxLife = 1.0;
            var life = normalSize * (maxLife - minLife) + minLife;

            return scene.primitives.add(new Cesium.ParticleSystem({
                image: getImage(),
                startColor: color,
                endColor: color.withAlpha(0.0),
                particleLife: life,
                speed: 100.0,
                imageSize: particlePixelSize,
                emissionRate: 0,
                emitter: new Cesium.SphereEmitter(0.1),
                bursts: bursts,
                lifetime: lifetime,
                updateCallback: force,
                modelMatrix: modelMatrix,
                emitterModelMatrix: emitterModelMatrix
            }));
        }

        var xMin = -100.0;
        var xMax = 100.0;
        var yMin = -80.0;
        var yMax = 100.0;
        var zMin = -50.0;
        var zMax = 50.0;

        var colorOptions = [{
            minimumRed: 0.75,
            green: 0.0,
            minimumBlue: 0.8,
            alpha: 1.0
        }, {
            red: 0.0,
            minimumGreen: 0.75,
            minimumBlue: 0.8,
            alpha: 1.0
        }, {
            red: 0.0,
            green: 0.0,
            minimumBlue: 0.8,
            alpha: 1.0
        }, {
            minimumRed: 0.75,
            minimumGreen: 0.75,
            blue: 0.0,
            alpha: 1.0
        }];

        for (var i = 0; i < numberOfFireworks; ++i) {
            var x = Cesium.Math.randomBetween(xMin, xMax);
            var y = Cesium.Math.randomBetween(yMin, yMax);
            var z = Cesium.Math.randomBetween(zMin, zMax);
            var offset = new Cesium.Cartesian3(x, y, z);
            var color = Cesium.Color.fromRandom(colorOptions[i % colorOptions.length]);

            var bursts = [];
            for (var j = 0; j < 3; ++j) {
                bursts.push(new Cesium.ParticleBurst({
                    time: Cesium.Math.nextRandomNumber() * lifetime,
                    minimum: burstSize,
                    maximum: burstSize
                }));
            }

            this.Fireworks.push(createFirework(offset, color, bursts));
        }

        if (callback && typeof callback === 'function') {
            callback(this.Fireworks);
        } else {
            var camera = Viewer.scene.camera;
            var cameraOffset = new Cesium.Cartesian3(-300.0, 0.0, 0.0);
            camera.lookAtTransform(modelMatrix, cameraOffset);
            camera.lookAtTransform(Cesium.Matrix4.IDENTITY);

            var toFireworks = Cesium.Cartesian3.subtract(emitterInitialLocation, cameraOffset, new Cesium.Cartesian3());
            Cesium.Cartesian3.normalize(toFireworks, toFireworks);
            var angle = Cesium.Math.PI_OVER_TWO - Math.acos(Cesium.Cartesian3.dot(toFireworks, Cesium.Cartesian3.UNIT_Z));
            camera.lookUp(angle);
        }
    };

    /* 烟雾
    *@param {Object} [PositionOrEntity] 位置或entity。
    *@param {Object} [option] 参数。{
    * type: 烟雾放射类型（圆形放射/球体放射/圆锥体放射/盒状放射），默认圆形放射。
    * rotation:旋转，Cesium.HeadingPitchRoll对象。
    * translation:平移，Cesium.Cartesian3对象。
    * gravity:重力方向。
    * particleSize:粒子大小。
    * emissionRate:每秒发射的粒子数。
    * minimumParticleLife:粒子寿命可能的持续时间的最小范围。
    * maximumParticleLife:粒子寿命可能的持续时间的最大范围。
    * startScale:粒子初始大小。
    * endScale：粒子最终大小。
    * lifetime：粒子存活时间。
    *}
     *@param {function} [callback] 回调。
    */
    particle.prototype.createSmog = function (PositionOrEntity, option, callback) {
        this._viewer.scene;
        var Viewer = this._viewer;
        var Cesium = this._cesium;
        var _this = this;

        if (!option || option === '') {
            option = {};
        }

        Cesium.Math.setRandomNumberSeed(3);

        var SmogData = {
            image: window.SmartEarthRootUrl + configData$1.smog,
            emissionRate: 50.0,
            gravity: 0.0,
            minimumParticleLife: 1,
            maximumParticleLife: 1.2,
            minimumSpeed: 1.0,
            maximumSpeed: 4.0,
            startScale: 1.0,
            endScale: 5.0,
            particleSize: 1.0,
            lifetime: 6.0
        };
        this._core.extend(SmogData, option, true);

        var particleSystem;
        var gravityScratch = new Cesium.Cartesian3();

        //添加烟雾
        var smog = addSmog(PositionOrEntity);
        this.Smog.push(smog);

        if (callback && typeof callback === 'function') {
            callback(this.Smog);
        }

        function addSmog(PositionData) {
            var scene = Viewer.scene;
            particleSystem = scene.primitives.add(new Cesium.ParticleSystem({
                image: SmogData.image,
                startColor: Cesium.Color.LIGHTSEAGREEN.withAlpha(0.7),
                endColor: Cesium.Color.WHITE.withAlpha(0.0),
                startScale: SmogData.startScale,
                endScale: SmogData.endScale,
                sizeInMeters: true,
                minimumParticleLife: SmogData.minimumParticleLife,
                maximumParticleLife: SmogData.maximumParticleLife,
                minimumSpeed: SmogData.minimumSpeed,
                maximumSpeed: SmogData.maximumSpeed,
                imageSize: new Cesium.Cartesian2(SmogData.particleSize, SmogData.particleSize),
                emissionRate: SmogData.emissionRate,
                lifetime: SmogData.lifetime,
                emitter: new Cesium.CircleEmitter(2.0),
                emitterModelMatrix: _this.computeEmitterModelMatrix(option.translation, option.rotation),
                updateCallback: applyGravity
            }));

            if (SmogData.type) {
                setType(SmogData.type);
            }

            Viewer.scene.preUpdate.addEventListener(function (scene, time) {
                if (particleSystem) {
                    particleSystem.modelMatrix = _this.computeModelMatrix(PositionData, time);
                    // Account for any changes to the emitter model matrix.
                    particleSystem.emitterModelMatrix = _this.computeEmitterModelMatrix(option.translation, option.rotation);
                }
            });
            return particleSystem;
        }

        function applyGravity(p, dt) {
            // We need to compute a local up vector for each particle in geocentric space.
            var position = p.position;

            Cesium.Cartesian3.normalize(position, gravityScratch);
            Cesium.Cartesian3.multiplyByScalar(gravityScratch, SmogData.gravity * dt, gravityScratch);

            p.velocity = Cesium.Cartesian3.add(p.velocity, gravityScratch, p.velocity);
        }

        function setType(newValue) {
            if (newValue === '圆形放射') {
                particleSystem.emitter = new Cesium.CircleEmitter(2);
            } else if (newValue === '球体放射') {
                particleSystem.emitter = new Cesium.SphereEmitter(2.5);
            } else if (newValue === '圆锥体放射') {
                particleSystem.emitter = new Cesium.ConeEmitter(Cesium.Math.toRadians(45.0));
            } else if (newValue === '盒状放射') {
                particleSystem.emitter = new Cesium.BoxEmitter(new Cesium.Cartesian3(10.0, 10.0, 10.0));
            }
        }

    };

    /* 喷泉
    *@param {Object} [PositionOrEntity] 位置或entity。
    *@param {Object} [option] 参数。{
    * angle: 圆锥喷泉角度。
    * rotation:旋转，Cesium.HeadingPitchRoll对象。
    * translation:平移，Cesium.Cartesian3对象。
    * gravity:重力方向。
    * particleSize:粒子大小。
    * emissionRate:每秒发射的粒子数。
    * minimumParticleLife:粒子寿命可能的持续时间的最小范围。
    * maximumParticleLife:粒子寿命可能的持续时间的最大范围。
    * minimumSpeed: 最小速度
    * maximumSpeed: 最大速度
    * startScale:粒子初始大小。
    * endScale：粒子最终大小。
    * lifetime：粒子存活时间。
    *}
     *@param {function} [callback] 回调。
    */
    particle.prototype.createFountain = function (PositionOrEntity, option, callback) {
        this._viewer.scene;
        var Viewer = this._viewer;
        var Cesium = this._cesium;
        var _this = this;
        if (!option || option === '') {
            option = {};
        }
        var FountainData = {
            image: window.SmartEarthRootUrl + configData$1.penquan,
            emissionRate: 50,// 粒子数量
            minimumParticleLife: 3,// 最小生命周期
            maximumParticleLife: 4,// 最大生命周期
            minimumSpeed: 9.0,// 最小速度
            maximumSpeed: 9.5,// 最大速度
            startScale: 1,// 开始大小比例
            endScale: 15,// 结束大小比例
            particleSize: 1,// 粒子大小
            lifetime: 6,  //存活时间
            gravity: -3.5  //重力方向
        };
        this._core.extend(FountainData, option, true);
        var gravityScratch = new Cesium.Cartesian3();
        var particleSystem;

        var fountain = addFountain();
        this.Fountain.push(fountain);

        if (callback && typeof callback === 'function') {
            callback(this.Fountain);
        }

        function addFountain() {
            particleSystem = Viewer.scene.primitives.add(new Cesium.ParticleSystem({
                image: FountainData.image,// 粒子的图片
                startColor: new Cesium.Color(1, 1, 1, 0.3),// 起始颜色
                endColor: new Cesium.Color(0.80, 0.86, 1, 0.4),// 结束颜色
                startScale: FountainData.startScale,
                endScale: FountainData.endScale,
                minimumParticleLife: FountainData.minimumParticleLife,
                maximumParticleLife: FountainData.maximumParticleLife,
                minimumSpeed: FountainData.minimumSpeed,
                maximumSpeed: FountainData.maximumSpeed,
                imageSize: new Cesium.Cartesian2(FountainData.particleSize, FountainData.particleSize * 2),
                emissionRate: FountainData.emissionRate,
                lifetime: FountainData.lifetime,
                loop: true,// 循环是否开启
                emitter: new Cesium.ConeEmitter(Cesium.Math.toRadians(Cesium.defaultValue(FountainData.angle, 7.0))),// 粒子的释放方向
                updateCallback: applyGravity,// 重力回调
                sizeInMeters: true// 是否以米为单位
            }));
            Viewer.scene.preUpdate.addEventListener(function (scene, time) {
                if (particleSystem) {
                    particleSystem.modelMatrix = _this.computeModelMatrix(PositionOrEntity, time);
                    particleSystem.emitterModelMatrix = _this.computeEmitterModelMatrix(option.translation, option.rotation);
                }
            });
            return particleSystem;
        }

        function applyGravity(p, dt) {
            var position = p.position;
            Cesium.Cartesian3.normalize(position, gravityScratch);
            Cesium.Cartesian3.multiplyByScalar(gravityScratch, FountainData.gravity * dt, gravityScratch);
            p.velocity = Cesium.Cartesian3.add(p.velocity, gravityScratch, p.velocity);
        }

    };

    /* 火焰
    *@param {Object} [PositionOrEntity] 位置或entity。
    *@param {Object} [option] 参数。{
    * rotation:旋转，Cesium.HeadingPitchRoll对象。
    * translation:平移，Cesium.Cartesian3对象。
    * gravity:重力方向。
    * particleSize:粒子大小。
    * emissionRate:每秒发射的粒子数。
    * minimumParticleLife:粒子寿命可能的持续时间的最小范围。
    * maximumParticleLife:粒子寿命可能的持续时间的最大范围。
    * minimumSpeed: 最小速度
    * maximumSpeed: 最大速度
    * startScale:粒子初始大小。
    * endScale：粒子最终大小。
    * lifetime：粒子存活时间。
    *}
     *@param {function} [callback] 回调。
    */
    particle.prototype.createFlame = function (PositionOrEntity, option, callback) {
        this._viewer.scene;
        var Viewer = this._viewer;
        var Cesium = this._cesium;
        var _this = this;

        if (!option || option === '') {
            option = {};
        }
        var FlameData = {
            image: window.SmartEarthRootUrl + configData$1.fire,
            emissionRate: 200.0,
            gravity: 0.0,
            minimumParticleLife: 1.0,
            maximumParticleLife: 3.0,
            minimumSpeed: 1.0,
            maximumSpeed: 4.0,
            startScale: 1.0,
            endScale: 6.0,
            particleSize: 1.0,
            lifetime: 16.0
        };
        this._core.extend(FlameData, option, true);


        var file = addFile(PositionOrEntity);
        this.Flame.push(file);

        if (callback && typeof callback === 'function') {
            callback(this.Flame);
        }

        function addFile(PositionData) {
            return Viewer.scene.primitives.add(
                new Cesium.ParticleSystem({
                    image: FlameData.image,
                    startColor: Cesium.Color.RED.withAlpha(0.7), //粒子出生时的颜色
                    endColor: Cesium.Color.YELLOW.withAlpha(0.3), //当粒子死亡时的颜色
                    startScale: FlameData.startScale, //粒子出生时的比例，相对于原始大小
                    endScale: FlameData.endScale, //粒子在死亡时的比例
                    minimumParticleLife: FlameData.minimumParticleLife, //设置粒子寿命的可能持续时间的最小界限（以秒为单位），粒子的实际寿命将随机生成
                    maximumParticleLife: FlameData.maximumParticleLife, //设置粒子寿命的可能持续时间的最大界限（以秒为单位），粒子的实际寿命将随机生成
                    minimumSpeed: FlameData.minimumSpeed, //设置以米/秒为单位的最小界限，超过该最小界限，随机选择粒子的实际速度。
                    maximumSpeed: FlameData.maximumSpeed, //设置以米/秒为单位的最大界限，超过该最大界限，随机选择粒子的实际速度。
                    imageSize: new Cesium.Cartesian2(FlameData.particleSize, FlameData.particleSize), //如果设置该属性，将会覆盖 minimumImageSize和maximumImageSize属性，以像素为单位缩放image的大小
                    emissionRate: FlameData.emissionRate, //每秒发射的粒子数。
                    sizeInMeters: true,// 是否以米为单位
                    lifetime: FlameData.lifetime, //多长时间的粒子系统将以秒为单位发射粒子
                    emitter: new Cesium.ConeEmitter(Cesium.Math.toRadians(16.0)), //此系统的粒子发射器  共有 圆形、锥体、球体、长方体 ( BoxEmitter,CircleEmitter,ConeEmitter,SphereEmitter ) 几类
                    modelMatrix: _this.computeModelMatrix(PositionData), // 4x4转换矩阵，可将粒子系统从模型转换为世界坐标
                    emitterModelMatrix: _this.computeEmitterModelMatrix(FlameData.translation, FlameData.rotation) // 4x4转换矩阵，用于在粒子系统本地坐标系中转换粒子系统发射器
                })
            );
        }
    };

    //粒子发射初始位置
    particle.prototype.computeModelMatrix = function (PositionData, time) {
        var Cesium = this._cesium;
        if (PositionData instanceof Cesium.Entity) {
            return PositionData.computeModelMatrix(time, new Cesium.Matrix4());
        } else if (PositionData.x && PositionData.y) {
            var Cartesian3;
            if (PositionData.x <= 180 && PositionData.x >= -180 && PositionData.y <= 90 && PositionData.y >= -90) {
                Cartesian3 = Cesium.Cartesian3.fromDegrees(PositionData.x, PositionData.y, PositionData.z || 0);
            } else {
                Cartesian3 = PositionData;
            }
            return Cesium.Transforms.eastNorthUpToFixedFrame(Cartesian3);
        }
    };


    // 改变粒子系统的位置
    particle.prototype.computeEmitterModelMatrix = function (translation, rotation) {
        var Cesium = this._cesium;
        var trs = new Cesium.TranslationRotationScale();
        var hpr = Cesium.HeadingPitchRoll.fromDegrees(0.0, 0.0, 0.0);
        trs.translation = Cesium.defaultValue(translation, Cesium.Cartesian3.fromElements(0.0, 0.0, 0.0));
        trs.rotation = Cesium.Quaternion.fromHeadingPitchRoll(Cesium.defaultValue(rotation, hpr));

        return Cesium.Matrix4.fromTranslationRotationScale(trs);
    };

    /**
     *
     * 这个方法用于创建地下模式。
     *
     * @alias UndergroundMode
     * @constructor
     *
     */
    function UndergroundMode(viewer, cesium) {
      this._viewer = viewer;
      this._cesium = cesium;
      this._core = new Core();
      this._tree = tree;
      this._indoormode = new Indoormode(viewer, cesium);
      this._model = null;
      this._relativeHeight = -100;
      this._groundHeightAtCameraPosition = 0;
      this._startMousePosition;
      this._mousePosition;
      this._cameraHeight;
      this._originalOption;
      this._alpha = 0.5;
      this._brightness = 0.3;
      this._depth = 300;
      this._canvas = null;
      this.isIndoor = false;
      this.isUndergroundMode = false;
      this._flags = {
        move: false,
        vertical: false,
        horizontally: false,
        rotate: false,
      };
      this.moveSpeed = 1;
    }

    //刷新格网
    UndergroundMode.prototype.refreshGridLines = function () {
      var showUndergroundSurface = this._relativeHeight < 0;
      var camera = this._viewer.camera;
      var s = new this._cesium.Cartographic(
        camera.positionCartographic.longitude,
        camera.positionCartographic.latitude,
        -this._depth
      );
      if (!this._model) {
        this._model = this.UndergroundGridLines(s, showUndergroundSurface);
      } else {
        //刷新地下网格线
        var newModel = this.UndergroundGridLines(s, showUndergroundSurface);
        this._viewer.scene.primitives.remove(this._model);
        this._model = newModel;
      }
    };
    /**
     * 这个方法用于创建地下模式开启
     * @param {Object} [option]参数{
     *      depth:地下深度，默认300m
     *      alpha:地表透明度，默认0.5
     *      height:相机视角高度，默认-100m
     *      isEnterUnderground:开启地下模式是否进入地下，默认是。
     *      isFlyToSky:退出地下模式是否回到天上，默认是。
     * }。
     * @param {Boolean} [isIndoor] 是否开启室内模式，默认否。
     *
     */
    UndergroundMode.prototype.UndergroundModelOpen = function (option, isIndoor) {
      if (this._model) return;
      this._getOriginalOption();
      var camera1 = this._viewer.camera;
      var s = new this._cesium.Cartographic(
        camera1.positionCartographic.longitude,
        camera1.positionCartographic.latitude,
        -this._depth
      );
      //修改
      var sop = new this._cesium.Cartographic(
        camera1.positionCartographic.longitude,
        camera1.positionCartographic.latitude,
        camera1.positionCartographic.height
      );
      this.destination = sop;
      this.orientation = {
        heading: camera1.heading,
        pitch: camera1.pitch,
        roll: 0.0,
      };
      if (this._cesium.ExpandBySmartEarth) {
        this._cesium.ExpandBySmartEarth.underEarth.cullFace = false;
        this._cesium.ExpandBySmartEarth.underEarth.enable = true;
        this._cesium.ExpandBySmartEarth.underEarth.enableDepth = this._depth;
        this._cesium.ExpandBySmartEarth.underEarth.enableSkirt = true;
      }
      this._viewer.scene.globe.baseColor = this._cesium.Color.WHITE.withAlpha(0.0);
      var cameraHeight;
      if (option) {
        this._depth = this._cesium.defaultValue(option.depth, 300);
        this._alpha = this._cesium.defaultValue(option.alpha, 0.5);
        this._brightness = this._cesium.defaultValue(option.brightness, 0.3);
        this.isEnterUnderground = this._cesium.defaultValue(
          option.isEnterUnderground,
          true
        );
        this.isFlyToSky = this._cesium.defaultValue(option.isFlyToSky, true);
        cameraHeight = this._cesium.defaultValue(option.height, -100);
      } else {
        this._depth = 300;
        this._alpha = 0.5;
        this._brightness = 0.3;
        this.isEnterUnderground = true;
        this.isFlyToSky = true;
        cameraHeight = -100;
      }
      this.setLayerAlpha(this._alpha, this._brightness);
      this._viewer.scene.globe.depthTestAgainstTerrain = true;
      this._viewer.scene.highDynamicRange = false;
      this._viewer.scene.skyAtmosphere.show = false;
      this._viewer.scene.skyBox.show = false;
      this._viewer.scene.fog.enabled = false;
      this._viewer.scene.backgroundColor = new this._cesium.Color(0.0, 0.0, 0.0, 1.0);
      this._viewer.container.style.backgroundImage = 'unset';
      this.isUndergroundMode = true;
      if (isIndoor) {
        this.isIndoor = true;
        this._indoormode.createIndoormode({
          undergroundMode: this,
        });
      } else {
        this.isIndoor = false;
      }
      var camera = this._viewer.camera;
      var s = new this._cesium.Cartographic(
        camera.positionCartographic.longitude,
        camera.positionCartographic.latitude,
        -this._depth
      );
      //创建地下网格
      this._model = this.UndergroundGridLines(s, true);
      this._viewer.scene.preRender.addEventListener(this.getRelativeHeight, this);
      this.getRelativeHeight();
      if (this._relativeHeight > 0 && this.isEnterUnderground) {
        //定位到地下
        this.enterUnderground(cameraHeight);
      }
      return this;
    };
    //关闭
    UndergroundMode.prototype.close = function () {
      if (this._model) {
        this._viewer.scene.preRender.removeEventListener(
          this.getRelativeHeight,
          this
        );
        this.setLayerAlpha(
          this._originalOption.alpha,
          this._originalOption.brightness
        );
        //移除网格线
        this._viewer.scene.primitives.remove(this._model);
        if (this._cesium.ExpandBySmartEarth) {
          this._cesium.ExpandBySmartEarth.underEarth.cullFace = undefined;
          this._cesium.ExpandBySmartEarth.underEarth.enable = false;
          this._cesium.ExpandBySmartEarth.underEarth.enableDepth = 0;
          this._cesium.ExpandBySmartEarth.underEarth.enableSkirt = false;
        }
        this._viewer.scene.globe.baseColor = this._cesium.Color.WHITE.withAlpha(
          1.0
        );
        this._viewer.scene.globe.depthTestAgainstTerrain = this._originalOption.depthTest;
        this._viewer.scene.skyBox &&
          (this._viewer.scene.skyBox.show = this._originalOption.skyBoxShow);
        this._viewer.scene.highDynamicRange = this._originalOption.highDynamicRange;
        this._viewer.scene.skyAtmosphere.show = this._originalOption.skyShow;
        this._viewer.scene.backgroundColor = this._originalOption.backgroundColor;
        this._viewer.container.style.backgroundImage = this._originalOption.backgroundImage;
        this._viewer.scene.fog.enabled = this._originalOption.fog;

        this.isUndergroundMode = false;
        this._model = null;
        oldCameraPosition = undefined;
        this._viewer.camera.positionCartographic;

        //取消地下模式移动事件
        detachMouseEvent(this);
        if (this.isFlyToSky) {
          //回到地面上
          if (this._relativeHeight > 500) return;
          this.flyToSky();
        }
      }
    };
    //获取原始参数
    UndergroundMode.prototype._getOriginalOption = function () {
      var e = {
        alpha: this._cesium.clone(
          this._viewer.imageryLayers._layers[0] &&
          this._viewer.imageryLayers._layers[0].alpha
        ),
        brightness: this._cesium.clone(
          this._viewer.imageryLayers._layers[0] &&
          this._viewer.imageryLayers._layers[0].brightness
        ),
        highDynamicRange: this._cesium.clone(this._viewer.scene.highDynamicRange),
        skyShow: this._cesium.clone(this._viewer.scene.skyAtmosphere.show),
        skyBoxShow: this._cesium.clone(
          this._viewer.scene.skyBox && this._viewer.scene.skyBox.show
        ),
        depthTest: this._cesium.clone(
          this._viewer.scene.globe.depthTestAgainstTerrain
        ),
        backgroundColor: this._viewer.scene.backgroundColor.clone(),
        backgroundImage: this._viewer.container.style.backgroundImage,
        fog: this._viewer.scene.fog.enabled
      };
      this._viewer.scene.globe._surface &&
        this._viewer.scene.globe._surface._tileProvider &&
        this._viewer.scene.globe._surface._tileProvider._renderState &&
        (e.blending = this._cesium.clone(
          this._viewer.scene.globe._surface._tileProvider._renderState.blending
        ));
      this._originalOption = e;
    };
    //进入地下
    UndergroundMode.prototype.enterUnderground = function (cameraHeight) {
      var camera = this._viewer.camera;
      var s = new this._cesium.Cartographic(
        camera.positionCartographic.longitude,
        camera.positionCartographic.latitude,
        -this._depth
      );
      //修改
      if (camera.positionCartographic.height <= 10) {
        return;
      }
      // 测试
      // var sop = new this._cesium.Cartographic(camera.positionCartographic.longitude, camera.positionCartographic.latitude, camera.positionCartographic.height);
      // this.destination=sop;
      // this.orientation={
      //        heading: camera.heading,
      //        pitch: camera.pitch,
      //        roll: 0.0
      //    };
      camera.flyTo({
        destination: new this._cesium.Cartesian3.fromRadians(
          s.longitude,
          s.latitude,
          cameraHeight || -this._depth / 3
        ), //Frederick coordinates
        orientation: {
          heading: this._cesium.Math.toRadians(0.0),
          pitch: this._cesium.Math.toRadians(0.0),
          roll: 0.0,
        },
        // orientation: {
        //     heading: camera.heading,
        //     pitch:camera.pitch,
        //     roll:0.0
        // },
        complete: function () { },
      });
    };
    //回到地面
    UndergroundMode.prototype.flyToSky = function () {
      var camera = this._viewer.camera;
      this._viewer.camera.positionCartographic;
      //修改
      if (camera.positionCartographic.height >= 10) {
        return;
      }
      // this._viewer.camera.flyTo({
      //     destination: new this._cesium.Cartesian3.fromRadians(s.longitude, s.latitude, s.height - this._relativeHeight + 500), //Frederick coordinates
      //     orientation: {
      //        heading: camera.heading,
      //        pitch:camera.pitch,
      //        roll:0.0
      //     }
      // });
      this._viewer.camera.flyTo({
        destination: new this._cesium.Cartesian3.fromRadians(
          this.destination.longitude,
          this.destination.latitude,
          this.destination.height
        ), //Frederick coordinates
        orientation: {
          heading: this.orientation.heading,
          pitch: this.orientation.pitch,
          roll: 0.0,
        },
      });
    };
    //图层透明度
    UndergroundMode.prototype.setLayerAlpha = function (alpha, brightness) {
      var num = this._viewer.imageryLayers.length;
      for (var i = 0; i < num; i++) {
        this._viewer.imageryLayers.get(i).alpha = alpha;
        brightness !== undefined &&
          (this._viewer.imageryLayers.get(i).brightness = brightness);
      }
      this._alpha = alpha;
      brightness !== undefined && (this._brightness = brightness);
    };
    //创建地下网格线
    UndergroundMode.prototype.UndergroundGridLines = function (e, t) {
      var n = e;
      e instanceof this._cesium.Cartesian3 &&
        (n = this._viewer.scene.globe.ellipsoid.cartesianToCartographic(e));
      var r = new this._cesium.GeometryInstance({
        geometry: new this._cesium.EllipseGeometry({
          center: this._cesium.Cartesian3.fromRadians(n.longitude, n.latitude),
          height: n.height,
          semiMinorAxis: 2e4,
          semiMajorAxis: 2e4,
          vertexFormat: this._cesium.VertexFormat.POSITION_AND_ST,
        }),
        id: "undergroundSurface",
      });
      var i = this._cesium.Material.fromType("Grid");
      i.uniforms.color = this._cesium.Color.WHITE.withAlpha(0.3);
      i.uniforms.cellAlpha = 0.01;
      i.uniforms.lineCount = new this._cesium.Cartesian2(200, 200);
      i.uniforms.lineThickness = new this._cesium.Cartesian2(1.0, 1.0);
      var s = this._viewer.scene.primitives.add(
        new this._cesium.Primitive({
          geometryInstances: r,
          appearance: new this._cesium.EllipsoidSurfaceAppearance({
            material: i,
          }),
        })
      );
      s.appearance.renderState.depthTest.enabled = true;
      s.show = t;
      return s;
    };

    //取消地下模式移动事件
    function detachMouseEvent(that) {
      var scene = that._viewer.scene;
      that._viewer.canvas;

      if (that._tree && that._tree.handler) {
        that._tree.handler.destroy();
        that._tree.handler = null;
      }

      scene.screenSpaceCameraController.enableRotate = true;
      scene.screenSpaceCameraController.enableTranslate = true;
      scene.screenSpaceCameraController.enableZoom = true;
      scene.screenSpaceCameraController.enableTilt = true;
      scene.screenSpaceCameraController.enableLook = true;
    }

    //添加地下模式移动事件
    UndergroundMode.prototype.attachMouseEvent = function () {
      var _this = this;
      var scene = this._viewer.scene;
      this._canvas = this._viewer.canvas;
      this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._canvas);
      this._canvas.setAttribute("tabindex", "0"); // needed to put focus on the canvas
      this._canvas.onclick = function () {
        _this._canvas.focus();
      };

      //禁止默认事件
      scene.screenSpaceCameraController.enableRotate = false;
      scene.screenSpaceCameraController.enableTranslate = false;
      scene.screenSpaceCameraController.enableZoom = false;
      scene.screenSpaceCameraController.enableTilt = false;
      scene.screenSpaceCameraController.enableLook = false;

      this._tree.handler.setInputAction(function (movement) {
        _this._flags.move = true;
        if (_this._viewer.camera.pitch > _this._cesium.Math.toRadians(5.0)) {
          _this._flags.vertical = true;
          _this._startMousePosition = movement.position;
        } else {
          _this._flags.horizontally = true;
        }
        _this._viewer.camera.positionCartographic;
        _this._cameraHeight = _this._viewer.camera.positionCartographic.height;
      }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);
      this._tree.handler.setInputAction(function (movement) {
        _this._flags.move = true;
        _this._flags.rotate = true;
      }, this._cesium.ScreenSpaceEventType.MIDDLE_DOWN);
      this._tree.handler.setInputAction(function (movement) {
        if (!_this._flags.vertical) {
          _this._startMousePosition = movement.startPosition;
        }
        _this._mousePosition = movement.endPosition;
        _this.mouseMoveEvent();
      }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
      this._tree.handler.setInputAction(function (position) {
        _this._flags.move = false;
        _this._flags.horizontally = false;
        _this._flags.vertical = false;
      }, this._cesium.ScreenSpaceEventType.LEFT_UP);
      this._tree.handler.setInputAction(function (position) {
        _this._flags.move = false;
        _this._flags.rotate = false;
      }, this._cesium.ScreenSpaceEventType.MIDDLE_UP);
      var zoom_speedScale = 1000;
      this._tree.handler.setInputAction(function (wheel) {
        var camera = _this._viewer.camera;
        var scale =
          camera.positionCartographic.height > 500
            ? camera.positionCartographic.height / zoom_speedScale
            : 0.1;
        if (
          (camera.pitch < 0 &&
            camera.positionCartographic.height < -200 &&
            wheel > 0) ||
          (camera.pitch > 0 &&
            camera.positionCartographic.height < -200 &&
            wheel < 0)
        ) {
          return;
        }
        camera.zoomIn(wheel * scale);
      }, this._cesium.ScreenSpaceEventType.WHEEL);
    };
    //鼠标移动事件
    UndergroundMode.prototype.mouseMoveEvent = function () {
      //参数
      var vertical_speedScale = 200 * this.moveSpeed;
      var horizontally_speedScale = 2;
      var rotate_speedScale = 0.001;

      var camera = this._viewer.camera;
      if (this._flags.move) {
        this._canvas.clientWidth;
        var height = this._canvas.clientHeight;
        var x = this._mousePosition.x - this._startMousePosition.x;
        var y = -(this._mousePosition.y - this._startMousePosition.y);

        //水平
        if (this._flags.horizontally) {
          camera.moveLeft(x * horizontally_speedScale);
          camera.moveBackward(y * horizontally_speedScale);
          camera.setView({
            destination: this._cesium.Cartesian3.fromRadians(
              camera.positionCartographic.longitude,
              camera.positionCartographic.latitude,
              this._cameraHeight
            ),
            orientation: {
              heading: camera.heading,
              pitch: camera.pitch,
              roll: camera.roll,
            },
          });
        }
        //垂直
        if (this._flags.vertical) {
          y = y / height;
          camera.setView({
            destination: this._cesium.Cartesian3.fromRadians(
              camera.positionCartographic.longitude,
              camera.positionCartographic.latitude,
              this._cameraHeight - y * vertical_speedScale
            ),
            orientation: {
              heading: camera.heading,
              pitch: camera.pitch,
              roll: camera.roll,
            },
          });
        }
        //旋转
        if (this._flags.rotate) {
          if (!camera.roll && camera.pitch < 0 && y < 0) {
            y = 0;
          } else if (!camera.roll && camera.pitch > 0 && y > 0) {
            y = 0;
          }
          camera.rotate(camera.position, x * rotate_speedScale);
          camera.lookUp(y * rotate_speedScale);
        }
      }
    };
    var oldCameraPosition;
    //获取相对高度
    UndergroundMode.prototype.getRelativeHeight = function () {
      var camera = this._viewer.camera;
      var groundHeight = this._viewer.scene.globe.getHeight(
        camera.positionCartographic
      );
      this._groundHeightAtCameraPosition =
        groundHeight || this._groundHeightAtCameraPosition;
      this._relativeHeight =
        camera.positionCartographic.height - this._groundHeightAtCameraPosition;
      if (this._relativeHeight < 1) {
        if (!this._tree.handler && !this.isIndoor) {
          //添加地下模式移动事件
          this.attachMouseEvent();
        }
        let _height = Math.abs(this._relativeHeight);
        if (_height < 50) {
          this.moveSpeed = 0.25;
        } else if (_height < 100) {
          this.moveSpeed = 0.5;
        } else if (_height < 150) {
          this.moveSpeed = 0.75;
        } else {
          this.moveSpeed = 1;
        }
      } else {
        if (this._tree.handler && !this.isIndoor) {
          //取消地下模式移动事件
          detachMouseEvent(this);
        }
      }
      !oldCameraPosition && (oldCameraPosition = camera.position.clone());
      if (
        this._core.getSpaceDistancem(
          [oldCameraPosition, camera.position],
          this._cesium
        ) > 1e4
      ) {
        oldCameraPosition = camera.position.clone();
        this.refreshGridLines();
      }
      if (this._relativeHeight < 0) {
        this._model && (this._model.show = true);
      } else {
        this._model && (this._model.show = false);
      }
    };
    //判断地形
    UndergroundMode.prototype.isHaveTerrain = function () {
      if (
        this._viewer.scene &&
        this._viewer.scene.terrainProvider &&
        this._viewer.scene.terrainProvider._layers
      ) {
        return true;
      }
      return false;
    };
    //设置fov
    UndergroundMode.prototype.setCesiumFov = function (fov) {
      this._viewer.camera.frustum.fov = this._cesium.Math.toRadians(fov);
    };

    /**
     *
     * 创建街景。
     *
     * @alias StreetView
     * @constructor
     *
     */
    function StreetView(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
        this.isStreetView = false;
        this.StreetViewType = undefined;
        Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.isStreetView = false);
        this.defaultSkyAtmosphere = true;
        this.StreetViewSphere = [null, null];  //街景球
        this.StreetViewSphere_Canvas = [null, null];  //街景图
        this.StreetViewNavigation = [];   //导航键
        this.StreetViewSphereIndex = 0;    //当前街景球索引
        this.URL = {
            getInitImageByPosition: '',
            getInitImageInfoById: '',
            getInitImageById: '',
            getSecondImageById: '',
            getThirdImageById: '',
            getImageInfo: ''
        };
        this.CallBack = {
            getInitImageByPositionCallBack: undefined,
            getImageInfoByIdCallBack: undefined,
            getInitImageByIdCallBack: undefined,
            getSecondImageByIdCallBack: undefined,
            getThirdImageByIdCallBack: undefined,
            selectJoinsCallBack: undefined,
            setImageDataCallback: undefined
        };

        this.StreetViewData = {   //街景数据
            name: '',
            radius: 5,
            defaultFov: 60,
            fov: 110,
            alpha: 1,
            speedScale: 1.5,
            lon: undefined,
            lat: undefined,
            height: 0,
            HeadingPitchRoll: null,
            getImageTileID: "",
            linkImagesData: [],
            isTwoTextures: false,
            isThreeTextures: false,
            _handler: null,
            navigation_handler: null
        };
        this.FirstImage = undefined;
    }


    /**
     * 这个方法用于初始化开启街景
     * @param {Object} [position] 位置{lon:经度，lat:纬度}
     * @param {Object} [option] 参数{
     *  getInitImageByPosition: 根据经纬度获取街景信息接口
     *  getInitImageInfoById: 根据id获取街景信息接口
     *  getInitImageById: 根据id获取一级街景图接口
     *  getSecondImageById: 根据id获取二级街景图接口
     *  getThirdImageById: 根据id获取三级街景图接口
     *  getInitImageByPositionCallBack: 根据经纬度获取街景信息回调 function(StreetViewData,data){
     *      StreetViewData.getImageTileID = ImageID;
     *      StreetViewData.lon = Lon;
     *      StreetViewData.lat = Lat;
     *      StreetViewData.height = height;
     *      StreetViewData.HeadingPitchRoll = HeadingPitchRoll;
     *      StreetViewData.linkImagesData=[{ImageID: LinkImageID, NavigationAngle: LinkAngle, Position: LinkPosition}];
     * }
     *  getImageInfoByIdCallBack:根据id获取街景信息回调,同上
     *  getInitImageByIdCallBack: 根据id获取一级街景图回调,
     *  getSecondImageByIdCallBack: 根据id获取二级街景图回调,
     *  getThirdImageByIdCallBack: 根据id获取三级街景图回调
     * }
     * @param {function} [callback] 回调函数
     */
    StreetView.prototype.StreetViewOpen = function (position, option, callback) {
        var _this = this;
        var viewer = this._viewer;
        if (!this.isStreetView) {
            if (this.StreetViewSphere.length > 0) {
                this.StreetViewSphere.forEach(function (item) {
                    item && viewer.entities.remove(item);
                });
                this.StreetViewSphere = [null, null];
            }
            this.StreetViewType = option.type;

            this.StreetViewData.linkImagesData = [];

            this.URL = this.extend(this.URL, option, false);
            this.CallBack = this.extend(this.CallBack, option, false);
            this.defaultSkyAtmosphere = !!viewer.scene.skyAtmosphere.show;
            if (!viewer.scene.skyAtmosphere.show) {
                viewer.scene.skyAtmosphere.show = true;
            }
            var camera = viewer.camera;

            // //首次加载一级图片
            this.getInitImageByPosition(position, function (canvas) {
                _this.isStreetView = true;
                Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.isStreetView = true);
                //camera.cancelFlight();
                //手动定位到目标
                camera.flyTo({
                    destination: new _this._cesium.Cartesian3.fromDegrees(_this.StreetViewData.lon, _this.StreetViewData.lat, _this.StreetViewData.height), //Frederick coordinates
                    orientation: {
                        heading: camera.heading,
                        pitch: (camera.pitch > _this._cesium.Math.toRadians(45.0) || camera.pitch < _this._cesium.Math.toRadians(-45.0)) ? 0 : camera.pitch,
                        roll: 0.0
                    },
                    duration: 5,
                    complete: function () {
                        callback && typeof callback === 'function' && callback();
                    }
                });
                //定义街景浏览事件
                _this.attachMouseEvent();
                ///创建导航按钮
                _this.createNavigation();
                _this.StreetViewSphereIndex = 0;
                _this.StreetViewSphere_Canvas[_this.StreetViewSphereIndex] = canvas;
                //获取街景球
                _this.StreetViewSphere[_this.StreetViewSphereIndex] = _this.createScene(_this.StreetViewData.lon, _this.StreetViewData.lat, _this.StreetViewData.height);
                _this.StreetViewSphere[_this.StreetViewSphereIndex].show = true;
                //偏移
                _this.StreetViewSphere[_this.StreetViewSphereIndex].orientation = _this._cesium.Transforms.headingPitchRollQuaternion(
                    _this._cesium.Cartesian3.fromDegrees(_this.StreetViewData.lon, _this.StreetViewData.lat, _this.StreetViewData.height),
                    new _this._cesium.HeadingPitchRoll(
                        _this._cesium.Math.toRadians(_this.StreetViewData.HeadingPitchRoll.heading + (_this.StreetViewType === 'lide' ? 90 : 0)),
                        _this._cesium.Math.toRadians(-_this.StreetViewData.HeadingPitchRoll.roll),
                        _this._cesium.Math.toRadians(_this.StreetViewData.HeadingPitchRoll.pitch)
                    )
                );
                if (_this.StreetViewType === 'lide') {
                    _this._core.xhr({
                        url: _this.URL.getImageInfo + _this.StreetViewData.getImageTileID,
                        type: 'get',
                        dataType: 'json',
                        success: function (data) {
                            if (_this.CallBack && _this.CallBack.setImageDataCallback) {
                                typeof _this.CallBack.setImageDataCallback === 'function' && _this.CallBack.setImageDataCallback(_this.StreetViewData, data);
                            }
                            //请求二级图片
                            _this.getSecondTexturesFromAtlasFile(_this.StreetViewData.getImageTileID, function (data) {
                                (data.index === _this.StreetViewSphereIndex && _this.StreetViewData.isTwoTextures === false) && (_this.StreetViewSphere_Canvas[_this.StreetViewSphereIndex] = data.canvas);
                                _this.StreetViewData.isTwoTextures = true;
                                _this.StreetViewData.isThreeTextures = false;
                            });
                        }
                    });
                } else {
                    //请求二级图片
                    _this.getSecondTexturesFromAtlasFile(_this.StreetViewData.getImageTileID, function (data) {
                        (data.index === _this.StreetViewSphereIndex && _this.StreetViewData.isTwoTextures === false) && (_this.StreetViewSphere_Canvas[_this.StreetViewSphereIndex] = data.canvas);
                        _this.StreetViewData.isTwoTextures = true;
                        _this.StreetViewData.isThreeTextures = false;
                    });
                }
            });
        }
        return this;
    };

    /**
     * 退出街景
     */
    StreetView.prototype.exit = function () {
        if (this.isStreetView) {
            var _this = this;
            var viewer = this._viewer;
            //清除街景球和导航键
            if (this.StreetViewSphere.length > 0) {
                this.StreetViewSphere.forEach(function (item) {
                    item && viewer.entities.remove(item);
                });
                this.StreetViewSphere = [null, null];
                this.StreetViewSphere_Canvas = [null, null];
            }
            if (this.StreetViewNavigation.length > 0) {
                this.StreetViewNavigation.forEach(function (item) {
                    viewer.entities.remove(item);
                });
                this.StreetViewNavigation = [];
            }
            //恢复默认fov
            this.setCesiumFov(this.StreetViewData.defaultFov);
            //恢复鼠标事件
            this.detachMouseEvent();
            viewer.scene.skyAtmosphere.show = this.defaultSkyAtmosphere;
            this.isStreetView = false;
            Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.isStreetView = false);

            //回到高空
            var s = viewer.camera.positionCartographic;
            viewer.camera.flyTo({
                destination: new this._cesium.Cartesian3.fromRadians(s.longitude, s.latitude, s.height + 3000),
                orientation: {
                    heading: viewer.camera.heading,
                    pitch: this._cesium.Math.toRadians(-90.0),
                    roll: 0.0
                },
                complete: function () {
                    _this.isStreetView = false;
                    Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.isStreetView = false);
                }
            });
        }
    };

    StreetView.prototype.extend = function (o, n, union) {
        for (var key in n) {
            if (n.hasOwnProperty(key) && (o.hasOwnProperty(key) || union)) {
                o[key] = n[key];
            }
        }
        return o;
    };

    /**
     * 获取根据经纬度获取街景信息URL
     * @param {object} position
     */
    StreetView.prototype.getInitImageByPositionURL = function (position) {
        var _url;
        if (this.URL && this.URL.getInitImageByPosition) {
            var url2;
            var url1 = this.URL.getInitImageByPosition.split('{lon}');
            if (url1[0].split('{lat}').length > 1) {
                url2 = url1[0].split('{lat}');
                _url = url2[0] + position.lat + url2[1] + position.lon + url1[1];
            } else {
                url2 = url1[1].split('{lat}');
                _url = url1[0] + position.lon + url2[0] + position.lat + url2[1];
            }
        }
        return _url;
    };
    /**
     * 获取一/二/三级街景图URL
     * @param {String} type
     * @param {String} id
     */
    StreetView.prototype.getImageByIdURL = function (type, id) {
        var _url, url;
        switch (type) {
            case 'one':
                url = this.URL.getInitImageById;
                break;
            case 'two':
                url = this.URL.getSecondImageById;
                break;
            case 'three':
                url = this.URL.getThirdImageById;
                break;
            case 'init':
                url = this.URL.getInitImageInfoById;
                break;
        }
        if (this.StreetViewType === 'lide') {
            id = id.replace('-0-', '-X-');
            type === 'one' && (url += '&row=0&col=0');
        }
        if (url) {
            var url1 = url.split('{id}');
            _url = url1[0] + id + url1[1];
        }
        return _url;
    };

    /**
      * 根据经纬度获取街景图片 一级图片
      * @param {object} position
      * @param {function} callback
      */
    StreetView.prototype.getInitImageByPosition = function (position, callback) {
        var _this = this;
        var _url = this.getInitImageByPositionURL(position);
        this.StreetViewData.linkImagesData = [];

        this._core.xhr({
            url: _url,
            type: 'get',
            dataType: 'json',
            success: datas => {
                if (_this.CallBack && _this.CallBack.getInitImageByPositionCallBack) {
                    typeof _this.CallBack.getInitImageByPositionCallBack === 'function' && _this.CallBack.getInitImageByPositionCallBack(_this.StreetViewData, datas);
                } else {
                    console.log('the getInitImageByPositionCallBack is undefined！');
                    return;
                }

                var imageUrl = _this.getImageByIdURL('one', _this.StreetViewData.getImageTileID);
                var imageObj = new Image();
                imageObj.onload = function () {
                    var imgWidth = imageObj.width;
                    var imgHeight = imageObj.height;
                    var tileWidth = imgWidth;
                    var tileHeight = imgHeight;
                    if (_this.StreetViewType === 'lide') {
                        tileWidth = 512;
                        tileHeight = 256;
                    }
                    var canvas = document.createElement("canvas");
                    var context = canvas.getContext("2d");
                    canvas.height = tileHeight;
                    canvas.width = tileWidth;
                    context.translate(tileWidth, 0);
                    context.scale(-1, 1);
                    context.drawImage(imageObj, 0, 0, tileWidth, tileHeight, 0, 0, tileWidth, tileHeight);
                    if (typeof callback == 'function') {
                        callback(canvas);
                    }
                };
                imageObj.setAttribute("crossOrigin", "Anonymous");
                try {
                    imageObj.src = imageUrl;
                } catch (error) {
                    imageObj.src = '';
                }
                _this.FirstImage = imageObj;
            },
            error: function (s1, s2, s3) {

            }
        });
    };

    /**
     * 请求第一张模糊的图片
     */
    StreetView.prototype.getInitImage = function (ImageTileID, callback) {
        var imageUrl = this.getImageByIdURL('one', ImageTileID);
        var imageObj = new Image();
        var _this = this;
        imageObj.onload = function () {
            var imgWidth = imageObj.width;
            var imgHeight = imageObj.height;
            var tileWidth = imgWidth;
            var tileHeight = imgHeight;
            if (_this.StreetViewType === 'lide') {
                tileWidth = 512;
                tileHeight = 256;
            }
            var canvas = document.createElement("canvas");
            var context = canvas.getContext("2d");
            canvas.height = tileHeight;
            canvas.width = tileWidth;
            context.translate(tileWidth, 0);
            context.scale(-1, 1);
            context.drawImage(imageObj, 0, 0, tileWidth, tileHeight, 0, 0, tileWidth, tileHeight);
            if (typeof callback == 'function') {
                callback(canvas);
            }
        };
        imageObj.setAttribute("crossOrigin", "Anonymous");
        try {
            imageObj.src = imageUrl;
        } catch (error) {
            imageObj.src = '';
        }
        _this.FirstImage = imageObj;
    };

    /**
     * 获取二级图片创建canvas
     */
    StreetView.prototype.getSecondTexturesFromAtlasFile = function (ImageTileID, callback) {
        var canvasIndex = this.StreetViewSphereIndex;
        var imageRootUrl = this.getImageByIdURL('two', ImageTileID);
        //console.log(imageRootUrl)
        var canvas = null,
            context = null;
        var num = 0;
        var imgs = [];
        let row = 4, col = 8;
        let params = '{row}-{col}';
        let maxWidth = Infinity;
        let maxHeight = Infinity;
        if (this.StreetViewType === 'lide') {
            params = '&row={row}&col={col}';
            row = this.StreetViewData.row;
            col = this.StreetViewData.col;
            maxWidth = this.StreetViewData.maxWidth;
            maxHeight = this.StreetViewData.maxHeight;
        }
        var imgWidth, imgHeight, tileWidth, tileHeight;
        var drawCanvas = () => {
            num++;
            if (num == row * col) {
                if (canvas == null) {
                    canvas = document.createElement("canvas");
                    context = canvas.getContext("2d");
                    canvas.height = tileHeight > maxHeight ? maxHeight : tileHeight;
                    canvas.width = tileWidth > maxWidth ? maxWidth : tileWidth;
                    context.translate(canvas.width, 0);
                    context.scale(-1, 1);
                }
                var _tileWidth = imgWidth;
                var _tileHeight = imgHeight;
                if (this.StreetViewType === 'lide') {
                    _tileWidth = 512;
                    _tileHeight = 256;
                }
                context.drawImage(this.FirstImage, 0, 0, _tileWidth, _tileHeight, 0, 0, canvas.width, canvas.height);
                for (var k = 0; k < imgs.length; k++) {
                    if (imgs[k].src) {
                        context.drawImage(
                            imgs[k],
                            0,
                            0,
                            imgWidth,
                            imgHeight,
                            imgWidth * (k % col),
                            imgHeight * Math.floor(k / col),
                            imgWidth,
                            imgHeight
                        );
                    }

                }
                callback({ index: canvasIndex, canvas: canvas });
            }
        };
        for (var i = 0; i < row; i++) {
            for (var j = 0; j < col; j++) {
                var imageUrl = imageRootUrl + params;
                imageUrl = imageUrl.replace('{row}', i).replace('{col}', j);
                var imageObj = new Image();
                imageObj.onload = function () {
                    imgWidth = this.width;
                    imgHeight = this.height;
                    tileWidth = imgWidth * col;
                    tileHeight = imgHeight * row;
                    drawCanvas();
                };
                imageObj.onerror = function () {
                    this.src = '';
                    this.onerror = undefined;
                    drawCanvas();
                };
                imageObj.setAttribute("crossOrigin", "Anonymous");
                try {
                    imageObj.src = imageUrl;
                } catch (error) {
                    imageObj.src = '';
                }

                imgs.push(imageObj);
            }
        }
    };

    /**
     * 获取三级图片创建canvas
     */
    StreetView.prototype.getThreeTexturesFromAtlasFile = function (ImageTileID, callback) {
        var canvasIndex = this.StreetViewSphereIndex;
        var imageRootUrl = this.getImageByIdURL('three', ImageTileID);
        var canvas = null,
            context = null;
        var num = 0;
        var imgs = [];
        for (var i = 0; i < 8; i++) {
            for (var j = 0; j < 16; j++) {
                var imageUrl = imageRootUrl + i + "-" + j;
                var imageObj = new Image();
                (function (i, j, imageObj) {
                    imageObj.onload = function () {
                        var imgWidth = imageObj.width;
                        var imgHeight = imageObj.height;
                        var tileWidth = 8192;
                        var tileHeight = 4096;
                        {
                            num++;
                            if (num == 128) {
                                if (canvas == null) {
                                    canvas = document.createElement("canvas");
                                    context = canvas.getContext("2d");
                                    canvas.height = tileHeight;
                                    canvas.width = tileWidth;
                                    context.translate(8192, 0);
                                    context.scale(-1, 1);
                                }
                                for (var k = 0; k < imgs.length; k++) {
                                    context.drawImage(
                                        imgs[k],
                                        0,
                                        0,
                                        imgWidth,
                                        imgHeight,
                                        imgWidth * (k % 16),
                                        imgHeight * Math.floor(k / 16),
                                        imgWidth,
                                        imgHeight
                                    );
                                }
                                callback({ index: canvasIndex, canvas: canvas });
                            }
                        }
                    };
                })(i, j, imageObj);
                imageObj.setAttribute("crossOrigin", "Anonymous");
                try {
                    imageObj.src = imageUrl;
                } catch (error) {
                    imageObj.src = '';
                }
                imgs.push(imageObj);
            }
        }
    };

    /**
     * 根据编号来请求图片
     */
    StreetView.prototype.InitSceneByID = function (_streetScape) {
        var _this = this;
        var viewer = this._viewer;
        //更新索引
        this.updateStreetSphereIndex();
        //定位到点
        // viewer.camera.flyTo({
        //     destination: this._cesium.Cartesian3.fromDegrees(this.StreetViewData.lon, this.StreetViewData.lat, this.StreetViewData.height),
        //     orientation: {
        //         heading: viewer.camera.heading,
        //         pitch: viewer.camera.pitch,
        //         roll: viewer.camera.roll
        //     },
        //     duration: 1.5
        // });
        //获取街景球
        this.StreetViewSphere[this.StreetViewSphereIndex] = this.createScene(this.StreetViewData.lon, this.StreetViewData.lat, this.StreetViewData.height);
        //获取一级
        this.getInitImage(this.StreetViewData.getImageTileID, function (canvas) {
            _this.StreetViewSphere_Canvas[_this.StreetViewSphereIndex] = canvas;
            setTimeout(function () {
                _this.StreetViewSphere[_this.StreetViewSphereIndex].show = true;
            }, 300);
        });

        this.StreetViewData.isTwoTextures = false;

        if (this.StreetViewType !== 'lide') {
            //根据当前场景id请求前后场景
            this.getImageInfoById(this.StreetViewData.getImageTileID, function (datas) {
                _this.StreetViewData.linkImagesData = [];
                if (_this.CallBack && _this.CallBack.getImageInfoByIdCallBack) {
                    typeof _this.CallBack.getImageInfoByIdCallBack === 'function' && _this.CallBack.getImageInfoByIdCallBack(_this.StreetViewData, datas);
                } else {
                    console.log('the getImageInfoByIdCallBack is undefined！');
                    return;
                }
                //位置
                _this.StreetViewSphere[_this.StreetViewSphereIndex].position = _this._cesium.Cartesian3.fromDegrees(_this.StreetViewData.lon, _this.StreetViewData.lat, _this.StreetViewData.height);
                viewer.camera.cancelFlight();
                //定位到点
                viewer.camera.flyTo({
                    destination: _this._cesium.Cartesian3.fromDegrees(_this.StreetViewData.lon, _this.StreetViewData.lat, _this.StreetViewData.height),
                    orientation: {
                        heading: viewer.camera.heading,
                        pitch: viewer.camera.pitch,
                        roll: 0.0
                    },
                    duration: 1.5
                });
                setTimeout(function () {
                    viewer.entities.remove(_streetScape);
                    _streetScape = null;
                }, 1300);
                //偏移
                _this.StreetViewSphere[_this.StreetViewSphereIndex].orientation = _this._cesium.Transforms.headingPitchRollQuaternion(
                    _this._cesium.Cartesian3.fromDegrees(_this.StreetViewData.lon, _this.StreetViewData.lat, _this.StreetViewData.height),
                    new _this._cesium.HeadingPitchRoll(
                        _this._cesium.Math.toRadians(_this.StreetViewData.HeadingPitchRoll.heading),
                        _this._cesium.Math.toRadians(-_this.StreetViewData.HeadingPitchRoll.roll),
                        _this._cesium.Math.toRadians(_this.StreetViewData.HeadingPitchRoll.pitch)
                    )
                );
                //更新一级
                _this.getInitImage(_this.StreetViewData.getImageTileID, function (canvas) {
                    if (!_this.StreetViewData.isTwoTextures) {
                        _this.StreetViewSphere_Canvas[_this.StreetViewSphereIndex] = canvas;
                    }
                });
                //请求二级图片
                _this.getSecondTexturesFromAtlasFile(_this.StreetViewData.getImageTileID, function (data) {
                    (data.index === _this.StreetViewSphereIndex && _this.StreetViewData.isTwoTextures === false) && (_this.StreetViewSphere_Canvas[_this.StreetViewSphereIndex] = data.canvas);
                    _this.StreetViewData.isTwoTextures = true;
                    _this.StreetViewData.isThreeTextures = false;
                });
                _this.createNavigation();
            });
        } else {
            //根据当前场景位置请求前后场景
            this.getInitImageByPosition(_this.StreetViewData, function (canvas) {
                //位置
                _this.StreetViewSphere[_this.StreetViewSphereIndex].position = _this._cesium.Cartesian3.fromDegrees(_this.StreetViewData.lon, _this.StreetViewData.lat, _this.StreetViewData.height);
                _this.StreetViewSphere_Canvas[_this.StreetViewSphereIndex] = canvas;
                //位置
                viewer.camera.cancelFlight();
                //定位到点
                viewer.camera.flyTo({
                    destination: _this._cesium.Cartesian3.fromDegrees(_this.StreetViewData.lon, _this.StreetViewData.lat, _this.StreetViewData.height),
                    orientation: {
                        heading: viewer.camera.heading,
                        pitch: viewer.camera.pitch,
                        roll: 0.0
                    },
                    duration: 1.5
                });
                setTimeout(function () {
                    viewer.entities.remove(_streetScape);
                    _streetScape = null;
                }, 1300);
                //偏移
                _this.StreetViewSphere[_this.StreetViewSphereIndex].orientation = _this._cesium.Transforms.headingPitchRollQuaternion(
                    _this._cesium.Cartesian3.fromDegrees(_this.StreetViewData.lon, _this.StreetViewData.lat, _this.StreetViewData.height),
                    new _this._cesium.HeadingPitchRoll(
                        _this._cesium.Math.toRadians(_this.StreetViewData.HeadingPitchRoll.heading + 90),
                        _this._cesium.Math.toRadians(-_this.StreetViewData.HeadingPitchRoll.roll),
                        _this._cesium.Math.toRadians(_this.StreetViewData.HeadingPitchRoll.pitch)
                    )
                );

                //请求二级图片
                _this.getSecondTexturesFromAtlasFile(_this.StreetViewData.getImageTileID, function (data) {
                    (data.index === _this.StreetViewSphereIndex && _this.StreetViewData.isTwoTextures === false) && (_this.StreetViewSphere_Canvas[_this.StreetViewSphereIndex] = data.canvas);
                    _this.StreetViewData.isTwoTextures = true;
                    _this.StreetViewData.isThreeTextures = false;
                });
            });
        }

    };

    /**
     * 根据当前场景id请求前后场景
     */
    StreetView.prototype.getImageInfoById = function (id, callback) {
        var url = this.getImageByIdURL('init', id);
        // $.ajax({
        this._core.xhr({
            url: url,
            type: 'get',
            dataType: 'json',
            success: function (data) {
                if (typeof callback == 'function') {
                    callback(data);
                }
            }
        });
    };

    /**
     * 创建场景球
     */
    StreetView.prototype.createScene = function (lon, lat, height) {
        var _this = this;
        var viewer = this._viewer;
        var index = this.StreetViewSphereIndex;
        //街景贴图
        var imgMaterial = new this._cesium.ImageMaterialProperty({
            image: new this._cesium.CallbackProperty(function () {
                return _this.StreetViewSphere_Canvas[index];
            }, false),
            transparent: true,
            color: this._cesium.Color.WHITE.withAlpha(this.StreetViewData.alpha)
        });
        var ellipsoid = {
            show: false,
            position: this._cesium.Cartesian3.fromDegrees(lon, lat, height),
            ellipsoid: {
                radii: new this._cesium.Cartesian3(this.StreetViewData.radius, this.StreetViewData.radius, this.StreetViewData.radius),
                material: imgMaterial,
            }
        };
        var s = viewer.entities.add(ellipsoid);
        s.geometryName = '街景';
        return s;
    };

    /**
     * 恢复鼠标事件
     */
    StreetView.prototype.detachMouseEvent = function () {
        var scene = this._viewer.scene;
        this._viewer.canvas;

        if (this.StreetViewData._handler) {
            this.StreetViewData._handler.destroy();
            this.StreetViewData._handler = undefined;
        }
        if (this.StreetViewData.navigation_handler) {
            this.StreetViewData.navigation_handler.destroy();
            this.StreetViewData.navigation_handler = undefined;
        }

        this.StreetViewType !== 'lide' && this._viewer.clock.onTick.removeEventListener(this.StreetView_onTick, this);

        scene.screenSpaceCameraController.enableRotate = true;
        scene.screenSpaceCameraController.enableTranslate = true;
        scene.screenSpaceCameraController.enableZoom = true;
        scene.screenSpaceCameraController.enableTilt = true;
        scene.screenSpaceCameraController.enableLook = true;
        //createMovePickEvent();
    };

    var startMousePosition;
    var mousePosition;
    var scene$1 = null;
    var canvas = null;
    var flags = {
        looking: false
    };

    /**
     * 定义街景鼠标事件
     */
    StreetView.prototype.attachMouseEvent = function () {
        var _this = this;
        scene$1 = this._viewer.scene;
        canvas = this._viewer.canvas;
        this.StreetViewData._handler = new this._cesium.ScreenSpaceEventHandler(canvas);
        canvas.setAttribute('tabindex', '0'); // needed to put focus on the canvas
        canvas.focus();
        canvas.onclick = function () {
            canvas.focus();
        };
        //设置当前fov
        setTimeout(function () {
            _this.setCesiumFov(_this.StreetViewData.fov);
        }, 4000);

        //禁止默认事件
        scene$1.screenSpaceCameraController.enableRotate = false;
        scene$1.screenSpaceCameraController.enableTranslate = false;
        scene$1.screenSpaceCameraController.enableZoom = false;
        scene$1.screenSpaceCameraController.enableTilt = false;
        scene$1.screenSpaceCameraController.enableLook = false;

        //自定义鼠标事件
        this.StreetViewData._handler.setInputAction(function (movement) {
            flags.looking = true;
        }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);

        this.StreetViewData._handler.setInputAction(function (movement) {
            if (flags.looking) {
                startMousePosition = movement.startPosition;
                mousePosition = movement.endPosition;
                _this.StreetView_mouseMove();
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.StreetViewData._handler.setInputAction(function (position) {
            flags.looking = false;
        }, this._cesium.ScreenSpaceEventType.LEFT_UP);

        this.StreetViewData._handler.setInputAction(function (wheelment) {
            var fov = _this.StreetViewData.fov + (wheelment / -10);
            if (fov > 30 && fov < 120) {
                _this.StreetViewData.fov = fov;
                _this.setCesiumFov(_this.StreetViewData.fov);
            }
        }, this._cesium.ScreenSpaceEventType.WHEEL);

        //监听放大缩小
        this.StreetViewType !== 'lide' && this._viewer.clock.onTick.addEventListener(_this.StreetView_onTick, this);
    };

    /**
     * 监听放大缩小
     */
    StreetView.prototype.StreetView_onTick = function () {
        var _this = this;
        //放大到50加载三级
        if (!this.StreetViewData.isThreeTextures && this.StreetViewData.fov < 50) {
            this.StreetViewData.isThreeTextures = true;
            this.getThreeTexturesFromAtlasFile(this.StreetViewData.getImageTileID, function (data) {
                (data.index === _this.StreetViewSphereIndex) && (_this.StreetViewSphere_Canvas[_this.StreetViewSphereIndex] = data.canvas);
            });
        }
    };

    /**
     * 鼠标移动
     */
    StreetView.prototype.StreetView_mouseMove = function () {
        var camera = this._viewer.camera;
        if (flags.looking) {
            var width = canvas.clientWidth;
            var height = canvas.clientHeight;
            var x = -(mousePosition.x - startMousePosition.x) / width;
            var y = (mousePosition.y - startMousePosition.y) / height;
            if (!camera.roll && camera.pitch < 0 && y < 0) {
                y = 0;
            } else if (!camera.roll && camera.pitch > 0 && y > 0) {
                y = 0;
            }
            camera.rotate(camera.position, x * this.StreetViewData.speedScale);
            camera.lookUp(y * this.StreetViewData.speedScale);
        }
    };

    /**
     * 设置街景球透明度
     */
    StreetView.prototype.setOpacity = function (opacity) {
        var _this = this;
        this.StreetViewSphere.forEach(function (item) {
            item && (item.ellipsoid.material.color._value = _this._cesium.Color.WHITE.withAlpha(opacity));
        });
        this.StreetViewData.alpha = opacity;
    };

    /**
     * 设置相机fov
     */
    StreetView.prototype.setCesiumFov = function (fov) {
        this._viewer.camera.frustum.fov = this._cesium.Math.toRadians(fov);
    };

    /**
     * 移动到
     */
    StreetView.prototype.MoveToLinkImage = function (data) {
        if (!data) {
            alert('暂无街景数据');
            return;
        } else if (this.StreetViewType === 'lide' && !data.ImageID) {
            if (this.CallBack && this.CallBack.selectJoinsCallBack) {
                typeof this.CallBack.selectJoinsCallBack === 'function' && this.CallBack.selectJoinsCallBack();
            }
            return
        }

        this.StreetViewData.name = data.name;
        this.StreetViewData.lon = data.Position[0];
        this.StreetViewData.lat = data.Position[1];
        this.StreetViewData.height = data.Position[2];
        this.StreetViewData.getImageTileID = data.ImageID;
        this.InitSceneByID(this.StreetViewSphere[this.StreetViewSphereIndex]);
    };

    /**
     * 更新街景球索引
     */
    StreetView.prototype.updateStreetSphereIndex = function () {
        this.StreetViewSphereIndex = ((this.StreetViewSphereIndex === 0) ? 1 : 0);
    };

    /**
     * 创建导航按钮
     */
    StreetView.prototype.createNavigation = function () {
        var _this = this;
        var viewer = this._viewer;
        if (this.StreetViewNavigation.length > 0) {
            this.StreetViewNavigation.forEach(function (item) {
                viewer.entities.remove(item);
            });
            this.StreetViewNavigation = [];
        }
        if (this.StreetViewData.navigation_handler) {
            this.StreetViewData.navigation_handler.destroy();
            this.StreetViewData.navigation_handler = null;
        }

        var Ea = 6378137.0;     //   赤道半径
        var Eb = 6356725.0;     //   极半径
        var position = {
            lon: this.StreetViewData.lon,
            lat: this.StreetViewData.lat,
            height: this.StreetViewData.height - 1
        };

        this.StreetViewData.linkImagesData.forEach(function (data) {
            var navigation = viewer.entities.add({
                polygon: {
                    hierarchy: new _this._cesium.CallbackProperty(function () {
                        var points = getNavigationPosition(position, data.NavigationAngle);
                        return new _this._cesium.PolygonHierarchy(_this._cesium.Cartesian3.fromDegreesArray(points));
                    }, false),
                    fill: true,
                    outline: true,
                    outlineColor: _this._cesium.Color.BLACK.withAlpha(0.2),
                    height: position.height
                }
            });
            navigation.geometryName = '街景';
            navigation.isNavigation = true;
            navigation.linkImageData = data;
            _this.StreetViewNavigation.push(navigation);
        });

        //定义按钮事件
        var pickObj;
        _this.StreetViewData.navigation_handler = new _this._cesium.ScreenSpaceEventHandler(canvas);
        _this.StreetViewData.navigation_handler.setInputAction(function (movement) {
            var pick = viewer.scene.pick(movement.position);
            if (_this._cesium.defined(pick)) {
                if (pick && pick.id && pick.id.isNavigation) {
                    if (pickObj) {
                        pickObj.polygon.outlineColor = _this._cesium.Color.BLACK.withAlpha(0.5);
                        pickObj.polygon.material = _this._cesium.Color.WHITE;
                    }
                    pickObj = pick.id;
                    pickObj.polygon.outlineColor = _this._cesium.Color.BLUE;
                    pickObj.polygon.material = _this._cesium.Color.WHITE.withAlpha(0.9);
                } else {
                    if (pickObj) {
                        pickObj.polygon.outlineColor = _this._cesium.Color.BLACK.withAlpha(0.5);
                        pickObj.polygon.material = _this._cesium.Color.WHITE;
                        pickObj = undefined;
                    }
                }
            }
            if (pickObj) {
                _this.MoveToLinkImage(pickObj.linkImageData);
            }
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        //通过角度和距离获取经纬度
        function GetPositionFromA_D(lon, lat, distance, angle) {
            var dx = distance * Math.sin(angle * Math.PI / 180.0);
            var dy = distance * Math.cos(angle * Math.PI / 180.0);

            var ec = Eb + (Ea - Eb) * (90.0 - lat) / 90.0;
            var ed = ec * Math.cos(lat * Math.PI / 180);

            var newLon = (dx / ed + lon * Math.PI / 180.0) * 180.0 / Math.PI;
            var newLat = (dy / ec + lat * Math.PI / 180.0) * 180.0 / Math.PI;

            return [newLon, newLat];
        }

        function getRad(d) {
            return d * Math.PI / 180.0;
        }

        //根据两点经纬度测算距离
        function getDistanceAndAngle(lng1, lat1, lng2, lat2) {
            var radLat1 = getRad(lat1);
            var radLat2 = getRad(lat2);
            var a = getRad(lat2) - getRad(lat1);
            var b = getRad(lng2) - getRad(lng1);

            var distance = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) + Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
            distance = distance * Ea;
            distance = Math.round(distance * 10000) / 10000.0;

            var angle;
            if (a === 0 && b > 0) {
                angle = 90;
            } else if (a === 0 && b < 0) {
                angle = 270;
            } else if (a < 0 && b === 0) {
                angle = 180;
            } else if (a >= 0 && b === 0) {
                angle = 0;
            } else if (a < 0 && b > 0) {
                angle = 180 - Math.atan(b / -a) * 180.0 / Math.PI;
            } else if (a < 0 && b < 0) {
                angle = 180 + Math.atan(b / a) * 180.0 / Math.PI;
            } else if (a > 0 && b < 0) {
                angle = 360 - Math.atan(-b / a) * 180.0 / Math.PI;
            } else {
                angle = Math.atan(b / a) * 180.0 / Math.PI;
            }
            return {
                angle: angle,
                distance: distance
            };
        }

        //通过角度和参考点获取经纬度
        function GetPositionFromA_P(origin, point, angle) {
            var data = getDistanceAndAngle(origin.lon, origin.lat, point.lon, point.lat);
            return GetPositionFromA_D(origin.lon, origin.lat, data.distance, angle - data.angle);
        }

        //获取导航箭头点串坐标
        function getNavigationPosition(position, angle) {
            var points = [];
            var point = GetPositionFromA_D(position.lon, position.lat, 3.5, viewer.camera.heading * 180 / Math.PI);
            var origin = { lon: point[0], lat: point[1] };
            point = GetPositionFromA_D(point[0], point[1], 1.1, 0);
            points.push(point[0], point[1]);
            point = GetPositionFromA_D(point[0], point[1], 0.5758, 135);
            points.push(point[0], point[1]);
            point = GetPositionFromA_D(point[0], point[1], 0.2, 270);
            points.push(point[0], point[1]);
            point = GetPositionFromA_D(point[0], point[1], 0.5, 180);
            points.push(point[0], point[1]);
            point = GetPositionFromA_D(point[0], point[1], 0.4, 270);
            points.push(point[0], point[1]);
            point = GetPositionFromA_D(point[0], point[1], 0.5, 0);
            points.push(point[0], point[1]);
            point = GetPositionFromA_D(point[0], point[1], 0.2, 270);
            points.push(point[0], point[1]);
            //旋转
            for (var i = 0, p; i < points.length - 1; i += 2) {
                p = GetPositionFromA_P(origin, { lon: points[i], lat: points[i + 1] }, angle);
                points[i] = p[0];
                points[i + 1] = p[1];
            }
            return points;
        }
    };

    /**
     *
     * 扫描线
     *
     * @alias Scan
     * @constructor
     *
     */
    function Scan(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 这个方法用于添加扩散圆扫描线
     *@param {Object} [position] 扫描中心。
     * @param {Object} [maxRadius=1500] 最大半径 米。
     * @param {Object} [scanColor=#ff0000] 扫描颜色。
     * @param {Object} [duration=4000] 持续时间 毫秒。
     * @param {Boolean} [clampToGround=true] 是否贴地。
     */
    Scan.prototype.createCircleScan = function (position, maxRadius = 1500, scanColor = "#ff0000", duration = 4000, clampToGround = true) {
        var Center = new this._cesium.Cartesian3.fromDegrees(position.lon, position.lat, position.height);
        this._position = position;
        var color = this._cesium.Color.fromCssColorString(scanColor);
        this.item = this.AddCircleScanPostStage(Center, maxRadius, color, duration, clampToGround);

        var obj = {
            id: this._core.getuid(),
            name: '新建扩散圆扫描',
            pId: 0,
            type: 'scan',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };

    /**
     * 这个方法用于添加扩散圆扫描线（三环）
     *@param {Object} [position] 扫描中心。
     * @param {Object} [maxRadius=1500] 最大半径 米。
     * @param {Object} [scanColor=#ff0000] 扫描颜色。
     * @param {Object} [duration=4000] 持续时间 毫秒。
     * @param {Boolean} [clampToGround=true] 是否贴地。
     */
    Scan.prototype.createMultiCircleScan = function (position, maxRadius = 1500, scanColor = "#ff0000", duration = 4000, clampToGround = true) {
        var Center = new this._cesium.Cartesian3.fromDegrees(position.lon, position.lat, position.height);
        this._position = position;
        var color;
        var color = this._cesium.Color.fromCssColorString(scanColor);
        this.item = this.AddCircleScanMultiPostStage(Center, maxRadius, color, duration, clampToGround);

        var obj = {
            id: this._core.getuid(),
            name: '新建扩散圆扫描',
            pId: 0,
            type: 'scan',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };

    /**
     * 这个方法用于添加雷达扫描线
     * @param {Object} [position] 扫描中心。
     * @param {Object} [maxRadius=1500] 最大半径 米。
     * @param {Object} [scanColor=#ff0000] 扫描颜色。
     * @param {Object} [duration=4000] 持续时间 毫秒。
     * @param {Boolean} [clampToGround=true] 是否贴地。
     */
    Scan.prototype.createRadarScan = function (position, maxRadius = 1500, scanColor = "#ff0000", duration = 4000, clampToGround = true) {
        var Center = new this._cesium.Cartesian3.fromDegrees(position.lon, position.lat, position.height);
        this._position = position;
        var color = this._cesium.Color.fromCssColorString(scanColor);
        this.item = this.AddRadarScanPostStage(Center, maxRadius, color, duration, clampToGround);

        var obj = {
            id: this._core.getuid(),
            name: '新建雷达扫描',
            pId: 0,
            type: 'scan',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };
    /**
     * 这个方法用于添加扩散扇形扫描线（五环）
     *@param {Object} [position] 扫描中心。
     * @param {Object} [maxRadius=1500] 最大半径 米。
     * @param {Object} [scanColor=#ff0000] 扫描颜色。
     * @param {float} [angle=90] 角度。
     * @param {float} [yaw=0] 方向。
     * @param {Object} [duration=4000] 持续时间 毫秒。
     * @param {Boolean} [clampToGround=true] 是否贴地。
     */
    Scan.prototype.createSectorScan = function (position, maxRadius = 1500, scanColor = "#ff0000", angle = 90, yaw = 0, duration = 4000, clampToGround = true) {
        var Cesium = this._cesium;
        var Center = new Cesium.Cartesian3.fromDegrees(position.lon, position.lat, position.height);
        this._position = position;
        var color = Cesium.Color.fromCssColorString(scanColor);
        this.item = this.AddSectorScanPostStage(Center, maxRadius, color, angle, yaw, duration, clampToGround);

        var obj = {
            id: this._core.getuid(),
            name: '新建扇形扩散扫描',
            pId: 0,
            type: 'scan',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };

    /**
     * 添加扩散扇形扫描线(五环)
     * @param {Object} [cartographicCenter] 扫描中心。
     * @param {Object} [maxRadius] 最大半径 米。
     * @param {Object} [scanColor] 扫描颜色。
     * @param {Object} [duration] 持续时间 毫秒。
     */
    Scan.prototype.AddSectorScanPostStage = function (cartographicCenter, maxRadius, scanColor, angle, yaw, duration, clampToGround) {
        var viewer = this._viewer;
        var Cesium = this._cesium;
        var _height = this._core.defaultValue(this._position.height, 0);
        var ellipseEentity = {};

        if (!Cesium.EllipsoidFadeMaterialProperty) {
            function EllipsoidFadeMaterialProperty(color, angle, duration) {
                this._definitionChanged = new Cesium.Event();
                this._color = undefined;
                this._colorSubscription = undefined;
                this.color = color;
                this.duration = duration;
                this._angle = angle;

                this._time = (new Date()).getTime();
            }
            Object.defineProperties(EllipsoidFadeMaterialProperty.prototype, {
                isConstant: {
                    get: function () {
                        return false
                    }
                },
                definitionChanged: {
                    get: function () {
                        return this._definitionChanged
                    }
                },
                color: Cesium.createPropertyDescriptor('color'),
                angle: Cesium.createPropertyDescriptor('angle'),
            });
            EllipsoidFadeMaterialProperty.prototype.getType = function (time) {
                return 'EllipsoidFade';
            };
            EllipsoidFadeMaterialProperty.prototype.getValue = function (time, result) {
                if (!Cesium.defined(result)) {
                    result = {};
                }
                result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.ColorWHITE, result
                    .color);
                result.angle = this._angle;

                return result;
            };
            EllipsoidFadeMaterialProperty.prototype.equals = function (other) {
                return this === other ||
                    (other instanceof EllipsoidFadeMaterialProperty && Property.equals(this._color, other._color))
            };
            Cesium.EllipsoidFadeMaterialProperty = EllipsoidFadeMaterialProperty;

            Cesium.Material.EllipsoidFadeType = "EllipsoidFade";
            // 自定义着色器
            Cesium.Material.EllipsoidFadeSource =
                "float getAngle(in vec2 dv)\n" +
                "{\n" +
                "    if(dv.y == 0.0 && dv.x > 0.0)\n" +
                "    {\n" +
                "        return 90.0;\n" +
                "    }\n" +
                "    if(dv.y == 0.0 && dv.x < 0.0)\n" +
                "    {\n" +
                "        return 270.0;\n" +
                "    }\n" +
                "    float rAngle = atan(dv.x/dv.y) * 180.0 / 3.1415926;\n" +
                "    if(dv.x > 0.0)\n" +
                "    {\n" +
                "        if(dv.y < 0.0)\n" +
                "        {\n" +
                "            rAngle = 180.0 + rAngle;\n" +
                "        }\n" +
                "    }\n" +
                "    if(dv.x <= 0.0)\n" +
                "    {\n" +
                "        if(dv.y < 0.0)\n" +
                "        {\n" +
                "            rAngle = 180.0 + rAngle;\n" +
                "        }\n" +
                "        if(dv.y > 0.0)\n" +
                "        {\n" +
                "            rAngle = 360.0 + rAngle;\n" +
                "        }\n" +
                "    }\n" +
                "    return rAngle;\n" +
                "}\n" +

                "float ripple(float dist, float rippleIntensity, float rippleScale) {\n" +
                "    return rippleScale * ((sin(dist * rippleIntensity - czm_frameNumber/10.0)-0.9) / (dist * rippleIntensity));\n" +
                "}\n" +
                "czm_material czm_getMaterial(czm_materialInput materialInput)\n" +
                "{\n" +
                "  czm_material material = czm_getDefaultMaterial(materialInput);\n" +
                "  material.diffuse = 1.5 * color.rgb;\n" +
                "  vec2 st = materialInput.st;\n" +
                "  float dis = distance(st, vec2(0.5, 0.5));\n" +
                "  float nowAngle = getAngle(st.xy-vec2(0.5, 0.5));\n" +
                "  if(nowAngle < angle)\n" +
                "  {\n" +
                "       material.alpha = 1.0 - dis/0.5;\n" +
                "       float intensity =step(0.001,ripple(dis, 100.0, 15.0));\n" +
                "       if(intensity == 1.0)\n" +
                "       {\n" +
                "           material.alpha = material.alpha/2.0;\n" +
                "       }\n" +
                "  }\n" +
                "  else{\n" +
                "       material.alpha = 0.0;\n" +
                "       discard;\n" +
                "  }\n" +
                "  return material;\n" +
                "}";


            Cesium.Material._materialCache.addMaterial(Cesium.Material.EllipsoidFadeType, {
                fabric: {
                    type: Cesium.Material.EllipsoidFadeType,
                    uniforms: {
                        color: new Cesium.Color(1.0, 0.0, 0.0, 1),
                        angle: 90
                    },
                    source: Cesium.Material.EllipsoidFadeSource

                },
                translucent: function (material) {
                    return true;
                }
            });
        }

        ellipseEentity = {
            name: 'EllipsoidFade',
            position: cartographicCenter,

            ellipse: {
                height: clampToGround ? undefined : _height,
                semiMinorAxis: maxRadius,
                semiMajorAxis: maxRadius,
                stRotation: yaw * Math.PI / 180,
                material: new Cesium.EllipsoidFadeMaterialProperty(scanColor, angle, duration)
            }
        };
        return viewer.entities.add(ellipseEentity);
    };
    /**
    * 添加扩散圆扫描线
    * @param {Object} [Center] 扫描中心。
    * @param {Object} [maxRadius] 最大半径 米。
    * @param {Object} [scanColor] 扫描颜色。
    * @param {Object} [duration] 持续时间 毫秒。
    */
    Scan.prototype.AddCircleScanPostStage = function (Center, maxRadius, scanColor, duration, clampToGround) {
        var viewer = this._viewer;
        var Cesium = this._cesium;
        var _height = this._core.defaultValue(this._position.height, 0);

        if (!Cesium.CircleScanMaterialProperty) {
            function CircleScanMaterialProperty(color, duration) {
                this._definitionChanged = new Cesium.Event();
                this._color = undefined;
                this._colorSubscription = undefined;
                this.color = color;
                this.duration = duration;

                this._time = (new Date()).getTime();
            }
            Object.defineProperties(CircleScanMaterialProperty.prototype, {
                isConstant: {
                    get: function () {
                        return false
                    }
                },
                definitionChanged: {
                    get: function () {
                        return this._definitionChanged
                    }
                },
                color: Cesium.createPropertyDescriptor('color')
            });
            CircleScanMaterialProperty.prototype.getType = function (time) {
                return 'CircleScan';
            };
            CircleScanMaterialProperty.prototype.getValue = function (time, result) {
                if (!Cesium.defined(result)) {
                    result = {};
                }
                result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.Color.WHITE, result.color);
                result.time = (((new Date()).getTime() - this._time) % this.duration) / this.duration;
                return result;
            };
            CircleScanMaterialProperty.prototype.equals = function (other) {
                return this === other ||
                    (other instanceof CircleScanMaterialProperty &&
                        Cesium.Property.equals(this._color, other._color))
            };
            Cesium.CircleScanMaterialProperty = CircleScanMaterialProperty;

            Cesium.Material.CircleScanType = "CircleScan";
            // 自定义着色器
            Cesium.Material.CircleScanSource =
                "czm_material czm_getMaterial(czm_materialInput materialInput)\n\
                {\n\
                    czm_material material = czm_getDefaultMaterial(materialInput);\n\
                    material.diffuse = color.rgb;\n\
                    vec2 st = materialInput.st;\n\
                    float dis = distance(st, vec2(0.5, 0.5));\n\
                    if(dis<time){\n\
                        float f = dis / time;\n\
                        material.alpha = pow(f, 4.0);\n\
                    }else{\n\
                        material.alpha = 0.0;\n\
                    }\n\
                    return material;\n\
                }";


            Cesium.Material._materialCache.addMaterial(Cesium.Material.CircleScanType, {
                fabric: {
                    type: Cesium.Material.CircleScanType,
                    uniforms: {
                        color: new Cesium.Color(1.0, 0.0, 0.0, 1),
                        time: 0
                    },
                    source: Cesium.Material.CircleScanSource

                },
                translucent: function (material) {
                    return true;
                }
            });
        }

        var ellipseEentity = {
            name: 'CircleScan',
            position: Center,
            ellipse: {
                height: clampToGround ? undefined : _height,
                semiMinorAxis: maxRadius,
                semiMajorAxis: maxRadius,
                material: new Cesium.CircleScanMaterialProperty(scanColor, duration)
            }
        };
        return viewer.entities.add(ellipseEentity);
    };

    /**
    * 添加扩散圆扫描线(三环)
    * @param {Object} [Center] 扫描中心。
    * @param {Object} [maxRadius] 最大半径 米。
    * @param {Object} [scanColor] 扫描颜色。
    * @param {Object} [duration] 持续时间 毫秒。
    */
    Scan.prototype.AddCircleScanMultiPostStage = function (Center, maxRadius, scanColor, duration, clampToGround) {
        var viewer = this._viewer;
        var Cesium = this._cesium;
        var _height = this._core.defaultValue(this._position.height, 0);

        if (!Cesium.CircleScanMultiMaterialProperty) {
            function CircleScanMultiMaterialProperty(color, duration) {
                this._definitionChanged = new Cesium.Event();
                this._color = undefined;
                this._colorSubscription = undefined;
                this.color = color;
                this.u_radius1 = 0;
                this.u_radius2 = 0;
                this.u_radius3 = 0;
                this.duration = duration;

                this._time = (new Date()).getTime();
            }
            Object.defineProperties(CircleScanMultiMaterialProperty.prototype, {
                isConstant: {
                    get: function () {
                        return false
                    }
                },
                definitionChanged: {
                    get: function () {
                        return this._definitionChanged
                    }
                },
                color: Cesium.createPropertyDescriptor('color')
            });
            CircleScanMultiMaterialProperty.prototype.getType = function (time) {
                return 'CircleScanMulti';
            };
            CircleScanMultiMaterialProperty.prototype.getValue = function (time, result) {
                if (!Cesium.defined(result)) {
                    result = {};
                }
                result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.Color.WHITE, result.color);
                result.time = (((new Date()).getTime() - this._time) % this.duration) / this.duration;
                if (result.time < 1 / 3 && this.u_radius2 === 0 && this.u_radius1 === 0) {
                    this.u_radius3 = result.time;
                } else if (result.time >= 1 / 3 && result.time < 2 / 3 && this.u_radius1 === 0) {
                    this.u_radius3 = result.time;
                    this.u_radius2 = this.u_radius3 - 1 / 3;
                } else if (result.time >= 2 / 3) {
                    this.u_radius3 = result.time;
                    this.u_radius2 = this.u_radius3 - 1 / 3;
                    this.u_radius1 = this.u_radius3 - 2 / 3;
                } else if (result.time < 1 / 3 && this.u_radius2 !== 0 && this.u_radius1 !== 0) {
                    this.u_radius1 = result.time;
                    this.u_radius2 = result.time + 1 / 3;
                    this.u_radius3 = result.time + 2 / 3;
                } else if (result.time >= 1 / 3 && result.time < 2 / 3 && this.u_radius1 !== 0) {
                    this.u_radius1 = result.time - 1 / 3;
                    this.u_radius2 = result.time;
                    this.u_radius3 = result.time + 1 / 3;
                }
                result.u_radius1 = this.u_radius1;
                result.u_radius2 = this.u_radius2;
                result.u_radius3 = this.u_radius3;
                return result;
            };
            CircleScanMultiMaterialProperty.prototype.equals = function (other) {
                return this === other ||
                    (other instanceof CircleScanMultiMaterialProperty &&
                        Cesium.Property.equals(this._color, other._color))
            };
            Cesium.CircleScanMultiMaterialProperty = CircleScanMultiMaterialProperty;

            Cesium.Material.CircleScanMultiType = "CircleScanMulti";
            // 自定义着色器
            Cesium.Material.CircleScanMultiSource =
                "czm_material czm_getMaterial(czm_materialInput materialInput)\n\
                {\n\
                    czm_material material = czm_getDefaultMaterial(materialInput);\n\
                    material.diffuse = color.rgb;\n\
                    vec2 st = materialInput.st;\n\
                    float dis = distance(st, vec2(0.5, 0.5));\n\
                    dis = dis * 2.0;\n\
                    if(dis < u_radius1)\n\n\
                    {\n\
                        float f = dis / u_radius1;\n\
                        material.alpha  = pow(f, 9.0);\n\
                    }else if(dis < u_radius2){\n\
                        float f = dis / u_radius2;\n\
                        material.alpha  = pow(f, 9.0);\n\
                    }else if(dis < u_radius3){\n\
                        float f = dis / u_radius3;\n\
                        material.alpha  = pow(f, 9.0);\n\
                    }else{\n\
                        material.alpha = 0.0;\n\
                    }\n\
                    return material;\n\
                }";


            Cesium.Material._materialCache.addMaterial(Cesium.Material.CircleScanMultiType, {
                fabric: {
                    type: Cesium.Material.CircleScanMultiType,
                    uniforms: {
                        color: new Cesium.Color(1.0, 0.0, 0.0, 1),
                        time: 0,
                        u_radius1: 0,
                        u_radius2: 0,
                        u_radius3: 0
                    },
                    source: Cesium.Material.CircleScanMultiSource

                },
                translucent: function (material) {
                    return true;
                }
            });
        }

        var ellipseEentity = {
            name: 'CircleScanMulti',
            position: Center,
            ellipse: {
                height: clampToGround ? undefined : _height,
                semiMinorAxis: maxRadius,
                semiMajorAxis: maxRadius,
                material: new Cesium.CircleScanMultiMaterialProperty(scanColor, duration)
            }
        };
        return viewer.entities.add(ellipseEentity);
    };

    /**
    * 添加雷达扫描线
    * @param {Object} [Center] 扫描中心。
    * @param {Object} [maxRadius] 最大半径 米。
    * @param {Object} [scanColor] 扫描颜色。
    * @param {Object} [duration] 持续时间 毫秒。
    */
    Scan.prototype.AddRadarScanPostStage = function (Center, maxRadius, scanColor, duration, clampToGround) {
        var viewer = this._viewer;
        var Cesium = this._cesium;
        var _height = this._core.defaultValue(this._position.height, 0);

        if (!Cesium.RadarScanMaterialProperty) {
            function RadarScanMaterialProperty(color, duration) {
                this._definitionChanged = new Cesium.Event();
                this._color = undefined;
                this._angle = 60;
                this.range = 360;
                this._colorSubscription = undefined;
                this.color = color;
                this.duration = duration;
                this.isReturn = false;
                this.isGradient = true;

                this._time = (new Date()).getTime();
            }
            Object.defineProperties(RadarScanMaterialProperty.prototype, {
                isConstant: {
                    get: function () {
                        return false
                    }
                },
                definitionChanged: {
                    get: function () {
                        return this._definitionChanged
                    }
                },
                color: Cesium.createPropertyDescriptor('color')
            });
            RadarScanMaterialProperty.prototype.getType = function (time) {
                return 'RadarScan';
            };
            RadarScanMaterialProperty.prototype.getValue = function (time, result) {
                if (!Cesium.defined(result)) {
                    result = {};
                }
                result.color = Cesium.Property.getValueOrClonedDefault(this._color, time, Cesium.Color.WHITE, result.color);
                result.time = (((new Date()).getTime() - this._time) % this.duration) / this.duration;
                result._angle = this._angle;
                result.range = this.range;
                result.gradient = this.isGradient;

                // 是否往返
                if (this.isReturn) {
                    // 上一次的时间
                    this.old === undefined && (this.old = result.time);
                    if (this.old > 0.5 && result.time < 0.5) {
                        // 正反切换
                        result.inverse = !result.inverse;
                    }
                    this.old = result.time;
                    // 是否渐变
                    if (result.gradient) {
                        if (result.inverse) {
                            // 反向
                            result.angle2 = this.range * (1 - result.time);
                            result._angle = this.range - result.angle2;
                            result._angle > this._angle && (result._angle = this._angle);
                            result.angle1 = result.angle2 - result._angle;
                            if (result.angle1 < 0) {
                                result._angle = result.angle2;
                                result.angle1 = 0;
                            }
                        } else {
                            // 正向
                            result.angle1 = this.range * result.time;
                            result._angle = result.angle1;
                            result._angle > this._angle && (result._angle = this._angle);
                            result.angle2 = result.angle1 + result._angle;
                            if (result.angle2 > this.range) {
                                result.angle2 = this.range;
                            }
                        }
                    } else {
                        result.range = this.range - this._angle;
                        result.angle1 = result.range * (result.inverse ? 1 - result.time : result.time);
                        result.angle2 = result.angle1 + this._angle;
                    }
                } else {
                    result.inverse = false;
                    result.angle1 = this.range * result.time;
                    result.angle2 = result.angle1 + this._angle;
                    if (result.angle2 > this.range) {
                        result.angle2 = result.angle2 - this.range;
                    }
                }
                return result;
            };
            RadarScanMaterialProperty.prototype.equals = function (other) {
                return this === other ||
                    (other instanceof RadarScanMaterialProperty &&
                        Cesium.Property.equals(this._color, other._color))
            };
            Cesium.RadarScanMaterialProperty = RadarScanMaterialProperty;

            Cesium.Material.RadarScanType = "RadarScan";
            // 自定义着色器
            Cesium.Material.RadarScanSource =
                "float getAngle(in vec2 dv)\n\
                {\n\
                    if(dv.y == 0.0 && dv.x > 0.0)\n\
                    {\n\
                        return 90.0;\n\
                    }\n\
                    if(dv.y == 0.0 && dv.x < 0.0)\n\
                    {\n\
                        return 270.0;\n\
                    }\n\
                    float rAngle = atan(dv.x/dv.y) * 180.0 / 3.1415926;\n\
                    if(dv.x > 0.0)\n\
                    {\n\
                        if(dv.y < 0.0)\n\
                        {\n\
                            rAngle = 180.0 + rAngle;\n\
                        }\n\
                    }\n\
                    if(dv.x <= 0.0)\n\
                    {\n\
                        if(dv.y < 0.0)\n\
                        {\n\
                            rAngle = 180.0 + rAngle;\n\
                        }\n\
                        if(dv.y > 0.0)\n\
                        {\n\
                            rAngle = 360.0 + rAngle;\n\
                        }\n\
                    }\n\
                    return rAngle;\n\
                }\n\
                float ripple(float dist, float rippleIntensity, float rippleScale) {\n\
                    return rippleScale * ((sin(dist * rippleIntensity - czm_frameNumber/10.0)-0.9) / (dist * rippleIntensity));\n\
                }\n\
                czm_material czm_getMaterial(czm_materialInput materialInput)\n\
                {\n\
                    czm_material material = czm_getDefaultMaterial(materialInput);\n\
                    material.diffuse = color.rgb;\n\
                    vec2 st = materialInput.st;\n\
                    float dis = distance(st, vec2(0.5, 0.5));\n\
                    float f = 0.0;\n\
                    float nowAngle = getAngle(st.xy-vec2(0.5, 0.5));\n\
                    if(nowAngle < angle2 && nowAngle > angle1)\n\
                    {\n\
                        if(gradient){\n\
                            f = (nowAngle - angle1) / _angle;\n\
                            material.alpha = f;\n\
                            if(inverse){\n\
                                material.alpha = 1.0 - material.alpha;\n\
                            }\n\
                        }else{\n\
                            material.alpha = 1.0;\n\
                        }\n\
                    }else if(nowAngle < range && nowAngle > angle1 && angle2 < _angle){\n\
                        if(gradient){\n\
                            f = (nowAngle - angle1) / _angle;\n\
                            material.alpha = f;\n\
                            if(inverse){\n\
                                material.alpha = 1.0 - material.alpha;\n\
                            }\n\
                        }else{\n\
                            material.alpha = 1.0;\n\
                        }\n\
                    }else if(nowAngle < angle2 && nowAngle > 0.0 && angle2 < _angle){\n\
                        if(gradient){\n\
                            f = (nowAngle + range - angle1) / _angle;\n\
                            material.alpha = f;\n\
                            if(inverse){\n\
                                material.alpha = 1.0 - material.alpha;\n\
                            }\n\
                        }else{\n\
                            material.alpha = 1.0;\n\
                        }\n\
                    }else{\n\
                        material.alpha = 0.0;\n\
                        discard;\n\
                    }\n\
                    return material;\n\
                }";


            Cesium.Material._materialCache.addMaterial(Cesium.Material.RadarScanType, {
                fabric: {
                    type: Cesium.Material.RadarScanType,
                    uniforms: {
                        color: new Cesium.Color(1.0, 0.0, 0.0, 1),
                        time: 0,
                        angle2: 0,
                        angle1: 0,
                        _angle: 60,
                        range: 360,
                        inverse: false,
                        gradient: true
                    },
                    source: Cesium.Material.RadarScanSource

                },
                translucent: function (material) {
                    return true;
                }
            });
        }

        var ellipseEentity = {
            name: 'RadarScan',
            position: Center,
            ellipse: {
                height: clampToGround ? undefined : _height,
                semiMinorAxis: maxRadius,
                semiMajorAxis: maxRadius,
                material: new Cesium.RadarScanMaterialProperty(scanColor, duration)
            }
        };
        return viewer.entities.add(ellipseEentity);
    };

    /**
     * 设置最大半径 米
     * @param {Number} radius 半径
     */
    Scan.prototype.setRadius = function (radius) {
        if (this.item) {
            this.item.ellipse.semiMinorAxis = parseFloat(radius);
            this.item.ellipse.semiMajorAxis = parseFloat(radius);
        }
    };

    /**
     * 设置持续时间 毫秒。
     * @param {Number} radius 半径
     */
    Scan.prototype.setTime = function (time) {
        if (this.item) {
            this.item.ellipse.material.duration = parseFloat(time);
        }
    };

    /**
     * 设置扫描线扇叶角度。
     * @param {Number} angle 角度
     */
    Scan.prototype.setRadarAngle = function (angle) {
        if (this.item && this.item.ellipse.material.getType() === 'RadarScan') {
            let range = this.item.ellipse.material.range;
            this.item.ellipse.material._angle = angle > range ? range : parseFloat(angle);
        }
    };

    /**
     * 设置扫描线范围。
     * @param {Number} range 范围
     */
    Scan.prototype.setRadarRange = function (range) {
        if (this.item && this.item.ellipse.material.getType() === 'RadarScan') {
            this.item.ellipse.material.range = range > 360 ? 360 : parseFloat(range);
        }
    };

    /**
     * 设置扫描线是否往返。
     * @param {Boolean} isReturn 是否往返
     */
    Scan.prototype.setRadarIsReturn = function (isReturn) {
        if (this.item && this.item.ellipse.material.getType() === 'RadarScan') {
            this.item.ellipse.material.isReturn = isReturn;
        }
    };

    /**
     * 设置扫描线是否渐变。
     * @param {Boolean} isGradient 是否渐变
     */
    Scan.prototype.setRadarIsGradient = function (isGradient) {
        if (this.item && this.item.ellipse.material.getType() === 'RadarScan') {
            this.item.ellipse.material.isGradient = isGradient;
        }
    };



    /**
     * 设置中心位置
     * @param {Object} [degrees] 经纬度
     * @param {Number} [degrees.lon] 经度
     * @param {Number} [degrees.lat] 纬度
     */
    Scan.prototype.setPosition = function (degrees) {
        if (this.item) {
            this.item.position = new Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat);
        }
    };

    Scan.prototype.remove = function () {
        this._viewer.entities.remove(this.item);
    };

    //工程树添加
    Scan.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    /**
     * 删除
     */
    Scan.prototype.deleteObject = function () {
        if (this.item) {
            this._viewer.entities.remove(this.item);
        }
    };

    /**
     * 设置polyline的显示隐藏
     * @param {boolean} [b] true|false
     */
    Scan.prototype.setVisibility = function (b) {
        if (this.item) {
            this.item.show = b;
        }
    };

    /**
     *
     *深度检测。
     *
     * @alias depthTestAgainstTerrain 
     * @constructor
     *
     */
    function depthTestAgainstTerrain(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    /**
    * 这个方法用于设置深度检测
    * @param {Bool} [obj]设置深度检测是否开启。
    * 
    */
    depthTestAgainstTerrain.prototype.depthTestAgainstTerrain = function (obj) {
        this._viewer.scene.globe.depthTestAgainstTerrain = obj;
    };
    depthTestAgainstTerrain.prototype.show = function () {
        return this._viewer.scene.globe.depthTestAgainstTerrain;
    };

    var d$5, v$4, m;

    var g$1, E, S,
        x,
        T,
        S, M;
    var H = [1, 1e5];

    var viewer$4;

    function L(t, n) {
        if (viewer$4.canvas.width <= 0 || viewer$4.canvas.height <= 0) return;
        var s;
        var ray = viewer$4.camera.getPickRay(t);
        if (ray) {
            s = viewer$4.scene.globe.pick(ray, viewer$4.scene);
        }
        var feature = viewer$4.scene.pick(t);
        if (feature && (feature.id instanceof Cesium.Entity)) {
            feature = undefined;
        }
        if (feature) {
            var _cartesian = viewer$4.scene.pickPosition(t);
            if (_cartesian) {
                s = _cartesian;
            }
        }
        return s;
    }

    /**
     *
     * 3D视域分析。
     *
     * @alias Viewshed
     * @constructor
     * 
     * @param {Viewer} oviewer 地图视图。
     * @param {Cesium} ocesium Cesium。
     *
     */
    function Viewshed(oviewer, ocesium) {
        this._normalShadowMap = oviewer.scene.shadowMap;
        viewer$4 = oviewer;
        Cesium.Scene.prototype.screenToWorld = L;
        this._viewer = oviewer;
        this._cesium = ocesium;
        this._core = new Core();
        this._getPosition = new getPosition(oviewer, ocesium);
        this._startPositionCartesian = null,
            this._startPositionCartographic = null,
            this._currentPosition = null,
            this._prevRadius = null,
            this._currentRadius = null,
            this._currentFovHorizontal = null,
            this._currentFovVertical = null,
            this._viewshedDirection = null,
            this._scratchCartesian3 = new Cesium.Cartesian3,
            this._texture = null,
            this._canEnlarge = !1,
            this._viewshedPrimitive = null,
            this._eventListener = null,
            this._viewshedMap = undefined,
            this._firstTime = !0,
            this._editingMode = !1,
            this._isSliderClicked = !1,
            this._currentObject = undefined,
            this._setNewPosition = !1,
            this._setNewPositionCanDrag = !1,
            this._setNewName = !1,
            this._listControl = undefined,
            this._addingViewshedMode = !1,
            this._initialCameraParams = {},
            this._isCancelledTerrain = !1,
            this._isCancelledPrimitives = !1,
            this._isSpherical = !1,
            this._occluder = undefined,
            this._horizonCullingDistanceFromPoint = undefined,
            this._mousePositionX = undefined,
            this._mousePositionY = undefined,
            this._zAxisNewPosition = undefined,
            this._startingRepoZHeight = undefined,
            this._viewshedCartoPos = undefined,
            this._propertiesChanged = !1,
            this._calculations = [],
            this._exposures = [],
            this._calculating = !1,
            this._calculatingExposure = !1,
            this.viewshedCalculateNormals = !1,
            this._txtUnit = "meters_short",
            this.isLoadingScreenOn = !1,
            this._primitiveColor = Cesium.Color.WHITE,
            this._predefinedPrimitiveColors = {
                BEYOND_THE_HORIZON: Cesium.Color.WHITE,
                DEFAULT: Cesium.Color.WHITE
            },
            this._layersStorage = null,
            this.getId = function () {
                return "Viewshed"
            };
        this.maxNumViewshed = 8;

        d$5 = 53 * Cesium.Math.RADIANS_PER_DEGREE, v$4 = 53 * Cesium.Math.RADIANS_PER_DEGREE, m = 6371010;

        g$1 = {
            ABOVE_SEA_LEVEL: 0,
            ABOVE_GROUND_LEVEL: 1,
            ABOVE_MODEL: 2
        };
        E = new Cesium.Cartesian3;
        S = new Cesium.Matrix4;
        x = new Cesium.Cartesian4;
        T = new Cesium.Cartesian3;
        S = new Cesium.Matrix4;
        M = new Array(4);
        M[0] = new Cesium.Cartesian4(-1, -1, 1, 1);
        M[1] = new Cesium.Cartesian4(1, -1, 1, 1);
        M[2] = new Cesium.Cartesian4(1, 1, 1, 1);
        M[3] = new Cesium.Cartesian4(-1, 1, 1, 1);
    }

    Viewshed.prototype.setOptions = function (options) {
        this._currentObject = {
            viewshedPrimitive: this._viewshedPrimitive,
            viewshedMap: this._viewshedMap,
            viewshedObjOptions: options || {}
        };
    };

    /**
     * 绘制视域。
     * 
     * @param {Object} [options] 参数。
     * @param {String} [options.name] 名称。
     * @param {Number} [options.height=1.6] 视角相对高度。
     * @param {Boolean} [options.isSpherical=false] 是否球形。
     * @param {Object} [options.color] 颜色，rgb对象(0-1)，可选。
     * @param {Object} [options.color.Back={ r: 1.0, g: 0.0, b: 0.0 }] 不可见颜色。
     * @param {Object} [options.color.Fore={ r: 0.0, g: 1.0, b: 0.0 }] 可见颜色。
     * @param {Object} [options.color.default={ r: 0.0, g: 0.0, b: 0.0 }] 默认阴影颜色。
     * 
     */
    Viewshed.prototype.startDraw = function (options) {
        if (this._viewshedPrimitive) {
            viewer$4.scene.primitives.remove(this._viewshedPrimitive);
            this._viewshedPrimitive = null;
        }
        this._core.setDepthTest('open', this._viewer);
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        this._eventListener && this._eventListener.destroy();
        this._eventListener = new Cesium.ScreenSpaceEventHandler(viewer$4.scene.canvas);
        this._viewshedDefaultNamingArray === undefined && (this._viewshedDefaultNamingArray = new Array(this.maxNumViewshed));

        this._addingViewshedMode = !0;
        this._editingMode = !1;

        this._currentObject = {
            viewshedPrimitive: this._viewshedPrimitive,
            viewshedMap: this._viewshedMap,
            viewshedObjOptions: options || {}
        };
        this._isSpherical = options.isSpherical;
        this._setNewPosition = !1;


        if (this._core.getBrowser().pc != 'pc') {
            this._eventListener.setInputAction($.proxy(this.setViewshedPositionMobile, this), Cesium.ScreenSpaceEventType.LEFT_CLICK);        viewer$4.scene.preRender.addEventListener(this.onPreFrameMobile, this);
        }
        else {
            this._eventListener.setInputAction($.proxy(this.setViewshedPosition, this), Cesium.ScreenSpaceEventType.LEFT_CLICK);
            viewer$4.scene.preRender.addEventListener(this.onPreFrame, this);
        }
        this.end = (type) => {
            this.end = undefined;
            viewer$4.scene.preRender.removeEventListener(this.onPreFrame, this);
            try {
                viewer$4.scene.preRender.removeEventListener(this.onPreFrameMobile, this);
            }
            catch (ex) { }
            this._eventListener && this._eventListener.destroy();
            this._core.setDepthTest('close', this._viewer);
            //设置鼠标样式
            this._core.mouse(this._viewer.container, 0);
        };
    };

    Viewshed.prototype.close = function () {

        viewer$4.scene.preRender.removeEventListener(this.onPreFrame, this);
        try {
            viewer$4.scene.preRender.removeEventListener(this.onPreFrameMobile, this);
        }
        catch (ex) { }
        this._eventListener && this._eventListener.destroy();
        if (this._viewshedPrimitive) {
            viewer$4.scene.primitives.remove(this._viewshedPrimitive);
            this._viewshedPrimitive = null;
        }
        var scene = viewer$4.scene;
        //scene.shadowMap.destroy();

        var context = viewer$4.scene.context;
        var shadowOptions = {
            context: context,
            lightCamera: scene._sunCamera,
            //cascadesEnabled: false
        };

        scene.shadowMap.destroy();
        scene.shadowMap = new Cesium.ShadowMap(shadowOptions);
        var shadowMap = scene.shadowMap;
        if (this._currentObject && this._currentObject.viewshedObjOptions && this._currentObject.viewshedObjOptions.color && this._currentObject.viewshedObjOptions.color.default) {
            var color = this._currentObject.viewshedObjOptions.color.default;
            shadowMap._color = new Cesium.Cartesian3(color.r, color.g, color.b);
        }
        shadowMap.enabled = true;
        shadowMap.debugShow = false;
        shadowMap.guid = void 0;
        //shadowMap._isSpotLight = false;
        shadowMap.show = true;
        shadowMap.maximumDistance = 10000;
        //shadowMap._pointLightRadius = distance;
        // Update render states for when polygon offset values change
        shadowMap.debugCreateRenderStates();
        //shadowMap._distance = distance;
        // Force all derived commands to update
        shadowMap.dirty = true;
        viewer$4.scene.globe.shadows = Cesium.ShadowMode.fromCastReceive(true, true);
        viewer$4.scene.globe.show = true;
        scene.skyAtmosphere.show = true;
        viewer$4.scene.shadowMap = this._normalShadowMap;

        this._startPositionCartesian = null;


        this.resetAllVariables();
        this._core.setDepthTest('close', this._viewer);
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 0);

    };

    Viewshed.prototype.setVisibility = function (b) {
        this._viewshedPrimitive.show = b;
        viewer$4.shadowMap.enabled = b;
    };

    Viewshed.prototype.reset = function () {
        // if (this._viewshedPrimitive) {
        //     viewer.scene.primitives.remove(this._viewshedPrimitive);
        //     this._viewshedPrimitive = null;
        // }
        // this._core.setDepthTest('close', this._viewer);
        // this._eventListener && this._eventListener.destroy();
        // viewer.scene.preRender.removeEventListener(this.onPreFrame, this);
        var scene = viewer$4.scene;
        //scene.shadowMap.destroy();

        var context = viewer$4.scene.context;
        var shadowOptions = {
            context: context,
            lightCamera: scene._sunCamera,
            //cascadesEnabled: false
        };

        scene.shadowMap.destroy();
        scene.shadowMap = new Cesium.ShadowMap(shadowOptions);
        var shadowMap = scene.shadowMap;
        if (this._currentObject && this._currentObject.viewshedObjOptions && this._currentObject.viewshedObjOptions.color && this._currentObject.viewshedObjOptions.color.default) {
            var color = this._currentObject.viewshedObjOptions.color.default;
            shadowMap._color = new Cesium.Cartesian3(color.r, color.g, color.b);
        }
        shadowMap.enabled = true;
        shadowMap.debugShow = false;
        shadowMap.guid = void 0;
        //shadowMap._isSpotLight = false;
        shadowMap.show = true;
        shadowMap.maximumDistance = 10000;
        //shadowMap._pointLightRadius = distance;
        // Update render states for when polygon offset values change
        shadowMap.debugCreateRenderStates();
        //shadowMap._distance = distance;
        // Force all derived commands to update
        shadowMap.dirty = true;
        viewer$4.scene.globe.shadows = Cesium.ShadowMode.fromCastReceive(true, true);
        viewer$4.scene.globe.show = true;
        scene.skyAtmosphere.show = true;
        viewer$4.scene.shadowMap = this._normalShadowMap;
    };

    /**
     * 添加视域。
     * 
     * @param {Object} [option] 参数。
     * @param {Number} [option.lon] 经度。
     * @param {Number} [option.lat] 纬度。
     * @param {Number} [option.height] 高度。
     * @param {Number} [option.distance=1000] 可视距离。
     * @param {Number} [option.heading=0] 水平视角。
     * @param {Number} [option.pitch=0] 垂直视角。
     * @param {Boolean} [option.isSpherical=false] 是否球形。
     * @param {Object} [option.color] 颜色，rgb对象(0-1)，可选。
     * @param {Object} [option.color.Back={ r: 1.0, g: 0.0, b: 0.0 }] 不可见颜色。
     * @param {Object} [option.color.Fore={ r: 0.0, g: 1.0, b: 0.0 }] 可见颜色。
     * @param {Object} [option.color.default={ r: 0.0, g: 0.0, b: 0.0 }] 默认阴影颜色。
     * 
     */
    Viewshed.prototype.addViewshed = function (option = {}) {
        this._viewshedPrimitive && this.close();

        let HeadingPitchRange = new Cesium.HeadingPitchRange(option.heading, option.pitch, 0.01);

        let position = Cesium.Cartesian3.fromDegrees(option.lon, option.lat, option.height);

        this._currentRadius = option.distance || 1000;
        this._isSpherical = option.isSpherical;

        this._currentObject = this.CreateViewshed(position, this._currentRadius, HeadingPitchRange, option);
        if (this._isSpherical) {
            this.createViewshedSpherePrimitive(position);
        } else {
            this.createViewshedCameraPrimitive(position, this._currentObject.viewshedMap._lightCamera);
        }
    };

    /**
     * 这个方法用于创建3D视域
     *
     */
    Viewshed.prototype.CreateViewshed = function (position, distance, direction, options) {
        var scene = viewer$4.scene;
        var spotLightCamera = new Cesium.Camera(scene);
        var context = viewer$4.scene.context;

        /*  var modelcenter = new Cesium.Cartesian3.fromDegrees((120.0005 + i * 0.0005), (29.9999 + i * 0.0005), 100); */
        //var vsPositionCarto = new Cesium.Cartesian3.fromDegrees(120 + i * 0.0005, 30 + i * 0.0005, 150);
        /*             var model = viewer.scene.primitives.add(Cesium.Model.fromGltf({
                        url: url,
                        modelMatrix: Cesium.Transforms.headingPitchRollToFixedFrame(modelcenter, new Cesium.HeadingPitchRoll(0, 0.0, 0.0))
                    })); */
        spotLightCamera.frustum.fov = 53 * Math.PI / 180;
        spotLightCamera.frustum.aspectRatio = 1.0;
        spotLightCamera.frustum.near = 1.0;
        spotLightCamera.frustum.far = distance;
        spotLightCamera.lookAt(position, direction);
        //Cesium.Cartesian3.clone(this._viewer.scene.globe.ellipsoid.geodeticSurfaceNormal(position, new Cesium.Cartesian3), spotLightCamera.up);
        var shadowOptions = {
            context: context,
            lightCamera: spotLightCamera,
            cascadesEnabled: false,
            isPointLight: this._isSpherical,
            pointLightRadius: distance
        };

        //scene.shadowMap.destroy();
        scene.shadowMap = new Cesium.ShadowMap(shadowOptions);

        var shadowMap = scene.shadowMap;
        if (options.color) {
            shadowMap._viewshed_Back = new Cesium.Cartesian3(options.color.Back.r, options.color.Back.g, options.color.Back.b);
            shadowMap._viewshed_Fore = new Cesium.Cartesian3(options.color.Fore.r, options.color.Fore.g, options.color.Fore.b);
        }
        shadowMap.enabled = true;
        shadowMap.debugShow = false;
        shadowMap.guid = Cesium.createGuid();
        //shadowMap._isSpotLight = false;
        shadowMap.show = true;
        shadowMap.maximumDistance = 10000;
        shadowMap._pointLightRadius = distance;
        // Update render states for when polygon offset values change
        shadowMap.debugCreateRenderStates();
        shadowMap._distance = distance;
        // Force all derived commands to update
        shadowMap.dirty = true;
        viewer$4.scene.globe.shadows = Cesium.ShadowMode.fromCastReceive(true, true);
        viewer$4.scene.globe.show = true;
        scene.skyAtmosphere.show = true;
        var viewsObj = {};
        viewsObj.position = position;
        viewsObj.distance = distance;
        viewsObj.direction = direction;

        viewsObj.viewshedObjOptions = options;
        viewsObj.guid = this._cesium.createGuid();
        viewsObj.viewshedObjOptions.originalDirection = direction;
        viewsObj.type = "viewshed";
        viewsObj.viewshedMap = shadowMap;
        return viewsObj;


    };

    Viewshed.prototype.resetAllVariables = function () {
        this._startPositionCartesian = null,
            this._startPositionCartographic = null,
            this._currentPosition = null,
            this._currentRadius = null,
            this._currentFovHorizontal = null,
            this._currentFovVertical = null,
            this._setNewPosition = !1,
            this._currentObject = undefined,
            this._viewshedMap = undefined,
            this._canEnlarge = !1,
            this._zAxisNewPosition = undefined,
            this._viewshedDirection = null;
    };

    Viewshed.prototype.setViewshedPosition = function (t) {
        if (!this._setNewPosition)
            if (this._canEnlarge && this._viewshedPrimitive != undefined) {
                this._canEnlarge = !1;
                this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE);
                this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_CLICK);
                this._currentObject.viewshedObjOptions.end && this._currentObject.viewshedObjOptions.end();
                //设置鼠标样式
                this._core.mouse(this._viewer.container, 0);

                if (this._viewshedMap != undefined && this._viewshedPrimitive != undefined) {
                    var n = this._viewshedPrimitive._camera;
                    //viewer.scene.primitives._primitives.pop();
                    //viewer.scene.viewsheds.pop();
                    this._currentObject.viewshedObjOptions.initialHeading = n.heading;
                    this._currentObject.viewshedObjOptions.initialPitch = n.pitch;
                    this._currentObject.viewshedObjOptions.initialRoll = n.roll;
                    this._currentObject.viewshedObjOptions.altitudeMethod = Cesium.defaultValue(this._currentObject.viewshedObjOptions.altitudeMethod, 2);
                    var r = {
                        displayName: this._currentObject.viewshedObjOptions.name,
                        color: this._currentObject.viewshedObjOptions.color,
                        hFOV: n.frustum.fov,
                        vFOV: n.frustum.fovy,
                        aspectRatio: n.frustum.aspectRatio,
                        height: this._currentObject.viewshedObjOptions.height,
                        distance: this._currentObject.viewshedObjOptions.distance,
                        xPos: this._currentObject.viewshedObjOptions.xPos,
                        yPos: this._currentObject.viewshedObjOptions.yPos,
                        altitudeMethod: this._currentObject.viewshedObjOptions.altitudeMethod,
                        pickHeight: this._currentObject.viewshedObjOptions.pickHeight,
                        horizonCullingDistanceFromViewshed: this._horizonCullingDistanceFromPoint,
                        initialHeading: this._currentObject.viewshedObjOptions.initialHeading,
                        initialPitch: this._currentObject.viewshedObjOptions.initialPitch,
                        initialRoll: this._currentObject.viewshedObjOptions.initialRoll
                    };
                    /*                         var gltf = Cesium.Model.fromGltf({
                                                url: '../ThirdParty/Cesium-1.41/Apps/SampleData/models/ShadowTester/Shadow_Tester_2.gltf',
                                                modelMatrix: Cesium.Transforms.eastNorthUpToFixedFrame(n.position)//Cesium.Transforms.headingPitchRollToFixedFrame(n.position, new Cesium.HeadingPitchRange(parseFloat(n.heading),parseFloat(n.pitch),parseFloat(n.roll)))
                                            });
                                            var model = this._viewer.scene.primitives.add(gltf); */

                    var i = this.CreateViewshed(n.position, Cesium.defaultValue(this._currentObject.viewshedObjOptions.distance, this._currentRadius), new Cesium.HeadingPitchRange(n.heading, n.pitch, 0.01), r);
                    this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_CLICK);
                    this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_DOWN);
                    this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_UP);
                    this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE);
                    if (i == -1) {
                        return
                    }
                    //i.viewshedPrimitive.update = this.updateViewshedPrimitive;
                    this.resetAllVariables();
                    this._currentObject = i;
                    var o = viewer$4.scene.primitives._primitives;
                        $.grep(o, function (e) {
                            return e.isViewshed === !0
                        });
                    var f = [];
                    o.forEach(function (e, t) {
                        e.isViewshed && f.push(t);
                    });
                    if (f.length > 1) {
                        var l = f[f.length - 2],
                            c = viewer$4.scene.primitives._primitives[l];
                        viewer$4.scene.primitives.remove(c);
                    }
                }
            } else if (Cesium.defined(t) && this._currentObject !== undefined) {
                // var h = viewer.scene.screenToWorld(t.position);
                var h = this._getPosition.getMousePosition(t);
                if (h !== undefined) {
                    var p = 0,
                        d = 0;
                    this._startPositionCartographic = viewer$4.scene.globe.ellipsoid.cartesianToCartographic(h),
                        this._currentObject.viewshedObjOptions.pickHeight = this._startPositionCartographic.height,
                        this._currentObject.viewshedObjOptions.height !== undefined && (d = this._currentObject.viewshedObjOptions.height);
                    var v = new Cesium.Cartesian3.fromRadians(this._startPositionCartographic.longitude, this._startPositionCartographic.latitude, this._startPositionCartographic.height + p + d);
                    this._startPositionCartesian = v;
                    var g = this._startPositionCartesian,
                        y = new Cesium.BoundingSphere(new Cesium.Cartesian3(0, 0, 0), m);
                    this._occluder = new Cesium.Occluder(y, g);
                    this._canEnlarge = !0;
                    this._eventListener.setInputAction($.proxy(this.onMouseMove, this), Cesium.ScreenSpaceEventType.MOUSE_MOVE);
                }
            }
    };

    /**
     * 更新视域。
     * 
     * @param {Object} [option] 参数。
     * @param {Number} [option.lon] 经度。
     * @param {Number} [option.lat] 纬度。
     * @param {Number} [option.height] 高度。
     * @param {Number} [option.distance=1000] 可视距离。
     * @param {Number} [option.heading=0] 水平视角。
     * @param {Number} [option.pitch=0] 垂直视角。
     * 
     */
    Viewshed.prototype.update = function (option = {}) {
        if (this._currentObject && this._currentObject.viewshedMap) {
            let HeadingPitchRange = this._currentObject.direction;
            Object.assign(HeadingPitchRange, option);

            let position = this._currentObject.position;
            if (option.lon !== undefined || option.lat !== undefined || option.height !== undefined) {
                let degrees = this._core.toDegrees(position);
                Object.assign(degrees, option);
                position = Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height);
                this._currentObject.position = position;
            }

            option.distance !== undefined && (this._currentRadius = option.distance);
            if (this._currentRadius) {
                this._currentObject.viewshedMap._lightCamera.frustum.far = this._currentRadius;
            } else {
                this._currentRadius = this._currentObject.viewshedMap._lightCamera.frustum.far;
            }

            this._currentObject.viewshedMap._lightCamera.lookAt(position, HeadingPitchRange);
            if (this._isSpherical) {
                this.createViewshedSpherePrimitive(position);
            } else {
                this.createViewshedCameraPrimitive(position, this._currentObject.viewshedMap._lightCamera);
            }
        }
    };

    Viewshed.prototype.setViewshedPositionMobile = function (t) {
        if (!this._setNewPosition) {

            // this.onPreFrame({})
            this.onMouseMove(t);

            this.createViewshedCameraPrimitive();
            if (this._canEnlarge && this._viewshedPrimitive != undefined) {
                // this._canEnlarge = !1;
                // this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE);
                // this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_CLICK);
                this._currentObject.viewshedObjOptions.end && this._currentObject.viewshedObjOptions.end();
                //设置鼠标样式
                this._core.mouse(this._viewer.container, 0);

                this.createViewshedMap();
                if (this._viewshedMap != undefined && this._viewshedPrimitive != undefined) {
                    //this.reset();
                    var n = this._viewshedPrimitive._camera;
                    //viewer.scene.primitives._primitives.pop();
                    //viewer.scene.viewsheds.pop();
                    this._currentObject.viewshedObjOptions.initialHeading = n.heading;
                    this._currentObject.viewshedObjOptions.initialPitch = n.pitch;
                    this._currentObject.viewshedObjOptions.initialRoll = n.roll;
                    this._currentObject.viewshedObjOptions.altitudeMethod = Cesium.defaultValue(this._currentObject.viewshedObjOptions.altitudeMethod, 2);
                    var r = {
                        displayName: this._currentObject.viewshedObjOptions.name,
                        color: this._currentObject.viewshedObjOptions.color,
                        hFOV: n.frustum.fov,
                        vFOV: n.frustum.fovy,
                        aspectRatio: n.frustum.aspectRatio,
                        height: this._currentObject.viewshedObjOptions.height,
                        distance: this._currentObject.viewshedObjOptions.distance,
                        xPos: this._currentObject.viewshedObjOptions.xPos,
                        yPos: this._currentObject.viewshedObjOptions.yPos,
                        altitudeMethod: this._currentObject.viewshedObjOptions.altitudeMethod,
                        pickHeight: this._currentObject.viewshedObjOptions.pickHeight,
                        horizonCullingDistanceFromViewshed: this._horizonCullingDistanceFromPoint,
                        initialHeading: this._currentObject.viewshedObjOptions.initialHeading,
                        initialPitch: this._currentObject.viewshedObjOptions.initialPitch,
                        initialRoll: this._currentObject.viewshedObjOptions.initialRoll
                    };
                    /*                         var gltf = Cesium.Model.fromGltf({
                                                url: '../ThirdParty/Cesium-1.41/Apps/SampleData/models/ShadowTester/Shadow_Tester_2.gltf',
                                                modelMatrix: Cesium.Transforms.eastNorthUpToFixedFrame(n.position)//Cesium.Transforms.headingPitchRollToFixedFrame(n.position, new Cesium.HeadingPitchRange(parseFloat(n.heading),parseFloat(n.pitch),parseFloat(n.roll)))
                                            });
                                            var model = this._viewer.scene.primitives.add(gltf); */

                    var i = this.CreateViewshed(n.position, Cesium.defaultValue(this._currentObject.viewshedObjOptions.distance, this._currentRadius), new Cesium.HeadingPitchRange(n.heading, n.pitch, 0.01), r);

                    // 允许多次点击修改角度 请注释
                    this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_CLICK);
                    this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_DOWN);
                    this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_UP);
                    this._eventListener.removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE);


                    if (i == -1) {
                        return
                    }
                    //i.viewshedPrimitive.update = this.updateViewshedPrimitive;

                    // this.resetAllVariables();
                    this._currentObject = i;
                    var o = viewer$4.scene.primitives._primitives;
                        $.grep(o, function (e) {
                            return e.isViewshed === !0
                        });
                    var f = [];
                    o.forEach(function (e, t) {
                        e.isViewshed && f.push(t);
                    });
                    if (f.length > 1) {
                        var l = f[f.length - 2],
                            c = viewer$4.scene.primitives._primitives[l];
                        viewer$4.scene.primitives.remove(c);
                    }
                }
            } else if (Cesium.defined(t) && this._currentObject !== undefined) {
                // var h = viewer.scene.screenToWorld(t.position);
                var h = this._getPosition.getMousePosition(t);
                if (h !== undefined) {
                    var p = 0,
                        d = 0;
                    this._startPositionCartographic = viewer$4.scene.globe.ellipsoid.cartesianToCartographic(h),
                        this._currentObject.viewshedObjOptions.pickHeight = this._startPositionCartographic.height,
                        this._currentObject.viewshedObjOptions.height !== undefined && (d = this._currentObject.viewshedObjOptions.height);
                    var v = new Cesium.Cartesian3.fromRadians(this._startPositionCartographic.longitude, this._startPositionCartographic.latitude, this._startPositionCartographic.height + p + d);
                    if (!this._startPositionCartesian)
                        this._startPositionCartesian = v;
                    var g = this._startPositionCartesian,
                        y = new Cesium.BoundingSphere(new Cesium.Cartesian3(0, 0, 0), m);
                    this._occluder = new Cesium.Occluder(y, g);
                    this._canEnlarge = !0;
                    this._eventListener.setInputAction($.proxy(this.onMouseMove, this), Cesium.ScreenSpaceEventType.MOUSE_MOVE);

                }
            }
        }
    };

    Viewshed.prototype.onMouseMove = function (t) {
        if (Cesium.defined(t)) {
            var n = {};
            // var r = viewer.scene.screenToWorld(t.endPosition, n);
            var r = this._getPosition.getMousePosition(t);

            if (r != undefined) {
                if (n.pickPrimitive != undefined && n.pickPrimitive._camera != undefined) return;
                var i = {};
                if (!this._setNewPosition) {
                    if (this._startPositionCartesian == null) return;
                    Cesium.Cartesian3.subtract(r, this._startPositionCartesian, i);
                    if (!(!isNaN(i.x) && !isNaN(i.y) && !isNaN(i.z))) return;
                    this._viewshedDirection = Cesium.Cartesian3.normalize(i, this._scratchCartesian3);
                    this._currentRadius = Cesium.Cartesian3.magnitude(i);
                } else if (!this._setNewPositionCanDrag) {
                    var s = r;
                    var o = Cesium.Matrix4.multiplyByVector(viewer$4.camera._viewMatrix, Cesium.Cartesian4.fromElements(s.x, s.y, s.z, 1, x), x);
                    var u = Cesium.Matrix4.multiplyByVector(viewer$4.camera.frustum.projectionMatrix, o, x);
                    var a = Cesium.Cartesian3.divideByScalar(u, u.w, T);
                    var f = Math.floor((a.x * .5 + .5) * viewer$4.canvas.width);
                    var l = Math.floor((a.y * .5 + .5) * viewer$4.canvas.height);
                    this._mousePositionX = f;
                    this._mousePositionY = l;
                } else {
                    var c = undefined;
                    var h = viewer$4.scene.globe.ellipsoid.cartesianToCartographic(r);
                    this._currentObject.viewshedObjOptions.pickHeight = h.height, this._currentObject.viewshedObjOptions.terrainHeight = viewer$4.scene.globe.getHeight(h);
                    if (this._zAxisNewPosition) {
                        var p = t.endPosition.y - this._startingRepoZ.y;
                        var d = Cesium.Cartesian3.magnitude(Cesium.Cartesian3.subtract(this._currentObject.position, viewer$4.camera.position, this._scratchCartesian3), this._scratchCartesian3);
                        var v = p / viewer$4.canvas.height;
                        var m = -1 * d * v;
                        if (this._viewshedCartoPos == undefined) {
                            this._viewshedCartoPos = new Cesium.Cartographic.fromCartesian(this._currentObject.position);
                        }
                        c = new Cesium.Cartesian3.fromRadians(this._viewshedCartoPos.longitude, this._viewshedCartoPos.latitude, this._viewshedCartoPos.height + m);
                    } else {
                        if (this._currentObject.viewshedObjOptions.altitudeMethod == g$1.ABOVE_SEA_LEVEL) {
                            c = new Cesium.Cartesian3.fromRadians(h.longitude, h.latitude, this._startingRepoZHeight);
                        } else {
                            c = r;
                        }
                    }
                    this._newPosition = c;
                }
            } else this._mousePositionX = undefined, this._mousePositionY = undefined;
        }
    };

    Viewshed.prototype.createViewshedSpherePrimitive = function (e, t) {
        try {
            var n = e != undefined ? e : this._startPositionCartesian,
                r = t != undefined ? t : this._currentRadius;
            if (r <= 1) return !1;
            this._viewshedPrimitive != null && viewer$4.scene.primitives.remove(this._viewshedPrimitive);
            var i = Cesium.Matrix4.multiplyByTranslation(Cesium.Transforms.eastNorthUpToFixedFrame(n), new Cesium.Cartesian3(0, 0, 0), S),
                s = new Cesium.GeometryInstance({
                    geometry: new Cesium.SphereOutlineGeometry({
                        radius: r,
                        stackPartitions: 12,
                        slicePartitions: 12
                    }),
                    modelMatrix: i,
                    attributes: {
                        //color: Cesium.Color.MIDNIGHTBLUE
                        color: Cesium.ColorGeometryInstanceAttribute.fromColor(new Cesium.Color(1, 1, 1, .5))
                    }
                });
            this._viewshedPrimitive = viewer$4.scene.primitives.add(new Cesium.Primitive({
                geometryInstances: s,
                appearance: new Cesium.PerInstanceColorAppearance({
                    flat: !0,
                    renderState: {
                        lineWidth: 1
                    }
                }),
                allowPicking: false,
                asynchronous: !1
            }));
            var o = new Cesium.Camera(viewer$4.scene);
            o.position = n, o.direction = Cesium.Cartesian3.negate(Cesium.Cartesian3.UNIT_Z, this._scratchCartesian3),
                this._viewshedPrimitive._camera = o;
        } catch (u) {
            return !1
        }
        return this._viewshedPrimitive
    };

    Viewshed.prototype.createViewshedCameraPrimitive = function (e, c) {
        this._viewshedPrimitive != null && viewer$4.scene.primitives.remove(this._viewshedPrimitive);
        var t = new Cesium.Camera(viewer$4.scene);
        if (!this._startPositionCartesian && !e) return;
        return e != undefined ? t.position = e : t.position = this._startPositionCartesian,
            this._viewshedDirection != undefined && !isNaN(this._viewshedDirection.x) && !isNaN(this._viewshedDirection.y) && (t.direction = this._viewshedDirection.clone(), t.up = viewer$4.scene.globe.ellipsoid.geodeticSurfaceNormal(t.position, E)),
            t.frustum.isViewshed = !0,
            t.frustum.fov = Cesium.defaultValue(this._currentObject.viewshedObjOptions.fov, d$5),
            t.frustum._fovy = Cesium.defaultValue(this._currentObject.viewshedObjOptions.fovy, v$4),
            t.frustum.aspectRatio = Math.tan(t.frustum.fov / 2) / Math.tan(t.frustum._fovy / 2),
            t.frustum.near = 1,
            this._currentRadius <= 1 ? !1 : (t.frustum.far = Cesium.defaultValue(this._currentObject.viewshedObjOptions.distance, this._currentRadius),
                this._viewshedPrimitive = viewer$4.scene.primitives.add(new Cesium.DebugCameraPrimitive({
                    camera: c || t,
                    color: this._primitiveColor
                    //color: Cesium.Color.MIDNIGHTBLUE
                })), this._viewshedPrimitive._numFrustrums = 0, this._viewshedPrimitive._outlineOnlyFrustum = !0, this._viewshedPrimitive.update = this.updateViewshedPrimitive, this._viewshedPrimitive)
    };

    Viewshed.prototype.createViewshedMap = function () {
        viewer$4.scene.viewsheds == undefined && viewer$4.scene.viewsheds;
        if (this._viewshedPrimitive._camera == undefined) return;
        this._canEnlarge && (this._viewshedMap == undefined ? (this._viewshedMap = new Cesium.ShadowMap({
            context: viewer$4.scene.context,
            lightCamera: this._viewshedPrimitive._camera,
            enabled: 1,
            isSpotLight: !0,
            fromLightSource: !0,
            softShadows: !1,
            isPointLight: this._isSpherical,
            pointLightRadius: Cesium.defaultValue(this._currentObject.viewshedObjOptions.distance, this._currentRadius)
        }),
            this._viewshedMap.show = !0,
            this._viewshedMap.isPreviewMode = !0,
            this._viewshedMap.guid = "SamplerViewshed",
            this._viewshedMap != undefined) : (this._viewshedMap._lightCamera.direction = this._viewshedPrimitive._camera.direction, this._viewshedMap._lightCamera.frustum.far = Cesium.defaultValue(this._currentObject.viewshedObjOptions.distance, this._currentRadius)));
    };

    Viewshed.prototype.updateViewshedPrimitive = function (e) {
        if (!this.show) return;
        this._updateOnChange && (this._outlinePrimitive = this._outlinePrimitive && this._outlinePrimitive.destroy());
        if (!Cesium.defined(this._outlinePrimitive)) {
            var t = this._camera,
                n = t.frustum,
                r = e.frustumSplits,
                i = r.length - 1;
            i = this._numFrustrums, i <= 0 && (r = H, r[0] = this._camera.frustum.near, r[1] = this._camera.frustum.far, i = 1);
            var s = this._camera.viewMatrix,
                o, u;
            if (Cesium.defined(t.frustum.fovy)) {
                var a = this._camera.frustum.projectionMatrix,
                    f = Cesium.Matrix4.multiply(a, s, S);
                u = Cesium.Matrix4.inverse(f, S);
            } else o = Cesium.Matrix4.inverseTransformation(s, S);
            var l = new Float64Array(12 * (i + 1) + 3);
            var c;
            for (c = 0; c < i + 1; ++c) for (var h = 0; h < 4; ++h) {
                var p = Cesium.Cartesian4.clone(M[h], Viewshed[h]);
                if (!Cesium.defined(u)) {
                    Cesium.defined(n._offCenterFrustum) && (n = n._offCenterFrustum);
                    var d, v;
                    c === i ? (d = r[c - 1], v = r[c]) : (d = r[c], v = r[c + 1]);
                    p.x = (p.x * (n.right - n.left) + n.left + n.right) * .5;
                    p.y = (p.y * (n.top - n.bottom) + n.bottom + n.top) * .5;
                    p.z = (p.z * (d - v) - d - v) * .5;
                    p.w = 1, Cesium.Matrix4.multiplyByVector(o, p, p);
                } else {
                    p = Cesium.Matrix4.multiplyByVector(u, p, p);
                    var m = 1 / p.w;
                    Cesium.Cartesian3.multiplyByScalar(p, m, p), Cesium.Cartesian3.subtract(p, this._camera.positionWC, p), Cesium.Cartesian3.normalize(p, p);
                    var g = Cesium.Cartesian3.dot(this._camera.directionWC, p);
                    Cesium.Cartesian3.multiplyByScalar(p, r[c] / g, p), Cesium.Cartesian3.add(p, this._camera.positionWC, p);
                }
                l[12 * c + h * 3] = p.x, l[12 * c + h * 3 + 1] = p.y, l[12 * c + h * 3 + 2] = p.z;
            }
            l[12 * i + 12] = this._camera.positionWC.x, l[12 * i + 12 + 1] = this._camera.positionWC.y, l[12 * i + 12 + 2] = this._camera.positionWC.z;
            var y = new Cesium.BoundingSphere.fromVertices(l),
                b = new Cesium.GeometryAttributes;
            b.position = new Cesium.GeometryAttribute({
                componentDatatype: Cesium.ComponentDatatype.DOUBLE,
                componentsPerAttribute: 3,
                values: l
            });
            var w, E, x = new Uint16Array(8 * (2 * i + 1 + 1));
            for (c = 0; c < i + 1; ++c) w = c * 8, E = c * 4, x[w] = E, x[w + 1] = E + 1, x[w + 2] = E + 1, x[w + 3] = E + 2, x[w + 4] = E + 2, x[w + 5] = E + 3, x[w + 6] = E + 3, x[w + 7] = E;
            for (c = 0; c < i; ++c) w = (i + 1 + c) * 8, E = c * 4, x[w] = E, x[w + 1] = E + 4, x[w + 2] = E + 1, x[w + 3] = E + 5, x[w + 4] = E + 2, x[w + 5] = E + 6, x[w + 6] = E + 3, x[w + 7] = E + 7;
            w += 8, x[w] = E + 8, x[w + 1] = E + 1, x[w + 2] = E + 8, x[w + 3] = E + 2, x[w + 4] = E + 8, x[w + 5] = E + 3, x[w + 6] = E + 8, x[w + 7] = E + 4, this._outlinePrimitive = new Cesium.Primitive({
                geometryInstances: new Cesium.GeometryInstance({
                    geometry: {
                        attributes: b,
                        indices: x,
                        primitiveType: Cesium.PrimitiveType.LINES,
                        boundingSphere: y
                    },
                    attributes: {
                        //color: Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.MIDNIGHTBLUE)
                        //color: Cesium.Color.MIDNIGHTBLUE
                        color: Cesium.ColorGeometryInstanceAttribute.fromColor(this._color)
                    },
                    id: this.id,
                    pickPrimitive: this
                }),
                appearance: new Cesium.PerInstanceColorAppearance({
                    translucent: !1,
                    flat: !0
                }),
                asynchronous: !1
            });
        }
        this._outlinePrimitive.isViewshedPart = !0, this._outlinePrimitive.update(e);
    };

    Viewshed.prototype.getHorizonDistance = function (e) {
        return Math.sqrt(Math.pow(m + e, 2) - Math.pow(m, 2))
    };

    Viewshed.prototype.onPreFrame = function (e) {
        var t, n;
        if (this._currentObject != undefined && this._currentObject.viewshedPrimitive != undefined && this._currentObject.viewshedMap != undefined) {
            t = new Cesium.Cartographic.fromCartesian(this._currentObject.viewshedPrimitive._camera.position);
            var r = this.getHorizonDistance(t.height);
            this._currentObject.viewshedMap.horizonCullingDistanceFromViewshed = r, n = viewer$4.scene.globe.getHeight(t), this._currentObject.viewshedMap.isBelowGround = t.height < n + .5;
        }
        this._currentObject != undefined && this._currentObject.viewshedMap != undefined, this._newPosition != undefined && this.toPreviewMode(this._currentObject);
        if (this._canEnlarge && this._currentRadius != null && this._prevRadius != this._currentRadius) {
            this._prevRadius = this._currentRadius;
            var i = this._isSpherical ? this.createViewshedSpherePrimitive() : this.createViewshedCameraPrimitive();
            i && this.createViewshedMap();
        } else if (this._currentObject != undefined && this._setNewPosition && this._mousePositionX != undefined && this._mousePositionY != undefined) {
            this.getPosXAndY();
            if (this._currentObject.viewshedObjOptions.isSpherical) {
                this._currentObject.viewshedMap._lightCamera.position = this._newPosition;
                this._currentObject.viewshedPrimitive = this.createViewshedSpherePrimitive(this._newPosition, this._currentObject.distance);
            } else {
                this.checkIfMouseOnPosition();
                if (this._newPosition != undefined) {
                    if (this._currentObject.viewshedObjOptions.altitudeMethod == g$1.ABOVE_GROUND_LEVEL && this._zAxisNewPosition == undefined) {
                        var s = Cesium.Cartographic.fromCartesian(this._newPosition.clone()),
                            o = Cesium.Cartesian3.fromRadians(s.longitude, s.latitude, viewer$4.scene.globe.getHeight(s) + this._currentObject.startingAltitudeAboveGround);
                        this._currentObject.viewshedPrimitive._camera.position = o;
                    } else if (this._currentObject.viewshedObjOptions.altitudeMethod == g$1.ABOVE_MODEL && this._zAxisNewPosition == undefined) {
                        var s = Cesium.Cartographic.fromCartesian(this._newPosition.clone()),
                            o = Cesium.Cartesian3.fromRadians(s.longitude, s.latitude, s.height + this._currentObject.startingAltitudeAboveModel);
                        this._currentObject.viewshedPrimitive._camera.position = o;
                    } else this._currentObject.viewshedPrimitive._camera.position = this._newPosition;
                    this.adjustDirections();
                }
            }
        }
    };

    Viewshed.prototype.onPreFrameMobile = function (e) {
        var t, n;
        if (this._currentObject != undefined && this._currentObject.viewshedPrimitive != undefined && this._currentObject.viewshedMap != undefined) {
            t = new Cesium.Cartographic.fromCartesian(this._currentObject.viewshedPrimitive._camera.position);
            var r = this.getHorizonDistance(t.height);
            this._currentObject.viewshedMap.horizonCullingDistanceFromViewshed = r, n = viewer$4.scene.globe.getHeight(t), this._currentObject.viewshedMap.isBelowGround = t.height < n + .5;
        }
        this._currentObject != undefined && this._currentObject.viewshedMap != undefined, this._newPosition != undefined && this.toPreviewMode(this._currentObject);
        if (this._canEnlarge && this._currentRadius != null) {
            this._prevRadius = this._currentRadius;
            var i = this._isSpherical ? this.createViewshedSpherePrimitive() : this.createViewshedCameraPrimitive();
            i && this.createViewshedMap();
        } else if (this._currentObject != undefined && this._setNewPosition && this._mousePositionX != undefined && this._mousePositionY != undefined) {
            this.getPosXAndY();
            if (this._currentObject.viewshedObjOptions.isSpherical) {
                this._currentObject.viewshedMap._lightCamera.position = this._newPosition;
                this._currentObject.viewshedPrimitive = this.createViewshedSpherePrimitive(this._newPosition, this._currentObject.distance);
            } else {
                this.checkIfMouseOnPosition();
                if (this._newPosition != undefined) {
                    if (this._currentObject.viewshedObjOptions.altitudeMethod == g$1.ABOVE_GROUND_LEVEL && this._zAxisNewPosition == undefined) {
                        var s = Cesium.Cartographic.fromCartesian(this._newPosition.clone()),
                            o = Cesium.Cartesian3.fromRadians(s.longitude, s.latitude, viewer$4.scene.globe.getHeight(s) + this._currentObject.startingAltitudeAboveGround);
                        this._currentObject.viewshedPrimitive._camera.position = o;
                    } else if (this._currentObject.viewshedObjOptions.altitudeMethod == g$1.ABOVE_MODEL && this._zAxisNewPosition == undefined) {
                        var s = Cesium.Cartographic.fromCartesian(this._newPosition.clone()),
                            o = Cesium.Cartesian3.fromRadians(s.longitude, s.latitude, s.height + this._currentObject.startingAltitudeAboveModel);
                        this._currentObject.viewshedPrimitive._camera.position = o;
                    } else this._currentObject.viewshedPrimitive._camera.position = this._newPosition;
                    this.adjustDirections();
                }
            }
        }
    };

    /**
     *
     * 天际线分析
     *
     * @alias SkylineAnalysis
     * @constructor
     *
     * @param {Viewer} [viewer] 地图视图
     * @param {Cesium} [cesium] Cesium对象
     */
    function SkylineAnalysis(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    /**
     * 创建天际线
     * @param {String} [color=#ff0000] 天际线颜色
     */
    SkylineAnalysis.prototype.createSkylineAnalysis = function (color = '#ff0000') {
        // 清除上一个天际线
        this.clear();
        // 颜色
        let skylineColor = Cesium.Color.fromCssColorString(color);

        let postProcessStages = Viewer.scene.postProcessStages;

        // 创建一个检测边缘的后期处理
        let edgeDetection = Cesium.PostProcessStageLibrary.createEdgeDetectionStage();

        let postProccessStage = new Cesium.PostProcessStage({
            name: 'czm_skylinetemp',
            fragmentShader: 'uniform sampler2D colorTexture;' +
                'uniform sampler2D depthTexture;' +

                'varying vec2 v_textureCoordinates;' +

                'void main(void)' +
                '{' +
                'float depth = czm_readDepth(depthTexture, v_textureCoordinates);' +
                'vec4 color = texture2D(colorTexture, v_textureCoordinates);' +
                'if(depth<1.0 - 0.000001){' +
                'gl_FragColor = color;' +
                '}' +
                'else{' +
                'gl_FragColor = vec4(1.0,0.0,0.0,1.0);' +
                '}' +
                '}'
        });

        let postProccessStage1 = new Cesium.PostProcessStage({
            name: 'czm_skylinetemp1',
            fragmentShader: 'uniform sampler2D colorTexture;' +
                'uniform sampler2D redTexture;' +
                'uniform sampler2D silhouetteTexture;' +
                'uniform vec4 skylineColor;' +

                'varying vec2 v_textureCoordinates;' +

                'void main(void)' +
                '{' +
                'vec4 redcolor=texture2D(redTexture, v_textureCoordinates);' +
                'vec4 silhouetteColor = texture2D(silhouetteTexture, v_textureCoordinates);' +
                'vec4 color = texture2D(colorTexture, v_textureCoordinates);' +
                'if(redcolor.r == 1.0){' +
                'gl_FragColor = mix(color, skylineColor, silhouetteColor.a);' +
                '}' +
                'else{' +
                'gl_FragColor = color;' +
                '}' +
                '}',
            uniforms: {
                redTexture: postProccessStage.name,
                silhouetteTexture: edgeDetection.name,
                skylineColor: skylineColor
            }
        });

        this.postProccessStage = new Cesium.PostProcessStageComposite({
            name: 'czm_skyline',
            stages: [edgeDetection, postProccessStage, postProccessStage1],
            inputPreviousStageTexture: false,
            uniforms: edgeDetection.uniforms
        });

        postProcessStages.add(this.postProccessStage);
    };
    /**
     * 清除
     */
    SkylineAnalysis.prototype.clear = function () {
        if (this.postProccessStage) {
            this._viewer.scene.postProcessStages.remove(this.postProccessStage);
        }
    };

    function executeDerivedCommand(command, nameDerived, commandName, scene, context, passState) {
        const defined = Cesium.defined;
        var frameState = scene._frameState;
        var derivedCommands = command.derivedCommands;
        if (!defined(derivedCommands)) {
            return;
        }

        if (frameState.useLogDepth && defined(derivedCommands.logDepth)) {
            command = derivedCommands.logDepth.command;
        }

        derivedCommands = command.derivedCommands;
        if (defined(derivedCommands[nameDerived])) {
            command = derivedCommands[nameDerived][commandName];
            command.execute(context, passState);
        }
    }

    var scratchPerspectiveFrustum, scratchPerspectiveOffCenterFrustum, scratchOrthographicFrustum, scratchOrthographicOffCenterFrustum;
    function executeDerivedCommandList(context, targetFramebuffer, passState, nameDerived, commandName, filter) {

        const { Pass, defined, PerspectiveFrustum, PerspectiveOffCenterFrustum, OrthographicFrustum, OrthographicOffCenterFrustum } = Cesium;

        scratchPerspectiveFrustum = scratchPerspectiveFrustum || new PerspectiveFrustum();
        scratchPerspectiveOffCenterFrustum = scratchPerspectiveOffCenterFrustum || new PerspectiveOffCenterFrustum();
        scratchOrthographicFrustum = scratchOrthographicFrustum || new OrthographicFrustum();
        scratchOrthographicOffCenterFrustum = scratchOrthographicOffCenterFrustum || new OrthographicOffCenterFrustum();


        let us = context._us,
            /**
              * @type {Cesium.FrameState}
              * @private
              */
            frameState = us._frameState,
            camera = frameState.camera,
            /**
             * @type {Cesium.Scene}
             * @private
             */
            scene = camera._scene,
            view = scene._view,
            frustumCommandsList = view.frustumCommandsList,
            numFrustums = frustumCommandsList.length;

        var globeTranslucencyState = scene._globeTranslucencyState;
        var globeTranslucent = globeTranslucencyState.translucent;

        // Create a working frustum from the original camera frustum.
        var frustum;
        if (defined(camera.frustum.fov)) {
            frustum = camera.frustum.clone(scratchPerspectiveFrustum);
        } else if (defined(camera.frustum.infiniteProjectionMatrix)) {
            frustum = camera.frustum.clone(scratchPerspectiveOffCenterFrustum);
        } else if (defined(camera.frustum.width)) {
            frustum = camera.frustum.clone(scratchOrthographicFrustum);
        } else {
            frustum = camera.frustum.clone(scratchOrthographicOffCenterFrustum);
        }

        /**
         * 
         * @param {Cesium.DrawCommand} command 
         * @param {*} scene 
         * @param {*} context 
         * @param {*} passState 
         * @private
         */
        function executeCommand(command, scene, context, passState) {
            let show = filter ? filter(command, scene) : true;
            if (show) {
                if (nameDerived && commandName) {
                    executeDerivedCommand(command, nameDerived, commandName, scene, context, passState);
                } else {
                    command.execute(context, passState);
                }
            }
        }


        var j, length, commands;
        for (var i = 0; i < numFrustums; ++i) {
            var index = numFrustums - i - 1;
            var frustumCommands = frustumCommandsList[index];

            var originalFramebuffer = passState.framebuffer;
            passState.framebuffer = targetFramebuffer;

            // reset frustum
            frustum.near =
                index !== 0
                    ? frustumCommands.near * scene.opaqueFrustumNearOffset
                    : frustumCommands.near;
            frustum.far = frustumCommands.far;
            us.updateFrustum(frustum);

            us.updatePass(Pass.GLOBE);
            commands = frustumCommands.commands[Pass.GLOBE];
            length = frustumCommands.indices[Pass.GLOBE];

            if (globeTranslucent) {
                globeTranslucencyState.executeGlobeCommands(
                    frustumCommands,
                    executeCommand,
                    globeTranslucencyFramebuffer,
                    scene,
                    passState
                );
            } else {
                for (j = 0; j < length; ++j) {
                    executeCommand(commands[j], scene, context, passState);
                }
            }

            // if (clearGlobeDepth) {
            //     clearDepth.framebuffer = passState.framebuffer;
            //     clearDepth.execute(context, passState);
            //     clearDepth.framebuffer = undefined;
            // }

            // if (clearGlobeDepth && useDepthPlane) {
            //     depthPlane.execute(context, passState);
            // }

            us.updatePass(Pass.CESIUM_3D_TILE);
            commands = frustumCommands.commands[Pass.CESIUM_3D_TILE];
            length = frustumCommands.indices[Pass.CESIUM_3D_TILE];
            for (j = 0; j < length; ++j) {
                executeCommand(commands[j], scene, context, passState);
            }

            us.updatePass(Pass.OPAQUE);
            commands = frustumCommands.commands[Pass.OPAQUE];
            length = frustumCommands.indices[Pass.OPAQUE];
            for (j = 0; j < length; ++j) {
                executeCommand(commands[j], scene, context, passState);
            }

            us.updatePass(Pass.TRANSLUCENT);
            commands = frustumCommands.commands[Pass.TRANSLUCENT];
            length = frustumCommands.indices[Pass.TRANSLUCENT];
            for (j = 0; j < length; ++j) {
                executeCommand(commands[j], scene, context, passState);
            }

            passState.framebuffer = originalFramebuffer;

        }

    }

    const packing = `
vec3 packNormalToRGB( const in vec3 normal ) {
	return normalize( normal ) * 0.5 + 0.5;
}

vec3 unpackRGBToNormal( const in vec3 rgb ) {
	return 2.0 * rgb.xyz - 1.0;
}

const float PackUpscale = 256. / 255.; // fraction -> 0..1 (including 1)
const float UnpackDownscale = 255. / 256.; // 0..1 -> fraction (excluding 1)

const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );

const float ShiftRight8 = 1. / 256.;

vec4 packDepthToRGBA( const in float v ) {
	vec4 r = vec4( fract( v * PackFactors ), v );
	r.yzw -= r.xyz * ShiftRight8; // tidy overflow
	return r * PackUpscale;
}

float unpackRGBAToDepth( const in vec4 v ) {
	return dot( v, UnpackFactors );
}

vec4 pack2HalfToRGBA( vec2 v ) {
	vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ));
	return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w);
}
vec2 unpackRGBATo2Half( vec4 v ) {
	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
}

// NOTE: viewZ/eyeZ is < 0 when in front of the camera per OpenGL conventions

float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
	return ( viewZ + near ) / ( near - far );
}
float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
	return linearClipZ * ( near - far ) - near;
}

// NOTE: https://twitter.com/gonnavis/status/1377183786949959682

float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
	return (( near + viewZ ) * far ) / (( far - near ) * viewZ );
}
float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
	return ( near * far ) / ( ( far - near ) * invClipZ - far );
}
`;

    const cmz_selected_glsl =
        "uniform sampler2D czm_selectedIdTexture; \n" +
        "uniform float czm_selectedIdTextureStep; \n" +
        "uniform float czm_selectedIdTextureWidth; \n" +

        "bool czm_selected(vec4 id) \n" +
        "{ \n" +
        "    bool selected = false;\n" +
        "    for (int i = 0; i < 1024000; i++) \n" +
        "    { \n" +
        "        vec4 selectedId = texture2D(czm_selectedIdTexture, vec2((float(i) + 0.5) * czm_selectedIdTextureStep, 0.5)); \n" +
        "        if (all(equal(id, selectedId))) \n" +
        "        { \n" +
        "            return true; \n" +
        "        } \n" +
        "       if(float(i)>czm_selectedIdTextureWidth)break;\n" +
        "    } \n" +
        "    return false; \n" +
        "} \n\n";

    /**
     * 
     * @param {Object} options {
            name:string
            vertexShader:string
            fragmentShader:string
            renderType?:string
            uniforms:{[key:string]:string|Cesium.Cartesian2|Cesium.Color|Cesium.Cartesian3|(()=>any)}
        }
     * @private
     */
    function CesiumRenderPass(options) {

        const { defaultValue, BoundingRectangle, Pass, Sampler, DrawCommand, Color, ShaderSource, defined, ClearCommand, RenderState, Texture, PixelDatatype, PixelFormat, Framebuffer } = Cesium;

        this._selectedIdTexture = null;

        let { name,
            vertexShader,
            fragmentShader,
            uniforms,
            renderStateProcess,
            beforeUpdate,
            renderType,
            textureScale,
            pixelFormat,
            pixelDatatype,
            sampler,
            viewportScale,
            shaderRedefine,
            overrideViewport
        } = options,
            passName = "renderPass_" + name.replace(/[\.\\\/\-]/g, '_'),
            nonMainName = `czm_non_${passName}_main`,
            mainName = `czm_${passName}_main`,
            rsCacheName = `_cache_${passName}`,
            commandName = passName + 'Command',
            framebuffer = null,
            colorTexture = null,
            depthTexture = null,
            stage = null,
            useHdr,
            clearCommand = new ClearCommand({
                color: Color.TRANSPARENT,
                depth: 1
            }),
            viewport = new BoundingRectangle(),
            scope = this;

        if (overrideViewport) {
            BoundingRectangle.clone(overrideViewport, viewport);
        }
        shaderRedefine = shaderRedefine || 'add';
        renderType = renderType || 'all';
        textureScale = textureScale || 1;

        if (textureScale < 0 || textureScale > 8) {
            throw new Cesium.DeveloperError('CesiumRenderPass：textureScale必须大于0小于等于8')
        }

        function getShaderProgram(context, shaderProgram, pickId, pickIdQualifier) {

            var shader = context.shaderCache.getDerivedShaderProgram(
                shaderProgram,
                passName
            );
            if (!defined(shader)) {
                var attributeLocations = shaderProgram._attributeLocations;
                var fs = shaderProgram.fragmentShaderSource;
                var vs = shaderProgram.vertexShaderSource;
                var vsStr = shaderProgram._vertexShaderText;

                //

                var sources = fs.sources;
                var length = sources.length;

                let hasSelected = !!stage && getSelected();

                var czm_selectedFS = cmz_selected_glsl;
                var is3dtiles = /texture2D\s?\(\s?tile_pickTexture\s?,\s?tile_featureSt\s?\)/.test(pickId);
                if (pickIdQualifier == 'varying' && !is3dtiles) {
                    czm_selectedFS += `
varying float me_isSelected;
bool czm_selected(){
    bool isSelected= me_isSelected>0.0000001;
    if(!isSelected){
        isSelected= czm_selected(${pickId});
    }
    return isSelected;
}
    `;
                } else {
                    czm_selectedFS += `
bool czm_selected(){ 
    return czm_selected(${pickId}); 
}`;
                }


                let czm_selectedVS = cmz_selected_glsl +
                    `
varying float me_isSelected;
bool czm_selected(){
    return czm_selected(${pickId});
}
`;

                var hasNormal = false, hasVNormal = false;
                if (/attribute\s?vec3\s?normal\s?;/.test(vsStr) || /\n\s?vec3\s?normal\s?;/.test(vsStr)) {
                    hasNormal = true;
                }
                else if (/varying\s?vec3\s?v_normal\s?;/.test(vsStr)) {
                    hasVNormal = true;
                }

                if (fragmentShader) {

                    var hasPacking = false;
                    for (i = 0; i < length; ++i) {
                        if (/vec4\s?packDepthToRGBA\s?\(/.test(sources[i])) {
                            hasPacking = true;
                            break;
                        }
                    }

                    let newMain =
                        (hasPacking ? '' : packing) +
                        (hasSelected ? czm_selectedFS : '') +
                        ShaderSource.replaceMain(fragmentShader, mainName) +
                        "void main() \n" +
                        "{ \n" +
                        (shaderRedefine != 'replace' ? `    ${nonMainName}(); \n` : '') +
                        `    ${mainName}(); \n` +
                        "} \n";
                    var newSources = new Array(length + 1);
                    for (var i = 0; i < length; ++i) {
                        newSources[i] = ShaderSource.replaceMain(sources[i], nonMainName);
                    }
                    newSources[length] = newMain;

                    if (hasNormal) {
                        fs.defines.push('HAS_NORMAL');
                    }
                    else if (hasVNormal) {
                        fs.defines.push('HAS_V_NORMAL');
                    }

                    fs = new ShaderSource({
                        sources: newSources,
                        defines: fs.defines,
                    });
                }

                //
                if (vertexShader || fragmentShader) {

                    sources = vs.sources;
                    length = sources.length;

                    var hasPacking = false;
                    for (i = 0; i < length; ++i) {
                        if (/vec4\s?packDepthToRGBA\s?\(/.test(sources[i])) {
                            hasPacking = true;
                            break
                        }
                    }

                    hasSelected = hasSelected && pickIdQualifier == 'varying' && !is3dtiles;

                    if (hasNormal) {
                        vs.defines.push('HAS_NORMAL');
                    }
                    else if (hasVNormal) {
                        vs.defines.push('HAS_V_NORMAL');
                    }

                    let newMain =
                        (hasPacking ? '' : packing) +
                        (hasSelected ? czm_selectedVS : '') +
                        ShaderSource.replaceMain(vertexShader || 'void main(){}', mainName) +
                        "void main() \n" +
                        "{ \n" +
                        (shaderRedefine != 'replace' ? `    ${nonMainName}(); \n` : '') +
                        (hasSelected ? '    me_isSelected=czm_selected()?1.:0.;\n' : '') +
                        `    ${mainName}(); \n` +
                        "} \n";

                    var newSources = new Array(length + 1);
                    for (var i = 0; i < length; ++i) {
                        newSources[i] = ShaderSource.replaceMain(sources[i], nonMainName);
                    }
                    newSources[length] = newMain;

                    vs = new ShaderSource({
                        sources: newSources,
                        defines: vs.defines,
                    });
                }

                shader = context.shaderCache.createDerivedShaderProgram(
                    shaderProgram,
                    passName,
                    {
                        vertexShaderSource: vs,
                        fragmentShaderSource: fs,
                        attributeLocations: attributeLocations,
                    }
                );
            }

            return shader;
        }
        function getRenderState(scene, renderState) {

            scene._renderPassCache = scene._renderPassCache || {};
            scene._renderPassCache[rsCacheName] = scene._renderPassCache[rsCacheName] || {};

            var cache = scene._renderPassCache[rsCacheName];
            var cacheRenderState = cache[renderState.id];
            if (!defined(cacheRenderState)) {
                var rs = RenderState.getState(renderState);
                if (typeof renderStateProcess == 'function') {
                    renderStateProcess.call(scope, rs);
                }
                cacheRenderState = RenderState.fromCache(rs);
                cache[renderState.id] = cacheRenderState;
            }

            return cacheRenderState;
        }
        function createDerivedCommand(command, scene, context) {

            let originalCommand = command;
            var frameState = scene._frameState;
            var derivedCommands = command.derivedCommands;
            if (!defined(derivedCommands)) {
                return;
            }

            if (frameState.useLogDepth && defined(derivedCommands.logDepth)) {
                command = derivedCommands.logDepth.command;
            }

            derivedCommands = command.derivedCommands;
            let result = derivedCommands.renderPass;
            if (!defined(derivedCommands.renderPass)) {
                result = derivedCommands.renderPass = {};
            }

            var shader;
            var renderState;
            if (defined(result[commandName])) {
                shader = result[commandName].shaderProgram;
                renderState = result[commandName].renderState;
            }

            result[commandName] = DrawCommand.shallowClone(command, result[commandName]);

            if (!defined(shader) || result.shaderProgramId !== command.shaderProgram.id) {
                let originalSp = command.shaderProgram;
                let pickIdQualifier = originalCommand._pickIdQualifier = new RegExp(`uniform\\s?vec4\\s?${command.pickId}`, 'g').test(originalSp._fragmentShaderText) ? 'uniform' : 'varying';

                result[commandName].shaderProgram = getShaderProgram(
                    context,
                    originalSp,
                    command.pickId,
                    pickIdQualifier
                );
                result[commandName].renderState = getRenderState(
                    scene,
                    command.renderState
                );
                result.shaderProgramId = command.shaderProgram.id;

            } else {
                result[commandName].shaderProgram = shader;
                result[commandName].renderState = renderState;
            }

            //uniformMap 
            var uniformMap = result[commandName].uniformMap;
            updateUniformMap(uniformMap);

        }
        function getUniformMapFunction(name) {
            return function () {
                var value = uniforms[name];
                if (typeof value === "function") {
                    return value();
                }
                return value;
            };
        }
        function getUniformMapDimensionsFunction(uniformMap, name) {
            return function () {
                var texture = uniformMap[name]();
                if (defined(texture)) {
                    return texture.dimensions;
                }
                return undefined;
            };
        }

        function updateUniformMap(uniformMap) {

            if (uniformMap.__created) {
                return;
            }

            uniformMap.czm_selectedIdTexture = function () {
                return stage._selectedIdTexture;
            };

            uniformMap.czm_selectedIdTextureWidth = function () {
                return stage._selectedIdTexture ? stage._selectedIdTexture.width : 0
            };

            uniformMap.czm_selectedIdTextureStep = function () {
                return stage._selectedIdTexture ? 1.0 / stage._selectedIdTexture.width : -1;
            };

            if (!uniforms) {
                return;
            }
            uniformMap.__created = true;

            for (var name in uniforms) {
                if (uniforms.hasOwnProperty(name)) {
                    if (typeof uniforms[name] !== "function") {
                        uniformMap[name] = getUniformMapFunction(name);

                    } else {
                        uniformMap[name] = uniforms[name];
                    }

                    var value = uniformMap[name]();
                    if (
                        typeof value === "string" ||
                        value instanceof Texture ||
                        value instanceof HTMLImageElement ||
                        value instanceof HTMLCanvasElement ||
                        value instanceof HTMLVideoElement
                    ) {
                        uniformMap[name + "Dimensions"] = getUniformMapDimensionsFunction(
                            uniformMap,
                            name
                        );
                    }
                }
            }

        }

        function udpateDerivedCommands(scene) {
            let view = scene._view,
                frustumCommandsList = view.frustumCommandsList,
                numFrustums = frustumCommandsList.length;

            var j, pass, length;
            for (var i = 0; i < numFrustums; ++i) {
                var index = numFrustums - i - 1;
                var frustumCommands = frustumCommandsList[index];

                for (pass = 0; pass < frustumCommands.commands.length; pass++) {
                    var commands = frustumCommands.commands[pass];
                    length = frustumCommands.indices[pass];
                    if (stage && pass == Pass.GLOBE) continue

                    for (j = 0; j < length; ++j) {
                        /**
                         * @type {Cesium.DrawCommand}
                         */
                        var command = commands[j];
                        createDerivedCommand(command, scene, scene._context);
                    }
                }
            }

        }
        function releaseResources() {
            if (colorTexture) {
                colorTexture.destroy();
                framebuffer.destroy();
                framebuffer = undefined;
                colorTexture = undefined;
            }
            if (depthTexture) {
                depthTexture.destroy();
                depthTexture = undefined;
            }
        }
        function updateFramebuffer(context, viewport, hdr, sceneFramebuffer) {
            var width = viewport.width;
            var height = viewport.height;

            if (
                colorTexture &&
                colorTexture.width === width &&
                colorTexture.height === height &&
                hdr === useHdr
            ) {
                return;
            }
            useHdr = hdr;

            releaseResources();

            colorTexture = new Texture({
                context: context,
                width: width,
                height: height,
                pixelFormat: defaultValue(pixelFormat, PixelFormat.RGBA),
                pixelDatatype: defaultValue(pixelDatatype, PixelDatatype.FLOAT),
                sampler: defaultValue(sampler, Sampler.NEAREST),
            });
            depthTexture = new Texture({
                context: context,
                width: width,
                height: height,
                pixelFormat: PixelFormat.DEPTH_COMPONENT,
                pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
                sampler: Sampler.NEAREST,
            });

            framebuffer = new Framebuffer({
                colorTextures: [colorTexture],
                context: context,
                destroyAttachments: false
                , depthTexture: depthTexture
                // , depthStencilTexture: sceneFramebuffer._depthStencilTexture,
                // depthStencilRenderbuffer: sceneFramebuffer._depthStencilRenderbuffer
            });

        }

        function getPassState(view) {
            if (!overrideViewport) {
                viewport = BoundingRectangle.clone(view.viewport, viewport);
                if (viewportScale) {
                    viewport.x = viewport.width * viewportScale.x;
                    viewport.y = viewport.height * viewportScale.y;
                    viewport.width *= viewportScale.width;
                    viewport.height *= viewportScale.height;
                } else {
                    viewport.width *= textureScale;
                    viewport.height *= textureScale;
                }
            }

            let passState = Object.assign({}, view.passState);
            passState.viewport = viewport;
            return passState
        }

        function update(context, useLogDepth) {
            const frameState = context._us._frameState,
                camera = frameState.camera,
                scene = camera._scene,
                view = scene._view;

            try {

                if (!vertexShader && !fragmentShader) {
                    let passState = getPassState(view);
                    if (typeof beforeUpdate == 'function') {
                        beforeUpdate.call(scope, scene, useLogDepth);
                    }
                    updateFramebuffer(context, viewport, scene.hdr, view.sceneFramebuffer);
                    executeDerivedCommandList(context, framebuffer, passState);
                } else
                //   if (stage && stage._selectedIdTexture) 
                {
                    let passState = getPassState(view);
                    if (typeof beforeUpdate == 'function') {
                        beforeUpdate.call(scope, scene, useLogDepth);
                    }
                    updateFramebuffer(context, viewport, scene.hdr, view.sceneFramebuffer);
                    udpateDerivedCommands(scene);
                    executeDerivedCommandList(
                        context, framebuffer, passState,
                        'renderPass', commandName,
                        renderType == 'all' || !stage || !stage._selectedIdTexture ? null : commandFilter
                    );
                }
            } catch (err) {
                console.error(err);
            }
        }

        function getSelected() {
            if (!stage) return;
            let selectedFeatures = stage.selected || stage.parentSelected;
            if (selectedFeatures.length) {
                return selectedFeatures;
            }
        }

        /**
         * 根据stage.selected(被选中的对象)过滤绘图命令，可以减少渲染通道不必要的渲染批次
         * @param {Cesium.DrawCommand} command 
         * @param {Cesium.Scene} scene 
         * @private
         */
        function commandFilter(command, scene) {

            let selectedFeatures = stage && (stage.selected || stage.parentSelected);

            if (!stage || !selectedFeatures || !selectedFeatures.length) return false;
            if (!command.pickId || command._pickIdQualifier != 'uniform') return true;

            let show = true, owner = command.owner;

            let renderSelected = renderType == 'selected';

            if (owner && owner.isObject3D) {
                for (let i = 0; i < selectedFeatures.length; i++) {
                    const feature = selectedFeatures[i];
                    if (feature == owner) return renderSelected;
                }
                return !renderSelected;
            }

            let uniformMap = command.uniformMap;
            if (uniformMap[command.pickId]) {
                let id = uniformMap[command.pickId]();

                show = !renderSelected;
                for (let i = 0; i < selectedFeatures.length; i++) {
                    const feature = selectedFeatures[i];
                    let pickIds = feature.pickId ? [feature.pickId] : feature.pickIds || feature._pickIds;
                    for (let j = 0; j < pickIds.length; j++) {
                        const pickId = pickIds[j];
                        if (pickId.color == id || Color.equals(pickId.color, id)) {
                            return renderSelected
                        }
                    }

                }
            }

            return show;
        }

        function clear(context) {
            if (framebuffer) {
                var view = context._us._frameState.camera._scene._view;
                clearCommand.framebuffer = framebuffer;
                clearCommand.execute(context, view.passState);
                clearCommand.framebuffer = undefined;
            }
        }

        function bindStage(pStage) {
            if (stage && scope.prevStageUpdate) {
                stage.update = scope.prevStageUpdate;
                scope.prevStageUpdate = null;
                scope.prevStageExecute = null;
            }

            stage = pStage;
            if (!stage) return;

            let oldUpdate = stage.update;
            scope.prevStageUpdate = oldUpdate;

            stage.update = function (context, useLogDepth) {
                clear(context);
                oldUpdate.call(stage, context, useLogDepth);

                if (!stage.enabled) return;

                if (!vertexShader && !fragmentShader) {
                    update(context, useLogDepth);
                } else {
                    let selectedFeatures = stage.selected || stage.parentSelected;
                    if (selectedFeatures && selectedFeatures.length) {
                        update(context, useLogDepth);
                    }
                }
            };

        }

        this.update = update;
        this.clear = clear;

        Object.defineProperties(this, {
            texture: {
                get() {
                    return colorTexture;
                }
            },
            depthTexture: {
                get() {
                    return depthTexture;
                }
            },
            stage: {
                get() {
                    return stage;
                },
                set(val) {
                    if (stage != val) {
                        bindStage(val);
                    }
                }
            }
        });
    }

    const _shadersSeparableBlur = "\n\
    varying vec2 v_textureCoordinates;\n\
    uniform sampler2D colorTexture;\n\
    uniform vec2 colorTextureDimensions;\n\
    uniform vec2 direction;\n\
    uniform float kernelRadius;\n\
    \n\
    float gaussianPdf(in float x, in float sigma) {\n\
        return 0.39894 * exp( -0.5 * x * x/( sigma * sigma))/sigma;\n\
    }\n\
    void main() {\
        vec2 vUv=v_textureCoordinates;\n\
        vec2 invSize = 1.0 / colorTextureDimensions;\
        float weightSum = gaussianPdf(0.0, kernelRadius);\
        vec4 diffuseSum = texture2D( colorTexture, vUv) * weightSum;\
        vec2 delta = direction * invSize * kernelRadius/float(MAX_RADIUS);\
        vec2 uvOffset = delta;\
        for( int i = 1; i <= MAX_RADIUS; i ++ ) {\
            float w = gaussianPdf(uvOffset.x, kernelRadius);\
            vec4 sample1 = texture2D( colorTexture, vUv + uvOffset);\
            vec4 sample2 = texture2D( colorTexture, vUv - uvOffset);\
            diffuseSum += ((sample1 + sample2) * w);\
            weightSum += (2.0 * w);\
            uvOffset += delta;\
        }\
        gl_FragColor = diffuseSum/weightSum;\
    }";

    /**
     *
     * 描边特效
     *
     * @alias EdgeStage
     * @constructor
     *
     * @param {Viewer} [viewer] 地图视图
     */
    function EdgeStage(viewer) {
        this._viewer = viewer;
        this._core = new Core();
    }

    /**
     * 创建描边后处理
     * @param {Object} [option] 参数
     * @param {Number} [option.width=2] 描边宽度
     * @param {Number} [option.thresholdAngle=10] 描边阈值（法线角度大于该值才有描边）
     * @param {String} [option.visibleColor=#00a8e0] 可视颜色
     * @param {String} [option.hiddenColor=#4d4d4d] 不可视颜色
     * @param {Boolean} [option.showGlow=true] 是否发光
     * @param {Number} [option.edgeGlow=1] 发光强度
     */
    EdgeStage.prototype.createEdgeStage = function (option = {}) {
        // 清除上一个描边特效
        this.clear();

        let name = "OutlineEffect";
        const { PostProcessStage, PostProcessStageComposite, Sampler, TextureMagnificationFilter, TextureMinificationFilter } = Cesium;
        let outlineWidth = this._core.defaultValue(option.width, 2);
        let thresholdAngle = this._core.defaultValue(option.thresholdAngle, 10) * Math.PI / 180;
        let useSingleColor = false, showOutlineOnly = false;
        let visibleEdgeColor = Cesium.Color.fromCssColorString(option.visibleColor || "#00a8e0");
        let hiddenEdgeColor = Cesium.Color.fromCssColorString(option.hiddenColor || "#4d4d4d");

        let showGlow = this._core.defaultValue(option.showGlow, true);
        let edgeGlow = this._core.defaultValue(option.edgeGlow, 1);
        let edgeStrength = 3, edgeOnly = false;


        let normalDepthPass = new CesiumRenderPass({
            name: name + 'Pass',
            vertexShader: `
        varying vec3 vOutlineNormal;
        void main(){
            #ifdef HAS_NORMAL
                vOutlineNormal = normal;
            #else
                #ifdef HAS_V_NORMAL
                    vOutlineNormal = v_normal;
                #else
                    vOutlineNormal=vec3(0.);
                #endif
            #endif
        }
        `,
            fragmentShader: `
        varying vec3 vOutlineNormal;
        void main(){
        //    if(!czm_selected())discard; 
            if(length(vOutlineNormal)>0.)gl_FragColor=vec4( vOutlineNormal ,gl_FragColor.a); 
        }
        `,
            sampler: new Sampler({
                minificationFilter: TextureMinificationFilter.LINEAR,
                magnificationFilter: TextureMagnificationFilter.LINEAR
            }),
            renderType: `all`
        });

        const maskStage = new PostProcessStage({
            name: name + 'Mask',
            uniforms: {
                outlineWidth() {
                    return outlineWidth;
                },
                devicePixelRatio: devicePixelRatio,
                thresholdAngle: function () {
                    return thresholdAngle
                },
                useSingleColor: function () {
                    return useSingleColor;
                },
                showOutlineOnly: function () {
                    return showOutlineOnly
                },
                visibleEdgeColor: function () {
                    return visibleEdgeColor
                },
                hiddenEdgeColor: function () {
                    return hiddenEdgeColor
                },
                maskTexture() {
                    return normalDepthPass.texture
                },
                maskDepthTexture() {
                    return normalDepthPass.depthTexture
                }
            },
            fragmentShader: `
        uniform sampler2D colorTexture;
        uniform vec2 colorTextureDimensions;
        uniform sampler2D depthTexture;

        uniform sampler2D maskTexture;
        uniform sampler2D maskDepthTexture;
        uniform float thresholdAngle;
        uniform bool showOutlineOnly;
         
        uniform float outlineWidth;
        uniform float devicePixelRatio;
        uniform vec3 visibleEdgeColor;
        uniform vec3 hiddenEdgeColor;
        uniform bool useSingleColor;

        varying vec2 v_textureCoordinates;
  
        float lengthSq(vec3 v){
            return v.x * v.x + v.y * v.y + v.z * v.z;
        }
        float normal_angleTo(vec3 a,vec3 b){
            float denominator =  sqrt(  lengthSq(a) * lengthSq(b) );
            if ( denominator == 0. ) return czm_pi / 2.;
            float theta = dot(a, b ) / denominator;
            // clamp, to handle numerical problems
            return  acos(  clamp( theta, - 1., 1. ) );
        }

        float compareNormal(vec4 n1,vec4 n2){
              if(  abs (  normal_angleTo( n1.xyz , n2.xyz ) ) < thresholdAngle ){
                  return 0.;
              }else{
                  return 1.;
              }
        }
 
        float compareDepth(const in vec2 uv){
            float maskDepth = czm_readDepth( maskDepthTexture, uv);
            float nonDepth = czm_readDepth( depthTexture, uv);
            return maskDepth>nonDepth?1.:0.;
        }

        void main(){

            vec2 vUv=v_textureCoordinates;

            // vec4 color = texture2D( colorTexture, vUv); 
            vec4 maskColor = texture2D( maskTexture, vUv);
             
            if( maskColor.a < 0.0001){
                // gl_FragColor =color;
                discard;
                return;
            }

            vec2 invSize = outlineWidth / colorTextureDimensions;
            vec4 uvOffset = vec4(1.0, 0.0, 0.0, 1.0) * vec4(invSize, invSize);
 
            vec4 c1 = texture2D( maskTexture, vUv + uvOffset.xy);
            vec4 c2 = texture2D( maskTexture, vUv - uvOffset.xy);
            vec4 c3 = texture2D( maskTexture, vUv + uvOffset.yw);
            vec4 c4 = texture2D( maskTexture, vUv - uvOffset.yw);
            
            float d;
            if(showOutlineOnly){
                float diff1 = (c1.a - c2.a)*0.5;
                float diff2 = (c3.a - c4.a)*0.5;
                d = length( vec2(diff1, diff2) );
            }
            else{ 
                float diff1 = compareNormal(c1,c2)*0.5;
                float diff2 = compareNormal(c3,c4)*0.5;
                d = length( vec2(diff1, diff2) );
            }
                    
            if(useSingleColor==false){
                float dp1 = compareDepth( vUv + uvOffset.xy);
                float dp2 = compareDepth( vUv - uvOffset.xy);
                float dp3 = compareDepth( vUv + uvOffset.yw);
                float dp4 = compareDepth( vUv - uvOffset.yw);
            
                float a1 = min(dp1, dp2);
                float a2 = min(dp3, dp4);
                float visibilityFactor = min(a1, a2);
                vec3 edgeColor = 1.0 - visibilityFactor > 0.001 ? visibleEdgeColor : hiddenEdgeColor;
            
                // gl_FragColor =color+ vec4( edgeColor , 1. ) * vec4(d);
                 gl_FragColor = vec4( edgeColor , 1. ) * vec4(d);
                 //gl_FragColor = vec4( 0.06, 0.9, 1.0 , 1. ) * vec4(d);
            }else{
                // gl_FragColor =color+ vec4( visibleEdgeColor , 1. ) * vec4(d);
                 gl_FragColor =  vec4( visibleEdgeColor , 1. ) * vec4(d);
                 //gl_FragColor =  vec4(  0.06, 0.9, 1.0 , 1. ) * vec4(d);
            }
        }
        `
        });
        normalDepthPass.stage = maskStage;

        const blurStage1 = this.createBlurStage(name + 'Blur1', 4, 1, 0.75);
        const blurStage2 = this.createBlurStage(name + 'Blur2', 4, 4, 0.5);

        const blurCompositeStage = new PostProcessStageComposite({
            name: name + "BlurComposite",
            stages: [maskStage, blurStage1, blurStage2],
            inputPreviousStageTexture: true
        });

        const addStage = new PostProcessStage({
            name: name + "Additive",
            uniforms: {
                showGlow: function () {
                    return showGlow
                },
                edgeGlow: function () {
                    return edgeGlow
                },
                edgeStrength: function () {
                    return edgeStrength
                },
                edgeOnly() {
                    return edgeOnly;
                },
                maskTexture() {
                    return normalDepthPass.texture
                },
                lineTexture: maskStage.name,
                edgeTexture1: blurStage1.name,
                edgeTexture2: blurCompositeStage.name
            },
            fragmentShader: `
        uniform sampler2D colorTexture;
        uniform sampler2D edgeTexture1;
        uniform sampler2D edgeTexture2;
        uniform sampler2D lineTexture;
        uniform sampler2D maskTexture;
        uniform bool showGlow;
        uniform float edgeGlow;
        uniform bool edgeOnly;
        uniform float edgeStrength;

        varying vec2 v_textureCoordinates;
        void main(){
            
            vec2 vUv =v_textureCoordinates;
            vec4 edgeColor=texture2D( lineTexture, vUv);
            vec4 color=texture2D( colorTexture, vUv);
            float opacity=1.;
            if(edgeOnly){
                vec4 maskColor=texture2D( maskTexture, vUv);
                opacity=1.-maskColor.a;
                gl_FragColor = maskColor;
                return;
            }
  
            if(showGlow){
                float visFactor= 1.;//czm_selected()?1.:0.;
                vec4 edgeValue1 = texture2D(edgeTexture1, vUv);
                vec4 edgeValue2 = texture2D(edgeTexture2, vUv);
                vec4 glowColor = edgeValue1 + edgeValue2 * edgeGlow;
                gl_FragColor = opacity * color + edgeColor + edgeStrength * (1. - edgeColor.r) * glowColor;
            }
            else{
                gl_FragColor = opacity * color + edgeColor;
            }
        }
        `
        });

        const compositeStage = new PostProcessStageComposite({
            name: name + "Composite",
            stages: [blurCompositeStage, addStage],
            inputPreviousStageTexture: false
        });

        function defUniforms(obj) {
            Object.defineProperties(obj, {
                showGlow: {
                    get() {
                        return showGlow;
                    },
                    set(val) {
                        showGlow = val;
                    }
                },
                edgeGlow: {
                    get() {
                        return edgeGlow;
                    },
                    set(val) {
                        edgeGlow = val;
                    }
                },
                edgeStrength: {
                    get() {
                        return edgeStrength;
                    },
                    set(val) {
                        edgeStrength = val;
                    }
                },
                thresholdAngle: {
                    get() {
                        return thresholdAngle
                    },
                    set(val) {
                        thresholdAngle = val;
                    }
                },
                showOutlineOnly: {
                    get() {
                        return showOutlineOnly
                    },
                    set(val) {
                        showOutlineOnly = val;
                    }
                },
                edgeOnly: {
                    get() {
                        return edgeOnly
                    },
                    set(val) {
                        edgeOnly = val;
                    }
                },
                useSingleColor: {
                    get() {
                        return useSingleColor;
                    },
                    set(val) {
                        useSingleColor = val;
                    }
                },
                outlineWidth: {
                    get() {
                        return outlineWidth
                    },
                    set(val) {
                        outlineWidth = val;
                    }
                },
                visibleEdgeColor: {
                    get() {
                        return visibleEdgeColor;
                    },
                    set(val) {
                        visibleEdgeColor = val;
                    }
                },
                hiddenEdgeColor: {
                    get() {
                        return hiddenEdgeColor
                    },
                    set(val) {
                        hiddenEdgeColor = val;
                    }
                }
            });
        }

        defUniforms(compositeStage);
        compositeStage._uniforms = compositeStage._uniforms || {};
        defUniforms(compositeStage._uniforms);

        compositeStage.selected = [1];
        compositeStage.enabled = true;
        this._viewer.postProcessStages.add(compositeStage);

        this.postProccessStage = compositeStage;

        return this;
    };

    /**
     * 创建模糊特效
     * @param {string} name
     * @param {number} maxRadius 
     * @param {number} kernelRadius 
     * @param {number} textureScale 
     * @returns {Cesium.PostProcessStageComposite}
     */
    EdgeStage.prototype.createBlurStage = function (name, maxRadius, kernelRadius, textureScale) {

        const { Cartesian2, PostProcessStage, PostProcessStageComposite, PostProcessStageSampleMode } = Cesium;

        let blurDirectionX = new Cartesian2(1.0, 0.0);
        let blurDirectionY = new Cartesian2(0.0, 1.0);

        let separableBlurShader = {
            defines: {
                "MAX_RADIUS": maxRadius
            },
            fragmentShader: _shadersSeparableBlur
        };
        this.parseDefines(separableBlurShader);

        let blurX = new PostProcessStage({
            name: name + "_x_direction",
            fragmentShader: separableBlurShader.fragmentShader,
            textureScale: textureScale,
            forcePowerOfTwo: true,
            uniforms: {
                kernelRadius: kernelRadius,
                direction: blurDirectionX
            },
            sampleMode: PostProcessStageSampleMode.LINEAR
        });

        let blurY = new PostProcessStage({
            name: name + "_y_direction",
            fragmentShader: separableBlurShader.fragmentShader,
            textureScale: textureScale,
            forcePowerOfTwo: true,
            uniforms: {
                kernelRadius: kernelRadius,
                direction: blurDirectionY
            },
            sampleMode: PostProcessStageSampleMode.LINEAR
        });

        let separableBlur = new PostProcessStageComposite({
            name: name,
            stages: [blurX, blurY],
            inputPreviousStageTexture: true
        });
        return separableBlur;
    };

    // 解析shader定义
    EdgeStage.prototype.parseDefines = function (shader) {
        let defines = [];
        for (const key in shader.defines) {
            if (shader.defines.hasOwnProperty(key)) {
                const val = shader.defines[key];
                defines.push('#define ' + key + ' ' + val);
            }
        }
        defines = defines.join('\n') + "\n";
        if (shader.fragmentShader) {
            shader.fragmentShader = defines + shader.fragmentShader;
        }
        if (shader.vertexShader) {
            shader.vertexShader = defines + shader.vertexShader;
        }
        return shader;
    };

    /**
     * 清除
     */
    EdgeStage.prototype.clear = function () {
        if (this.postProccessStage) {
            this._viewer.scene.postProcessStages.remove(this.postProccessStage);
        }
        this.postProccessStage = undefined;
    };

    /**
     *
     * 缓冲区分析。
     *
     * @alias BufferAnalysis
     * @constructor
     *
     */
    function BufferAnalysis(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._scene = viewer.scene;
        this._core = new Core();
        this._getPosition = new getPosition(viewer, cesium);

        this.num = 100;
        this.buffs = [];
        this.tooltip = this._core.CreateTooltip();
    }

    /**
     * 设置缓冲区大小
     * @param {Number} [value] 半径，米
     *
     */
    BufferAnalysis.prototype.changeBurr = function (value) {
        this.num = value;
        if (this.this_buff) {
            switch (this.type) {
                case 'point':
                    this.setPointBuff(this.num);
                    break;
                case 'polyline':
                    this.setPolylineBuff(this.num);
                    break;
                case 'polygon':
                    this.setPolygonBuff(this.num);
                    break;
            }
        }
    };

    /**
     * 画点
     * 
     * @param {Number|Object} radiusOrOption 半径或参数
     * @param {Function} [callback] 回调函数
     */
    BufferAnalysis.prototype.DrawPoint = function (radiusOrOption, callback) {
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = null;
        }
        this.this_buff && this.this_buff.entity && this._viewer.entities.remove(this.this_buff.entity);
        var Viewer = this._viewer;
        var Cesium = this._cesium;
        let num, option;
        if (typeof radiusOrOption === "number") {
            num = radiusOrOption;
            option = {};
        } else if (typeof radiusOrOption === "object") {
            option = radiusOrOption;
            num = option.radius;
        }
        this.num = num || this.num;
        this.drawHandler = new Cesium.ScreenSpaceEventHandler(Viewer.scene.canvas);
        this.this_buff = {
            entity: null,
            buff: null
        };
        this.type = 'point';
        this.positions = [];
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        //鼠标左键单击
        this.drawHandler.setInputAction(function (movement) {
            var Degrees = this._getPosition.getMouseDegrees(movement);
            if (!Degrees) return;
            var longitude = Degrees.lon;
            var latitude = Degrees.lat;

            this.positions.push(longitude, latitude);
            this.this_buff.entity = Viewer.entities.add({
                name: "新建缓冲点",
                position: Cesium.Cartesian3.fromDegrees(longitude, latitude),
                point: {
                    pixelSize: 10,
                    color: Cesium.Color.YELLOW,
                    outlineWidth: 3,
                    outlineColor: Cesium.Color.YELLOW.withAlpha(0.4),
                    heightReference: 1
                }
            });
            this.buffs.push(this.this_buff.entity);
            this.this_buff.entity = undefined;
            this.setPointBuff(this.num, option);
            callback && typeof callback === 'function' && callback(Degrees);
            this.end && this.end();
        }.bind(this), Cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.end = () => {
            this.tooltip.show(false);
            this.drawHandler.destroy();
            //设置鼠标样式
            this._core.mouse(this._viewer.container, 0);
            this.drawHandler = null;
            this.end = undefined;
        };

        //鼠标移动
        this.drawHandler.setInputAction(function (movement) {
            this.tooltip.showAt(movement.endPosition, "点击绘制点");
        }.bind(this), Cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return this;
    };

    /**
     * 设置点缓冲区大小
     * @param {Number} [radius] 半径，米
     *
     */
    BufferAnalysis.prototype.setPointBuff = function (radius, option) {
        let pointF = Cesium.turf.point(this.positions);
        let positions = this.getBuff(pointF, radius);
        if (!this.this_buff.buff) {
            this.this_buff.buff = this.addBufferPolyogn(positions, option);
            this.buffs.push(this.this_buff.buff);
        }
    };

    /**
     * 画线
     * @param {Number|Object} radiusOrOption 半径或参数
     * @param {Function} [callback] 回调函数
     */
    BufferAnalysis.prototype.DrawPolyline = function (radiusOrOption, callback) {
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = null;
        }
        this.this_buff && this.this_buff.entity && this._viewer.entities.remove(this.this_buff.entity);
        var Viewer = this._viewer;
        var Cesium = this._cesium;

        let num, option;
        if (typeof radiusOrOption === "number") {
            num = radiusOrOption;
            option = {};
        } else if (typeof radiusOrOption === "object") {
            option = radiusOrOption;
            num = option.radius;
        }
        this.num = num || this.num;
        var clickNum = 0;
        this.drawHandler = new Cesium.ScreenSpaceEventHandler(Viewer.scene.canvas);
        this.this_buff = {
            entity: null,
            buff: null
        };
        this.type = 'polyline';
        this.positions = [];
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        //鼠标左键单击
        this.drawHandler.setInputAction(function (movement) {
            var Degrees = this._getPosition.getMouseDegrees(movement);
            if (!Degrees) return;
            var longitude = Degrees.lon;
            var latitude = Degrees.lat;

            this.positions.push(longitude, latitude);
            if (clickNum === 0) {
                this.positions.push(longitude, latitude);
                this.this_buff.entity = Viewer.entities.add({
                    name: "新建缓冲线",
                    polyline: {
                        positions: Cesium.Cartesian3.fromDegreesArray(this.positions),
                        width: 2,
                        material: new Cesium.ColorMaterialProperty(Cesium.Color.YELLOW),
                        //material: Cesium.Color.YELLOW,
                        clampToGround: true,
                        zIndex: 1
                    }
                });
                this.this_buff.entity.polyline.positions = new Cesium.CallbackProperty(function () {
                    return Cesium.Cartesian3.fromDegreesArray(this.positions);
                }.bind(this), false);
            }
            clickNum++;
        }.bind(this), Cesium.ScreenSpaceEventType.LEFT_CLICK);

        //鼠标右键单击
        this.drawHandler.setInputAction(function (movement) {
            this.end && this.end();
        }.bind(this), Cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            this.tooltip.show(false);
            this.drawHandler.destroy();
            //设置鼠标样式
            this._core.mouse(this._viewer.container, 0);
            this.drawHandler = null;

            this.end = undefined;
            if (type === 'cancel') {
                Viewer.entities.remove(this.this_buff.entity);
                this.this_buff = undefined;
                return;
            }
            var that = this;
            if (this.positions.length <= 4) {
                window.layuiLayer && window.layuiLayer.msg("当前点数小于两点，请重新绘制");
                Viewer.entities.remove(this.this_buff.entity);
                this.this_buff = undefined;
                callback && typeof callback === 'function' && callback(that);
                return;
            }
            this.positions.pop();
            this.positions.pop();

            this.this_buff.entity.polyline.positions = Cesium.Cartesian3.fromDegreesArray(this.positions);

            this.buffs.push(this.this_buff.entity);
            this.this_buff.entity = undefined;
            this.positions = this.degreesArrayToPoints(this.positions);
            this.setPolylineBuff(this.num, option);
            callback && typeof callback === 'function' && callback(that);
        };

        //鼠标移动
        this.drawHandler.setInputAction(function (movement) {
            if (clickNum === 0) {
                this.tooltip.showAt(movement.endPosition, "点击开始绘制折线");
                return;
            } else if (clickNum === 1) {
                this.tooltip.showAt(movement.endPosition, "点击绘制折线");
            } else {
                this.tooltip.showAt(movement.endPosition, "右击结束绘制");
            }
            var Degrees = this._getPosition.getMouseDegrees(movement);
            if (!Degrees) return;
            var longitude = Degrees.lon;
            var latitude = Degrees.lat;
            this.positions.splice(this.positions.length - 2, 2);
            this.positions.push(longitude, latitude);
        }.bind(this), Cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return this;
    };

    /**
     * 设置线缓冲区大小
     * @param {Number} [radius] 半径，米
     *
     */
    BufferAnalysis.prototype.setPolylineBuff = function (radius, option) {
        let polylineF = Cesium.turf.lineString(this.positions);
        let positions = this.getBuff(polylineF, radius);
        if (!this.this_buff.buff) {
            this.this_buff.buff = this.addBufferPolyogn(positions, option);
            this.buffs.push(this.this_buff.buff);
        }
    };

    /**
     * 画面
     * @param {Number|Object} radiusOrOption 半径或参数
     * @param {Function} [callback] 回调函数
     */
    BufferAnalysis.prototype.DrawPolygon = function (radiusOrOption, callback) {
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = null;
        }
        this.this_buff && this.this_buff.entity && this._viewer.entities.remove(this.this_buff.entity);
        var Viewer = this._viewer;
        var Cesium = this._cesium;

        let num, option;
        if (typeof radiusOrOption === "number") {
            num = radiusOrOption;
            option = {};
        } else if (typeof radiusOrOption === "object") {
            option = radiusOrOption;
            num = option.radius;
        }

        this.num = num || this.num;
        var clickNum = 0;
        this.drawHandler = new Cesium.ScreenSpaceEventHandler(Viewer.scene.canvas);
        this.this_buff = {
            entity: null,
            buff: null
        };
        this.type = 'polygon';
        this.positions = [];
        let that = this;
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        //鼠标左键单击
        this.drawHandler.setInputAction(function (movement) {
            var Degrees = this._getPosition.getMouseDegrees(movement);
            if (!Degrees) return;
            var longitude = Degrees.lon;
            var latitude = Degrees.lat;
            this.positions.push(longitude, latitude);
            if (clickNum === 0) {
                this.positions.push(longitude, latitude);
                this.this_buff.entity = Viewer.entities.add({
                    name: '临时线',
                    polyline: {
                        positions: new Cesium.CallbackProperty(function () {
                            return Cesium.Cartesian3.fromDegreesArray(that.positions);
                        }, false),
                        clampToGround: true,
                        material: new Cesium.ColorMaterialProperty(Cesium.Color.YELLOW.withAlpha(0.5)),
                        width: 3,
                    }
                });
            } else if (clickNum === 1) {
                this.this_buff.entity && Viewer.entities.remove(this.this_buff.entity);
                this.this_buff.entity = Viewer.entities.add({
                    name: "新建缓冲面",
                    polygon: {
                        hierarchy: new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromDegreesArray(this.positions)),
                        material: new Cesium.ColorMaterialProperty(Cesium.Color.YELLOW.withAlpha(0.5)),
                        zIndex: 1
                    }
                });
                this.this_buff.entity.polygon.hierarchy = new Cesium.CallbackProperty(function () {
                    return new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromDegreesArray(this.positions));
                }.bind(this), false);
            }
            clickNum++;
        }.bind(this), Cesium.ScreenSpaceEventType.LEFT_CLICK);

        //鼠标右键单击
        this.drawHandler.setInputAction(function (movement) {
            this.end && this.end();
        }.bind(this), Cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            this.tooltip.show(false);
            this.drawHandler.destroy();
            //设置鼠标样式
            this._core.mouse(this._viewer.container, 0);
            this.drawHandler = null;

            this.end = undefined;


            if (type === 'cancel') {
                Viewer.entities.remove(this.this_buff.entity);
                this.this_buff = undefined;
                return;
            }

            if (this.positions.length <= 6) {
                window.layuiLayer && window.layuiLayer.msg("当前点数小于三点，请重新绘制");
                Viewer.entities.remove(this.this_buff.entity);
                this.this_buff = undefined;
                callback && typeof callback === 'function' && callback(this);
                return;
            }
            this.positions.pop();
            this.positions.pop();

            this.this_buff.entity.polygon.hierarchy = Cesium.Cartesian3.fromDegreesArray(this.positions);

            this.buffs.push(this.this_buff.entity);
            this.this_buff.entity = undefined;
            this.positions = this.degreesArrayToPoints(this.positions);
            this.positions.push(this.positions[0]);//面闭合
            this.setPolygonBuff(this.num, option);
            callback && typeof callback === 'function' && callback(this);
        };

        //鼠标移动
        this.drawHandler.setInputAction(function (movement) {
            if (clickNum === 0) {
                this.tooltip.showAt(movement.endPosition, "点击开始绘制多边形");
                return;
            } else if (clickNum < 3) {
                this.tooltip.showAt(movement.endPosition, "点击绘制多边形");
            } else {
                this.tooltip.showAt(movement.endPosition, "右击结束绘制");
            }
            var Degrees = this._getPosition.getMouseDegrees(movement);
            if (!Degrees) return;
            var longitude = Degrees.lon;
            var latitude = Degrees.lat;
            this.positions.splice(this.positions.length - 2, 2);
            this.positions.push(longitude, latitude);
        }.bind(this), Cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return this;
    };

    /**
     * 设置面缓冲区
     * @param {Number} [radius] 半径，米
     *
     */
    BufferAnalysis.prototype.setPolygonBuff = function (radius, option) {
        let polygonF = Cesium.turf.polygon([this.positions]);
        let positions = this.getBuff(polygonF, radius);
        if (!this.this_buff.buff) {
            this.this_buff.buff = this.addBufferPolyogn(positions, option);
            this.buffs.push(this.this_buff.buff);
        }
    };

    //获取缓冲区
    BufferAnalysis.prototype.getBuff = function (geometry, radius, option = {}) {
        let buffered = Cesium.turf.buffer(geometry, radius, { units: 'meters', ...option });
        let coordinates = buffered.geometry.coordinates;

        let degreesArray = this.pointsToDegreesArray(coordinates[0]);
        let data = {
            positions: Cesium.Cartesian3.fromDegreesArray(degreesArray)
        };
        if (coordinates.length > 1) {
            data.holes = [];
            for (let i = 1, positions; i < coordinates.length; i++) {
                degreesArray = this.pointsToDegreesArray(coordinates[i]);
                positions = Cesium.Cartesian3.fromDegreesArray(degreesArray);
                data.holes.push(positions);
            }
        }
        return data;
    };

    //数组格式转换
    BufferAnalysis.prototype.pointsToDegreesArray = function (points) {
        let degreesArray = [];
        points.map(item => {
            degreesArray.push(item[0]);
            degreesArray.push(item[1]);
        });
        return degreesArray;
    };

    //数组格式转换
    BufferAnalysis.prototype.degreesArrayToPoints = function (degreesArray) {
        let points = [];
        for (let i = 0; i < degreesArray.length - 1; i += 2) {
            points.push([degreesArray[i], degreesArray[i + 1]]);
        }
        return points;
    };

    //添加缓冲面
    BufferAnalysis.prototype.addBufferPolyogn = function (data, option = {}) {
        let positions, holes;
        positions = data.positions;
        if (data.holes) {
            holes = [];
            data.holes.forEach(item => {
                holes.push(new Cesium.PolygonHierarchy(item));
            });
        }
        return this._viewer.entities.add({
            polygon: {
                hierarchy: new Cesium.CallbackProperty(function () {
                    return new Cesium.PolygonHierarchy(positions, holes);
                }, false),
                material: Cesium.Color.RED.withAlpha(0.6),
                outline: true,
                outlineColor: Cesium.Color.YELLOW,
                outlineWidth: 10,
                zIndex: 0,
                ...option
            },
        });
    };

    //清除
    BufferAnalysis.prototype.clearBuff = function () {
        var Viewer = this._viewer;
        if (this.buffs.length > 0) {
            this.buffs.forEach(function (buff) {
                Viewer.entities.remove(buff);
            });
            this.buffs.length = 0;
        }
    };

    /**
     *
     * 地形开挖。
     *
     * @alias TerrainExcavation
     * @constructor
     *
     */
    function TerrainExcavation(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._scene = viewer.scene;
        this._core = new Core();

        this.tooltip = this._core.CreateTooltip();
        this.FlattenIsDraw = false;
        this.wallArr = [];
        this.heightsort = [];
        this.FlattenPolygon = [];
        this.deepth = 100;
    }

    /**
     * 画面
     *
     */
    TerrainExcavation.prototype.CreatePolygon = function (height, option, callback) {
        if (this.FlattenIsDraw) return;
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = null;
        }
        this.FlattenIsDraw = true;
        var Viewer = this._viewer;
        var Cesium = this._cesium;

        this.deepth = height || this.deepth;
        this.clear();

        !option && (option = {});

        var positions = [];
        var hierarchy = [];
        var polygon;
        var tempPosition;
        var bottomH = null;
        var clickNum = 0;
        var heightsort = this.heightsort;
        var deepth = this.deepth;
        var wallArr = this.wallArr;
        var _this = this;

        this.drawHandler = new Cesium.ScreenSpaceEventHandler(Viewer.scene.canvas);
        this._core.setDepthTest('open', Viewer);
        var tooltip = this.tooltip;
        let polyline;
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        //鼠标左键单击
        this.drawHandler.setInputAction(function (movement) {
            tempPosition = getPointFromWindowPoint(movement.position);
            var cartographic = Cesium.Cartographic.fromCartesian(tempPosition);
            var lng = Cesium.Math.toDegrees(cartographic.longitude);//经度值
            var lat = Cesium.Math.toDegrees(cartographic.latitude);//纬度值
            positions.push(tempPosition);
            hierarchy.push(lng, lat, cartographic.height);
            //修改
            //hierarchy = new Cesium.PolygonHierarchy(positions);
            if (clickNum === 0) {
                positions.push(tempPosition);
                hierarchy.push(lng, lat, cartographic.height);
                polyline = Viewer.entities.add({
                    name: '临时线',
                    polyline: {
                        positions: new Cesium.CallbackProperty(() => {
                            return positions;
                        }, false),
                        clampToGround: true,
                        material: new Cesium.ColorMaterialProperty(Cesium.Color.YELLOW.withAlpha(0.3)),
                        width: 3,
                    }
                });
            } else if (clickNum === 1) {
                polyline && Viewer.entities.remove(polyline);

                polygon = Viewer.entities.add({
                    name: null,
                    polygon: {
                        //hierarchy: Cesium.Cartesian3.fromDegreesArrayHeights(hierarchy),
                        hierarchy: new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromDegreesArrayHeights(hierarchy)),
                        material: Cesium.Color.YELLOW.withAlpha(0.3)
                    }
                });
                polygon.polygon.hierarchy = new Cesium.CallbackProperty(getHierarchy, false);
            }
            clickNum++;
        }, Cesium.ScreenSpaceEventType.LEFT_CLICK);

        //鼠标移动
        this.drawHandler.setInputAction(function (movement) {
            if (clickNum === 0) {
                tooltip.showAt(movement.endPosition, "左键点击开始绘制点");
                return;
            } else if (clickNum === 1) {
                tooltip.showAt(movement.endPosition, "点击添加第二个点");
            } else {
                tooltip.showAt(movement.endPosition, "右键结束绘制");
            }
            tempPosition = getPointFromWindowPoint(movement.endPosition);
            var cartographic = Cesium.Cartographic.fromCartesian(tempPosition);
            var lng = Cesium.Math.toDegrees(cartographic.longitude);//经度值
            var lat = Cesium.Math.toDegrees(cartographic.latitude);//纬度值
            hierarchy.splice(hierarchy.length - 3, 3);
            positions.splice(positions.length - 1, 1);
            positions.push(tempPosition);
            hierarchy.push(lng, lat, cartographic.height);
        }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);

        //鼠标右键单击结束绘制
        this.drawHandler.setInputAction(function (movement) {
            this.end && this.end();
        }.bind(this), Cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            tooltip.show(false);
            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0);
            _this.drawHandler.destroy();

            polyline && Viewer.entities.remove(polyline);
            polygon && Viewer.entities.remove(polygon);
            this.FlattenIsDraw = false;
            this.end = undefined;

            if (type === 'cancel' || positions.length < 3) {
                return;
            }
            if (clickNum < 2) {
                clickNum = 0;
                return;
            }
            clickNum = 0;
            for (var i = 2; i < hierarchy.length; i = i + 3) {
                heightsort.push(hierarchy[i]);
            }
            heightsort.sort(function (a, b) {
                return a - b;
            });
            polygon = Viewer.entities.add({
                name: null,
                polygon: {
                    hierarchy:
                        new Cesium.CallbackProperty(function () {
                            return new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromDegreesArrayHeights(hierarchy));
                        }, false),
                    material: new Cesium.ImageMaterialProperty({
                        image: _this._core.defaultValue(option.url, window.SmartEarthRootUrl + configData$1.bottomplane),
                        repeat: new Cesium.Cartesian2(1, 1)
                    })
                }
            });

            // var parentId = sgworld.ProjectTree.findItem("绘制对象");
            // if (parentId == "") {
            //     parentId = sgworld.ProjectTree.createGroup("绘制对象", true, 0);
            // }
            // var pId = sgworld.ProjectTree.createGroup("地形开挖", true, parentId);
            // sgworld.ProjectTree.insertProjectTree(pId, "坑底", "坑底", sgworld.ProjectTree.exitsObjectType.polygon, polygon, true);

            positions.push(positions[0]);
            var cartographic1, cartographic2, lng1, lng2, lat1, lat2;
            for (var i = 0; i < positions.length - 1; i++) {
                cartographic1 = Cesium.Cartographic.fromCartesian(positions[i]);
                cartographic2 = Cesium.Cartographic.fromCartesian(positions[i + 1]);
                lng1 = Cesium.Math.toDegrees(cartographic1.longitude);//经度值
                lat1 = Cesium.Math.toDegrees(cartographic1.latitude);//纬度值

                lng2 = Cesium.Math.toDegrees(cartographic2.longitude);//经度值
                lat2 = Cesium.Math.toDegrees(cartographic2.latitude);//纬度值
                if (bottomH) {
                    bottomH = bottomH > cartographic2.height ? cartographic2.height : bottomH;
                } else {
                    bottomH = cartographic1.height > cartographic2.height ? cartographic2.height : cartographic1.height;
                }
                getPoint(lng1, lat1, lng2, lat2, cartographic1.height, cartographic2.height);
            }
            polygon.polygon.height = heightsort[0] - deepth;
            this.FlattenPolygon.push(polygon);
            this.originHeight = heightsort[0];
            groundClipping(positions);

            typeof callback === 'function' && callback();
        };

        //动态绘制多边形
        function getHierarchy() {
            return new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromDegreesArrayHeights(hierarchy));
        }

        function getPointFromWindowPoint(point) {
            var position;
            if (Viewer.scene.terrainProvider.constructor.name === "EllipsoidTerrainProvider") {
                position = Viewer.camera.pickEllipsoid(point, Viewer.scene.globe.ellipsoid);
            } else {
                var ray = Viewer.scene.camera.getPickRay(point);
                position = Viewer.scene.globe.pick(ray, Viewer.scene);
            }
            var feature = Viewer.scene.pick(point);
            if (feature) {
                var _cartesian = Viewer.scene.pickPosition(point);
                if (_cartesian) {
                    position = _cartesian;
                    var cartographic = Cesium.Cartographic.fromCartesian(position);
                    var height = Viewer.scene.globe.getHeight(cartographic);
                    cartographic.height = height;
                    position = Cesium.Cartographic.toCartesian(cartographic);
                }
            }

            return position;
        }

        function groundClipping(positions) {
            // Create clipping planes for polygon around area to be clipped.
            var globe = Viewer.scene.globe;
            var points = positions.concat();
            points.splice(points.length - 1, 1);
            //去除相同点
            for (var i = 0; i < points.length - 1; i++) {
                if (points[i].x === points[i + 1].x && points[i].y === points[i + 1].y) {
                    points.splice(i, 1);
                    i--;
                }
            }
            var pointsLength = points.length;
            //判断是否为顺时针
            if (PolygonIsClockwise(points)) {
                points.reverse();
            }
            // Create center points for each clipping plane
            var clippingPlanes = [];
            for (var i = 0; i < pointsLength; ++i) {
                var nextIndex = (i + 1) % pointsLength;
                var midpoint = Cesium.Cartesian3.add(points[i], points[nextIndex], new Cesium.Cartesian3());
                midpoint = Cesium.Cartesian3.multiplyByScalar(midpoint, 0.5, midpoint);

                var up = Cesium.Cartesian3.normalize(midpoint, new Cesium.Cartesian3());
                var right = Cesium.Cartesian3.subtract(points[nextIndex], midpoint, new Cesium.Cartesian3());
                right = Cesium.Cartesian3.normalize(right, right);

                var normal = Cesium.Cartesian3.cross(right, up, new Cesium.Cartesian3());
                normal = Cesium.Cartesian3.normalize(normal, normal);

                // 起始点为坐标原点
                var originCenteredPlane = new Cesium.Plane(normal, 0.0);
                var distance = Cesium.Plane.getPointDistance(originCenteredPlane, midpoint);
                clippingPlanes.push(new Cesium.ClippingPlane(normal, distance));
            }
            globe.clippingPlanes = new Cesium.ClippingPlaneCollection({
                planes: clippingPlanes
            });
        }

        function getPoint(lng1, lat1, lng2, lat2, height1, height2) {
            // //获取面上的高程和经纬度

            var pointSum = 160;  //取样点个数
            var addXTT = Cesium.Math.lerp(lng1, lng2, 1.0 / pointSum) - lng1;
            var addYTT = Cesium.Math.lerp(lat1, lat2, 1.0 / pointSum) - lat1;
            var wallJwd = [];
            var positions = [];
            var heightA = [];
            var Cartesian;
            wallJwd.push(lng1, lat1);
            Cartesian = Cesium.Cartesian3.fromDegrees(lng1, lat1);
            positions.push(Cesium.Cartographic.fromCartesian(Cartesian));
            for (var i = 0; i < pointSum; i++) {
                var longitude = lng1 + (i + 1) * addXTT;
                var latitude = lat1 + (i + 1) * addYTT;
                wallJwd.push(longitude, latitude);
                Cartesian = Cesium.Cartesian3.fromDegrees(longitude, latitude);
                positions.push(Cesium.Cartographic.fromCartesian(Cartesian));
            }
            wallJwd.push(lng2, lat2);
            Cartesian = Cesium.Cartesian3.fromDegrees(lng2, lat2);
            positions.push(Cesium.Cartographic.fromCartesian(Cartesian));
            var heightB = [];
            //获取高度
            getHeightsFromLonLat(positions, function (data) {
                if (data) {
                    heightA = data;
                    for (i = 0; i < heightA.length; i++) {
                        heightB.push(heightsort[0] - deepth);

                    }
                    drawwall(wallJwd, heightA, heightB);
                }
            });
        }

        //根据经纬度获取高度
        function getHeightsFromLonLat(positions, callback) {
            var camera = Viewer.camera;
            var heights = [];
            if (isHaveTerrain()) {
                //根据经纬度计算出地形高度。
                var promise = Cesium.sampleTerrainMostDetailed(Viewer.terrainProvider, positions);
                camera.positionCartographic.height;
                Cesium.when(promise, function (updatedPositions) {
                    updatedPositions.forEach(function (item) {
                        heights.push(item.height);
                    });
                    if (typeof callback === "function") {
                        callback(heights);
                    }
                });
            } else {
                positions.forEach(function (p) {
                    heights.push(Viewer.scene.globe.getHeight(p));
                });
                if (typeof callback === "function") {
                    callback(heights);
                }
            }
        }

        //是否有地形
        function isHaveTerrain() {
            if (Viewer.scene && Viewer.scene.terrainProvider && Viewer.scene.terrainProvider._layers) {
                return true;
            }
            return false;
        }

        //判断多边形是否为顺时针绘制
        function PolygonIsClockwise(points) {
            if (points.length >= 3) {
                //求向量积
                var type = (points[1].x - points[0].x) * (points[2].y - points[1].y) - (points[1].y - points[0].y) * (points[2].x - points[1].x);
                if (type > 0) {
                    return false;
                }
                return true;
            }
        }

        //绘制墙
        function drawwall(wallJwd, heightA, heightB) {
            var blueWall = Viewer.entities.add({

                wall: {
                    //坐标点，不指定高度
                    positions:
                        new Cesium.CallbackProperty(function () {
                            return Cesium.Cartesian3.fromDegreesArray(wallJwd);
                        }, false),
                    // material : Cesium.Color.BLUE,
                    maximumHeights: heightA,
                    minimumHeights: heightB,
                }

            });
            var ellipse = blueWall.wall;
            ellipse.material = new Cesium.ImageMaterialProperty({
                image: window.SmartEarthRootUrl + configData$1.wall,
                repeat: new Cesium.Cartesian2(1, 1)
            });
            wallArr.push(blueWall);
        }

        return this;
    };

    TerrainExcavation.prototype.setDeepth = function (deepth) {
        this.FlattenPolygon[0] && this.FlattenPolygon[0].polygon.height.setValue(this.originHeight - deepth);
        this.wallArr.forEach(item => {
            let minimumHeights = item.wall.minimumHeights.getValue();
            minimumHeights = Array(minimumHeights.length);
            minimumHeights.fill(this.originHeight - deepth);
            item.wall.minimumHeights.setValue(minimumHeights);
        });
    };

    //清除
    TerrainExcavation.prototype.clear = function () {
        var Viewer = this._viewer;
        if (this.wallArr.length > 0) {
            for (var i = 0; i < this.wallArr.length; i++) {
                Viewer.entities.remove(this.wallArr[i]);
            }
            this.wallArr = [];
        }
        if (Viewer.scene.globe.clippingPlanes) {
            Viewer.scene.globe.clippingPlanes.removeAll();
        }
        if (this.FlattenPolygon && this.FlattenPolygon.length > 0) {
            this.FlattenPolygon.forEach(function (entity) {
                Viewer.entities.remove(entity);
            });
            this.FlattenPolygon = [];
        }
        this.FlattenIsDraw = false;
    };

    /**
     *
     * 阴影分析。
     *
     * @alias ShadowsAnalysis
     * @constructor
     *
     */
    function ShadowsAnalysis(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._scene = viewer.scene;
        this._core = new Core();

        this.currentSpeed = '1x';
        this.currentTime = null;
        this.currentPlayMode = '1';  //0暂停，1前，2后
        this.timer = null;
    }

    /**
     * 创建阴影分析
     * @param {Number} [value] 半径，米
     *
     */
    ShadowsAnalysis.prototype.createAnalysis = function () {
        this.shadows = true;
        this.currentSpeed = 1;
        this.currentPlayMode = '1';
        this.Forword();

        return this;
    };

    /**
     * 时间设置
     * @param {String} [time] 回调
     *
     */
    ShadowsAnalysis.prototype.setCurrentTime = function (time) {
        var date1 = new Date(time);
        var julian_time = this._cesium.JulianDate.fromDate(date1);
        this._viewer.clock.currentTime = julian_time.clone();
    };

    /**
     * 时间获取
     * @param {Function} [callback] 回调
     *
     */
    ShadowsAnalysis.prototype.getCurrentTime = function (callback) {
        this.currentSpeed = $(this._viewer.container).find('.cesium-viewer-animationContainer .cesium-animation-svgText tspan').eq(2).html();
        clearInterval(this.timer);
        timer = null;
        timer = setInterval(function () {
            this.currentTime = utcToBeijing(this._viewer.animation.viewModel.dateLabel, this._viewer.animation.viewModel.timeLabel);
            (callback && typeof callback === 'function') && callback(this.currentTime);
        }, 1000);
    };

    /**
     * 加速
     * @param {Function} [callback] 回调
     *
     */
    ShadowsAnalysis.prototype.SpeedIncress = function (callback) {
        //倍率加
        this._viewer.animation.viewModel.faster();
        this.currentSpeed = $(this._viewer.container).find('.cesium-viewer-animationContainer .cesium-animation-svgText tspan').eq(2).html();
        (callback && typeof callback === 'function') && callback(this.currentSpeed);
    };

    /**
     * 减速
     * @param {Function} [callback] 回调
     *
     */
    ShadowsAnalysis.prototype.SpeedDecress = function (callback) {
        // 倍率减
        this._viewer.animation.viewModel.slower();
        this.currentSpeed = $(this._viewer.container).find('.cesium-viewer-animationContainer .cesium-animation-svgText tspan').eq(2).html();
        (callback && typeof callback === 'function') && callback(this.currentSpeed);
    };

    /**
     * 往前播放
     * @param {Function} [callback] 回调
     *
     */
    ShadowsAnalysis.prototype.Forword = function (callback) {
        this._viewer.animation.viewModel.playForwardViewModel.command();
        this.currentPlayMode = '1';
        if (this.currentSpeed[0] == '-') {
            this.currentSpeed = this.currentSpeed.slice(1);
        }
        (callback && typeof callback === 'function') && callback(this.currentSpeed);
    };

    /**
     * 往后播放
     * @param {Function} [callback] 回调
     *
     */
    ShadowsAnalysis.prototype.Bacword = function (callback) {
        this._viewer.animation.viewModel.playReverseViewModel.command();
        this.currentPlayMode = '2';
        if (this.currentSpeed[0] !== '-') {
            this.currentSpeed = '-' + this.currentSpeed;
        }
        (callback && typeof callback === 'function') && callback(this.currentSpeed);
    };

    /**
     * 暂停/继续
     *
     */
    ShadowsAnalysis.prototype.Pause = function () {
        this._viewer.animation.viewModel.pauseViewModel.command();
    };

    // utc时间转为北京时间
    function utcToBeijing(date, time) {
        // 转为正常的时间格式 年-月-日 时:分:秒
        date = date.replace(/January|Jan/, '01').replace(/February|Feb/, '02')
            .replace(/March|Mar/, '03').replace(/April|Apr/, '04')
            .replace(/May/, '05').replace(/June|Jun/, '06')
            .replace(/July|Jul/, '07').replace(/August|Aug/, '08')
            .replace(/September|Sept/, '09').replace(/October|Oct/, '10')
            .replace(/November|Nov/, '11').replace(/December|Dec/, '12');

        var dateArr = date.split(' ');
        date = dateArr[2] + '-' + dateArr[0] + '-' + dateArr[1];

        var timeArr = time.split(' ');
        time = timeArr[0];
        var timestamp = new Date(Date.parse(date + ' ' + time));
        timestamp = timestamp.getTime();
        timestamp = timestamp / 1000;

        // 增加8个小时，北京时间比utc时间多八个时区
        timestamp = timestamp + 8 * 60 * 60;

        // 时间戳转为时间
        var beijing_datetime = new Date(parseInt(timestamp) * 1000).toLocaleString('chinese', { hour12: false }).replace(/年|月|\//g, "-").replace(/日/g, " ");
        return beijing_datetime; // 2017-03-31 16:02:06
    }

    Object.defineProperties(ShadowsAnalysis.prototype, {
        shadows: {
            get: function () {
                return this._viewer.shadows;
            },
            set: function (value) {
                this._viewer.shadows = value;
            }
        },
        currentSpeed: {
            get: function () {
                return $(this._viewer.container).find('.cesium-viewer-animationContainer .cesium-animation-svgText tspan').eq(2).html();
            },
            set: function (value) {
                value = value.toString().replace('x', '');
                this._viewer.clock.multiplier = parseFloat(value);
            }
        }
    });

    /**
     *
     * 截图
     *
     * @alias Screenshot 
     * @constructor
     * 
     * @param {Viewer} viewer 地图视图
     * @param {Cesium} cesium Cesium对象
     * 
     */
    function Screenshot(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }
    /**
     * 截图
     * 
     * @param {String} [type='png'] 图片类型
     */
    Screenshot.prototype.createScreenshot = function (type = 'png') {
        var canvas = this._viewer.scene.canvas;
        var base64url = canvas.toDataURL('image/' + type);

        var triggerDownload = document.createElement('a');
        triggerDownload.download = '截图.' + type;
        triggerDownload.href = base64url;
        triggerDownload.click();
    };

    /**
     * 创建截图对比
     * 
     * @param {String} [title='截图对比'] 弹窗标题
     * @param {layuiLayer} layer layuiLayer对象，可选
     */
    Screenshot.prototype.createScreenshotCompared = function (title, layer) {
        var canvas = this._viewer.scene.canvas;
        var base64url = canvas.toDataURL('image/png');

        (layer || layuiLayer).open({
            title: title || '截图对比',
            type: 1, //0（信息框，默认）1（页面层）2（iframe层）3（加载层）4（tips层）
            skin: 'other-class',
            shade: 0,
            shadeClose: true,
            resize: false,
            moveOut: true,
            area: [canvas.width * 0.7 + 'px', canvas.height * 0.7 + 42 + 'px'],
            content: '<img src="' + base64url + '" style="height:100%;width:100%;">'
        });
    };

    /**
    *
    * 定点绕飞
    *
    * @alias PointFly
    * @constructor
    *
    */
    function PointFly(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._getPosition = new getPosition(viewer, cesium);
    }
    /**
    * 双击定点绕飞
    */
    PointFly.prototype.setPointFly = function (option) {
        !option && (option = {});
        let tooltip = this._core.CreateTooltip();
        let viewer = this._viewer;
        let that = this;
        let isFly = false;

        let Billboard;
        let pickHandler;

        option.pitch && (option.pitch = Cesium.Math.toRadians(option.pitch));
        // 相机的当前heading
        let initialHeading, position;
        // 给定飞行一周所需时间，比如10s, 那么每秒转动度数
        let angle = 360 / (option.time || 30);
        let Exection = function TimeExecution() {
            // 当前已经过去的时间，单位s
            let delTime = Cesium.JulianDate.secondsDifference(viewer.clock.currentTime, viewer.clock.startTime);
            let heading = Cesium.Math.toRadians(delTime * angle) + initialHeading;
            viewer.scene.camera.setView({
                destination: position, // 点的坐标
                orientation: {
                    heading: heading,
                    pitch: that.pitch,

                }
            });
            viewer.scene.camera.moveBackward(that.distance);

            if (Cesium.JulianDate.compare(viewer.clock.currentTime, viewer.clock.stopTime) >= 0) {
                viewer.clock.onTick.removeEventListener(Exection);
            }
        };
        let fly = (_position) => {
            position = _position;
            that.pitch = option.pitch || viewer.camera.pitch;
            // 给定相机距离点多少距离飞行，这里取值为5000m
            that.distance = option.distance;
            if (!that.distance) {
                that.distance = Cesium.Cartesian3.distance(viewer.camera.position, _position);
            }
            initialHeading = viewer.camera.heading;
            let startTime = Cesium.JulianDate.fromDate(new Date());
            viewer.clock.startTime = startTime.clone();  // 开始时间
            viewer.clock.currentTime = startTime.clone(); // 当前时间
            viewer.clock.clockRange = Cesium.ClockRange.CLAMPED; // 行为方式
            viewer.clock.clockStep = Cesium.ClockStep.SYSTEM_CLOCK; // 时钟设置为当前系统时间; 忽略所有其他设置。

            viewer.clock.onTick.addEventListener(Exection);

            !option.hideImage && (Billboard = that._viewer.entities.add({
                id: that._core.getuid(),
                name: '定点',
                position: position,
                billboard: {
                    horizontalOrigin: that._cesium.HorizontalOrigin.CENTER,
                    verticalOrigin: that._cesium.VerticalOrigin.BOTTOM,
                    scale: that._core.defaultValue(option.scale, 1),
                    image: that._core.defaultValue(option.image, window.SmartEarthRootUrl + configData$1.mark),
                    disableDepthTestDistance: Number.POSITIVE_INFINITY
                }
            }));
        };
        if (option.position) {
            fly(option.position);
        } else {
            this.drawHandler && this.drawHandler.destroy();
            //设置鼠标样式
            this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

            pickHandler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
            //高亮显示代码
            pickHandler.setInputAction(function (movement) {
                if (!isFly) {
                    tooltip.showAt(movement.position, '点击结束绕飞');
                    isFly = true;
                    let degree = that._getPosition.getMouseDegrees(movement);
                    let position = Cesium.Cartesian3.fromDegrees(degree.lon, degree.lat, degree.height);
                    fly(position);
                } else {
                    that.end && that.end();
                }
            }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
            pickHandler.setInputAction(function (movement) {
                !isFly && tooltip.showAt(movement.endPosition, '点击选择定位点');
                isFly && tooltip.showAt(movement.endPosition, '点击结束绕飞');
            }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
            pickHandler.setInputAction(function (movement) {
                that.distance -= movement * that.distance / 2000;
                that.distance < 1 && (that.distance = 1);
            }, Cesium.ScreenSpaceEventType.WHEEL);
            this.drawHandler = pickHandler;
        }

        this.end = (type) => {
            this.end = undefined;
            tooltip.show(false);
            pickHandler && pickHandler.destroy();
            that._viewer.entities.remove(Billboard);
            Billboard = undefined;
            //设置鼠标样式
            that._core.mouse(that._viewer.container, 0);

            viewer.clock.onTick.removeEventListener(Exection);
            option.end && option.end();
        };
        return this;
    };

    /**
     * 日照阴影分析
     * @alias SunshineAnalysis
     * @constructor
     *
     */
    function SunshineAnalysis(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
        this._getPosition = new getPosition(this._viewer, this._cesium);
        this.tooltip = this._core.CreateTooltip();
        this.sunshineOption = {};
        this.loadingImg = window.SmartEarthRootUrl + configData$1.loading;
    }
    //第一个是要分析的点的位置（是世界坐标）
    //date（日期），经纬度，startTime是开始时间，endTime是结束时间，这里经纬度不传值的话默认是前面的要日照分析的点。,date,startTime,endTime
    SunshineAnalysis.prototype.PointSunshineAnalysis = function (postion, wuti) {
        this._viewer.entities.remove(this._viewer.entities.getById("1"));
        this._viewer.entities.remove(this._viewer.entities.getById("point"));
        //第一步，获取要分析的点位置
        if (postion != null) {
            if (postion.constructor.name != "Cartesian3") {
                throw "传入参数必须是三维坐标";
            }
        } else {
            throw "无效参数";
        }
        //第二步，获取太阳的世界坐标,这里获取太阳的坐标的做法是很傻的，现在做一个函数，根据日期，时间，来推算出太阳高度角和太阳俯视角
        // console.log(postion.x + "  " + postion.y);
        if (!this._viewer.scene.sun.show) {
            this._viewer.scene.sun.show = true;
        }
        //1、获取太阳位置的方法
        //var sunPostion = Cesium.Simon1994PlanetaryPositions.computeSunPositionInEarthInertialFrame(date);地球为中心的坐标系下的太阳位置

        var sunposition2 = this._viewer.scene.context.uniformState.sunPositionWC;//这个应该是贴图的位置，
        // console.log(sunposition2.x + "  " + sunposition2.y);
        var fx = new Cesium.Cartesian3(sunposition2.x - postion.x, sunposition2.y - postion.y, sunposition2.z - postion.z);
        var dec = Math.sqrt(fx.x * fx.x + fx.y * fx.y + fx.z * fx.z);
        var fxxl = new Cesium.Cartesian3(fx.x / dec, fx.y / dec, fx.z / dec);//方向向量
        var changdu = 200;
        var zd = new Cesium.Cartesian3(postion.x + changdu * fxxl.x, postion.y + changdu * fxxl.y, postion.z + changdu * fxxl.z);
        //第三步，做射线，
        // var arrowPositions = [
        //     postion,
        //     zd
        // ];
        // var arrow = this._viewer.entities.add({
        //     id: "1",
        //     polyline: {
        //         positions: arrowPositions,
        //         width: 10,
        //         followSurface: false,
        //         material: new Cesium.PolylineArrowMaterialProperty(Cesium.Color.WHITE)
        //     }
        // });
        //第四步，一天进行日照分析，如果线之间被隔断，就认为该点被阻挡了
        //console.log(wuti.id);
        // this.jiance(postion, zd, wuti);
        this.pickFromRay(postion, zd, wuti);
    };
    /**
     * 日照分析(点)
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    SunshineAnalysis.prototype.sunshineAnalysisPoint = function (option, callBack) {
        !option && (option = {});
        this.sunshineOption = option;

        var that = this;
        var viewer = this._viewer;
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        this.drawHandler.setInputAction(function (event) {
            var position = that._getPosition.getMousePosition(event);
            that.PointSunshineAnalysis(position);
            if (position) {
                var point = viewer.entities.add({
                    id: that._core.getuid(),
                    name: 'Point',
                    position: position,
                    point: {
                        pixelSize: 16,
                        color: that._cesium.Color.BLUE,
                        outlineWidth: that._core.defaultValue(option.outlineWidth, 2),
                        outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                        heightReference: that._cesium.HeightReference.CLAMP_TO_GROUND,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000)
                    }
                });

                that.drawHandler.destroy();
                that.drawHandler = undefined;
                that.tooltip.show(false);
                setTimeout(function () {
                    tree.states = 0;
                }, 100);
                //恢复鼠标样式
                that._core.mouse(that._viewer.container, 0, "0");
                //回调
                callBack && typeof callBack === 'function' && callBack(point);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        this.drawHandler.setInputAction(function (event) {
            that.tooltip.showAt(event.endPosition, "点击绘制点");
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return this;
    };
    /**
    * 日照分析(面)
    * 
    * @param {Object} [option] 参数{
    *   start: '2019-09-17 13:00',   //开始时间
    *   end: '2019-09-17 15:00',   //结束时间
    *   interval: 60,   //时间间隔(分钟)
    *   spacing: 10,   //空间间距(米)
    *   startHeight: 0,   //起始高度，默认第一个点的海拔(米)
    *   endHeight: 40,   //终止高度(米)
    * }
    * @param {Function} [callBack] 回调
    */
    SunshineAnalysis.prototype.sunshineAnalysisPolygon = function (option, callBack) {
        !option && (option = {});
        this.sunshineOption = option;

        var that = this;
        var viewer = this._viewer;
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        if (!this.loading) {
            this.addLoading();
        }
        this.remove();

        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;
        var positions = [];
        var polygon, polyline;
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        this.drawHandler.setInputAction(function (event) {
            var cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;
            if (!positions.length) {
                let cartographic = Cesium.Cartographic.fromCartesian(cartesian);
                that.sunshineOption.defaultHeight = cartographic.height;
                positions.push(cartesian);
            }
            positions.push(cartesian);

            if (positions.length === 2 && !polyline) {
                polyline = viewer.entities.add({
                    name: '临时线',
                    polyline: {
                        positions: new that._cesium.CallbackProperty(function () {
                            return positions
                        }, false),
                        clampToGround: true,
                        material: that._cesium.Color.LIME.withAlpha(0.6),
                        width: 3,
                    }
                });
            }

            if (positions.length === 3 && !polygon) {
                polyline && viewer.entities.remove(polyline);

                option.clampToGround = that._core.defaultValue(option.clampToGround, true);
                polygon = viewer.entities.add({
                    id: that._core.getuid(),
                    name: '新建面',
                    polygon: {
                        hierarchy: new that._cesium.CallbackProperty(function () {
                            return new that._cesium.PolygonHierarchy(positions);
                        }, false),
                        material: new that._cesium.ImageMaterialProperty({
                            image: null,
                            repeat: new that._cesium.Cartesian2(1, 1),
                            color: that._cesium.Color.LIME.withAlpha(0.6)
                        }),
                        perPositionHeight: !that._core.defaultValue(option.clampToGround, false),
                        heightReference: option.clampToGround ? 1 : 0,
                        outline: that._core.defaultValue(option.outline, false),
                        outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
                        distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000)
                    }
                });
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        this.drawHandler.setInputAction(function (event) {
            if (positions.length === 0) {
                that.tooltip.showAt(event.endPosition, "点击添加第一个点");
            } else if (positions.length === 1) {
                that.tooltip.showAt(event.endPosition, "点击添加第二个点");
            } else {
                that.tooltip.showAt(event.endPosition, "点击添加点，右键结束绘制");
                var cartesian = that._getPosition.getMousePosition(event);
                if (!cartesian) return;
                positions.pop();
                positions.push(cartesian);
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        this.end = function (type) {
            that.drawHandler.destroy();
            that.drawHandler = undefined;
            that.tooltip.show(false);
            that.end = undefined;
            setTimeout(function () {
                tree.states = 0;
            }, 100);
            //恢复鼠标样式
            that._core.mouse(that._viewer.container, 0, "0");

            polyline && viewer.entities.remove(polyline);
            polygon && viewer.entities.remove(polygon);

            if (type === 'cancel' || positions.length < 3) {
                return;
            }


            setTimeout(() => {
                that.analysis(polygon, option.start || '2019-09-17 13:00', option.end || '2019-09-17 15:00', option.interval || 60, callBack);
            }, 100);
        };
        this.drawHandler.setInputAction(function (event) {
            that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        return this;
    };
    //分析时间内数据
    SunshineAnalysis.prototype.analysis = function (entity, startTime, endTime, Seconds, callBack) {
        var beginDate = new Date(startTime);
        var endDate = new Date(endTime);
        var i = 0;
        var that = this;
        let startHeight = this.sunshineOption.startHeight || this.sunshineOption.defaultHeight;
        var pointss = that.getPoint(entity, this.sunshineOption.spacing || 10, startHeight, startHeight + that._core.defaultValue(this.sunshineOption.addHeight, 30));

        if (!this._viewer.scene.sun.show) {
            this._viewer.scene.sun.show = true;
        }

        let originalTime = this._viewer.clock.currentTime.clone();

        function analyse(sunP) {
            for (let j = 0; j < pointss.length; j++) {
                if (that.Sunshine(pointss[j], sunP)) {
                    //在阴影中
                    pointss[j].through++;
                } else {
                    //不在阴影中
                    pointss[j].out++;
                }
            }
        }

        function getSunPosition(time, callback) {
            //设置当前时间
            that.SetTimeNow(time);
            setTimeout(() => {
                let sunposition2 = that._viewer.scene.context.uniformState.sunPositionWC;//这个应该是贴图的位置，
                // console.log(sunposition2.x + "  " + sunposition2.y + "  " + sunposition2.z);
                callback(sunposition2);
            }, 100);
        }

        function start() {
            var current = beginDate.getTime() + 1000 * 60 * Seconds * i;
            var currentTime = new Date(current);
            if (currentTime > endDate) {
                that.createPoint(pointss);
                that._viewer.clock.currentTime = originalTime;
                that.isLoading(false);

                //回调
                callBack && typeof callBack === 'function' && callBack(pointss);
            } else {
                getSunPosition(currentTime, function (sunP) {
                    analyse(sunP);
                    i++;
                    start();
                });
            }
        }

        let _time = endDate - beginDate;
        let num = _time / (1000 * 60 * Seconds);
        if (num * pointss.length > 1500) {
            window.layuiLayer && window.layuiLayer.msg('当前分析时间过长，是否继续分析？', {
                time: 0,
                btn: ['继续', '取消'],
                btnAlign: 'c',
                yes: (index) => {
                    layuiLayer.close(index);
                    that.isLoading(true);
                    start();
                },
                btn2: () => {
                    //回调
                    callBack && typeof callBack === 'function' && callBack(pointss);
                }
            });
        } else {
            that.isLoading(true);
            start();
        }
    };
    //创建点
    SunshineAnalysis.prototype.createPoint = function (points) {
        var that = this;

        this.ResultPoint = that._viewer.scene.primitives.add(new that._cesium.PointPrimitiveCollection());
        for (var i = 0; i < points.length; i++) {
            var point = points[i];
            var sta = points[i].through + points[i].out;
            var bfb = points[i].out / sta;
            var color = "";
            if (bfb >= 0.7) {
                color = that._cesium.Color.BLUE;
            } else if (bfb < 0.7 && bfb >= 0.3) {
                color = that._cesium.Color.YELLOW;
            } else if (bfb < 0.3) {
                color = that._cesium.Color.RED;
            }
            var poin = {
                id: {
                    isshowderData: true,
                    data: "阴影率:" + (1 - bfb) * 100 + "%"
                },
                position: that._cesium.Cartesian3.fromDegrees(point.lon, point.lat, point.height),
                color: color
            };
            that.ResultPoint.add(poin);
        }
        this.showResultTooltip(true);
    };

    SunshineAnalysis.prototype.showResultTooltip = function (show) {
        if (this.ResultTooltipHandler) {
            this.ResultTooltipHandler.destroy();
            this.ResultTooltipHandler = undefined;
            this.tooltip.show(false);
        }

        if (show) {
            let that = this;
            this.ResultTooltipHandler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
            this.ResultTooltipHandler.setInputAction(function (event) {
                let feature = that._viewer.scene.pick(event.position);
                if (feature && feature.id && feature.id.isshowderData) {
                    that.tooltip.showAt(event.position, feature.id.data);
                } else {
                    that.tooltip.show(false);
                }
            }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
            this.ResultTooltipHandler.setInputAction(function (event) {
                that.tooltip.show(false);
            }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        }
    };
    //创建面内采样点
    SunshineAnalysis.prototype.getPoint = function (entity, spacing, startheight, endheight) {
        var that = this;
        var hierarchy = [];
        var dx = entity.polygon.hierarchy.getValue().positions;
        for (var j = 0; j < dx.length; j++) {
            var x = that._cesium.Math.toDegrees(that._cesium.Cartographic.fromCartesian(dx[j]).longitude);
            var y = that._cesium.Math.toDegrees(that._cesium.Cartographic.fromCartesian(dx[j]).latitude);
            hierarchy.push(x);
            hierarchy.push(y);
        }
        var bottomPoint = that.getTheBottomPoint(hierarchy);
        var pointsInPolygon = that.scanningPolygon(bottomPoint, spacing, spacing, hierarchy);
        var pointss = [];
        var frequency = (endheight - startheight) / spacing;
        for (var n = 0; n < frequency; n++) {
            for (var m = 0; m < pointsInPolygon.length; m++) {
                var point = pointsInPolygon[m];
                var point1 = {
                    lon: point.lon,
                    lat: point.lat,
                    height: startheight + spacing * n,
                    through: 0,
                    out: 0,
                    color: "",
                };
                pointss.push(point1);
            }
        }
        return pointss;
        //for (var n = 1; n < 5; n++) {
        //    for (var m = 0; m < pointsInPolygon.length; m++) {
        //        var point = pointsInPolygon[m];
        //        var points = that._viewer.entities.add({
        //            name: 'Point',
        //            position: that._cesium.Cartesian3.fromDegrees(point.lon, point.lat, 10 * n),
        //            point: {
        //                pixelSize: 10,
        //                color: that._cesium.Color.BLUE,
        //                //outlineWidth: 2,
        //                //outlineColor: that._cesium.Color.WHITE.withAlpha(0.6),
        //                //heightReference: that._cesium.HeightReference.CLAMP_TO_GROUND,
        //                //disableDepthTestDistance: Number.POSITIVE_INFINITY,
        //                distanceDisplayCondition: new that._cesium.DistanceDisplayCondition(0, 100000000)
        //            }
        //        });
        //    }
        //}
    };
    //获取纬度最低点
    SunshineAnalysis.prototype.getTheBottomPoint = function (points) {
        var minLat = 90;
        var minIndex = 0;
        for (var i = 1; i < points.length; i += 2) {
            minLat = minLat < points[i] ? minLat : (minIndex = i) && points[i];
        }
        return {
            lon: points[minIndex - 1],
            lat: points[minIndex]
        };
    };
    //扫描多边形
    SunshineAnalysis.prototype.scanningPolygon = function (bottomPoint, dx, dy, area) {
        var points = [];
        var minLon = 180, maxLon = -180, maxLat = -90;
        var d_lon, d_lat;
        var westPoint, eastPoint, centerPoint;
        for (var i = 0; i < area.length; i += 2) {
            maxLat = maxLat > area[i + 1] ? maxLat : area[i + 1];
            minLon = minLon < area[i] ? minLon : area[i];
            maxLon = maxLon > area[i] ? maxLon : area[i];
        }
        var point1 = this.GetPositionFromA_D(bottomPoint.lat, bottomPoint.lon, dy, 0);
        var point2 = this.GetPositionFromA_D(bottomPoint.lat, bottomPoint.lon, dx, 90);
        //获取经纬度差
        d_lon = point2[0] - bottomPoint.lon;
        d_lat = point1[1] - bottomPoint.lat;
        points.push({ lon: bottomPoint.lon, lat: bottomPoint.lat });
        centerPoint = { lon: bottomPoint.lon, lat: bottomPoint.lat };
        //扫描
        for (centerPoint.lat += d_lat; centerPoint.lat <= maxLat; centerPoint.lat += d_lat) {
            westPoint = { lon: centerPoint.lon - d_lon, lat: centerPoint.lat };
            eastPoint = { lon: centerPoint.lon + d_lon, lat: centerPoint.lat };
            if (this.IsInPolygon(centerPoint.lon, centerPoint.lat, area)) {
                points.push({ lon: centerPoint.lon, lat: centerPoint.lat });
            }
            for (; westPoint.lon >= minLon; westPoint.lon -= d_lon) {
                if (this.IsInPolygon(westPoint.lon, westPoint.lat, area)) {
                    points.push({ lon: westPoint.lon, lat: westPoint.lat });
                }
            }
            for (; eastPoint.lon <= maxLon; eastPoint.lon += d_lon) {
                if (this.IsInPolygon(eastPoint.lon, eastPoint.lat, area)) {
                    points.push({ lon: eastPoint.lon, lat: eastPoint.lat });
                }
            }
        }
        return points;
    };
    //通过角度和距离获取经纬度
    SunshineAnalysis.prototype.GetPositionFromA_D = function (lat, lon, distance, angle) {
        var Ea = 6378137.0;     //   赤道半径
        var Eb = 6356725.0;     //   极半径
        var dx = distance * Math.sin(angle * Math.PI / 180.0);
        var dy = distance * Math.cos(angle * Math.PI / 180.0);
        var ec = Eb + (Ea - Eb) * (90.0 - lat) / 90.0;
        var ed = ec * Math.cos(lat * Math.PI / 180);
        var newLon = (dx / ed + lon * Math.PI / 180.0) * 180.0 / Math.PI;
        var newLat = (dy / ec + lat * Math.PI / 180.0) * 180.0 / Math.PI;
        return [newLon, newLat];
    };
    //是否在多边形内
    SunshineAnalysis.prototype.IsInPolygon = function (lon, lat, area) {
        var isIn = 0;
        var dLon1, dLon2, dLat1, dLat2, dLon;
        if (area.length < 6) {
            return false;
        }
        area.push(area[0], area[1]);
        for (var i = 0; i < area.length - 2; i += 2) {
            dLon1 = area[i];
            dLat1 = area[i + 1];
            dLon2 = area[i + 2];
            dLat2 = area[i + 3];

            //判断点是否在边的两端点的水平平行线之间，在则可能有交点
            if (((lat >= dLat1) && (lat < dLat2)) || ((lat >= dLat2) && (lat < dLat1))) {
                if (Math.abs(dLat1 - dLat2) > 0) {
                    //得到点向左射线与边的交点的x坐标：
                    dLon = dLon1 - ((dLon1 - dLon2) * (dLat1 - lat)) / (dLat1 - dLat2);
                    //判断交点是否在左射线上
                    if (dLon <= lon)
                        isIn++;
                }
            }
        }
        //交点为奇数则在多边形内
        if (isIn % 2 !== 0) {
            return true;
        }
        return false;
    };
    //设置时间
    SunshineAnalysis.prototype.SetTimeNow = function (startTime) {
        var date = new this._cesium.JulianDate.fromDate(startTime);//获取当前时间
        this._viewer.clock.currentTime = date;
    };
    //分析点
    SunshineAnalysis.prototype.Sunshine = function (postion, sunP) {
        let _postion = Cesium.Cartesian3.fromDegrees(postion.lon, postion.lat, postion.height);
        return this.pickFromRay(_postion, sunP);
    };
    //判断是否通视
    SunshineAnalysis.prototype.jiance = function (start, end) {
        var num = 20;
        var isshowders = false;
        var rad1 = this._cesium.Cartographic.fromCartesian(start);
        var rad2 = this._cesium.Cartographic.fromCartesian(end);//开始节点和结束节点转换为以弧度计算的经纬度
        //这里表示插值函数，start和end是起始点，然后进行插值，检测高程，如果获取的地面点比差值点的高程高的话就代表有焦点
        //坐标转经纬度
        var startpoint = {};
        startpoint.longitude = rad1.longitude / Math.PI * 180;
        startpoint.latitude = rad1.latitude / Math.PI * 180;
        startpoint.czheight = rad1.height;//将开始节点转换为角度的点
        var endpoint = {};
        endpoint.longitude = rad2.longitude / Math.PI * 180;
        endpoint.latitude = rad2.latitude / Math.PI * 180;
        endpoint.czheight = rad2.height;//将结束节点节点转换为角度的点
        for (var i = 0; i < num; i++) {
            var point = {};
            point.longitude = this._cesium.Math.lerp(startpoint.longitude, endpoint.longitude, 0.01 * (i + 1));
            point.latitude = this._cesium.Math.lerp(startpoint.latitude, endpoint.latitude, 0.01 * (i + 1));
            point.czheight = startpoint.czheight - (startpoint.czheight - endpoint.czheight) * 0.01 * (i + 1);
            var terCartographic = new this._cesium.Cartographic(this._cesium.Math.toRadians(point.longitude), this._cesium.Math.toRadians(point.latitude), 0);//转经纬度对像
            var cartographichight = this._viewer.scene.sampleHeight(terCartographic);//坐标点获取建筑物高程
            this._cesium.Cartesian3.fromDegrees(point.longitude, point.latitude, cartographichight);//经纬度转世界坐标
            //this.viewer.entities.add({
            //    position: cartographic,
            //    point: {
            //        pixelSize: 4,
            //        color: this._cesium.Color.RED,
            //        outlineColor: this._cesium.Color.BLACK,
            //        outlineWidth: 2
            //    }
            //});
            point.zsheight = cartographichight;//真实点的高程
            if (point.zsheight > point.czheight) {
                isshowders = true;
            }
        }
        return isshowders;
        //if (isshowders) console.log("在阴影中");
        //else console.log("不在阴影中");
    };

    SunshineAnalysis.prototype.pickFromRay = function (start, end) {
        // 计算射线的方向，目标点left 视点right
        let direction = Cesium.Cartesian3.normalize(Cesium.Cartesian3.subtract(end, start, new Cesium.Cartesian3()), new Cesium.Cartesian3());
        // 建立射线
        let ray = new Cesium.Ray(start, direction);
        let result = this._viewer.scene.pickFromRay(ray, []); // 计算交互点，返回第一个
        let isshowders = false;
        if (result && result.object) {
            isshowders = true;
        }
        return isshowders;
    };

    SunshineAnalysis.prototype.remove = function () {
        this.ResultPoint && this._viewer.scene.primitives.remove(this.ResultPoint);
        this.ResultPoint = undefined;
        if (this.ResultTooltipHandler) {
            this.ResultTooltipHandler.destroy();
            this.ResultTooltipHandler = undefined;
            this.tooltip.show(false);
        }
        this.showResultTooltip(false);
    };
    SunshineAnalysis.prototype.addLoading = function () {
        var loading = document.createElement('div');
        loading.id = 'cesiumLoading';
        loading.style.cssText = 'width: 100%;height: 100%;display:none;pointer-events: none;position: absolute;top: 0;left: 0;-moz-box-sizing: border-box;box-sizing: border-box;background-color: unset;z-index: 99999;';
        var img = document.createElement('img');
        img.style.cssText = 'position: relative;width: 110px;height: 110px;margin: auto;top: 50%;left: 50%;margin-top: -55px;margin-left: -55px;';
        img.src = this.loadingImg;
        loading.appendChild(img);
        this.loading = loading;
        this._viewer.container.appendChild(loading);
    };

    SunshineAnalysis.prototype.isLoading = function (loading) {
        if (loading) {
            this.loading.style.display = 'block';
        } else {
            this.loading.style.display = 'none';
        }
    };

    SunshineAnalysis.prototype.removeLoading = function () {
        this.loading && this.loading.remove();
        this.loading = undefined;
    };

    /**
     *
     * 分析模块。
     *
     * @alias Analysis
     * @constructor
     *
     */
    function Analysis(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._measureTerrainPerimeter = new measureTerrainPerimeter(this._viewer, this._cesium);
        this._measureTerrainHeight = new measureTerrainHeight(this._viewer, this._cesium);
        this._measureTerrainArea = new measureTerrainArea(this._viewer, this._cesium);
        this._measureTerrainkPerimeter = new measureTerrainkPerimeter(this._viewer, this._cesium);
        this._elevationContour = new ElevationContour(this._viewer, this._cesium);
        this._createTerrainProfile = new createTerrainProfile(this._viewer, this._cesium);
        this._createterrainExaggeration = new terrainExaggeration(this._viewer, this._cesium);
        this._createcurtaincontrast = new curtaincontrast(this._viewer, this._cesium);
        this._createindoormode = new Indoormode(this._viewer, this._cesium);
        this._createWeather = new weather(this._viewer, this._cesium);
        this._Particle = new particle(this._viewer, this._cesium);
        this._UndergroundMode = new UndergroundMode(this._viewer, this._cesium);
        this._StreetView = new StreetView(this._viewer, this._cesium);
        this._depthTestAgainstTerrain = new depthTestAgainstTerrain(this._viewer, this._cesium);
        this._create3DViewshed = new Viewshed(this._viewer, this._cesium);
        this._skylineAnalysis = new SkylineAnalysis(this._viewer, this._cesium);
        this._EdgeStage = new EdgeStage(this._viewer, this._cesium);
        this._bufferAnalysis = new BufferAnalysis(this._viewer, this._cesium);
        this._terrainExcavation = new TerrainExcavation(this._viewer, this._cesium);
        this._shadowsAnalysis = new ShadowsAnalysis(this._viewer, this._cesium);
        this._screenshot = new Screenshot(this._viewer, this._cesium);
        this._PointFly = new PointFly(this._viewer, this._cesium);
        this._SunshineAnalysis = new SunshineAnalysis(this._viewer, this._cesium);
    }
    /**
    *
    *  测量水平距离
    * @version 3.1.0
    * 测量水平距离
    * 分析
    * param {Array} pIGeometry 经纬度数组
    * @example {Array} pIGeometry 参数说明
    *    [{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]
    * Success-Response:
    *     distance
    * {json} 异常:
    *      exception
    */
    Analysis.prototype.measureTerrainPerimeter = function (pIGeometry) {
        return this._measureTerrainPerimeter.measureTerrainPerimeter(pIGeometry);
    };

    /**
    *
    *  设置深度检测
    * @version 3.1.0
    * 设置深度检测
    * 分析
    * param {bool} obj 是否开启经纬度
    * @example {bool} obj 参数说明
    *    true|false
    * Success-Response:
    *    true|false
    * {json} 异常:
    *    exception
    */
    Analysis.prototype.depthTestAgainstTerrain = function (obj) {
        return this._depthTestAgainstTerrain.depthTestAgainstTerrain(obj);
    };
    /**
    *
    * Analysis.DrawPointBuffer(radius,callback) 绘制点缓冲区
    * @version 3.1.0
    * 绘制点缓冲区
    * 分析
    * param {double} radius 缓冲区半径
    * param {object} callback 回调函数
    * @example  参数说明
    *    radius：半径
    *    callback：function(item){}
    * Success-Response:
    *    {
    *     type:'point',
    *     positions:[],
    *     this_buff:object
    *    }
    * {json} 异常:
    *    exception
    */
    Analysis.prototype.DrawPointBuffer = function (option,radius, callback) {
        return this._bufferAnalysis.DrawPoint(option,radius, callback);
    };
    /**
    *
    * Analysis.DrawPolylineBuffer(radius,callback) 绘制线缓冲区
    * @version 3.1.0
    * 绘制线缓冲区
    * 分析
    * param {double} radius 缓冲区半径
    * param {object} callback 回调函数
    * @example  参数说明
    *    radius：半径
    *    callback：function(item){}
    * Success-Response:
    *    {
    *     type:'line',
    *     positions:[],
    *     this_buff:object
    *    }
    * {json} 异常:
    *    exception
    */
    Analysis.prototype.DrawPolylineBuffer = function (option,radius, callback) {
        return this._bufferAnalysis.DrawPolyline(option,radius, callback);
    };
    /**
    *
    * Analysis.DrawPolygonBuffer(radius,callback) 绘制面缓冲区
    * @version 3.1.0
    * 绘制面缓冲区
    * 分析
    * param {double} radius 缓冲区半径
    * param {object} callback 回调函数
    * @example  参数说明
    *    radius：半径
    *    callback：function(item){}
    * Success-Response:
    *    {
    *     type:'polygon',
    *     positions:[],
    *     this_buff:object
    *    }
    * {json} 异常:
    *    exception
    */
    Analysis.prototype.DrawPolygonBuffer = function (option,radius, callback) {
        return this._bufferAnalysis.DrawPolygon(option,radius, callback);
    };
    /**
    *
    * Analysis.TerrainExcavation(height,option,callback) 地形开挖
    * @version 3.1.0
    * 地形开挖
    * 分析
    * param {double} height 开挖高度
    * param {object} option 开挖参数
    * param {object} callback 回调函数
    * @example  参数说明
    *    height：开挖高度
    *    option:{url:'贴图地址'}
    *    callback：function(item){}
    * Success-Response:
    *    {
    *    }
    * {json} 异常:
    *    exception
    */
    Analysis.prototype.TerrainExcavation = function (height, option, callback) {
        return this._terrainExcavation.CreatePolygon(height, option, callback);
    };
    /**
    *
    * Analysis.ShadowsAnalysis() 创建阴影分析
    * @version 3.1.0
    * 创建阴影分析
    * 分析
    * {json} 异常:
    *    exception
    */
    Analysis.prototype.ShadowsAnalysis = function () {
        return this._shadowsAnalysis.createAnalysis();
    };

    /**
     * 创建天际线
     * @param {String} [color=#ff0000] 天际线颜色
     */
    Analysis.prototype.createSkylineAnalysis = function (color) {
        return this._skylineAnalysis.createSkylineAnalysis(color);
    };

    /**
     * 创建描边特效
     * @param {Object} [option] 参数
     * @param {Number} [option.width=2] 描边宽度
     * @param {Number} [option.thresholdAngle=10] 描边阈值（法线角度大于该值才有描边）
     * @param {String} [option.visibleColor=#00a8e0] 可视颜色
     * @param {String} [option.hiddenColor=#4d4d4d] 不可视颜色
     * @param {Boolean} [option.showGlow=true] 是否发光
     * @param {Number} [option.edgeGlow=1] 发光强度
     */
    Analysis.prototype.createEdgeStage = function (option) {
        return this._EdgeStage.createEdgeStage(option);
    };

    /**
    * 清除天际线分析
    */
    Analysis.prototype.clearSkylineAnalysis = function () {
        return this._skylineAnalysis.clear();
    };
    /**
     * 这个方法三维球面截图
     *
     */

    Analysis.prototype.createScreenshot = function (type) {
        return this._screenshot.createScreenshot(type);
    };
    /**
     * 这个方法创建截图对比
     *
     */
    Analysis.prototype.ScreenshotCompared = function (title) {
        return this._screenshot.createScreenshotCompared(title);
    };
    /**
     * 定点绕飞
     *
     */
    Analysis.prototype.setPointFly = function (option) {
        return this._PointFly.setPointFly(option)
    };
    /**
     * 这个方法用于添加扩散圆扫描线
     *@param {Object} [position] 扫描中心。
     * @param {Object} [maxRadius=1500] 最大半径 米。
     * @param {Object} [scanColor=#ff0000] 扫描颜色。
     * @param {Object} [duration=4000] 持续时间 毫秒。
     * @param {Boolean} [clampToGround=true] 是否贴地。
     */
    Analysis.prototype.createCircleScan = function (position, maxRadius, scanColor, duration, clampToGround) {
        var scan = new Scan(this._viewer, this._cesium);
        return scan.createCircleScan(position, maxRadius, scanColor, duration, clampToGround);
    };
    /**
     * 这个方法用于添加扩散圆扫描线（三环）
     *@param {Object} [position] 扫描中心。
     * @param {Object} [maxRadius=1500] 最大半径 米。
     * @param {Object} [scanColor=#ff0000] 扫描颜色。
     * @param {Object} [duration=4000] 持续时间 毫秒。
     * @param {Boolean} [clampToGround=true] 是否贴地。
     */
    Analysis.prototype.createMultiCircleScan = function (position, maxRadius, scanColor, duration, clampToGround) {
        var scan = new Scan(this._viewer, this._cesium);
        return scan.createMultiCircleScan(position, maxRadius, scanColor, duration, clampToGround);
    };
    /**
     * 这个方法用于添加扩散扇形扫描线（五环）
     *@param {Object} [position] 扫描中心。
     * @param {Object} [maxRadius=1500] 最大半径 米。
     * @param {Object} [scanColor=#ff0000] 扫描颜色。
     * @param {float} [angle=90] 角度。
     * @param {float} [yaw=0] 方向。
     * @param {Object} [duration=4000] 持续时间 毫秒。
     * @param {Boolean} [clampToGround=true] 是否贴地。
     */
    Analysis.prototype.createSectorScan = function (position, maxRadius, scanColor, angle, yaw, duration, clampToGround) {
        var scan = new Scan(this._viewer, this._cesium);
        return scan.createSectorScan(position, maxRadius, scanColor, angle, yaw, duration, clampToGround);
    };
    /**
     * 这个方法用于添加雷达扫描线
     * @param {Object} [position] 扫描中心。
     * @param {Object} [maxRadius=1500] 最大半径 米。
     * @param {Object} [scanColor=#ff0000] 扫描颜色。
     * @param {Object} [duration=4000] 持续时间 毫秒。
     * @param {Boolean} [clampToGround=true] 是否贴地。
     */
    Analysis.prototype.createRadarScan = function (position, maxRadius, scanColor, duration, clampToGround) {
        var scan = new Scan(this._viewer, this._cesium);
        return scan.createRadarScan(position, maxRadius, scanColor, duration, clampToGround);
    };
    /**
    *
    * Analysis.UndergroundModelOpen(option,isIndoor) 地下模式开启
    * @version 3.1.0
    * 地下模式开启
    * 分析
    * param {object} option 选项参数
    * param {bool} isIndoor 是否开启室内模式，默认否
    * @example  参数说明
    *    option：{
    *      depth:地下深度，默认300m
    *      alpha:地表透明度，默认0.5
    *      height:相机视角高度，默认-100m
    *    }
    *    isIndoor：false
    * Success-Response:
    *    {}
    * {json} 异常:
    *    exception
    */
    Analysis.prototype.UndergroundModelOpen = function (option, isIndoor) {
        return this._UndergroundMode.UndergroundModelOpen(option, isIndoor);
    };
    /**
    *
    * Analysis.UndergroundModelClose() 地下模式关闭
    * @version 3.1.0
    * 地下模式关闭
    * 分析
    * Success-Response:
    *    {}
    * {json} 异常:
    *    exception
    */
    Analysis.prototype.UndergroundModelClose = function () {
        return this._UndergroundMode.close();
    };

    /**
     * 地下模式
     * @param {Boolean} show 是否开启
     * @param {Number} [alpha=0.5] 地表透明度
     * 
     */
    Analysis.prototype.UndergroundMode = function (show, alpha) {
        //地下模式
        if (show) {
            if (!this._viewer.scene.globe.translucency.enabled) {
                this._viewer.scene.globe.translucency.enabled = true;
                this._viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
                this._viewer.scene.globe.translucency.backFaceAlpha = 0;
                this.undergroundValue("set");
            }
            if (alpha !== undefined) {
                this._viewer.scene.globe.translucency.frontFaceAlpha = alpha;
            } else {
                this._viewer.scene.globe.translucency.frontFaceAlpha = 0.5;
            }
            let viewer = this._viewer;
            return {
                get alpha() {
                    return viewer.scene.globe.translucency.frontFaceAlpha;
                },
                set alpha(e) {
                    viewer.scene.globe.translucency.frontFaceAlpha = e;
                }
            }
        } else {
            if (this._viewer.scene.globe.translucency.enabled) {
                this._viewer.scene.globe.translucency.enabled = false;
                this._viewer.scene.screenSpaceCameraController.enableCollisionDetection = true;
                this._viewer.scene.globe.translucency.backFaceAlpha = 1;
                this.undergroundValue("get");
            }
        }
    };

    Analysis.prototype.undergroundValue = function (type) {
        if (type === "set") {
            this.defaultUnderground = {
                highDynamicRange: this._viewer.scene.highDynamicRange,
                skyBox: this._viewer.scene.skyBox.show,
                fog: this._viewer.scene.fog.enabled,
                undergroundColor: this._viewer.scene.globe.undergroundColor
            };
            this._viewer.scene.highDynamicRange = false;
            this._viewer.scene.skyBox.show = false;
            this._viewer.scene.fog.enabled = false;
            this._viewer.scene.globe.undergroundColor = undefined;
        } else {
            this._viewer.scene.highDynamicRange = this.defaultUnderground.highDynamicRange;
            this._viewer.scene.skyBox.show = this.defaultUnderground.skyBox;
            this._viewer.scene.fog.enabled = this.defaultUnderground.fog;
            this._viewer.scene.globe.undergroundColor = this.defaultUnderground.undergroundColor;
        }
    };

    /**
    *
    * Analysis.StreetViewOpen(position,option,callback) 开启街景
    * @version 3.1.0
    * 开启街景
    * 分析
    * param {object} position 选项参数
    * param {object} option 街景参数
    * param {object} callback 是否开启室内模式，默认否
    * @example  参数说明
    *    position：{lon:经度，lat:纬度}
    *    option：{
        *  getInitImageByPosition: 根据经纬度获取街景信息接口
        *  getInitImageInfoById: 根据id获取街景信息接口
        *  getInitImageById: 根据id获取一级街景图接口
        *  getSecondImageById: 根据id获取二级街景图接口
        *  getThirdImageById: 根据id获取三级街景图接口
        *  getInitImageByPositionCallBack: 根据经纬度获取街景信息回调 function(StreetViewData,data){
     *      StreetViewData.getImageTileID = ImageID;
     *      StreetViewData.lon = Lon;
     *      StreetViewData.lat = Lat;
     *      StreetViewData.height = height;
     *      StreetViewData.HeadingPitchRoll = HeadingPitchRoll;
     *      StreetViewData.linkImagesData=[{ImageID: LinkImageID, NavigationAngle: LinkAngle, Position: LinkPosition}];
     * }
    *    callback：function () {}
    * Success-Response:
    *    {}
    * {json} 异常:
    *    exception
    */
    Analysis.prototype.StreetViewOpen = function (position, option, callback) {
        return this._StreetView.StreetViewOpen(position, option, callback);
    };
    /**
     * 退出街景
     */
    Analysis.prototype.ExitStreetView = function () {
        return this._StreetView.exit();
    };
    /**
     * 这个方法用于添加雨雪雾
     */
    Analysis.prototype.createWeather = function (type, isOpen, value) {
        return this._createWeather.createWeather(type, isOpen, value);
    };
    /**
     * 这个方法用于添加粒子特效
     *@param {string} [type] 类型（烟花/烟雾/喷泉/火焰）。(fireworks/smog/fountain/flame)
     *@param {Object} [PositionOrEntity] 位置或entity。
     *@param {Object} [option] 参数。
     *@param {function} [callback] 回调。
     */
    Analysis.prototype.createParticleEffect = function (type, PositionOrEntity, option, callback) {
        return this._Particle.createParticleEffect(type, PositionOrEntity, option, callback);
    };
    /**
     * 这个方法用于移除粒子特效
     *
     */
    Analysis.prototype.removeParticleEffect = function (type) {
        return this._Particle.removeParticleEffect(type);
    };
    /**
    *
    * Analysis.measureTerrainArea(pIGeometry) 测量高度
    * @version 3.1.0
    * 测量高度
    * 分析
    * param {Array} pIGeometry 经纬度数组
    * @example {Object} pIGeometry 参数说明
    *    [{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]
    * Success-Response:
    *     {
    *           item:{}
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Analysis.prototype.measureTerrainHeight = function (pIGeometry) {
        return this._measureTerrainHeight.measureTerrainHeight(pIGeometry);
    };
    /**
     * 室内模式
     * @param {number} [numb] 数字类型。
     *
     */
    Analysis.prototype.createindoormode = function () {
        return this._createindoormode.createIndoormode();
    };
    /**
     * 室内模式关闭
     * @param {number} [numb] 数字类型。
     *
     */
    Analysis.prototype.Indoormodeclose = function () {
        return this._createindoormode.Indoormodeclose();
    };
    /**
     * 地形夸张
     * @param {number} [numb] 数字类型。
     */
    Analysis.prototype.createterrainExaggeration = function (numb) {
        return this._createterrainExaggeration.createterrainExaggeration(numb);
    };
    /**
     * 卷帘对比
     * @param {number} [leftIndex] 左侧图层索引。
     * @param {number} [rightIndex] 右侧图层索引。
     *
     */
    Analysis.prototype.createCurtainContrast = function (leftIndex, rightIndex) {
        return this._createcurtaincontrast.curtainContrast(leftIndex, rightIndex);
    };
    /**
     * 关闭卷帘对比
     *
     */
    Analysis.prototype.clearCurtainContrast = function () {
        return this._createcurtaincontrast.close();
    };
    /**
    *
    * Analysis.measureTerrainArea(pIGeometry) 测量水平面积
    * @version 3.1.0
    * 测量水平面积
    * 分析
    * param {Array} pIGeometry 经纬度数组
    * @example {Object} pIGeometry 参数说明
    *    [{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]
    * Success-Response:
    *     {
    *           item:{}
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Analysis.prototype.measureTerrainArea = function (pIGeometry) {
        return this._measureTerrainArea.measureTerrainArea(pIGeometry);
    };
    /**
    *
    * Analysis.measureTerrainkPerimeter(pIGeometry) 测量空间距离
    * @version 3.1.0
    * 测量空间距离
    * 分析
    * param {Array} pIGeometry 经纬度数组
    * @example {Object} pIGeometry 参数说明
    *    [{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]
    * Success-Response:
    *     {
    *           item:{}
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Analysis.prototype.measureTerrainkPerimeter = function (pIGeometry) {
        return this._measureTerrainkPerimeter.measureTerrainkPerimeter(pIGeometry);
    };
    /**
     * 创建等高线。
     */
    Analysis.prototype.createElevationContour = function (hasContour, selectedShading, option) {
        return this._elevationContour.createElevationContour(hasContour, selectedShading, option);
    };
    /**
     * 获取高程绘制剖面分析
     * @param {Array} [pIGeometry] 一个经纬度数组例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
     * @returns {Promise.<Array>} 返回一个高程数组例如：[1,1,2,2]。
     */
    Analysis.prototype.createTerrainProfile = function (pIGeometry) {
        return this._createTerrainProfile.createTerrainProfile(pIGeometry);
    };
    /**
     * 绘制视域。
     * 
     * @param {Object} [options] 参数。
     * @param {String} [options.name] 名称。
     * @param {Number} [options.height=1.6] 视角相对高度。
     * @param {Object} [options.color] 颜色，rgb对象(0-1)，可选。
     * @param {Object} [options.color.Back={ r: 1.0, g: 0.0, b: 0.0 }] 不可见颜色。
     * @param {Object} [options.color.Fore={ r: 0.0, g: 1.0, b: 0.0 }] 可见颜色。
     * @param {Object} [options.color.default={ r: 0.0, g: 0.0, b: 0.0 }] 默认阴影颜色。
     * 
     */
    Analysis.prototype.create3DViewshed = function (options) {
        this._create3DViewshed.startDraw(options);
        return this._create3DViewshed;
    };
    Analysis.prototype.set3DViewshedOptions = function (options) {
        this._create3DViewshed.setOptions(options);
        return this._create3DViewshed;
    };
    /**
     * 添加视域。
     * 
     * @param {Object} [option] 参数。
     * @param {Number} [option.lon] 经度。
     * @param {Number} [option.lat] 纬度。
     * @param {Number} [option.height] 高度。
     * @param {Number} [option.distance=1000] 可视距离。
     * @param {Number} [option.heading=0] 水平视角。
     * @param {Number} [option.pitch=0] 垂直视角。
     * @param {Object} [option.color] 颜色，rgb对象(0-1)，可选。
     * @param {Object} [option.color.Back={ r: 1.0, g: 0.0, b: 0.0 }] 不可见颜色。
     * @param {Object} [option.color.Fore={ r: 0.0, g: 1.0, b: 0.0 }] 可见颜色。
     * @param {Object} [option.color.default={ r: 0.0, g: 0.0, b: 0.0 }] 默认阴影颜色。
     * 
     */
    Analysis.prototype.add3DViewshed = function (option) {
        this._create3DViewshed.addViewshed(option);
        return this._create3DViewshed;
    };
    /**
    *
    * Analysis.close3DViewshed() 删除视域分析
    * @version 3.1.0
    *  删除视域分析
    * 分析
    * Success-Response:
    *     {
    *           item:{}
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Analysis.prototype.close3DViewshed = function () {
        return this._create3DViewshed.close();
    };
    /**
     * 创建一个通视分析
     * @param {String} name 名称
     * @param {object} vsPositionCarto 位置
     * @param {float} FOVX FOVX
     * @param {float} FOVY FOVY
     * @param {float} hpra hpra
     * @param {object} 名称
     */
    Analysis.prototype.createlineOfSight = function (parameter, methond) {
        var _lineOfSight = new lineOfSight(this._viewer, this._cesium);
        return _lineOfSight.createlineOfSight(parameter, methond);
    };

    /**
     * 创建通视分析
     * 
     * @param {Object} option 参数
     */
    Analysis.prototype.createSightLine = function (option) {
        let _SightLine = new SightLine(this._viewer);
        return _SightLine.createSightLine(option);
    };
    /**
    * 日照分析（点分析）
    * @param {object} 名称
    */
    Analysis.prototype.SunshineAnalysisPoint = function (option, callBack) {
        return this._SunshineAnalysis.sunshineAnalysisPoint(option, callBack);
    };
    /**
    * 日照分析（面分析）
    * @param {object} 名称
    */
    Analysis.prototype.SunshineAnalysisPolygon = function (option, callBack) {
        return this._SunshineAnalysis.sunshineAnalysisPolygon(option, callBack);
    };

    /**
    *
    * 给模型批量高亮。
    *
    * @alias Highvolume 
    * @constructor
    *
    */
    function Highvolume(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    /**
    * 给模型批量高亮。
    * 
    */
    Highvolume.prototype.Highvolume = function (Array = []) {
        var _this = this;
        var silhouetteBlue = _this._cesium.PostProcessStageLibrary.createEdgeDetectionStage();
        silhouetteBlue.uniforms.color = _this._cesium.Color.BLUE;
        silhouetteBlue.uniforms.length = 0.01;
        silhouetteBlue.selected = Array;
        _this._viewer.scene.postProcessStages.add(_this._cesium.PostProcessStageLibrary.createSilhouetteStage([silhouetteBlue]));
    };

    /**
     *
     * 扫描线(PostProcessStage方式)
     *
     * @alias ScanPostProcessStage
     * @constructor
     *
     */
    function ScanPostProcessStage(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 这个方法用于添加扩散圆扫描线
     *@param {Object} [position] 扫描中心。
     * @param {Object} [maxRadius] 最大半径 米。
     * @param {Object} [scanColor] 扫描颜色。
     * @param {Object} [duration] 持续时间 毫秒。
     */
    ScanPostProcessStage.prototype.createCircleScan = function (position, maxRadius, scanColor, duration) {
        var CartographicCenter = new this._cesium.Cartographic.fromDegrees(position.lon, position.lat);
        var color;
        if (!scanColor) {
            color = new Cesium.Color(1.0, 0.0, 0.0, 1);
        } else {
            color = this._cesium.Color.fromCssColorString(scanColor);
        }
        this.item = this.AddCircleScanPostStage(CartographicCenter, this._cesium.defaultValue(maxRadius, 1500), color, this._cesium.defaultValue(duration, 4000));

        var obj = {
            id: this._core.getuid(),
            name: '新建扩散圆扫描',
            pId: 0,
            type: 'scan',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };

    /**
     * 这个方法用于添加扩散圆扫描线（三环）
     *@param {Object} [position] 扫描中心。
     * @param {Object} [maxRadius] 最大半径 米。
     * @param {Object} [scanColor] 扫描颜色。
     * @param {Object} [duration] 持续时间 毫秒。
     */
    ScanPostProcessStage.prototype.createMultiCircleScan = function (position, maxRadius, scanColor, duration) {
        var CartographicCenter = new this._cesium.Cartographic.fromDegrees(position.lon, position.lat);
        var color;
        if (!scanColor) {
            color = new Cesium.Color(1.0, 0.0, 0.0, 1);
        } else {
            color = this._cesium.Color.fromCssColorString(scanColor);
        }
        this.item = this.AddCircleScanMultiPostStage(CartographicCenter, this._cesium.defaultValue(maxRadius, 1500), color, this._cesium.defaultValue(duration, 4000));

        var obj = {
            id: this._core.getuid(),
            name: '新建扩散圆扫描',
            pId: 0,
            type: 'scan',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };

    /**
     * 这个方法用于添加雷达扫描线
     *@param {Object} [position] 扫描中心。
     * @param {Object} [maxRadius] 最大半径 米。
     * @param {Object} [scanColor] 扫描颜色。
     * @param {Object} [duration] 持续时间 毫秒。
     */
    ScanPostProcessStage.prototype.createRadarScan = function (position, maxRadius, scanColor, duration) {
        var CartographicCenter = new this._cesium.Cartographic.fromDegrees(position.lon, position.lat);
        var color;
        if (!scanColor) {
            color = new Cesium.Color(1.0, 0.0, 0.0, 1);
        } else {
            color = this._cesium.Color.fromCssColorString(scanColor);
        }
        this.item = this.AddRadarScanPostStage(CartographicCenter, this._cesium.defaultValue(maxRadius, 1500), color, this._cesium.defaultValue(duration, 4000));

        var obj = {
            id: this._core.getuid(),
            name: '新建雷达扫描',
            pId: 0,
            type: 'scan',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };
    /**
          * 这个方法用于添加扩散扇形扫描线（五环）
          *@param {Object} [position] 扫描中心。
          * @param {Object} [maxRadius] 最大半径 米。
          * @param {Object} [scanColor] 扫描颜色。
          * @param {float} [angle] 角度。
          * @param {float} [yaw] 方向。
          * @param {Object} [duration] 持续时间 毫秒。
          */
    ScanPostProcessStage.prototype.createSectorScan = function (position, maxRadius, scanColor, angle, yaw, duration) {
        this._viewer;
        var Cesium = this._cesium;
        var CartographicCenter = new Cesium.Cartographic.fromDegrees(position.lon, position.lat);
        var color;
        if (!scanColor) {
            color = new Cesium.Color(1.0, 0.0, 0.0, 1);
        } else {
            color = Cesium.Color.fromCssColorString(scanColor);
        }
        this.item = this.AddSectorScanPostStage(CartographicCenter, Cesium.defaultValue(maxRadius, 1500), color, angle, yaw, Cesium
            .defaultValue(duration, 4000));

        var obj = {
            id: this._core.getuid(),
            name: '新建扇形扩散扫描',
            pId: 0,
            type: 'scan',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };

    /**
     * 添加扩散扇形扫描线(五环)
     * @param {Object} [cartographicCenter] 扫描中心。
     * @param {Object} [maxRadius] 最大半径 米。
     * @param {Object} [scanColor] 扫描颜色。
     * @param {Object} [duration] 持续时间 毫秒。
     */
    ScanPostProcessStage.prototype.AddSectorScanPostStage = function (cartographicCenter, maxRadius, scanColor, angle, yaw, duration) {
        var viewer = this._viewer;
        var Cesium = this._cesium;
        var ScanSegmentShader =
            "uniform sampler2D colorTexture;\n" +
            "uniform sampler2D depthTexture;\n" +
            "varying vec2 v_textureCoordinates;\n" +
            "uniform vec4 u_scanCenterEC;\n" +
            "uniform vec3 u_scanPlaneNormalEC;\n" +
            "uniform float u_radius;\n" +
            "uniform float u_maxRadius;\n" +
            "uniform vec4 u_scanColor;\n" +
            "uniform float u_angle;\n" +
            "uniform float u_yaw;\n" +
            "vec4 toEye(in vec2 uv, in float depth)\n" +
            " {\n" +
            " vec2 xy = vec2((uv.x * 2.0 - 1.0),(uv.y * 2.0 - 1.0));\n" +
            " vec4 posInCamera =czm_inverseProjection * vec4(xy, depth, 1.0);\n" +
            " posInCamera =posInCamera / posInCamera.w;\n" +
            " return posInCamera;\n" +
            " }\n" +

            "vec3 pointProjectOnPlane(in vec3 planeNormal, in vec3 planeOrigin, in vec3 point)\n" +
            "{\n" +
            "vec3 v01 = point -planeOrigin;\n" +
            "float d = dot(planeNormal, v01) ;\n" +
            "return (point - planeNormal * d);\n" +
            "}\n" +

            "float getDepth(in vec4 depth)\n" +
            "{\n" +
            "float z_window = czm_unpackDepth(depth);\n" +
            "z_window = czm_reverseLogDepth(z_window);\n" +
            "float n_range = czm_depthRange.near;\n" +
            "float f_range = czm_depthRange.far;\n" +
            "return (2.0 * z_window - n_range - f_range) / (f_range - n_range);\n" +
            "}\n" +
            "float getAngle(in vec3 dv)\n" +
            "{\n" +
            "    if(dv.y == 0.0 && dv.x > 0.0)\n" +
            "    {\n" +
            "        return 90.0;\n" +
            "    }\n" +
            "    if(dv.y == 0.0 && dv.x < 0.0)\n" +
            "    {\n" +
            "        return 270.0;\n" +
            "    }\n" +
            "    float angle = atan(dv.x/dv.y) * 180.0 / 3.1415926;\n" +
            "    if(dv.x > 0.0)\n" +
            "    {\n" +
            "        if(dv.y < 0.0)\n" +
            "        {\n" +
            "            angle = 180.0 + angle;\n" +
            "        }\n" +
            "    }\n" +
            "    if(dv.x <= 0.0)\n" +
            "    {\n" +
            "        if(dv.y < 0.0)\n" +
            "        {\n" +
            "            angle = 180.0 + angle;\n" +
            "        }\n" +
            "        if(dv.y > 0.0)\n" +
            "        {\n" +
            "            angle = 360.0 + angle;\n" +
            "        }\n" +
            "    }\n" +
            "    return angle;\n" +
            "}\n" +
            "float ripple(float dist, float rippleIntensity, float rippleScale) {\n" +
            "    return rippleScale * ((sin(dist * rippleIntensity - czm_frameNumber/10.0)-0.9) / (dist * rippleIntensity));\n" +
            "}\n" +
            "void main()\n" +
            "{\n" +
            "   gl_FragColor = texture2D(colorTexture, v_textureCoordinates);\n" +
            "   float depth = getDepth( texture2D(depthTexture, v_textureCoordinates));\n" +
            "   vec4 viewPos = toEye(v_textureCoordinates, depth);\n" +
            "   vec3 prjOnPlane = pointProjectOnPlane(u_scanPlaneNormalEC.xyz, u_scanCenterEC.xyz, viewPos.xyz);\n" +
            "   float dis = length(prjOnPlane.xyz - u_scanCenterEC.xyz);\n" +
            "   if(dis < u_radius)\n" +
            "   {\n" +
            "       vec3 worldCoordi = (czm_inverseView * vec4(prjOnPlane,1.0)).xyz - (czm_inverseView * u_scanCenterEC).xyz; \n" +

            "       float angle = getAngle(worldCoordi);\n" +
            "       float maxAngle =  fract((u_yaw + (u_angle/2.0))/360.0)*360.0;\n" +
            "       float minAngle = fract((u_yaw - (u_angle/2.0) + 360.0)/360.0)*360.0;\n" +
            "       bool showPixel = false;   \n" +

            "       if(minAngle < maxAngle)\n" +
            "       {\n" +
            "           showPixel = angle > minAngle && angle < maxAngle;\n" +
            "       }\n" +
            "       else\n" +
            "       {\n" +
            "           showPixel = angle > minAngle || angle < maxAngle;\n" +
            "       }\n" +

            "       if(showPixel)\n" +
            "       {\n" +
            "           float f = dis / u_radius;\n" +
            "           f = 1.0 - f;\n" +
            "           gl_FragColor = mix(gl_FragColor, u_scanColor, f);\n" +

            "           float intensity =step(0.001,ripple(dis + 0.1, 0.1, 15.0));\n" +
            "           gl_FragColor.rgb += gl_FragColor.rgb * intensity;\n" +

            "       }\n" +
            "   }\n" +
            "}\n";
        var _Cartesian3Center = Cesium.Cartographic.toCartesian(cartographicCenter);
        var _Cartesian4Center = new Cesium.Cartesian4(_Cartesian3Center.x, _Cartesian3Center.y,
            _Cartesian3Center.z, 1);

        var _CartographicCenter1 = new Cesium.Cartographic(cartographicCenter.longitude, cartographicCenter
            .latitude, cartographicCenter.height + 500);
        var _Cartesian3Center1 = Cesium.Cartographic.toCartesian(_CartographicCenter1);
        var _Cartesian4Center1 = new Cesium.Cartesian4(_Cartesian3Center1.x, _Cartesian3Center1.y,
            _Cartesian3Center1.z, 1);

        (new Date()).getTime();

        var _scratchCartesian4Center = new Cesium.Cartesian4();
        var _scratchCartesian4Center1 = new Cesium.Cartesian4();
        var _scratchCartesian3Normal = new Cesium.Cartesian3();

        var ScanPostStage = new Cesium.PostProcessStage({
            fragmentShader: ScanSegmentShader,
            uniforms: {
                u_scanCenterEC: function () {
                    return Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix,
                        _Cartesian4Center, _scratchCartesian4Center);
                },
                u_scanPlaneNormalEC: function () {
                    var temp = Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix,
                        _Cartesian4Center, _scratchCartesian4Center);
                    var temp1 = Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix,
                        _Cartesian4Center1, _scratchCartesian4Center1);
                    _scratchCartesian3Normal.x = temp1.x - temp.x;
                    _scratchCartesian3Normal.y = temp1.y - temp.y;
                    _scratchCartesian3Normal.z = temp1.z - temp.z;

                    Cesium.Cartesian3.normalize(_scratchCartesian3Normal, _scratchCartesian3Normal);
                    return _scratchCartesian3Normal;
                },
                u_radius: function () {
                    return maxRadius;
                },
                u_angle: function () {
                    return angle;
                },
                u_yaw: function () {
                    return yaw + 150;
                },
                u_maxRadius: maxRadius,
                u_scanColor: scanColor
            }
        });
        return viewer.scene.postProcessStages.add(ScanPostStage);
    };
    /*
    * 添加扩散圆扫描线
    * @param {Object} [cartographicCenter] 扫描中心。
    * @param {Object} [maxRadius] 最大半径 米。
    * @param {Object} [scanColor] 扫描颜色。
    * @param {Object} [duration] 持续时间 毫秒。
    */
    ScanPostProcessStage.prototype.AddCircleScanPostStage = function (cartographicCenter, maxRadius, scanColor, duration) {
        var viewer = this._viewer;
        var Cesium = this._cesium;
        var ScanSegmentShader =
            "uniform sampler2D colorTexture;\n" +
            "uniform sampler2D depthTexture;\n" +
            "varying vec2 v_textureCoordinates;\n" +
            "uniform vec4 u_scanCenterEC;\n" +
            "uniform vec3 u_scanPlaneNormalEC;\n" +
            "uniform float u_radius;\n" +
            "uniform vec4 u_scanColor;\n" +

            "vec4 toEye(in vec2 uv, in float depth)\n" +
            " {\n" +
            " vec2 xy = vec2((uv.x * 2.0 - 1.0),(uv.y * 2.0 - 1.0));\n" +
            " vec4 posInCamera =czm_inverseProjection * vec4(xy, depth, 1.0);\n" +
            " posInCamera =posInCamera / posInCamera.w;\n" +
            " return posInCamera;\n" +
            " }\n" +

            "vec3 pointProjectOnPlane(in vec3 planeNormal, in vec3 planeOrigin, in vec3 point)\n" +
            "{\n" +
            "vec3 v01 = point -planeOrigin;\n" +
            "float d = dot(planeNormal, v01) ;\n" +
            "return (point - planeNormal * d);\n" +
            "}\n" +

            "float getDepth(in vec4 depth)\n" +
            "{\n" +
            "float z_window = czm_unpackDepth(depth);\n" +
            "z_window = czm_reverseLogDepth(z_window);\n" +
            "float n_range = czm_depthRange.near;\n" +
            "float f_range = czm_depthRange.far;\n" +
            "return (2.0 * z_window - n_range - f_range) / (f_range - n_range);\n" +
            "}\n" +

            "void main()\n" +
            "{\n" +
            "gl_FragColor = texture2D(colorTexture, v_textureCoordinates);\n" +
            "float depth = getDepth( texture2D(depthTexture, v_textureCoordinates));\n" +
            "vec4 viewPos = toEye(v_textureCoordinates, depth);\n" +
            "vec3 prjOnPlane = pointProjectOnPlane(u_scanPlaneNormalEC.xyz, u_scanCenterEC.xyz, viewPos.xyz);\n" +
            "float dis = length(prjOnPlane.xyz - u_scanCenterEC.xyz);\n" +
            "if(dis < u_radius)\n" +
            "{\n" +
            "float f = 1.0 -abs(u_radius - dis) / u_radius;\n" +
            "f = pow(f, 4.0);\n" +
            "gl_FragColor = mix(gl_FragColor, u_scanColor, f);\n" +
            "}\n" +
            "}\n";

        var _Cartesian3Center = Cesium.Cartographic.toCartesian(cartographicCenter);
        var _Cartesian4Center = new Cesium.Cartesian4(_Cartesian3Center.x, _Cartesian3Center.y, _Cartesian3Center.z, 1);

        var _CartographicCenter1 = new Cesium.Cartographic(cartographicCenter.longitude, cartographicCenter.latitude, cartographicCenter.height + 500);
        var _Cartesian3Center1 = Cesium.Cartographic.toCartesian(_CartographicCenter1);
        var _Cartesian4Center1 = new Cesium.Cartesian4(_Cartesian3Center1.x, _Cartesian3Center1.y, _Cartesian3Center1.z, 1);

        var _time = (new Date()).getTime();

        var _scratchCartesian4Center = new Cesium.Cartesian4();
        var _scratchCartesian4Center1 = new Cesium.Cartesian4();
        var _scratchCartesian3Normal = new Cesium.Cartesian3();

        var ScanPostStage = new Cesium.PostProcessStage({
            fragmentShader: ScanSegmentShader,
            uniforms: {
                u_scanCenterEC: function () {
                    return Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center, _scratchCartesian4Center);
                },
                u_scanPlaneNormalEC: function () {
                    var temp = Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center, _scratchCartesian4Center);
                    var temp1 = Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center1, _scratchCartesian4Center1);
                    _scratchCartesian3Normal.x = temp1.x - temp.x;
                    _scratchCartesian3Normal.y = temp1.y - temp.y;
                    _scratchCartesian3Normal.z = temp1.z - temp.z;

                    Cesium.Cartesian3.normalize(_scratchCartesian3Normal, _scratchCartesian3Normal);
                    return _scratchCartesian3Normal;
                },
                u_radius: function () {
                    return maxRadius * (((new Date()).getTime() - _time) % duration) / duration;
                },
                u_scanColor: scanColor
            }
        });
        return viewer.scene.postProcessStages.add(ScanPostStage);
    };

    /*
    * 添加扩散圆扫描线(三环)
    * @param {Object} [cartographicCenter] 扫描中心。
    * @param {Object} [maxRadius] 最大半径 米。
    * @param {Object} [scanColor] 扫描颜色。
    * @param {Object} [duration] 持续时间 毫秒。
    */
    ScanPostProcessStage.prototype.AddCircleScanMultiPostStage = function (cartographicCenter, maxRadius, scanColor, duration) {
        var viewer = this._viewer;
        var Cesium = this._cesium;
        var ScanSegmentShader =
            "uniform sampler2D colorTexture;\n" +
            "uniform sampler2D depthTexture;\n" +
            "varying vec2 v_textureCoordinates;\n" +
            "uniform vec4 u_scanCenterEC;\n" +
            "uniform vec3 u_scanPlaneNormalEC;\n" +
            "uniform float u_radius1;\n" +
            "uniform float u_radius2;\n" +
            "uniform float u_radius3;\n" +
            "uniform float u_maxRadius;\n" +
            "uniform vec4 u_scanColor;\n" +

            "vec4 toEye(in vec2 uv, in float depth)\n" +
            " {\n" +
            " vec2 xy = vec2((uv.x * 2.0 - 1.0),(uv.y * 2.0 - 1.0));\n" +
            " vec4 posInCamera =czm_inverseProjection * vec4(xy, depth, 1.0);\n" +
            " posInCamera =posInCamera / posInCamera.w;\n" +
            " return posInCamera;\n" +
            " }\n" +

            "vec3 pointProjectOnPlane(in vec3 planeNormal, in vec3 planeOrigin, in vec3 point)\n" +
            "{\n" +
            "vec3 v01 = point -planeOrigin;\n" +
            "float d = dot(planeNormal, v01) ;\n" +
            "return (point - planeNormal * d);\n" +
            "}\n" +

            "float getDepth(in vec4 depth)\n" +
            "{\n" +
            "float z_window = czm_unpackDepth(depth);\n" +
            "z_window = czm_reverseLogDepth(z_window);\n" +
            "float n_range = czm_depthRange.near;\n" +
            "float f_range = czm_depthRange.far;\n" +
            "return (2.0 * z_window - n_range - f_range) / (f_range - n_range);\n" +
            "}\n" +

            "void main()\n" +
            "{\n" +
            "gl_FragColor = texture2D(colorTexture, v_textureCoordinates);\n" +
            "float depth = getDepth( texture2D(depthTexture, v_textureCoordinates));\n" +
            "vec4 viewPos = toEye(v_textureCoordinates, depth);\n" +
            "vec3 prjOnPlane = pointProjectOnPlane(u_scanPlaneNormalEC.xyz, u_scanCenterEC.xyz, viewPos.xyz);\n" +
            "float dis = length(prjOnPlane.xyz - u_scanCenterEC.xyz);\n" +
            "if(dis < u_radius1)\n" +
            "{\n" +
            "float f = dis / u_radius1;\n" +
            "f = pow(f, 9.0);\n" +
            "gl_FragColor = mix(gl_FragColor, u_scanColor, f);\n" +
            "}else if(dis < u_radius2){\n" +
            "float f = dis / u_radius2;\n" +
            "f = pow(f, 9.0);\n" +
            "gl_FragColor = mix(gl_FragColor, u_scanColor, f);\n" +
            "}else if(dis < u_radius3){\n" +
            "float f = dis / u_radius3;\n" +
            "f = pow(f, 9.0);\n" +
            "gl_FragColor = mix(gl_FragColor, u_scanColor, f);\n" +
            "}\n" +
            "}\n";

        var _Cartesian3Center = Cesium.Cartographic.toCartesian(cartographicCenter);
        var _Cartesian4Center = new Cesium.Cartesian4(_Cartesian3Center.x, _Cartesian3Center.y, _Cartesian3Center.z, 1);

        var _CartographicCenter1 = new Cesium.Cartographic(cartographicCenter.longitude, cartographicCenter.latitude, cartographicCenter.height + 500);
        var _Cartesian3Center1 = Cesium.Cartographic.toCartesian(_CartographicCenter1);
        var _Cartesian4Center1 = new Cesium.Cartesian4(_Cartesian3Center1.x, _Cartesian3Center1.y, _Cartesian3Center1.z, 1);

        var _time = (new Date()).getTime();

        var _scratchCartesian4Center = new Cesium.Cartesian4();
        var _scratchCartesian4Center1 = new Cesium.Cartesian4();
        var _scratchCartesian3Normal = new Cesium.Cartesian3();

        var radius1 = 0, radius2 = 0, radius3 = 0;
        var ScanPostStage = new Cesium.PostProcessStage({
            fragmentShader: ScanSegmentShader,
            uniforms: {
                u_scanCenterEC: function () {
                    return Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center, _scratchCartesian4Center);
                },
                u_scanPlaneNormalEC: function () {
                    var temp = Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center, _scratchCartesian4Center);
                    var temp1 = Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center1, _scratchCartesian4Center1);
                    _scratchCartesian3Normal.x = temp1.x - temp.x;
                    _scratchCartesian3Normal.y = temp1.y - temp.y;
                    _scratchCartesian3Normal.z = temp1.z - temp.z;

                    Cesium.Cartesian3.normalize(_scratchCartesian3Normal, _scratchCartesian3Normal);
                    return _scratchCartesian3Normal;
                },
                u_radius1: function () {
                    return radius1;
                },
                u_radius2: function () {
                    return radius2;
                },
                u_radius3: function () {
                    let thisRadius = maxRadius * (((new Date()).getTime() - _time) % duration) / duration;
                    if (thisRadius < maxRadius / 3 && radius2 === 0 && radius1 === 0) {
                        radius3 = thisRadius;
                    } else if (thisRadius >= maxRadius / 3 && thisRadius < maxRadius * 2 / 3 && radius1 === 0) {
                        radius3 = thisRadius;
                        radius2 = radius3 - maxRadius / 3;
                    } else if (thisRadius >= maxRadius * 2 / 3) {
                        radius3 = thisRadius;
                        radius2 = radius3 - maxRadius / 3;
                        radius1 = radius3 - maxRadius * 2 / 3;
                    } else if (thisRadius < maxRadius / 3 && radius2 !== 0 && radius1 !== 0) {
                        radius1 = thisRadius;
                        radius2 = thisRadius + maxRadius / 3;
                        radius3 = thisRadius + maxRadius * 2 / 3;
                    } else if (thisRadius >= maxRadius / 3 && thisRadius < maxRadius * 2 / 3 && radius1 !== 0) {
                        radius1 = thisRadius - maxRadius / 3;
                        radius2 = thisRadius;
                        radius3 = thisRadius + maxRadius / 3;
                    }

                    return radius3;
                },
                u_maxRadius: maxRadius,
                u_scanColor: scanColor
            }
        });
        return viewer.scene.postProcessStages.add(ScanPostStage);
    };

    /*
    * 添加雷达扫描线
    * @param {Object} [cartographicCenter] 扫描中心。
    * @param {Object} [maxRadius] 最大半径 米。
    * @param {Object} [scanColor] 扫描颜色。
    * @param {Object} [duration] 持续时间 毫秒。
    */
    ScanPostProcessStage.prototype.AddRadarScanPostStage = function (cartographicCenter, maxRadius, scanColor, duration) {
        var viewer = this._viewer;
        var Cesium = this._cesium;
        var ScanSegmentShader =
            "uniform sampler2D colorTexture;\n" +
            "uniform sampler2D depthTexture;\n" +
            "varying vec2 v_textureCoordinates;\n" +
            "uniform vec4 u_scanCenterEC;\n" +
            "uniform vec3 u_scanPlaneNormalEC;\n" +
            "uniform vec3 u_scanLineNormalEC;\n" +
            "uniform float u_radius;\n" +
            "uniform vec4 u_scanColor;\n" +

            "vec4 toEye(in vec2 uv, in float depth)\n" +
            " {\n" +
            " vec2 xy = vec2((uv.x * 2.0 - 1.0),(uv.y * 2.0 - 1.0));\n" +
            " vec4 posInCamera =czm_inverseProjection * vec4(xy, depth, 1.0);\n" +
            " posInCamera =posInCamera / posInCamera.w;\n" +
            " return posInCamera;\n" +
            " }\n" +

            "bool isPointOnLineRight(in vec3 ptOnLine, in vec3 lineNormal, in vec3 testPt)\n" +
            "{\n" +
            "vec3 v01 = testPt - ptOnLine;\n" +
            "normalize(v01);\n" +
            "vec3 temp = cross(v01, lineNormal);\n" +
            "float d = dot(temp, u_scanPlaneNormalEC);\n" +
            "return d > 0.5;\n" +
            "}\n" +

            "vec3 pointProjectOnPlane(in vec3 planeNormal, in vec3 planeOrigin, in vec3 point)\n" +
            "{\n" +
            "vec3 v01 = point -planeOrigin;\n" +
            "float d = dot(planeNormal, v01) ;\n" +
            "return (point - planeNormal * d);\n" +
            "}\n" +

            "float distancePointToLine(in vec3 ptOnLine, in vec3 lineNormal, in vec3 testPt)\n" +
            "{\n" +
            "vec3 tempPt = pointProjectOnPlane(lineNormal, ptOnLine, testPt);\n" +
            "return length(tempPt - ptOnLine);\n" +
            "}\n" +

            "float getDepth(in vec4 depth)\n" +
            "{\n" +
            "float z_window = czm_unpackDepth(depth);\n" +
            "z_window = czm_reverseLogDepth(z_window);\n" +
            "float n_range = czm_depthRange.near;\n" +
            "float f_range = czm_depthRange.far;\n" +
            "return (2.0 * z_window - n_range - f_range) / (f_range - n_range);\n" +
            "}\n" +

            "void main()\n" +
            "{\n" +
            "gl_FragColor = texture2D(colorTexture, v_textureCoordinates);\n" +
            "float depth = getDepth( texture2D(depthTexture, v_textureCoordinates));\n" +
            "vec4 viewPos = toEye(v_textureCoordinates, depth);\n" +
            "vec3 prjOnPlane = pointProjectOnPlane(u_scanPlaneNormalEC.xyz, u_scanCenterEC.xyz, viewPos.xyz);\n" +
            "float dis = length(prjOnPlane.xyz - u_scanCenterEC.xyz);\n" +
            "float twou_radius = u_radius * 2.0;\n" +
            "if(dis < u_radius)\n" +
            "{\n" +
            "vec3 lineEndPt = vec3(u_scanCenterEC.xyz) + u_scanLineNormalEC * u_radius;\n" +
            "float f = 0.0;\n" +
            "if(isPointOnLineRight(u_scanCenterEC.xyz, u_scanLineNormalEC.xyz, prjOnPlane.xyz))\n" +
            "{\n" +
            "float dis1= length(prjOnPlane.xyz - lineEndPt);\n" +
            "f = abs(twou_radius -dis1) / twou_radius;\n" +
            "f = pow(f, 3.0);\n" +
            "}\n" +
            "gl_FragColor = mix(gl_FragColor, u_scanColor, f);\n" +
            "}\n" +
            "}\n";

        var _Cartesian3Center = Cesium.Cartographic.toCartesian(cartographicCenter);
        var _Cartesian4Center = new Cesium.Cartesian4(_Cartesian3Center.x, _Cartesian3Center.y, _Cartesian3Center.z, 1);

        var _CartographicCenter1 = new Cesium.Cartographic(cartographicCenter.longitude, cartographicCenter.latitude, cartographicCenter.height + 500);
        var _Cartesian3Center1 = Cesium.Cartographic.toCartesian(_CartographicCenter1);
        var _Cartesian4Center1 = new Cesium.Cartesian4(_Cartesian3Center1.x, _Cartesian3Center1.y, _Cartesian3Center1.z, 1);

        var _CartographicCenter2 = new Cesium.Cartographic(cartographicCenter.longitude + Cesium.Math.toRadians(0.001), cartographicCenter.latitude, cartographicCenter.height);
        var _Cartesian3Center2 = Cesium.Cartographic.toCartesian(_CartographicCenter2);
        var _Cartesian4Center2 = new Cesium.Cartesian4(_Cartesian3Center2.x, _Cartesian3Center2.y, _Cartesian3Center2.z, 1);
        var _RotateQ = new Cesium.Quaternion();
        var _RotateM = new Cesium.Matrix3();

        var _time = (new Date()).getTime();

        var _scratchCartesian4Center = new Cesium.Cartesian4();
        var _scratchCartesian4Center1 = new Cesium.Cartesian4();
        var _scratchCartesian4Center2 = new Cesium.Cartesian4();
        var _scratchCartesian3Normal = new Cesium.Cartesian3();
        var _scratchCartesian3Normal1 = new Cesium.Cartesian3();

        var ScanPostStage = new Cesium.PostProcessStage({
            fragmentShader: ScanSegmentShader,
            uniforms: {
                u_scanCenterEC: function () {
                    return Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center, _scratchCartesian4Center);
                },
                u_scanPlaneNormalEC: function () {
                    var temp = Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center, _scratchCartesian4Center);
                    var temp1 = Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center1, _scratchCartesian4Center1);
                    _scratchCartesian3Normal.x = temp1.x - temp.x;
                    _scratchCartesian3Normal.y = temp1.y - temp.y;
                    _scratchCartesian3Normal.z = temp1.z - temp.z;

                    Cesium.Cartesian3.normalize(_scratchCartesian3Normal, _scratchCartesian3Normal);
                    return _scratchCartesian3Normal;
                },
                u_radius: maxRadius,
                u_scanLineNormalEC: function () {
                    var temp = Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center, _scratchCartesian4Center);
                    var temp1 = Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center1, _scratchCartesian4Center1);
                    var temp2 = Cesium.Matrix4.multiplyByVector(viewer.camera._viewMatrix, _Cartesian4Center2, _scratchCartesian4Center2);

                    _scratchCartesian3Normal.x = temp1.x - temp.x;
                    _scratchCartesian3Normal.y = temp1.y - temp.y;
                    _scratchCartesian3Normal.z = temp1.z - temp.z;

                    Cesium.Cartesian3.normalize(_scratchCartesian3Normal, _scratchCartesian3Normal);

                    _scratchCartesian3Normal1.x = temp2.x - temp.x;
                    _scratchCartesian3Normal1.y = temp2.y - temp.y;
                    _scratchCartesian3Normal1.z = temp2.z - temp.z;

                    var tempTime = (((new Date()).getTime() - _time) % duration) / duration;
                    Cesium.Quaternion.fromAxisAngle(_scratchCartesian3Normal, tempTime * Cesium.Math.PI * 2, _RotateQ);
                    Cesium.Matrix3.fromQuaternion(_RotateQ, _RotateM);
                    Cesium.Matrix3.multiplyByVector(_RotateM, _scratchCartesian3Normal1, _scratchCartesian3Normal1);
                    Cesium.Cartesian3.normalize(_scratchCartesian3Normal1, _scratchCartesian3Normal1);
                    return _scratchCartesian3Normal1;
                },
                u_scanColor: scanColor
            }
        });
        return viewer.scene.postProcessStages.add(ScanPostStage);
    };

    ScanPostProcessStage.prototype.remove = function () {
        this._viewer.scene.postProcessStages.remove(this.item);
    };

    //工程树添加
    ScanPostProcessStage.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    /**
     * 删除
     */
    ScanPostProcessStage.prototype.deleteObject = function () {
        if (this.item) {
            this._viewer.scene.postProcessStages.remove(this.item);
        }
    };

    /**
     * 设置polyline的显示隐藏
     * @param {boolean} [b] true|false
     */
    ScanPostProcessStage.prototype.setVisibility = function (b) {
        if (this.item) {
            this.item.enabled = b;
        }
    };

    /**
    *
    * 视野范围限制
    *
    * @alias Scopefieldvision 
    * @constructor
    *
    */
    function Scopefieldvision(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
        this._points = [];
        this._xjwz = null;
        this._polygonsd = [];
        this._rectangle = null;
    }
    /**
    * 视野范围限制
    * @param {number} [numb] 数字类型。
    */
    Scopefieldvision.prototype.executeScopefieldvision = function () {
        var _this = this;
        var PolygonPrimitive = (function () {
            function execute(positions) {
                this.options = {
                    name: '',
                    polygon: {
                        fill: true,
                        hierarchy: [],
                        height: 0,
                        perPositionHeight: true,
                        heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND,
                        material: _this._cesium.Color.YELLOW.withAlpha(0.3)
                    }
                };
                this.hierarchy = positions;
                this._init();
            }
            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.hierarchy;
                };
                //实时更新polygon.hierarchy
                this.options.polygon.hierarchy = new _this._cesium.CallbackProperty(_update, false);
                this.polygon = _this._viewer.entities.add(this.options);
                _this.item = this.polygon;
            };
            return execute;
        })();
        var handler = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var positions = [];
        var poly = undefined;
        //鼠标单击画点
        handler.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.position, _this._viewer.scene.globe.ellipsoid);
            if (positions.length == 0) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        handler.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.endPosition, _this._viewer.scene.globe.ellipsoid);
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolygonPrimitive(positions);
                } else {
                    if (cartesian != undefined) {
                        positions.pop();
                        cartesian.y += (1 + Math.random());
                        positions.push(cartesian);
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //鼠标右键单击结束绘制
        handler.setInputAction(function (movement) {
            handler.destroy();
            //创建面对象并返回面对象
            var ploylinejl = { polygon: {}, positions: [], area: [] };
            ploylinejl.polygon = poly;
            var positionsop = [];
            for (var j = 0; j < positions.length; j++) {
                var cartographicdr = _this._cesium.Cartographic.fromCartesian(positions[j]);
                var longitudeStringdr = _this._cesium.Math.toDegrees(cartographicdr.longitude);
                var latitudeStringdr = _this._cesium.Math.toDegrees(cartographicdr.latitude);
                var heightStringdr = cartographicdr.height;
                positionsop.push({ lon: longitudeStringdr, lat: latitudeStringdr, hei: heightStringdr });
                var js = [longitudeStringdr, latitudeStringdr];//左上, 右上, 右下, 左下
                _this._polygonsd.push(js);
            }
            ploylinejl.positions = positionsop;
            var heading = _this._viewer.camera.heading;
            var pitch = _this._viewer.camera.pitch;
            var roll = _this._viewer.camera.roll;
            var position = _this._viewer.camera.position.clone();
            _this._xjwz = { "orientation": { "heading": heading, "pitch": pitch, "roll": roll }, "position": position };

            _this._viewer.scene.camera.moveEnd.addEventListener(function () {
                var rectangle = _this._viewer.camera.computeViewRectangle();
                if (rectangle == _this._rectangle) {
                    return;
                }
                _this._rectangle = rectangle;
                // 弧度转为经纬度，west为左（西）侧边界的经度，以下类推
                var west = rectangle.west / Math.PI * 180;
                var north = rectangle.north / Math.PI * 180;
                var east = rectangle.east / Math.PI * 180;
                var south = rectangle.south / Math.PI * 180;
                // 鉴于高德、leaflet获取的边界都是southwest和northeast字段来表示，本例保持一致性
                var point = [(west + east) / 2, (north + south) / 2];
                var fh = _this.exports(point, _this._polygonsd);
                if (fh) ; else {
                    if (_this._xjwz != null) {
                        _this._viewer.camera.setView({
                            // Cesium的坐标是以地心为原点，一向指向南美洲，一向指向亚洲，一向指向北极州
                            // fromDegrees()方法，将经纬度和高程转换为世界坐标
                            //destination: _this._cesium.Cartesian3.fromDegrees(117.48, 30.67, 15000.0),
                            destination: _this._xjwz.position,
                            orientation: _this._xjwz.orientation
                        });
                    }
                }
            });
            //左上, 右上, 右下, 左下
            //var textArea = core.getArea(tempPoints, positions, cesium) + "平方公里";
            //  ploylinejl.area = core.getArea(tempPoints, positions, cesium);
            ///工程树添加
            var GroupID = 0;
            if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                GroupID = tree.selectedItem.id;
            var id = _this._core.getuid();
            tree.insertGroupId({
                id: id,
                name: '视野范围面' + id,
                pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'polygon',
                item: _this
            }, _this._core.isnull(GroupID) ? 0 : GroupID);
            if (typeof method == 'function') {
                method(ploylinejl);
            }
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        return this;
    };
    Scopefieldvision.prototype.exports = function (point, vs) {
        // ray-casting algorithm based on
        // http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
        var x = point[0], y = point[1];

        var inside = false;
        for (var i = 0, j = vs.length - 1; i < vs.length; j = i++) {
            var xi = vs[i][0], yi = vs[i][1];
            var xj = vs[j][0], yj = vs[j][1];

            var intersect = ((yi > y) != (yj > y))
                && (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
            if (intersect) inside = !inside;
        }

        return inside;
    };

    /**
     *
     * 添加线。
     *
     * @alias Polyline
     * @constructor
     *
     */
    function Polyline(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._Color = new Color(this._viewer, this._cesium);
        this._core = new Core();
        this._getPosition = new getPosition(this._viewer, this._cesium);
        this._tree = tree;
        this._points = [];
        this._polylines = [];
        //this._polylines1 = [];
        //this._labels = [];
    }

    /**
     * 向三维场景中添加线。
     * @param {Array} [Geometry] 一个经纬度数组 例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
     * @param {String} [LineColor] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Polyline.prototype.createPolyline = function (Geometry, LineColor, AltitudeType, GroupID, Description) {
        var pArray = [];
        if (!Geometry[0].x && !Geometry[0].y) {
            if (Geometry[0].length === 2) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1]));
                }
            } else if (Geometry[0].length === 3) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1], Geometry[i][2]));
                }
            }
        } else {
            if (Geometry[0].z !== undefined) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y, Geometry[i].z));
                }
            } else {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y));
                }
            }
        }
        var clampToGround = true;
        if (AltitudeType === 2) {
            clampToGround = false;
        }
        this.item = this._viewer.entities.add({
            polyline: {
                positions: pArray,
                //positions: position1,
                width: 10.0,
                material: new this._cesium.PolylineGlowMaterialProperty({
                    outlineColor: this._cesium.Color.BLACK,
                    color: new Color(this._viewer, this._cesium).colorFromHtmlColor(LineColor),
                }),
                clampToGround: clampToGround
            }
        });
        var obj = {
            id: this.item.id,
            name: Description,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polyline',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);

        return this;
    };


    /**
      * 获取polyline样式
      */
    Polyline.prototype.getstyles = function () {
        var styles = {};
        styles.show = this.item.polyline.show ? this.item.polyline.show.getValue() : true;
        styles.positions = this.item.polyline.positions.getValue().toString();
        styles.width = this.item.polyline.width.toString();
        styles.granularity = this.item.polyline.granularity ? this.item.polyline.granularity.toString() : null;
        styles.material = {};
        styles.material.color = this.item.polyline.material && this.item.polyline.material.color && this.item.polyline.material.color._value ? 'rgba' + this.item.polyline.material.color.toString() : null;
        styles.material.outlineColor = this.item.polyline.material.outlineColor && this.item.polyline.material.outlineColor._value ? 'rgba' + this.item.polyline.material.outlineColor.toString() : null;
        styles.material.outlineWidth = this.item.polyline.material.outlineWidth && this.item.polyline.material.outlineWidth._value ? this.item.polyline.material.outlineWidth.toString() : null;
        styles.classificationType = this.item.polyline.classificationType ? this.item.polyline.classificationType.toString() : null;
        styles.near = this.item.polyline.distanceDisplayCondition ? this.item.polyline.distanceDisplayCondition._value.near : null;
        styles.far = this.item.polyline.distanceDisplayCondition ? this.item.polyline.distanceDisplayCondition._value.far : null;
        // styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
     * 向三维场景中添加链路。
     * @param {Array} [position1] 点1。
     * @param {Array} [position2] 点2。
     * @param {Object} [options] 参数。{
        lineType: 1,   //线形（可选）
        num: 200,   //线段采样数（可选）
        width: 2,  //线宽（可选）
        speed: 1,  //倍速（可选）
        lineColor: 'rgba(255,255,255,0.5)',  //线颜色（可选）
        pointColor: 'rgba(255,255,255,0.5)',   //点填充颜色（可选）
        outlineColor: 'rgba(255,255,255,0.5)',  //点边框线颜色（可选）
        outlineWidth: 2,   //点边框宽度（可选）
        size: 8,   //点大小（可选）
    }
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Polyline.prototype.createLink = function (position1, position2, options) {
        !options && (options = {});
        var pArray = [];
        var position = [];
        if (position1.lon && position1.lat) {
            if (position1.height !== undefined) {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1.lon, position1.lat, position1.height));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2.lon, position2.lat, position2.height));
                position.push({ x: position1.lon, y: position1.lat, z: position1.height }, { x: position2.lon, y: position2.lat, z: position2.height });
            } else {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1.lon, position1.lat));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2.lon, position2.lat));
                position.push({ x: position1.lon, y: position1.lat, z: 0 }, { x: position2.lon, y: position2.lat, z: 0 });
            }
        } else if (position1.x && position1.y) {
            if (position1.z !== undefined) {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1.x, position1.y, position1.z));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2.x, position2.y, position2.z));
                position.push(position1, position2);
            } else {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1.x, position1.y));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2.x, position2.y));
                position1.z = 0;
                position2.z = 0;
                position.push(position1, position2);
            }
        } else {
            if (position1.length === 2) {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1[0], position1[1]));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2[0], position2[1]));
                position.push({ x: position1[0], y: position1[1], z: 0 }, { x: position2[0], y: position2[1], z: 0 });
            } else if (position1.length === 3) {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1[0], position1[1], position1[2]));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2[0], position2[1], position2[2]));
                position.push({ x: position1[0], y: position1[1], z: position1[2] }, { x: position2[0], y: position2[1], z: position2[2] });
            }
        }
        if (options.lineType === 1) {
            options.material = new this._cesium.PolylineDashMaterialProperty({
                color: this._core.defaultValue(options.lineColor && this._cesium.Color.fromCssColorString(options.lineColor), this._cesium.Color.AQUAMARINE)
            });
        } else if (options.lineType === 2) {
            options.material = new this._cesium.PolylineGlowMaterialProperty({
                glowPower: 0.3,
                color: this._core.defaultValue(options.lineColor && this._cesium.Color.fromCssColorString(options.lineColor), this._cesium.Color.BLUE)
            });
        } else {
            options.material = this._core.defaultValue(options.lineColor && this._cesium.Color.fromCssColorString(options.lineColor), this._cesium.Color.AQUAMARINE);
        }

        if (options.cylinder) {
            var _height = position[1].z - position[0].z;
            var startP = Cesium.Cartesian3.fromDegrees(position[0].x, position[0].y, 0);
            //计算经度方向的夹角
            var endX = Cesium.Cartesian3.fromDegrees(position[1].x, position[0].y, 0);
            var innerS = this._core.getSpaceDistancem([startP, endX], this._cesium);
            var angleX = _height === 0 ? Math.PI / 2 : Math.atan(innerS / _height);

            //计算直线长度
            var lengthl = this._core.getSpaceDistancem(pArray, this._cesium);

            //计算纬度方向的夹角
            var endY = Cesium.Cartesian3.fromDegrees(position[0].x, position[1].y, 0);
            innerS = this._core.getSpaceDistancem([startP, endY], this._cesium);
            var angleY = Math.asin(innerS / lengthl);

            if (position[0].x > position[1].x && position[0].y > position[1].y) {
                angleY = _height < 0 ? -angleY : angleY;
            } else if (position[0].x > position[1].x && position[0].y < position[1].y) {
                angleY = _height >= 0 ? -angleY : angleY;
            } else if (position[0].x < position[1].x && position[0].y <= position[1].y) {
                //angleY = _height > 0 ? -angleY : angleY;
                angleX = _height !== 0 ? -angleX : angleX;
                angleY = _height > 0 ? -angleY : angleY;
            } else if (position[0].x < position[1].x && position[0].y > position[1].y) {
                angleY = _height < 0 ? -angleY : angleY;
                angleX = -angleX;
            }
            //计算朝向
            var hpr = new Cesium.HeadingPitchRoll(0.0, angleX, angleY);
        }


        var pointPosition = pArray[0];
        this.item = this._viewer.entities.add({
            position: new this._cesium.CallbackProperty(function () {
                return pointPosition;
            }, false),
            orientation: options.cylinder ? new this._cesium.CallbackProperty(function () {
                return Cesium.Transforms.headingPitchRollQuaternion(pointPosition, hpr);
            }, false) : undefined,
            polyline: {
                positions: pArray,
                width: this._core.defaultValue(options.width, 2.0),
                material: options.material,
                clampToGround: false
            },
            cylinder: options.cylinder ? {
                length: this._core.defaultValue(options.length, 20.0),
                topRadius: this._core.defaultValue(options.size, 8.0),
                bottomRadius: this._core.defaultValue(options.size, 8.0),
                material: this._core.defaultValue(options.pointColor && this._cesium.Color.fromCssColorString(options.pointColor), this._cesium.Color.RED)
            } : undefined,
            point: !options.cylinder ? {
                color: this._core.defaultValue(options.pointColor && this._cesium.Color.fromCssColorString(options.pointColor), this._cesium.Color.RED),
                outlineColor: this._core.defaultValue(options.outlineColor && this._cesium.Color.fromCssColorString(options.outlineColor), this._cesium.Color.YELLOW),
                outlineWidth: this._core.defaultValue(options.outlineWidth, 2),
                pixelSize: this._core.defaultValue(options.size, 8),
            } : undefined
        });

        var pointSum = this._core.defaultValue(options.num, 200);

        var addX = this._cesium.Math.lerp(position[0].x, position[1].x, 1.0 / pointSum) - position[0].x;
        var addY = this._cesium.Math.lerp(position[0].y, position[1].y, 1.0 / pointSum) - position[0].y;
        var addZ = this._cesium.Math.lerp(position[0].z, position[1].z, 1.0 / pointSum) - position[0].z;

        var positions = [];
        positions.push(pArray[0]);
        for (let i = 0; i < pointSum; i++) {
            let lon = position[0].x + (i + 1) * addX;
            let lat = position[0].y + (i + 1) * addY;
            let h = position[0].z + (i + 1) * addZ;
            positions.push(this._cesium.Cartesian3.fromDegrees(lon, lat, h));
        }
        positions.push(pArray[1]);

        var speed = this._core.defaultValue(options.speed, 1);
        var thisIndex = 0;
        // 执行动画效果
        this._viewer.clock.onTick.addEventListener(function () {
            thisIndex += speed;
            thisIndex = parseInt(thisIndex);
            if (thisIndex >= positions.length - 1 && speed > 0) {
                speed = -speed;
            } else if (thisIndex <= 0 && speed < 0) {
                speed = -speed;
            }
            pointPosition = positions[thisIndex];
        });

        var obj = {
            id: this.item.id,
            name: '新建链路',
            pId: 0,
            type: 'polyline',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };
    Polyline.prototype.createLinkPros = function (callback) {
        //空间距离测量
        // 取消双击事件-追踪该位置
        var _this = this;
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        this._tree.removeHandler();
        this._tree.starttemporaryItem(this._viewer);
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positions = [];
        var poly = null;
        var distance = "0米";
        var cartesian = null;
        var _this = this;
        var endcd = "";
        //导入tool提示框
        var tooltip = this._core.CreateTooltip();
        var coloroptions = {
            "point": _this._cesium.Color.RED,
            "polyline": _this._cesium.Color.BLUE
        };
        this._tree.handler.setInputAction(function (movement) {
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            //tool创建
            if (positions.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束绘制！');
            }
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive1(positions);
                } else {
                    if (positions.length > _this._points.length) {
                        positions.pop();
                        positions.push(cartesian);
                    } else {
                        positions.push(cartesian);
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this._tree.handler.setInputAction(function (movement) {
            _this._viewer.camera.getPickRay(movement.position);
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            if (positions.length == 0) {
                positions.push(cartesian, cartesian);
            } else {
                if (positions.length > _this._points.length) {
                    positions.pop();
                    positions.push(cartesian);
                } else {
                    positions.push(cartesian, cartesian);
                }
            }
            //兼容移动端未触发移动事件
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive1(positions);
                }
                distance = _this._core.getSpaceDistance(positions, _this._cesium);
                //distance = distance + "千米";
            }
            endcd = "总长：" + distance;
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            _this.end && _this.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            var options1 = {
                width: 4, //线宽（可选）
                lineColor: "#0000ff", //线颜色（可选）
            };
            //poly.
            var pArray = poly.positions;

            tooltip.show(false);
            _this._tree && _this._tree.endtemporaryItem();
            _this._points[_this._points.length - 1] && (_this._points[_this._points.length - 1].label.text = endcd);
            _this._tree && _this._tree.handler.destroy(); //关闭事件句柄
            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0, "0");
            _this.end = undefined;

            _this._viewer.entities.remove(_this.item);
            if (type === 'cancel' || positions.length < 2) {
                return;
            }
            _this.item = _this._viewer.entities.add({
                name: '新建链路',
                polyline: {
                    positions: pArray,
                    width: _this._core.defaultValue(options1.width, 2.0),
                    material: _this._core.getLinkMaterial(options1.lineColor, options1.pointColor, options1.time),
                    clampToGround: true
                }
            });
            callback && callback(_this.item);
        };

        var PolyLinePrimitive1 = (function () {
            function execute(positions) {
                this.options = {
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: coloroptions.polyline,
                        width: 3,
                        clampToGround: true
                    }
                };
                this.positions = positions;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                var polyline = _this._viewer.entities.add(this.options);
                _this.item = polyline;
                _this._tree.temporaryItem.obj.push(polyline);
                _this._core.getuid();
            };
            return execute;
        })();
        return this;
    };
    /**
     * 向三维场景中添加链路(优化版)。
     * @param {Array} [position1] 点1。
     * @param {Array} [position2] 点2。
     * @param {Object} [options] 参数。{
        width: 2,  //线宽（可选）
        time: 1,  //倍速（可选）
        lineColor: 'rgba(255,255,255,0.5)',  //线颜色（可选）
        pointColor: 'rgba(255,255,255,0.5)',   //点填充颜色（可选）
    }
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Polyline.prototype.createLinkPro = function (position1, position2, options) {
        !options && (options = {});
        var pArray = [];
        var position = [];
        if (position1.lon && position1.lat) {
            if (position1.height !== undefined) {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1.lon, position1.lat, position1.height));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2.lon, position2.lat, position2.height));
                position.push({ x: position1.lon, y: position1.lat, z: position1.height }, { x: position2.lon, y: position2.lat, z: position2.height });
            } else {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1.lon, position1.lat));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2.lon, position2.lat));
                position.push({ x: position1.lon, y: position1.lat, z: 0 }, { x: position2.lon, y: position2.lat, z: 0 });
            }
        } else if (position1.x && position1.y) {
            if (position1.z !== undefined) {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1.x, position1.y, position1.z));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2.x, position2.y, position2.z));
                position.push(position1, position2);
            } else {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1.x, position1.y));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2.x, position2.y));
                position1.z = 0;
                position2.z = 0;
                position.push(position1, position2);
            }
        } else {
            if (position1.length === 2) {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1[0], position1[1]));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2[0], position2[1]));
                position.push({ x: position1[0], y: position1[1], z: 0 }, { x: position2[0], y: position2[1], z: 0 });
            } else if (position1.length === 3) {
                pArray.push(this._cesium.Cartesian3.fromDegrees(position1[0], position1[1], position1[2]));
                pArray.push(this._cesium.Cartesian3.fromDegrees(position2[0], position2[1], position2[2]));
                position.push({ x: position1[0], y: position1[1], z: position1[2] }, { x: position2[0], y: position2[1], z: position2[2] });
            }
        }

        this.item = this._viewer.entities.add({
            name: '新建链路',
            polyline: {
                positions: pArray,
                width: this._core.defaultValue(options.width, 2.0),
                material: this._core.getLinkMaterial(options.lineColor, options.pointColor, options.time)
            }
        });

        var obj = {
            id: this.item.id,
            name: '新建链路',
            pId: 0,
            type: 'polyline',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };
    /**
     * 向三维场景中添加线。
     * @param {object} [method] 回调函数
     *
     */
    Polyline.prototype.executePolyline = function (parameter, method) {
        var _this = this;
        var PolyLinePrimitive = (function () {
            function execute(positions) {
                this.options = {
                    polyline: {
                        show: true,
                        positions: [],
                        material: new _this._cesium.PolylineOutlineMaterialProperty({
                            color: _this._core.defaultValue(parameter.color, _this._cesium.Color.YELLOW)
                        }),
                        clampToGround: _this._core.defaultValue(parameter.clampToGround, true),
                        width: _this._core.defaultValue(parameter.width, 3),
                    }
                };
                this.positions = positions;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                //实时更新polyline.positions
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                this.polyline = _this._viewer.entities.add(this.options);
                _this.item = this.polyline;
            };
            return execute;
        })();
        var handler = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var positions = [];
        var poly = undefined;
        var tooltip = this._core.CreateTooltip();
        //隐藏选中容器标识
        //鼠标左键单击画点
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        handler.setInputAction(function (movement) {
            var cartesian = _this._getPosition.getMousePosition(movement);
            if (positions.length == 0) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        handler.setInputAction(function (movement) {
            if (positions.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束绘制！');
            }

            var cartesian = _this._getPosition.getMousePosition(movement);
            //var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.endPosition, _this._viewer.scene.globe.ellipsoid);
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive(positions);
                } else {
                    if (cartesian != undefined) {
                        positions.pop();
                        cartesian.y += (1 + Math.random());
                        positions.push(cartesian);
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //单击鼠标右键结束画线
        handler.setInputAction(function (movement) {
            tooltip.show(false);
            var ploylinejl = {
                polyline: {},
                positions: [],
                positionsp: [],
                distance: []
            };
            ploylinejl.setDistance = function () {
                alert("qq");
            };
            handler.destroy();
            //callback(positions);
            ploylinejl.polyline = poly;
            var positionsop = [];
            for (var j = 0; j < positions.length; j++) {
                var cartographicdr = _this._cesium.Cartographic.fromCartesian(positions[j]);
                var longitudeStringdr = _this._cesium.Math.toDegrees(cartographicdr.longitude);
                var latitudeStringdr = _this._cesium.Math.toDegrees(cartographicdr.latitude);
                var heightStringdr = cartographicdr.height;
                positionsop.push({
                    lon: longitudeStringdr,
                    lat: latitudeStringdr,
                    hei: heightStringdr
                });
            }
            ploylinejl.positions = positionsop;
            for (var i = 1; i < positions.length; i++) {
                ploylinejl.distance[i - 1] = Cdcl(positions[i - 1].y, positions[i - 1].x, positions[i].y, positions[i].x);
            }
            ploylinejl.positionsp = positions;
            ///工程树添加
            //var GroupID = 0;
            //if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            //    GroupID = tree.selectedItem.id;
            //var id = _this._core.getuid();
            //var obj = {
            //    id: id,
            //    name: '新建折线' + id,
            //    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
            //    type: 'polyline',
            //    item: _this
            //};
            //_this.setTreeobj(obj);
            //tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);

            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0, "0");
            if (typeof method == 'function') {
                method(ploylinejl);
            }
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        return this;
    };
    //空间距离测量
    Polyline.prototype.executePolyline1 = function (methond, parameter) {
        //空间距离测量
        // 取消双击事件-追踪该位置
        var _this = this;
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        this._tree.removeHandler();
        this._tree.starttemporaryItem(this._viewer);
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positions = [];
        var poly = null;
        var distance = "0米";
        var cartesian = null;
        var _this = this;
        var floatingPoint;
        var endcd = "";
        var we;
        //导入tool提示框
        var tooltip = this._core.CreateTooltip();
        //隐藏选中容器标识
        //spot点坐标，distance距离，label距离对象数组
        var Distance = {
            name: '',
            spot: [],
            distance: [],
            label: [],
            ployline: []
        };
        var coloroptions = {
            "point": _this._cesium.Color.RED,
            "polyline": _this._cesium.Color.YELLOW
        };
        if (Object.keys(parameter).length > 0) {
            if (parameter.point != "" && parameter.point != undefined) {
                coloroptions.point = parameter.point;
            }
            if (parameter.polyline != "" && parameter.polyline != undefined) {
                coloroptions.polyline = parameter.polyline;
            }
        }
        this._tree.handler.setInputAction(function (movement) {
            //var ray = _this._viewer.camera.getPickRay(movement.endPosition);
            //cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            //cartesian = _this._viewer.scene.pickPosition(movement.endPosition);
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            //var feature = scene.pick(movement.endPosition);
            //if (feature == undefined) {
            //    cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            //}
            //else if (feature) {
            //    cartesian = _this._viewer.scene.pickPosition(movement.endPosition);
            //} else if (feature.id != null && feature.id.polygon != undefined && feature.id.polygon != null) {
            //    cartesian = _this._viewer.scene.pickPosition(movement.endPosition);
            //} else {
            //    cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            //}
            //tool创建
            if (positions.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束绘制！');
            }
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive1(positions);
                } else {
                    if (positions.length > _this._points.length) {
                        positions.pop();
                        positions.push(cartesian);
                    } else {
                        positions.push(cartesian);
                    }
                }
                distance = _this._core.getSpaceDistance(positions, _this._cesium);
                //distance = distance + "千米";
            }

            we && (_this._viewer.entities.remove(we), we = undefined);
            we = _this._viewer.entities.add({
                name: '空间直线距离',
                // position: Cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180,cartographic.height),
                position: positions[positions.length - 1],
                label: {
                    text: "总长：" + distance,
                    font: '16px 宋体',
                    fillColor: Cesium.Color.GOLD,
                    verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                    pixelOffset: new Cesium.Cartesian2(20, -20),
                    showBackground: true,
                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
                }
            });
            _this._tree.temporaryItem.obj.push(we);
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this._tree.handler.setInputAction(function (movement) {
            _this._viewer.camera.getPickRay(movement.position);
            //cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            //cartesian = _this._viewer.scene.pickPosition(movement.position);
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            //var feature = scene.pick(movement.position);
            //if (feature == undefined) {
            //    cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            //}
            //else if (feature) {
            //    cartesian = _this._viewer.scene.pickPosition(movement.position);
            //} else if (feature.id != null && feature.id.polygon != undefined && feature.id.polygon != null) {
            //    cartesian = _this._viewer.scene.pickPosition(movement.position);
            //} else {
            //    cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            //}
            if (positions.length == 0) {
                positions.push(cartesian, cartesian);
            } else {
                if (positions.length > _this._points.length) {
                    positions.pop();
                    positions.push(cartesian);
                } else {
                    positions.push(cartesian, cartesian);
                }
            }

            //兼容移动端未触发移动事件
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive1(positions);
                }
                distance = _this._core.getSpaceDistance(positions, _this._cesium);
                //distance = distance + "千米";
            }
            we && (_this._viewer.entities.remove(we), we = undefined);
            //兼容移动端未触发移动事件

            var textDisance = distance;
            endcd = "总长：" + distance;
            //空间距离标签添加
            floatingPoint = _this._viewer.entities.add({
                name: '空间直线距离',
                // position: Cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180,cartographic.height),
                position: positions[positions.length - 1],
                point: {
                    pixelSize: 5,
                    color: coloroptions.point,
                    outlineColor: _this._cesium.Color.WHITE,
                    outlineWidth: 2,
                    clampToGround: true,
                },
                label: {
                    text: textDisance,
                    font: '16px 宋体',
                    fillColor: Cesium.Color.GOLD,
                    verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                    pixelOffset: new Cesium.Cartesian2(20, -20),
                    showBackground: true,
                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
                }
            });
            _this._tree.temporaryItem.obj.push(floatingPoint);
            _this._points.push(floatingPoint);
            Distance.spot.push(cartesian);
            Distance.distance.push(distance);
            Distance.label.push(floatingPoint);
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            _this.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = function (type) {
            tooltip.show(false);
            _this._tree && _this._tree.endtemporaryItem();
            _this.end = undefined;
            we && (_this._viewer.entities.remove(we), we = undefined, positions.pop()); //最后一个点无效
            _this._points[_this._points.length - 1] && (_this._points[_this._points.length - 1].label.text = endcd);
            _this._tree && _this._tree.handler.destroy(); //关闭事件句柄
            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0, "0");
            if (type === 'cancel') {
                _this.deleteObject();
                return;
            }
            positions.length < 2 && _this.deleteObject();
            if (methond != "" && methond != null) {
                if (typeof methond == 'function')
                    methond(Distance);
            }
        };

        var PolyLinePrimitive1 = (function () {
            function execute(positions) {
                this.options = {
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: coloroptions.polyline,
                        width: 3,
                        clampToGround: false
                    }
                };
                this.positions = positions;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                var polyline = _this._viewer.entities.add(this.options);
                _this.item = polyline;
                _this._tree.temporaryItem.obj.push(polyline);
                Distance.ployline.push(polyline);
                var id = _this._core.getuid();
                Distance.name = '新建空间距离' + id;
                ///工程树添加
                //var GroupID = 0;
                //if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                //    GroupID = tree.selectedItem.id;
                //var id = _this._core.getuid();
                //tree.insertGroupId({
                //    id: id,
                //    name: '新建空间距离' + id,
                //    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                //    type: 'polyline',
                //    item: _this
                //}, _this._core.isnull(GroupID) ? 0 : GroupID);
            };
            return execute;
        })();
        return this;
    };
    //水平距离测量
    Polyline.prototype.executeHorizontal = function (methond, parameter) {
        //水平距离测量
        // 取消双击事件-追踪该位置
        var _this = this;
        this._tree.removeHandler();
        this._tree.starttemporaryItem(this._viewer);
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positions = [];
        var poly = null;
        var distance = "0米";
        var cartesian = null;
        var _this = this;
        var floatingPoint;
        var endcd = "";
        var we;
        //导入tool提示框
        var tooltip = this._core.CreateTooltip();
        //隐藏选中容器标识
        //spot点坐标，distance距离，label距离对象数组
        var Distance = {
            spot: [],
            distance: [],
            label: [],
            ployline: []
        };
        var coloroptions = {
            "point": _this._cesium.Color.RED,
            "polyline": _this._cesium.Color.YELLOW
        };
        if (Object.keys(parameter).length > 0) {
            if (parameter.point != "" && parameter.point != undefined) {
                coloroptions.point = parameter.point;
            }
            if (parameter.polyline != "" && parameter.polyline != undefined) {
                coloroptions.polyline = parameter.polyline;
            }
        }
        this._tree.handler.setInputAction(function (movement) {
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            //tool创建
            if (positions.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束绘制！');
            }
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive1(positions);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                }
                distance = _this._core.getSpaceDistance(positions, _this._cesium);
                //distance = distance + "千米";
            }

            _this._viewer.entities.remove(we);
            we = _this._viewer.entities.add({
                name: '空间直线距离',
                // position: Cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180,cartographic.height),
                position: positions[positions.length - 1],
                label: {
                    text: "总长：" + distance,
                    font: '16px 宋体',
                    fillColor: Cesium.Color.GOLD,
                    verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                    pixelOffset: new Cesium.Cartesian2(20, -20),
                    showBackground: true,
                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
                }
            });
            _this._tree.temporaryItem.obj.push(we);
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this._tree.handler.setInputAction(function (movement) {
            _this._viewer.camera.getPickRay(movement.position);
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            SurfaceLine(cartesian);
            if (positions.length == 0) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);
            var textDisance = distance;
            endcd = "总长：" + distance;
            //空间距离标签添加
            floatingPoint = _this._viewer.entities.add({
                name: '空间直线距离',
                // position: Cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180,cartographic.height),
                position: positions[positions.length - 1],
                point: {
                    pixelSize: 5,
                    color: coloroptions.point,
                    outlineColor: _this._cesium.Color.WHITE,
                    outlineWidth: 2,
                    clampToGround: true,
                },
                label: {
                    text: textDisance,
                    font: '16px 宋体',
                    fillColor: Cesium.Color.GOLD,
                    verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                    pixelOffset: new Cesium.Cartesian2(20, -20),
                    showBackground: true,
                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
                }
            });
            _this._tree.temporaryItem.obj.push(floatingPoint);
            _this._points.push(floatingPoint);
            Distance.spot.push(cartesian);
            Distance.distance.push(distance);
            Distance.label.push(floatingPoint);
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //线段之间地表插值
        var SurfaceLine = function (cartographic) {
            polylineCartographic.push(cartographic);
            var terrainSamplePositions = [];
            if (polylineCartographic.length > 1) {
                var p1 = polylineCartographic[polylineCartographic.length - 2];
                var p2 = polylineCartographic[polylineCartographic.length - 1];
                var a = Math.abs(p1.longitude - p2.longitude) * 10000000;
                var b = Math.abs(p1.latitude - p2.latitude) * 10000000;
                if (a > b) b = a;
                var length = parseInt(b / 10);
                if (length > 1000) length = 1000;
                if (length < 2) length = 2;
                for (var i = 0; i < length; ++i) {
                    terrainSamplePositions.push(
                        new _this._cesium.Cartographic(
                            _this._cesium.Math.lerp(p1.longitude, p2.longitude, i / (length - 1)),
                            _this._cesium.Math.lerp(p1.latitude, p2.latitude, i / (length - 1))
                        )
                    );
                }

            } else {
                terrainSamplePositions = polylineCartographic;
            }
            if (terrainSamplePositions.length > 0) {
                for (var j = 0; j < terrainSamplePositions.length; j++) {
                    //地理坐标（弧度）转经纬度坐标
                    var cartographic = terrainSamplePositions[j];
                    var height = _this._viewer.scene.globe.getHeight(cartographic);
                    _this._cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180, height);
                    //console.log(point);
                }
            }
        };
        this._tree.handler.setInputAction(function (movement) {
            tooltip.show(false);
            _this._tree.endtemporaryItem();
            _this._viewer.entities.remove(we);
            _this._points[_this._points.length - 1].label.text = endcd;
            _this._tree.handler.destroy(); //关闭事件句柄
            positions.pop(); //最后一个点无效
            if (methond != "" && methond != null) {
                if (typeof methond == 'function')
                    methond(Distance);
            }

        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        var PolyLinePrimitive1 = (function () {
            function execute(positions) {
                this.options = {
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: coloroptions.polyline,
                        width: 3,
                        clampToGround: false
                    }
                };
                this.positions = positions;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                var polyline = _this._viewer.entities.add(this.options);
                _this.item = polyline;
                _this._tree.temporaryItem.obj.push(polyline);
                Distance.ployline.push(polyline);
            };
            return execute;
        })();
        return this;
    };
    //水平距离测量（包括地形）
    Polyline.prototype.executeHorizontals = function (methond, parameter) {
        this._tree.removeHandler();
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        this._tree.starttemporaryItem(this._viewer);
        var _this = this;
        var isDraw = false;
        var polylinePath = [];
        var endcd = "";
        var polylineCartographic = []; //弧度数组,地表插值用
        var polyline = undefined;
        var scene = _this._viewer.scene;
        var ellipsoid = scene.globe.ellipsoid;
        //spot点坐标，distance距离，label距离对象数组
        var Distance = {
            name: '',
            spot: [],
            distance: [],
            label: [],
            polyline: []
        };
        var coloroptions = {
            "point": _this._cesium.Color.RED,
            "polyline": _this._cesium.Color.YELLOW
        };
        if (Object.keys(parameter).length > 0) {
            if (parameter.point != "" && parameter.point != undefined) {
                coloroptions.point = parameter.point;
            }
            if (parameter.polyline != "" && parameter.polyline != undefined) {
                coloroptions.polyline = parameter.polyline;
            }
        }
        var billboards = new _this._cesium.BillboardCollection();
        scene.primitives.add(billboards);
        var WebMercatorProjection = new _this._cesium.WebMercatorProjection();
        this._tree.handler = new _this._cesium.ScreenSpaceEventHandler(scene.canvas);
        //导入tool提示框
        var tooltip = this._core.CreateTooltip();
        var distancePositionArr = [];
        var we;
        //隐藏选中容器标识
        isDraw = true;
        this._tree.handler.setInputAction(function (movement) {
            //新增部分
            var position1;
            var cartographic;
            if (polylinePath.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束绘制！');
            }

            position1 = _this._getPosition.getMousePosition(movement, Distance.polyline.concat(Distance.label));
            if (!position1) {
                return;
            }
            cartographic = _this._cesium.Ellipsoid.WGS84.cartesianToCartographic(position1);
            if (cartographic) {
                //地理坐标（弧度）转经纬度坐标
                var point = position1;
                if (isDraw) {
                    if (polylinePath.length < 1) {
                        return;
                    }
                    if (!_this._cesium.defined(polyline)) {
                        polyline = new CreatePolyline(polylinePath, _this._cesium);
                    } else {
                        polyline.path.pop();
                        polyline.path.push(point);
                        distancePositionArr.pop();
                        distancePositionArr.push(point);
                    }

                    var distance = getDistance(distancePositionArr);
                    we && (_this._viewer.entities.remove(we), we = undefined);
                    we = _this._viewer.entities.add({
                        name: '空间直线距离',
                        position: polyline.path[polyline.path.length - 1],
                        label: {
                            text: "总长：" + distance,
                            font: '16px 宋体',
                            fillColor: Cesium.Color.GOLD,
                            verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                            pixelOffset: new Cesium.Cartesian2(20, -20),
                            showBackground: true,
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        }
                    });
                }
            }

        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        //线段之间地表插值
        var SurfaceLine = function (cartographic) {
            polylineCartographic.push(cartographic);
            var terrainSamplePositions = [];
            if (polylineCartographic.length > 1) {
                var p1 = polylineCartographic[polylineCartographic.length - 2];
                var p2 = polylineCartographic[polylineCartographic.length - 1];
                var a = Math.abs(p1.longitude - p2.longitude) * 10000000;
                var b = Math.abs(p1.latitude - p2.latitude) * 10000000;
                if (a > b) b = a;
                var length = parseInt(b / 10);
                if (length > 1000) length = 1000;
                if (length < 2) length = 2;
                for (var i = 0; i < length; ++i) {
                    terrainSamplePositions.push(
                        new _this._cesium.Cartographic(
                            _this._cesium.Math.lerp(p1.longitude, p2.longitude, i / (length - 1)),
                            _this._cesium.Math.lerp(p1.latitude, p2.latitude, i / (length - 1))
                        )
                    );
                }
                terrainSamplePositions.push(p2.clone());

            } else {
                terrainSamplePositions = polylineCartographic;
            }
            if (terrainSamplePositions.length > 0) {
                for (var j = 0; j < terrainSamplePositions.length; j++) {
                    //地理坐标（弧度）转经纬度坐标
                    var cartographic = terrainSamplePositions[j];
                    var height = _this._viewer.scene.globe.getHeight(cartographic);
                    var point = _this._cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, height);
                    distancePositionArr.push(point);
                }
            }
        };

        this._tree.handler.setInputAction(function (movement) {
            var position1 = _this._getPosition.getMousePosition(movement, Distance.polyline.concat(Distance.label));
            var cartographic;

            if (position1)
                cartographic = _this._cesium.Ellipsoid.WGS84.cartesianToCartographic(position1);
            if (cartographic) {
                //地理坐标（弧度）转经纬度坐标
                var point = position1;
                if (isDraw) {
                    if (distancePositionArr.length > 0) {
                        distancePositionArr.pop();
                    }
                    SurfaceLine(cartographic);

                    if (polylinePath.length === 0) {
                        polylinePath.push(point, point);
                    } else {
                        polylinePath.push(point);
                    }
                    if (!_this._cesium.defined(polyline)) {
                        polyline = new CreatePolyline(polylinePath, _this._cesium);
                    }
                    we && (_this._viewer.entities.remove(we), we = undefined);

                    var text = "0米";
                    if (polyline) {
                        text = getDistance(distancePositionArr);
                    }
                    distancePositionArr.push(point);

                    endcd = '总长：' + text;
                    Distance.spot.push(point);
                    Distance.distance.push(text);
                    var objsd = _this._viewer.entities.add({
                        position: point,
                        point: {
                            pixelSize: 5,
                            color: coloroptions.point,
                            outlineColor: _this._cesium.Color.WHITE,
                            outlineWidth: 1,
                            clampToGround: true,
                        },
                        label: {
                            text: text,
                            font: '16px 宋体',
                            fillColor: Cesium.Color.GOLD,
                            verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                            pixelOffset: new Cesium.Cartesian2(20, -20),
                            showBackground: true,
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        }
                    });
                    Distance.label.push(objsd);
                    _this._points.push(objsd);
                }
            }

        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this._tree.handler.setInputAction(function () {
            _this.end();
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = function (type) {
            _this._tre && _this._tree.endtemporaryItem();
            we && _this._viewer.entities.remove(we);
            _this._points[_this._points.length - 1] && (_this._points[_this._points.length - 1].label.text = endcd);
            _this._tree && _this._tree.handler.destroy();
            _this.end = undefined;

            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0, "0");
            polylinePath.pop();
            tooltip.show(false);

            if (type === 'cancel') {
                _this.deleteObject();
                return;
            }
            polylinePath.length < 2 && _this.deleteObject();
            if (methond != "" && methond != null) {
                if (typeof methond == 'function')
                    methond(Distance);
            }
            //关闭按钮执行事件
        };

        //获取线段距离
        var getDistance = function (path) {
            var Len = 0;
            var distance = 0 + '米';
            var cg, cs, x1, y1, x2, y2;
            for (var i = 0; i < path.length - 1; i++) {
                cg = ellipsoid.cartesianToCartographic(path[i]);
                cs = WebMercatorProjection.project(cg);
                x1 = cs.x;
                y1 = cs.y;
                cg = ellipsoid.cartesianToCartographic(path[i + 1]);
                cs = WebMercatorProjection.project(cg);
                x2 = cs.x;
                y2 = cs.y;
                Len = Len + Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
            }
            if (Len > 0) {
                distance = Len.toFixed(2) + '米';
            }
            if (Len / 1000 >= 1) {
                distance = (Len / 1000).toFixed(2) + '千米';
            }
            return distance;
        };
        var CreatePolyline = (function () {
            function execute(positons, cesium) {
                if (!_this._cesium.defined(positons)) {
                    throw new _this._cesium.DeveloperError('positions is required!');
                }
                if (positons.length < 2) {
                    throw new _this._cesium.DeveloperError('positions 的长度必须大于等于2');
                }
                var material = _this._cesium.Material.fromType(_this._cesium.Material.ColorType);
                material.uniforms.color = new _this._cesium.Color(1.0, 1.0, 0.0, 0.5);
                this.options = {
                    name: "直线",
                    polyline: {
                        show: true,
                        positions: [],
                        material: coloroptions.polyline,
                        width: 3,
                        clampToGround: true,
                    }
                };
                this.path = positons;
                this._init(_this._cesium);
            }

            execute.prototype._init = function (cesium) {
                var that = this;
                var positionCBP = function () {
                    return that.path;
                };
                this.options.polyline.positions = new _this._cesium.CallbackProperty(positionCBP, false);
                this.lineEntity = _this._viewer.entities.add(this.options);
                _this.item = this.lineEntity;
                Distance.polyline.push(this.lineEntity);
                var id = _this._core.getuid();
                Distance.name = '新建水平距离' + id;
            };
            return execute;
        })();
        return this;
    };
    //获取高度差
    Polyline.prototype.getHeight = function (_positions) {
        var cartographic = this._cesium.Cartographic.fromCartesian(_positions[0]);
        var cartographic1 = this._cesium.Cartographic.fromCartesian(_positions[1]);
        var height_temp = cartographic1.height - cartographic.height;
        if (height_temp < 1000) {
            height_temp = height_temp.toFixed(2) + '米';
        } else {
            height_temp = height_temp / 1000;
            height_temp = height_temp.toFixed(2) + '千米';
        }
        return height_temp;
    };
    //高度测量
    Polyline.prototype.executeHeight = function (methond) {
        var _this = this;
        this._tree.starttemporaryItem(this._viewer);
        this._tree.removeHandler();
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positions = [];
        var poly = null;
        var height = 0;
        //导入tool提示框
        var tooltip = this._core.CreateTooltip();
        //隐藏选中容器标识
        var cartesian = null;
        this._tree.handler.setInputAction(function (movement) {
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            if (positions.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束绘制！');
            }
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive3(positions);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                }
                if (positions.lenght > 1) {
                    height = _this._core.getHeight(positions, _this._cesium);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this._tree.handler.setInputAction(function (movement) {
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            var ds = height + "米";
            if (positions.length == 0) {
                positions.push(cartesian.clone());
                positions.push(cartesian);
                var floatingPoint_g = _this._viewer.entities.add({
                    name: '高度',
                    position: positions[0],
                    point: {
                        pixelSize: 5,
                        color: _this._cesium.Color.RED,
                        outlineColor: _this._cesium.Color.WHITE,
                        outlineWidth: 2,
                        clampToGround: true,
                        heightReference: _this._cesium.HeightReference.none
                    },
                    label: {
                        text: ds,
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -20),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                });
                _this._tree.temporaryItem.obj.push(floatingPoint_g);
                _this._points.push(floatingPoint_g);
            } else if (positions.length >= 1) {
                _this._tree.endtemporaryItem();
                if (methond != "" && methond != null) {
                    if (typeof methond == 'function')
                        methond(positions);
                }
            }

        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            _this._tree.handler.destroy();
            var textDisance = height + "米";
            var point1cartographic = _this._cesium.Cartographic.fromCartesian(positions[0]);
            var point2cartographic = _this._cesium.Cartographic.fromCartesian(positions[1]);
            var point_temp = _this._cesium.Cartesian3.fromDegrees(cesium.Math.toDegrees(point1cartographic.longitude), _this._cesium.Math.toDegrees(point1cartographic.latitude), point2cartographic.height);
            //回调函数及方法
            var fg = _this._viewer.entities.add({
                name: '直线距离',
                position: point_temp,
                point: {
                    pixelSize: 5,
                    color: _this._cesium.Color.RED,
                    outlineColor: _this._cesium.Color.WHITE,
                    outlineWidth: 2,
                    clampToGround: true,
                    heightReference: _this._cesium.HeightReference.none
                },
                label: {
                    text: textDisance,
                    font: '16px 宋体',
                    fillColor: Cesium.Color.GOLD,
                    verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                    pixelOffset: new Cesium.Cartesian2(20, -20),
                    showBackground: true,
                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
                }
            });
            _this._tree.temporaryItem.obj.push(fg);
            _this._points.push(fg);
        }, this._cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
        var PolyLinePrimitive3 = (function () {
            function execute(positions) {
                this.options = {
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.YELLOW,
                        clampToGround: true,
                        width: 3
                    },
                    ellipse: {
                        show: false,
                        material: _this._cesium.Color.GREEN.withAlpha(0.5),
                        clampToGround: true,
                        outline: true // height must be set for outline to display
                    }
                };
                this.positions = positions;
                this._init3();
            }

            execute.prototype._init3 = function () {
                var _self = this;
                var _update = function () {
                    var temp_position = [];
                    temp_position.push(_self.positions[0]);
                    var point1cartographic = _this._cesium.Cartographic.fromCartesian(_self.positions[0]);
                    try {
                        var point2cartographic = _this._cesium.Cartographic.fromCartesian(_self.positions[1]);
                    } catch (ex) {
                        return;
                    }
                    var point_temp = _this._cesium.Cartesian3.fromDegrees(_this._cesium.Math.toDegrees(point1cartographic.longitude), _this._cesium.Math.toDegrees(point1cartographic.latitude), point2cartographic.height);
                    temp_position.push(point_temp);
                    return temp_position;
                };
                //var _update_ellipse = function () {
                //    return _self.positions[0];
                //};
                //var _semiMinorAxis = function () {
                //    var point1cartographic = _this._cesium.Cartographic.fromCartesian(_self.positions[0]);
                //    var point2cartographic = _this._cesium.Cartographic.fromCartesian(_self.positions[1]);
                //    /**根据经纬度计算出距离**/
                //    var geodesic = new _this._cesium.EllipsoidGeodesic();
                //    geodesic.setEndPoints(point1cartographic, point2cartographic);
                //    var s = geodesic.surfaceDistance;
                //    return s;
                //};
                //var _height = function () {
                //    if (_self.positions.lenght > 1) {
                //        var height_temp = _this._core.getHeight(_self.positions, _this._cesium);
                //    }
                //    return height_temp;
                //};
                //实时更新polyline.positions
                //if (this.positions.length >= 2 && this.positions[1] != null && this.positions[1].length != 0) {
                //    this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                //}
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                //this.options.position = new _this._cesium.CallbackProperty(_update_ellipse, false);
                //this.options.ellipse.height = new _this._cesium.CallbackProperty(_height, false);
                var polyline = _this._viewer.entities.add(this.options);
                _this.item = polyline;
                _this._tree.temporaryItem.obj.push(polyline);
                ///工程树添加
                //var GroupID = 0;
                //if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                //    GroupID = tree.selectedItem.id;
                //var id = _this._core.getuid();
                //tree.insertGroupId({
                //    id: id,
                //    name: '新建高度' + id,
                //    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                //    type: 'polyline',
                //    item: _this
                //}, _this._core.isnull(GroupID) ? 0 : GroupID);
            };
            return execute;
        })();
        return this;
    };
    //模仿te创建高度测量
    Polyline.prototype.executeHeightTe = function (methond) {
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        this._tree.removeHandler();
        this._tree.starttemporaryItem(this._viewer);
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positionsTriangle = [];
        var tempPoints; //保存直角点
        var poly = null;
        var cartesian = null;
        var _this = this;
        var Distance = {
            name: '',
            spot: [],
            kjdistance: "",
            spdistance: "",
            gddistance: "",
            point: [],
            polyline: []
        };
        var isAdsorption = false;
        var tooltip = this._core.CreateTooltip();
        this._tree.handler.setInputAction(function (movement) {
            if (positionsTriangle.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '中键开启/关闭吸附,右键结束！');
            }
            cartesian = _this._getPosition.getMousePosition(movement, Distance.polyline.concat(Distance.point), 0, isAdsorption);
            if (!cartesian) {
                return;
            }
            if (positionsTriangle.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolylinePrimitive(positionsTriangle);
                    var floatingPoint_end = _this._viewer.entities.add({
                        // parent: measure_entities,
                        name: '高度测量',
                        position: new _this._cesium.CallbackProperty(function () {
                            return positionsTriangle[1];
                        }, false),
                        point: {
                            pixelSize: 5,
                            color: _this._cesium.Color.RED,
                            outlineColor: _this._cesium.Color.WHITE,
                            outlineWidth: 2,
                            heightReference: _this._cesium.HeightReference.none,
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    _this._tree.temporaryItem.obj.push(floatingPoint_end);
                    Distance.point.push(floatingPoint_end);
                    _this._points.push(floatingPoint_end);
                    tempPoints = point_conf(positionsTriangle);
                    //在三维场景中添加线
                    var dx = _this._viewer.entities.add({
                        // parent: measure_entities,
                        position: new _this._cesium.CallbackProperty(function () {
                            return _this._cesium.Cartesian3.midpoint(tempPoints.eq_lon_lat[0], tempPoints.eq_lon_lat[1], new _this._cesium.Cartesian3());
                        }, false),
                        name: '等经纬度',
                        polyline: {
                            show: true,
                            positions: new _this._cesium.CallbackProperty(function () {
                                return tempPoints.eq_lon_lat;
                            }, false),
                            // material: new _this._cesium.PolylineDashMaterialProperty({
                            //     color: _this._cesium.Color.RED
                            // }),
                            material: _this._cesium.Color.GOLD,
                            width: 2
                        },
                        label: {
                            text: new _this._cesium.CallbackProperty(function () {
                                var textDistance = _this.getHeight(tempPoints.eq_lon_lat);
                                var dw = "米";
                                var Distancexp = textDistance;
                                if (textDistance.indexOf("千米") !== -1) {
                                    dw = "千米";
                                    Distancexp = textDistance.replace("千米", "");
                                } else {
                                    Distancexp = textDistance.replace("米", "");
                                }
                                var Distancexp = parseFloat(Distancexp);
                                if (Distancexp < 0) {
                                    Distancexp = Math.abs(Distancexp);
                                    textDistance = Distancexp + dw;
                                } else {
                                    textDistance = Distancexp + dw;
                                }
                                textDistance = "高度：" + textDistance;
                                Distance.gddistance = textDistance;
                                return textDistance;
                            }, false),
                            font: '16px 宋体',
                            fillColor: Cesium.Color.GOLD,
                            verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                            pixelOffset: new Cesium.Cartesian2(20, -20),
                            showBackground: true,
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        }
                    });
                    Distance.polyline.push(dx);
                    _this._polylines.push(dx);
                    //textDistance = getDistance(tempPositions2) + "千米";
                    var la = _this._viewer.entities.add({
                        //parent: measure_entities,
                        position: new _this._cesium.CallbackProperty(function () {
                            return _this._cesium.Cartesian3.midpoint(tempPoints.eq_height[0], tempPoints.eq_height[1], new _this._cesium.Cartesian3());
                        }, false),
                        name: '等高度直线',
                        polyline: {
                            show: true,
                            positions: new _this._cesium.CallbackProperty(function () {
                                return tempPoints.eq_height;
                            }, false),
                            // material: new _this._cesium.PolylineDashMaterialProperty({
                            //     color: _this._cesium.Color.RED
                            // }),
                            material: _this._cesium.Color.GOLD,
                            width: 2
                        },
                        label: {
                            text: new _this._cesium.CallbackProperty(function () {
                                var textDistance = _this._core.getHorizontalDistance(tempPoints.eq_height, _this._cesium);
                                textDistance = "水平距离：" + textDistance;
                                Distance.spdistance = textDistance;
                                return textDistance;
                            }, false),
                            font: '16px 宋体',
                            fillColor: Cesium.Color.GOLD,
                            verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                            pixelOffset: new Cesium.Cartesian2(20, -20),
                            showBackground: true,
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        }
                    });
                    Distance.polyline.push(la);
                    _this._polylines.push(la);
                } else {
                    positionsTriangle.pop();
                    positionsTriangle.push(cartesian.clone());
                    tempPoints = point_conf(positionsTriangle);

                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this._tree.handler.setInputAction(function (movement) {
            // cartesian = viewer.scene.camera.pickEllipsoid(movement.position, viewer.scene.globe.ellipsoid);
            cartesian = _this._getPosition.getMousePosition(movement, Distance.polyline.concat(Distance.point), 0, isAdsorption);
            if (!cartesian) {
                return;
            }
            if (positionsTriangle.length == 0) {
                positionsTriangle.push(cartesian.clone());
                positionsTriangle.push(cartesian.clone());
                tempPoints = point_conf(positionsTriangle);
                var floatingPoint_first = _this._viewer.entities.add({
                    // parent: measure_entities,
                    name: '高度测量',
                    position: positionsTriangle[0],
                    point: {
                        pixelSize: 5,
                        color: _this._cesium.Color.RED,
                        outlineColor: _this._cesium.Color.WHITE,
                        outlineWidth: 2,
                        heightReference: _this._cesium.HeightReference.none,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY
                    }
                });
                _this._tree.temporaryItem.obj.push(floatingPoint_first);
                Distance.point.push(floatingPoint_first);
                _this._points.push(floatingPoint_first);
            } else {
                //兼容移动端鼠标移动事件未触发
                if (positionsTriangle.length >= 2) {
                    if (!_this._cesium.defined(poly)) {
                        poly = new PolylinePrimitive(positionsTriangle);
                        var floatingPoint_end = _this._viewer.entities.add({
                            // parent: measure_entities,
                            name: '高度测量',
                            position: new _this._cesium.CallbackProperty(function () {
                                return positionsTriangle[1];
                            }, false),
                            point: {
                                pixelSize: 5,
                                color: _this._cesium.Color.RED,
                                outlineColor: _this._cesium.Color.WHITE,
                                outlineWidth: 2,
                                heightReference: _this._cesium.HeightReference.none,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY
                            }
                        });
                        _this._tree.temporaryItem.obj.push(floatingPoint_end);
                        Distance.point.push(floatingPoint_end);
                        _this._points.push(floatingPoint_end);
                        tempPoints = point_conf(positionsTriangle);
                        //在三维场景中添加线
                        var dx = _this._viewer.entities.add({
                            // parent: measure_entities,
                            position: new _this._cesium.CallbackProperty(function () {
                                return _this._cesium.Cartesian3.midpoint(tempPoints.eq_lon_lat[0], tempPoints.eq_lon_lat[1], new _this._cesium.Cartesian3());
                            }, false),
                            name: '等经纬度',
                            polyline: {
                                show: true,
                                positions: new _this._cesium.CallbackProperty(function () {
                                    return tempPoints.eq_lon_lat;
                                }, false),
                                // material: new _this._cesium.PolylineDashMaterialProperty({
                                //     color: _this._cesium.Color.RED
                                // }),
                                material: _this._cesium.Color.GOLD,
                                width: 2
                            },
                            label: {
                                text: new _this._cesium.CallbackProperty(function () {
                                    var textDistance = _this.getHeight(tempPoints.eq_lon_lat);
                                    var dw = "米";
                                    var Distancexp = textDistance;
                                    if (textDistance.indexOf("千米") !== -1) {
                                        dw = "千米";
                                        Distancexp = textDistance.replace("千米", "");
                                    } else {
                                        Distancexp = textDistance.replace("米", "");
                                    }
                                    var Distancexp = parseFloat(Distancexp);
                                    if (Distancexp < 0) {
                                        Distancexp = Math.abs(Distancexp);
                                        textDistance = Distancexp + dw;
                                    } else {
                                        textDistance = Distancexp + dw;
                                    }
                                    textDistance = "高度：" + textDistance;
                                    Distance.gddistance = textDistance;
                                    return textDistance;
                                }, false),
                                font: '16px 宋体',
                                fillColor: Cesium.Color.GOLD,
                                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                                pixelOffset: new Cesium.Cartesian2(20, -20),
                                showBackground: true,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            }
                        });
                        Distance.polyline.push(dx);
                        _this._polylines.push(dx);
                        //textDistance = getDistance(tempPositions2) + "千米";
                        var la = _this._viewer.entities.add({
                            //parent: measure_entities,
                            position: new _this._cesium.CallbackProperty(function () {
                                return _this._cesium.Cartesian3.midpoint(tempPoints.eq_height[0], tempPoints.eq_height[1], new _this._cesium.Cartesian3());
                            }, false),
                            name: '等高度直线',
                            polyline: {
                                show: true,
                                positions: new _this._cesium.CallbackProperty(function () {
                                    return tempPoints.eq_height;
                                }, false),
                                // material: new _this._cesium.PolylineDashMaterialProperty({
                                //     color: _this._cesium.Color.RED
                                // }),
                                material: _this._cesium.Color.GOLD,
                                width: 2
                            },
                            label: {
                                text: new _this._cesium.CallbackProperty(function () {
                                    var textDistance = _this._core.getHorizontalDistance(tempPoints.eq_height, _this._cesium);
                                    textDistance = "水平距离：" + textDistance;
                                    Distance.spdistance = textDistance;
                                    return textDistance;
                                }, false),
                                font: '16px 宋体',
                                fillColor: Cesium.Color.GOLD,
                                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                                pixelOffset: new Cesium.Cartesian2(20, -20),
                                showBackground: true,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            }
                        });
                        Distance.polyline.push(la);
                        _this._polylines.push(la);
                    } else {
                        positionsTriangle.pop();
                        positionsTriangle.push(cartesian.clone());
                        tempPoints = point_conf(positionsTriangle);
                    }
                }
            }
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            isAdsorption = !isAdsorption;
        }, _this._cesium.ScreenSpaceEventType.MIDDLE_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            _this.end();
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            _this.end();
        }, _this._cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);

        this.end = function (type) {
            _this._tree.handler.destroy();
            tooltip.show(false);
            _this.end = undefined;
            _this._tree.endtemporaryItem();
            _this._core.mouse(_this._viewer.container, 0, "0");
            // handler_g.destroy();//关闭事件句柄	
            if (type === 'cancel') {
                _this.deleteObject();
                return;
            }
            if (methond != "" && methond != null) {
                if (typeof methond == 'function')
                    methond(Distance);
            }
        };

        function point_conf(_positions) {
            var cartographic = _this._cesium.Cartographic.fromCartesian(_positions[0]);
            var cartographic1 = _this._cesium.Cartographic.fromCartesian(_positions[1]);
            // var height_temp = cartographic1.height - cartographic.height;
            cartographic1.height - (cartographic1.height - cartographic.height);
            //var point_temp = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(point1cartographic.longitude), Cesium.Math.toDegrees(point1cartographic.latitude), point2cartographic.height);

            var position, eq_height, eq_lon_lat;
            if (cartographic1.height - cartographic.height > 0) {
                position = _this._cesium.Cartesian3.fromDegrees(_this._cesium.Math.toDegrees(cartographic.longitude), _this._cesium.Math.toDegrees(cartographic.latitude), cartographic1.height);
                eq_height = [_positions[1], position];
                eq_lon_lat = [_positions[0], position];
            } else {
                position = _this._cesium.Cartesian3.fromDegrees(_this._cesium.Math.toDegrees(cartographic1.longitude), _this._cesium.Math.toDegrees(cartographic1.latitude), cartographic.height);
                eq_height = [_positions[0], position];
                eq_lon_lat = [_positions[1], position];
            }
            // return height_temp.toFixed(2);
            return {
                new: position,
                eq_height: eq_height,
                eq_lon_lat: eq_lon_lat
            };
        }

        var PolylinePrimitive = (function () {
            function Polyline(positions) {
                this.options = {
                    // parent: measure_entities,
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.GOLD,
                        width: 2
                    },
                    label: {
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, 20),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                };

                this.positions = positions;
                this._init();
            }

            //空间两点距离计算函数
            function getSpaceDistance1(_positions) {
                var point1cartographic = _this._cesium.Cartographic.fromCartesian(_positions[0]);
                var point2cartographic = _this._cesium.Cartographic.fromCartesian(_positions[1]);
                /**根据经纬度计算出距离**/
                var geodesic = new _this._cesium.EllipsoidGeodesic();
                geodesic.setEndPoints(point1cartographic, point2cartographic);
                var s = geodesic.surfaceDistance;
                //console.log(Math.sqrt(Math.pow(distance, 2) + Math.pow(endheight, 2)));
                //返回两点之间的距离
                s = Math.sqrt(Math.pow(s, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2));
                if (s >= 1000) {
                    s = (s / 1000).toFixed(2) + "千米";
                } else {
                    s = (s.toFixed(2)) + "米";
                }
                return s;
            }

            Polyline.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                var _update_label = function () {
                    return _this._cesium.Cartesian3.midpoint(tempPoints.eq_height[0], tempPoints.eq_height[1], new _this._cesium.Cartesian3());
                };
                var _text = function () {
                    var text_temp = getSpaceDistance1(_self.positions);
                    text_temp = "空间距离：" + text_temp;
                    Distance.kjdistance = text_temp;
                    return text_temp;
                };
                //实时更新polygon.hierarchy
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                this.options.position = new _this._cesium.CallbackProperty(_update_label, false);
                this.options.label.text = new _this._cesium.CallbackProperty(_text, false);
                var di = _this._viewer.entities.add(this.options);
                _this.item = di;
                _this._tree.temporaryItem.obj.push(di);
                Distance.polyline.push(di);
                var id = _this._core.getuid();
                Distance.name = '新建垂直高度' + id;
            };
            return Polyline;
        })();
        return this;
    };
    //模仿te创建高度测量
    Polyline.prototype.executeHeightTe1 = function (methond) {
        this._tree.removeHandler();
        this._tree.starttemporaryItem(this._viewer);
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positionsTriangle = [];
        var poly = null;
        ///水平线
        var poly1 = null;
        ///垂直线
        var poly2 = null;

        var cartesian = null;
        var _this = this;
        var Distance = {
            spot: [],
            kjdistance: "",
            spdistance: "",
            gddistance: "",
            point: [],
            polyline: []
        };
        var tooltip = this._core.CreateTooltip();
        this._tree.handler.setInputAction(function (movement) {
            if (positionsTriangle.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束绘制！');
            }
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            //cartesian = viewer.scene.camera.pickEllipsoid(movement.endPosition, viewer.scene.globe.ellipsoid);
            if (positionsTriangle.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolylinePrimitive(positionsTriangle);
                } else {
                    positionsTriangle.pop();
                    positionsTriangle.push(cartesian.clone());
                    point_conf(positionsTriangle);

                }

                ///水平线
                if (!_this._cesium.define(poly1)) {
                    poly1 = new PolylinePrimitive1(positionsTriangle);
                }
                ///垂直线
                if (!_this._cesium.define(poly2)) {
                    poly2 = new PolylinePrimitive2(positionsTriangle);
                }

            }

        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this._tree.handler.setInputAction(function (movement) {
            // cartesian = viewer.scene.camera.pickEllipsoid(movement.position, viewer.scene.globe.ellipsoid);
            if (positionsTriangle.length == 0) {
                cartesian = _this._getPosition.getMousePosition(movement);
                if (!cartesian) {
                    return;
                }
                positionsTriangle.push(cartesian.clone());
                positionsTriangle.push(cartesian.clone());

                point_conf(positionsTriangle);

                var floatingPoint_g = _this._viewer.entities.add({
                    // parent: measure_entities,
                    name: '高度测量',
                    position: positionsTriangle[0],
                    point: {
                        pixelSize: 5,
                        color: _this._cesium.Color.RED,
                        outlineColor: _this._cesium.Color.WHITE,
                        outlineWidth: 2,
                        heightReference: _this._cesium.HeightReference.none
                    }
                });
                _this._tree.temporaryItem.obj.push(floatingPoint_g);
                Distance.point.push(floatingPoint_g);
            }
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            _this._tree.handler.destroy();
            tooltip.show(false);
            _this._tree.endtemporaryItem();
            // // handler_g.destroy();//关闭事件句柄		
            // tempPoints = point_conf(positionsTriangle);
            // //在三维场景中添加线
            // var tempPositions1 = [];
            // var tempPositions2 = [];
            // tempPositions1.push(positionsTriangle[0].clone());
            // tempPositions1.push(tempPoints.clone());
            // //var textDistance = '未知' + "米";
            // var textDistance = getHeight(tempPositions1) + "米";
            // textDistance = "高度：" + textDistance;
            // Distance.gddistance = textDistance;
            // var dx = _this._viewer.entities.add({
            //     // parent: measure_entities,
            //     name: '等经纬度',
            //     position: tempPositions1[0].clone(),
            //     polyline: {
            //         show: true,
            //         positions: tempPositions1,
            //         // material: new _this._cesium.PolylineDashMaterialProperty({
            //         //     color: _this._cesium.Color.RED
            //         // }),
            //         material: _this._cesium.Color.GOLD,
            //         width: 2
            //     },
            //     label: {
            //         text: textDistance,
            //         font: '18px sans-serif',
            //         fillColor: _this._cesium.Color.GOLD,
            //         style: _this._cesium.LabelStyle.FILL_AND_OUTLINE,
            //         outlineWidth: 2,
            //         verticalOrigin: _this._cesium.VerticalOrigin.BOTTOM,
            //         pixelOffset: new _this._cesium.Cartesian2(20, -20)
            //     }
            // });
            // Distance.polyline.push(dx);
            // tempPositions2.push(tempPoints.clone());
            // tempPositions2.push(positionsTriangle[1].clone());
            // //textDistance = getDistance(tempPositions2) + "千米";
            // textDistance = _this._core.getHorizontalDistance(tempPositions2, _this._cesium) * 1000 + "米";
            // textDistance = "水平距离：" + textDistance;
            // Distance.spdistance = textDistance;
            // var la = _this._viewer.entities.add({
            //     //parent: measure_entities,
            //     name: '等高度直线',
            //     position: tempPositions2[0].clone(),
            //     polyline: {
            //         show: true,
            //         positions: tempPositions2,
            //         // material: new _this._cesium.PolylineDashMaterialProperty({
            //         //     color: _this._cesium.Color.RED
            //         // }),
            //         material: _this._cesium.Color.GOLD,
            //         width: 2
            //     },
            //     label: {
            //         text: textDistance,
            //         font: '18px sans-serif',
            //         fillColor: _this._cesium.Color.GOLD,
            //         style: _this._cesium.LabelStyle.FILL_AND_OUTLINE,
            //         outlineWidth: 2,
            //         verticalOrigin: _this._cesium.VerticalOrigin.BOTTOM,
            //         pixelOffset: new _this._cesium.Cartesian2(60, -20)
            //     }
            // });
            // Distance.polyline.push(la);
            if (methond != "" && methond != null) {
                if (typeof methond == 'function')
                    methond(Distance);
            }
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        function point_conf(_positions) {
            var cartographic = _this._cesium.Cartographic.fromCartesian(_positions[0]);
            var cartographic1 = _this._cesium.Cartographic.fromCartesian(_positions[1]);
            // var height_temp = cartographic1.height - cartographic.height;
            cartographic1.height - (cartographic1.height - cartographic.height);
            //var point_temp = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(point1cartographic.longitude), Cesium.Math.toDegrees(point1cartographic.latitude), point2cartographic.height);

            var position = _this._cesium.Cartesian3.fromDegrees(_this._cesium.Math.toDegrees(cartographic.longitude), _this._cesium.Math.toDegrees(cartographic.latitude), cartographic1.height);
            // return height_temp.toFixed(2);
            return position;
        }

        var PolylinePrimitive = (function () {
            function Polyline(positions) {
                this.options = {
                    // parent: measure_entities,
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.GOLD,
                        width: 2
                    },
                    label: {
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -40),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                };

                this.positions = positions;
                this._init();
            }

            //空间两点距离计算函数
            function getSpaceDistance1(_positions) {
                var point1cartographic = _this._cesium.Cartographic.fromCartesian(_positions[0]);
                var point2cartographic = _this._cesium.Cartographic.fromCartesian(_positions[1]);
                /**根据经纬度计算出距离**/
                var geodesic = new _this._cesium.EllipsoidGeodesic();
                geodesic.setEndPoints(point1cartographic, point2cartographic);
                var s = geodesic.surfaceDistance;
                //console.log(Math.sqrt(Math.pow(distance, 2) + Math.pow(endheight, 2)));
                //返回两点之间的距离
                s = Math.sqrt(Math.pow(s, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2));
                if (s >= 1000) {
                    s = (s / 1000).toFixed(2) + "千米";
                } else {
                    s = (s.toFixed(2)) + "米";
                }
                return s;
            }

            Polyline.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                var _update_label = function () {
                    return _self.positions[1].clone();
                };
                var _text = function () {
                    var text_temp = getSpaceDistance1(_self.positions);
                    text_temp = "空间距离：" + text_temp;
                    Distance.kjdistance = text_temp;
                    return text_temp;
                };
                //实时更新polygon.hierarchy
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                this.options.position = new _this._cesium.CallbackProperty(_update_label, false);
                this.options.label.text = new _this._cesium.CallbackProperty(_text, false);
                var di = _this._viewer.entities.add(this.options);
                _this._tree.temporaryItem.obj.push(di);
                Distance.polyline.push(di);
            };
            return Polyline;
        })();

        ///水平线
        var PolylinePrimitive1 = (function () {
            function Polyline(positions) {
                this.options = {
                    // parent: measure_entities,
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.GOLD,
                        width: 2
                    },
                    label: {
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -40),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                };

                this.positions = positions;
                this._init();
            }

            //空间两点距离计算函数
            function getSpaceDistance1(_positions) {
                var point1cartographic = _this._cesium.Cartographic.fromCartesian(_positions[0]);
                var point2cartographic = _this._cesium.Cartographic.fromCartesian(_positions[1]);
                /**根据经纬度计算出距离**/
                var geodesic = new _this._cesium.EllipsoidGeodesic();
                geodesic.setEndPoints(point1cartographic, point2cartographic);
                var s = geodesic.surfaceDistance;
                //console.log(Math.sqrt(Math.pow(distance, 2) + Math.pow(endheight, 2)));
                //返回两点之间的距离
                s = Math.sqrt(Math.pow(s, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2));
                if (s >= 1000) {
                    s = (s / 1000).toFixed(2) + "千米";
                } else {
                    s = (s.toFixed(2)) + "米";
                }
                return s;
            }

            Polyline.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                var _update_label = function () {
                    return _self.positions[1].clone();
                };
                var _text = function () {
                    var text_temp = getSpaceDistance1(_self.positions);
                    text_temp = "空间距离：" + text_temp;
                    Distance.kjdistance = text_temp;
                    return text_temp;
                };
                //实时更新polygon.hierarchy
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                this.options.position = new _this._cesium.CallbackProperty(_update_label, false);
                this.options.label.text = new _this._cesium.CallbackProperty(_text, false);
                var di = _this._viewer.entities.add(this.options);
                _this._tree.temporaryItem.obj.push(di);
                Distance.polyline.push(di);
            };
            return Polyline;
        })();

        ///垂直线
        var PolylinePrimitive2 = (function () {
            function Polyline(positions) {
                this.options = {
                    // parent: measure_entities,
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.GOLD,
                        width: 2
                    },
                    label: {
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -40),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                };

                this.positions = positions;
                this._init();
            }

            //空间两点距离计算函数
            function getSpaceDistance1(_positions) {

                var point1cartographic = _this._cesium.Cartographic.fromCartesian(_positions[0]);
                var point2cartographic = _this._cesium.Cartographic.fromCartesian(_positions[1]);
                /**根据经纬度计算出距离**/
                var geodesic = new _this._cesium.EllipsoidGeodesic();
                geodesic.setEndPoints(point1cartographic, point2cartographic);
                var s = geodesic.surfaceDistance;
                //console.log(Math.sqrt(Math.pow(distance, 2) + Math.pow(endheight, 2)));
                //返回两点之间的距离
                s = Math.sqrt(Math.pow(s, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2));
                if (s >= 1000) {
                    s = (s / 1000).toFixed(2) + "千米";
                } else {
                    s = (s.toFixed(2)) + "米";
                }
                return s;
            }

            Polyline.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                var _update_label = function () {
                    return _self.positions[1].clone();
                };
                var _text = function () {
                    var text_temp = getSpaceDistance1(_self.positions);
                    text_temp = "空间距离：" + text_temp;
                    Distance.kjdistance = text_temp;
                    return text_temp;
                };
                //实时更新polygon.hierarchy
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                this.options.position = new _this._cesium.CallbackProperty(_update_label, false);
                this.options.label.text = new _this._cesium.CallbackProperty(_text, false);
                var di = _this._viewer.entities.add(this.options);
                _this._tree.temporaryItem.obj.push(di);
                Distance.polyline.push(di);
            };
            return Polyline;
        })();
        return this;
    };

    //俯仰角测量薛鹏修改
    Polyline.prototype.executeAngle = function (methond) {
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        this._tree.removeHandler();
        this._tree.starttemporaryItem(this._viewer);
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positionsTriangle = [];
        var tempPoints; //保存直角点
        var poly = null;
        var cartesian = null;
        var _this = this;
        var startpoint;
        var start;
        var endpoint;
        var Distance = {
            name: '',
            spot: [],
            kjdistance: "",
            spdistance: "",
            gddistance: "",
            point: [],
            polyline: [],
            labels: []
        };
        var isAdsorption = false;
        var tooltip = this._core.CreateTooltip();
        this._tree.handler.setInputAction(function (movement) {
            if (positionsTriangle.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '中键开启/关闭吸附,右键结束！');
            }
            cartesian = _this._getPosition.getMousePosition(movement, Distance.polyline.concat(Distance.point), 0, isAdsorption);
            if (!cartesian) {
                return;
            }
            if (positionsTriangle.length >= 2) {
                //计算角度
                var textDistance = _this._core.ElevationAngle(start, cartesian, _this._cesium);
                //textDistance = "俯视角：" + (90-Math.abs(textDistance)).toFixed(2);
                //startpoint.label.text="角度：" + (90-Math.abs(textDistance)).toFixed(2);
                var jd1 = "";
                var jd2 = "";
                if (start.z <= cartesian.z) {
                    jd1 = "角度：" + (90 - Math.abs(textDistance)).toFixed(2);
                    jd2 = "角度：" + Math.abs(textDistance).toFixed(2);
                } else {
                    jd1 = "角度：" + Math.abs(textDistance).toFixed(2);
                    jd2 = "角度：" + (90 - Math.abs(textDistance)).toFixed(2);
                }
                startpoint.label.text = jd1;
                if (!_this._cesium.defined(poly)) {
                    endpoint = _this._viewer.entities.add({
                        position: cartesian,
                        name: '等经纬度',
                        label: {
                            text: jd2,
                            font: '16px 宋体',
                            fillColor: Cesium.Color.GOLD,
                            verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                            pixelOffset: new Cesium.Cartesian2(20, -20),
                            showBackground: true,
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    Distance.labels.push(endpoint);
                    _this._points.push(endpoint);
                } else {
                    endpoint.position.setValue(cartesian);
                    endpoint.label.text = jd2;
                }
                if (!_this._cesium.defined(poly)) {
                    poly = new PolylinePrimitive(positionsTriangle);
                    var floatingPoint_end = _this._viewer.entities.add({
                        // parent: measure_entities,
                        name: '角度测量',
                        position: new _this._cesium.CallbackProperty(function () {
                            return positionsTriangle[1];
                        }, false),
                        point: {
                            pixelSize: 5,
                            color: _this._cesium.Color.RED,
                            outlineColor: _this._cesium.Color.WHITE,
                            outlineWidth: 2,
                            heightReference: _this._cesium.HeightReference.none,
                            disableDepthTestDistance: Number.POSITIVE_INFINITY
                        }
                    });
                    _this._tree.temporaryItem.obj.push(floatingPoint_end);
                    Distance.point.push(floatingPoint_end);
                    _this._points.push(floatingPoint_end);
                    tempPoints = point_conf(positionsTriangle);
                    //在三维场景中添加线
                    var dx = _this._viewer.entities.add({
                        position: new _this._cesium.CallbackProperty(function () {
                            return positionsTriangle[0];
                        }, false),
                        name: '等经纬度',
                        polyline: {
                            show: true,
                            positions: new _this._cesium.CallbackProperty(function () {
                                return tempPoints.eq_lon_lat;
                            }, false),
                            material: _this._cesium.Color.GOLD,
                            width: 2
                        },
                        //label: {
                        //    text: new _this._cesium.CallbackProperty(function () {
                        //        var textDistance = _this._core.ElevationAngle(positionsTriangle[0], positionsTriangle[1], _this._cesium);
                        //        textDistance = "俯视角：" + (90-Math.abs(textDistance)).toFixed(2);;
                        //        Distance.gddistance = textDistance;
                        //        return textDistance;
                        //    }, false),
                        // font: '16px 宋体',
                        // fillColor: Cesium.Color.GOLD,
                        // verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        // pixelOffset: new Cesium.Cartesian2(20, -20),
                        // showBackground: true,
                        // disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        //}
                    });
                    Distance.polyline.push(dx);
                    _this._polylines.push(dx);
                    var la = _this._viewer.entities.add({
                        position: new _this._cesium.CallbackProperty(function () {
                            return positionsTriangle[1];
                        }, false),
                        name: '等高度直线',
                        polyline: {
                            show: true,
                            positions: new _this._cesium.CallbackProperty(function () {
                                return tempPoints.eq_height;
                            }, false),
                            material: _this._cesium.Color.GOLD,
                            width: 2
                        },
                        //label: {
                        //    text: new _this._cesium.CallbackProperty(function () {
                        //        var textDistance = _this._core.ElevationAngle(positionsTriangle[0], positionsTriangle[1], _this._cesium);
                        //        textDistance = "水平角度：" + Math.abs(textDistance).toFixed(2);;
                        //        Distance.spdistance = textDistance;
                        //        return textDistance;
                        //    }, false),
                        // font: '16px 宋体',
                        // fillColor: Cesium.Color.GOLD,
                        // verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        // pixelOffset: new Cesium.Cartesian2(60, -20),
                        // showBackground: true,
                        // disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        //}
                    });
                    Distance.polyline.push(la);
                    _this._polylines.push(la);
                } else {
                    positionsTriangle.pop();
                    positionsTriangle.push(cartesian.clone());
                    tempPoints = point_conf(positionsTriangle);

                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this._tree.handler.setInputAction(function (movement) {
            cartesian = _this._getPosition.getMousePosition(movement, Distance.polyline.concat(Distance.point), 0, isAdsorption);
            if (!cartesian) {
                return;
            }
            if (positionsTriangle.length == 0) {
                start = cartesian;
                startpoint = _this._viewer.entities.add({
                    position: cartesian,
                    name: '等经纬度',
                    label: {
                        text: "0",
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -20),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                });
                Distance.labels.push(startpoint);
                var dx = _this._viewer.entities.add({
                    position: new _this._cesium.CallbackProperty(function () {
                        return _this._cesium.Cartesian3.midpoint(tempPoints.eq_lon_lat[0], tempPoints.eq_lon_lat[1], new _this._cesium.Cartesian3());
                    }, false),
                    label: {
                        //text: new _this._cesium.CallbackProperty(function () {
                        //    var textDistance = _this.getHeight(tempPoints.eq_lon_lat);
                        //    var dw = "米";
                        //    var Distancexp = textDistance;
                        //    if (textDistance.indexOf("千米") !== -1) {
                        //        dw = "千米";
                        //        Distancexp = textDistance.replace("千米", "");
                        //    } else {
                        //        Distancexp = textDistance.replace("米", "");
                        //    }
                        //    var Distancexp = parseFloat(Distancexp);
                        //    if (Distancexp < 0) {
                        //        Distancexp = Math.abs(Distancexp);
                        //        textDistance = Distancexp + dw;
                        //    } else {
                        //        textDistance = Distancexp + dw;
                        //    }
                        //    textDistance = "高度：" + textDistance;
                        //    Distance.gddistance = textDistance;
                        //    return textDistance;
                        //}, false),
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -20),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                });
                positionsTriangle.push(cartesian.clone());
                positionsTriangle.push(cartesian.clone());
                tempPoints = point_conf(positionsTriangle);
                var floatingPoint_first = _this._viewer.entities.add({
                    // parent: measure_entities,
                    name: '高度测量',
                    position: positionsTriangle[0],
                    point: {
                        pixelSize: 5,
                        color: _this._cesium.Color.RED,
                        outlineColor: _this._cesium.Color.WHITE,
                        outlineWidth: 2,
                        heightReference: _this._cesium.HeightReference.none,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY
                    }
                });
                _this._tree.temporaryItem.obj.push(floatingPoint_first);
                Distance.point.push(floatingPoint_first);
                _this._points.push(startpoint, floatingPoint_first);
            } else {
                //兼容移动端鼠标移动事件未触发
                if (positionsTriangle.length >= 2) {
                    if (!_this._cesium.defined(poly)) {
                        poly = new PolylinePrimitive(positionsTriangle);
                        var floatingPoint_end = _this._viewer.entities.add({
                            // parent: measure_entities,
                            name: '高度测量',
                            position: new _this._cesium.CallbackProperty(function () {
                                return positionsTriangle[1];
                            }, false),
                            point: {
                                pixelSize: 5,
                                color: _this._cesium.Color.RED,
                                outlineColor: _this._cesium.Color.WHITE,
                                outlineWidth: 2,
                                heightReference: _this._cesium.HeightReference.none,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY
                            }
                        });
                        _this._tree.temporaryItem.obj.push(floatingPoint_end);
                        Distance.point.push(floatingPoint_end);
                        _this._points.push(floatingPoint_end);
                        tempPoints = point_conf(positionsTriangle);
                        //在三维场景中添加线
                        var dx = _this._viewer.entities.add({
                            // parent: measure_entities,
                            position: new _this._cesium.CallbackProperty(function () {
                                return _this._cesium.Cartesian3.midpoint(tempPoints.eq_lon_lat[0], tempPoints.eq_lon_lat[1], new _this._cesium.Cartesian3());
                            }, false),
                            name: '等经纬度',
                            polyline: {
                                show: true,
                                positions: new _this._cesium.CallbackProperty(function () {
                                    return tempPoints.eq_lon_lat;
                                }, false),
                                // material: new _this._cesium.PolylineDashMaterialProperty({
                                //     color: _this._cesium.Color.RED
                                // }),
                                material: _this._cesium.Color.GOLD,
                                width: 2
                            },
                            label: {
                                text: new _this._cesium.CallbackProperty(function () {
                                    var textDistance = _this.getHeight(tempPoints.eq_lon_lat);
                                    var dw = "米";
                                    var Distancexp = textDistance;
                                    if (textDistance.indexOf("千米") !== -1) {
                                        dw = "千米";
                                        Distancexp = textDistance.replace("千米", "");
                                    } else {
                                        Distancexp = textDistance.replace("米", "");
                                    }
                                    var Distancexp = parseFloat(Distancexp);
                                    if (Distancexp < 0) {
                                        Distancexp = Math.abs(Distancexp);
                                        textDistance = Distancexp + dw;
                                    } else {
                                        textDistance = Distancexp + dw;
                                    }
                                    textDistance = "高度：" + textDistance;
                                    Distance.gddistance = textDistance;
                                    return textDistance;
                                }, false),
                                font: '16px 宋体',
                                fillColor: Cesium.Color.GOLD,
                                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                                pixelOffset: new Cesium.Cartesian2(20, -20),
                                showBackground: true,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            }
                        });
                        Distance.polyline.push(dx);
                        _this._polylines.push(dx);
                        //textDistance = getDistance(tempPositions2) + "千米";
                        var la = _this._viewer.entities.add({
                            //parent: measure_entities,
                            position: new _this._cesium.CallbackProperty(function () {
                                return _this._cesium.Cartesian3.midpoint(tempPoints.eq_height[0], tempPoints.eq_height[1], new _this._cesium.Cartesian3());
                            }, false),
                            name: '等高度直线',
                            polyline: {
                                show: true,
                                positions: new _this._cesium.CallbackProperty(function () {
                                    return tempPoints.eq_height;
                                }, false),
                                // material: new _this._cesium.PolylineDashMaterialProperty({
                                //     color: _this._cesium.Color.RED
                                // }),
                                material: _this._cesium.Color.GOLD,
                                width: 2
                            },
                            label: {
                                text: new _this._cesium.CallbackProperty(function () {
                                    //var textDistance = _this._core.getHorizontalDistance(tempPoints.eq_height, _this._cesium);
                                    var textDistance = _this._core.ElevationAngle(firtP, cartesian, _this._cesium);
                                    textDistance = "角度：" + textDistance.toFixed(2);
                                    Distance.spdistance = textDistance;
                                    return textDistance;
                                }, false),
                                font: '16px 宋体',
                                fillColor: Cesium.Color.GOLD,
                                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                                pixelOffset: new Cesium.Cartesian2(60, -20),
                                showBackground: true,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                            }
                        });
                        Distance.polyline.push(la);
                        _this._polylines.push(la);
                    } else {
                        positionsTriangle.pop();
                        positionsTriangle.push(cartesian.clone());
                        tempPoints = point_conf(positionsTriangle);
                    }
                }
            }
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            isAdsorption = !isAdsorption;
        }, _this._cesium.ScreenSpaceEventType.MIDDLE_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            _this.end();
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            _this.end();
        }, _this._cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);

        this.end = function (type) {
            _this._tree.handler.destroy();
            tooltip.show(false);
            _this._tree.endtemporaryItem();
            _this.end = undefined;
            _this._core.mouse(_this._viewer.container, 0, "0");
            if (type === 'cancel') {
                _this.deleteObject();
                return;
            }
            // handler_g.destroy();//关闭事件句柄		
            if (methond != "" && methond != null) {
                if (typeof methond == 'function') {
                    this.labels = Distance.labels;
                    methond(Distance);
                }
            }

        };

        function point_conf(_positions) {
            var cartographic = _this._cesium.Cartographic.fromCartesian(_positions[0]);
            var cartographic1 = _this._cesium.Cartographic.fromCartesian(_positions[1]);
            // var height_temp = cartographic1.height - cartographic.height;
            cartographic1.height - (cartographic1.height - cartographic.height);
            //var point_temp = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(point1cartographic.longitude), Cesium.Math.toDegrees(point1cartographic.latitude), point2cartographic.height);
            var position, eq_height, eq_lon_lat;
            if (cartographic1.height - cartographic.height > 0) {
                position = _this._cesium.Cartesian3.fromDegrees(_this._cesium.Math.toDegrees(cartographic.longitude), _this._cesium.Math.toDegrees(cartographic.latitude), cartographic1.height);
                eq_height = [_positions[1], position];
                eq_lon_lat = [_positions[0], position];
            } else {
                position = _this._cesium.Cartesian3.fromDegrees(_this._cesium.Math.toDegrees(cartographic1.longitude), _this._cesium.Math.toDegrees(cartographic1.latitude), cartographic.height);
                eq_height = [_positions[0], position];
                eq_lon_lat = [_positions[1], position];
            }
            // return height_temp.toFixed(2);
            return {
                new: position,
                eq_height: eq_height,
                eq_lon_lat: eq_lon_lat
            };
        }

        var PolylinePrimitive = (function () {
            function Polyline(positions) {
                this.options = {
                    // parent: measure_entities,
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.GOLD,
                        width: 2
                    },
                    label: {
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -20),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                };

                this.positions = positions;
                this._init();
            }
            Polyline.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                var _update_label = function () {
                    return _this._cesium.Cartesian3.midpoint(_self.positions[0], _self.positions[1], new _this._cesium.Cartesian3());
                };
                //实时更新polygon.hierarchy
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                this.options.position = new _this._cesium.CallbackProperty(_update_label, false);
                var di = _this._viewer.entities.add(this.options);
                _this.item = di;
                _this._tree.temporaryItem.obj.push(di);
                Distance.polyline.push(di);
                var id = _this._core.getuid();
                Distance.name = '新建垂直高度' + id;
            };
            return Polyline;
        })();
        return this;
    };
    //等高测量
    Polyline.prototype.executeHeightDg = function (methond) {
        this._tree.removeHandler();
        var _this = this;
        this._tree.handler = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var positionsTriangle = [];
        var tempPoints; //保存直角点
        var poly = null;
        var cartesian = null;
        this._tree.handler.setInputAction(function (movement) {
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            //cartesian = viewer.scene.camera.pickEllipsoid(movement.endPosition, viewer.scene.globe.ellipsoid);
            if (positionsTriangle.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolylinePrimitive(positionsTriangle);
                } else {
                    positionsTriangle.pop();
                    positionsTriangle.push(cartesian.clone());
                    tempPoints = point_conf(positionsTriangle);
                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        this._tree.handler.setInputAction(function (movement) {
            // cartesian = viewer.scene.camera.pickEllipsoid(movement.position, viewer.scene.globe.ellipsoid);
            if (positionsTriangle.length == 0) {
                cartesian = _this._getPosition.getMousePosition(movement);
                if (!cartesian) {
                    return;
                }
                positionsTriangle.push(cartesian.clone());
                positionsTriangle.push(cartesian.clone());
                // tempPoints= point_conf(positionsTriangle);	
                _this._viewer.entities.add({
                    parent: measure_entities,
                    name: '多边形面积',
                    position: positionsTriangle[0],
                    point: {
                        pixelSize: 5,
                        color: _this._cesium.Color.RED,
                        outlineColor: _this._cesium.Color.WHITE,
                        outlineWidth: 2,
                        heightReference: _this._cesium.HeightReference.none
                    }
                });
            }
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            _this._tree.handler.destroy();
            // handler_g.destroy();//关闭事件句柄		
            // tempPoints =point_conf(positionsTriangle);
            //在三维场景中添加线
            var tempPositions1 = [];
            var tempPositions2 = [];
            tempPositions1.push(positionsTriangle[0].clone());
            tempPositions1.push(tempPoints.clone());
            var textDistance = _this.getHeight(tempPositions1);
            _this._viewer.entities.add({
                parent: measure_entities,
                name: '等经纬度',
                position: tempPositions1[0].clone(),
                polyline: {
                    show: true,
                    clampToGround: true,
                    positions: tempPositions1,
                    material: new _this._cesium.PolylineDashMaterialProperty({
                        color: _this._cesium.Color.RED
                    }),
                    width: 2
                },
                label: {
                    text: textDistance,
                    font: '16px 宋体',
                    fillColor: Cesium.Color.GOLD,
                    verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                    pixelOffset: new Cesium.Cartesian2(20, -20),
                    showBackground: true,
                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
                }
            });
            tempPositions2.push(tempPoints.clone());
            tempPositions2.push(positionsTriangle[1].clone());
            textDistance = getDistance(tempPositions2) + "千米";
            _this._viewer.entities.add({
                parent: measure_entities,
                name: '等高度直线',
                position: tempPositions2[0].clone(),
                polyline: {
                    show: true,
                    positions: tempPositions2,
                    clampToGround: true,
                    material: new _this._cesium.PolylineDashMaterialProperty({
                        color: _this._cesium.Color.RED
                    }),
                    width: 2
                },
                label: {
                    text: textDistance,
                    font: '16px 宋体',
                    fillColor: Cesium.Color.GOLD,
                    verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                    pixelOffset: new Cesium.Cartesian2(60, -20),
                    showBackground: true,
                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
                }
            });

        }, _this._cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
        var PolylinePrimitive = (function () {
            function Polyline(positions) {
                this.options = {
                    parent: measure_entities,
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        clampToGround: true,
                        material: _this._cesium.Color.GOLD,
                        width: 2
                    },
                    label: {
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -40),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                };
                this.positions = positions;
                this._init();
            }

            Polyline.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                var _update_label = function () {
                    return _self.positions[1].clone();
                };
                var _text = function () {
                    var text_temp = getSpaceDistance(_self.positions);
                    //text_temp = text_temp + "千米";
                    return text_temp;
                };
                //实时更新polygon.hierarchy
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                this.options.position = new _this._cesium.CallbackProperty(_update_label, false);
                this.options.label.text = new _this._cesium.CallbackProperty(_text, false);
                _this._viewer.entities.add(this.options);
            };
            return Polyline;
        })();
    };
    //角度测量
    Polyline.prototype.executeAnge = function (methond) {
        var _this = this;
        this._tree.removeHandler();
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positions = [];
        var poly = null;
        var dis = "";
        var cartesian = null;
        var floatingPoint;
        var angleOfLine = 0;
        //spot点坐标，distance距离，label距离对象数组
        var Distance = {
            spot: [],
            distance: 0,
            label: {},
            angle: 0
        };
        this._tree.handler.setInputAction(function (movement) {
            _this._viewer.camera.getPickRay(movement.endPosition);
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive6(positions);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                }
                //distance = _this._core.getSpaceDistance(positions, _this._cesium);
                dis = _this._core.getSpaceDistance(positions, _this._cesium);
            }
            //创建
            //var textDisance = distance + "千米";
            var textDisance = dis;
            //空间距离标签添加
            _this._viewer.entities.remove(floatingPoint);
            if (positions.length > 1) {
                //假设点一（X1, Y1），点二（X2, Y2）
                angleOfLine = (Math.atan2((positions[1].y - positions[0].y), (positions[1].x - positions[0].x)) * 180 / Math.PI).toFixed(0);
                floatingPoint = _this._viewer.entities.add({
                    name: '空间直线距离',
                    // position: cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180,cartographic.height),
                    position: positions[positions.length - 1],
                    label: {
                        text: textDisance + ";" + angleOfLine + "度",
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -20),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                });
            }

        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        var dj = 0;
        this._tree.handler.setInputAction(function (movement) {
            if (dj > 0) {
                _this._tree.handler.destroy(); //关闭事件句柄
                positions.pop(); //最后一个点无效
            }
            _this._viewer.camera.getPickRay(movement.position);
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            if (positions.length == 0) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);
            Distance.spot.push(cartesian);
            Distance.distance = dis;
            Distance.label = floatingPoint;
            _this._points.push(floatingPoint);
            Distance.angle = angleOfLine;

            if (dj == 1) {
                if (methond != "" && methond != null) {
                    if (typeof methond == 'function')
                        methond(Distance);
                }
            }
            dj = dj + 1;
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //画线
        var PolyLinePrimitive6 = (function () {
            function execute(positions) {
                this.options = {
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.YELLOW,
                        width: 3,
                        clampToGround: true
                    },
                };
                this.positions = positions;
                this._init6();
            }

            execute.prototype._init6 = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                var polyline = _this._viewer.entities.add(this.options);
                _this.item = polyline;
                ///工程树添加
                //var GroupID = 0;
                //if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                //    GroupID = tree.selectedItem.id;
                //var id = _this._core.getuid();
                //tree.insertGroupId({
                //    id: _this.item.id,
                //    name: '新建角度测量' + id,
                //    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                //    type: 'polyline',
                //    item: _this
                //}, _this._core.isnull(GroupID) ? 0 : GroupID);
            };
            return execute;
        })();
        return this;
    };
    //剖面分析
    Polyline.prototype.executeProfile = function (parameter, methond) {
        var _this = this;
        this._tree.removeHandler();
        this._tree.starttemporaryItem(this._viewer);
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positions = [];
        var positionsxp = [];
        var poly = null;
        var parameterd = parameter.parameterd;
        var objid = parameter.objid;
        var cyjj = parameter.cyjj;
        //坐标
        var positionsxp = [];
        var distance = 0;
        //导入tool提示框
        var tooltip = this._core.CreateTooltip();
        //隐藏选中容器标识
        var cartesian = null;
        var floatingPoint;
        //spot点坐标，distance距离，label距离对象数组
        var Distance = {
            spot: [],
            min: 0.0,
            max: 0.0,
            distance: 0,
            label: {},
            cys: 0,
            gcs: []
        };
        this._tree.handler.setInputAction(function (movement) {
            if (positions.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '再次点击结束绘制！');
            }
            var ray = _this._viewer.camera.getPickRay(movement.endPosition);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);

            var feature = _this._viewer.scene.pick(movement.endPosition);
            if (feature) {
                var _cartesian = _this._viewer.scene.pickPosition(movement.endPosition);
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            }
            if (!cartesian) {
                return;
            }
            //cartesian = _this._viewer.scene.pickPosition(movement.position);
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive10(positions);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                }
                distance = _this._core.getSpaceDistance(positions, _this._cesium);
            }
            //创建
            var textDisance = distance;
            //空间距离标签添加
            _this._viewer.entities.remove(floatingPoint);
            if (positions.length > 1) {
                //假设点一（X1, Y1），点二（X2, Y2）
                (Math.atan2((positions[1].y - positions[0].y), (positions[1].x - positions[0].x)) * 180 / Math.PI).toFixed(0);
                floatingPoint = _this._viewer.entities.add({
                    name: '空间直线距离',
                    // position: cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180,cartographic.height),
                    position: positions[positions.length - 1],
                    label: {
                        text: textDisance,
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -20),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                });
                _this._tree.temporaryItem.obj.push(floatingPoint);
                _this._points.push(floatingPoint);
            }

        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        var dj = 0;
        this._tree.handler.setInputAction(function (movement) {
            if (dj > 0) {
                _this._tree.handler.destroy(); //关闭事件句柄
                positions.pop(); //最后一个点无效
                tooltip.show(false);
            }
            var ray = _this._viewer.camera.getPickRay(movement.position);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            var feature = _this._viewer.scene.pick(movement.position);
            if (feature) {
                var _cartesian = _this._viewer.scene.pickPosition(movement.position);
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            }
            if (!cartesian) {
                return;
            }
            //cartesian = _this._viewer.scene.pickPosition(movement.position);
            if (positions.length == 0) {
                positions.push(cartesian.clone());
            }
            positionsxp.push(cartesian);
            positions.push(cartesian);
            Distance.spot.push(cartesian);
            Distance.label = floatingPoint;
            //Distance.angle = angleOfLine;
            if (dj == 1) {
                _this._tree.endtemporaryItem();
                var pointSum = parameterd; //取样点个数
                _this._core.getPmfx(positionsxp, pointSum, cyjj, _this._cesium, _this._viewer, function (gc) {
                    Distance.distance = gc.juli;
                    Distance.gcs = gc.gcs;
                    Distance.gcs = gc.gcs;
                    Distance.cys = gc.cys;
                    Distance.max = gc.max;
                    Distance.min = gc.min;
                    tooltip.show(false);
                    if (methond != "" && methond != null) {
                        if (typeof methond == 'function')
                            methond(Distance);
                    }
                });
            } else {
                ({
                    leftX: movement.position.x,
                    leftY: movement.position.y
                });
                //leftX = movement.position.x;
                //leftY = movement.position.y;
            }
            dj = dj + 1;
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //画线
        var PolyLinePrimitive10 = (function () {
            function execute(positions) {
                this.options = {
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.YELLOW,
                        width: 2,
                        clampToGround: true
                    },
                };
                this.positions = positions;
                this._init10();
            }

            execute.prototype._init10 = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                var polyline = _this._viewer.entities.add(this.options);
                _this.item = polyline;
                _this._tree.temporaryItem.obj.push(polyline);
                if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                    tree.selectedItem.id;
                var id = _this._core.getuid();
                var obj = {
                    id: id,
                    name: '新建剖面分析' + id,
                    pId: _this._core.isnull(objid) ? 0 : objid,
                    type: 'polyline',
                    item: _this
                };
                _this.setTreeobj(obj);
                tree.insertGroupId(obj, _this._core.isnull(objid) ? 0 : objid);
            };
            return execute;
        })();
        return this;
    };
    //剖面分析-多段
    Polyline.prototype.executeProfilePro = function (parameter, methond) {
        var _this = this;
        this._tree.removeHandler();
        this._tree.starttemporaryItem(this._viewer);
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positions = [];
        var poly = null;
        var parameterd = parameter.parameterd;
        var objid = parameter.objid;
        var cyjj = parameter.cyjj;
        //坐标

        //提升框
        var tooltip = this._core.CreateTooltip();
        var cartesian = null;

        //spot点坐标，distance距离，label距离对象数组
        var Distance = {
            spot: [],
            min: 0.0,
            max: 0.0,
            distance: 0,
            label: {},
            cys: 0,
            gcs: []
        };
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        this._tree.handler.setInputAction(function (movement) {
            if (positions.length >= 3) {
                tooltip.showAt(movement.endPosition, '右键结束绘制');
            } else {
                tooltip.showAt(movement.endPosition, '点击绘制剖面点');
            }
            var ray = _this._viewer.camera.getPickRay(movement.endPosition);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);

            var feature = _this._viewer.scene.pick(movement.endPosition);
            if (feature) {
                var _cartesian = _this._viewer.scene.pickPosition(movement.endPosition);
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            }
            if (!cartesian) {
                return;
            }
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive10(positions);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        this._tree.handler.setInputAction(function (movement) {

            _this.end();

        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        this.end = function (type) {
            _this._tree.handler.destroy(); //关闭事件句柄
            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0);
            _this._tree.endtemporaryItem();
            if (_this._core.getBrowser().pc == 'pc')
                positions.pop(); //最后一个点无效
            tooltip.show(false);
            _this.end = undefined;
            if (type === 'cancel') {
                _this.item && _this._viewer.entities.remove(_this.item);
                return;
            }

            if (positions.length <= 1) {
                window.layuiLayer && window.layuiLayer.msg("剖面点小于两点，请重新绘制");
                return;
            }

            Distance.spot = positions;
            var pointSum = parameterd; //取样点个数
            _this._core.getPmfxPro(positions, pointSum, cyjj, _this._cesium, _this._viewer, function (gc) {
                Distance.distance = gc.juli;
                Distance.gcs = gc.gcs;
                Distance.cys = gc.cys;
                Distance.max = gc.max;
                Distance.min = gc.min;
                Distance.allPoint = gc.allPoint;
                if (methond != "" && methond != null) {
                    if (typeof methond == 'function')
                        methond(Distance);
                }
            });
        };
        this._tree.handler.setInputAction(function (movement) {
            var ray = _this._viewer.camera.getPickRay(movement.position);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            var feature = _this._viewer.scene.pick(movement.position);
            if (feature) {
                var _cartesian = _this._viewer.scene.pickPosition(movement.position);
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            }
            if (!cartesian) {
                return;
            }
            if (positions.length === 0) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);
            if (positions.length > 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive10(positions);
                }
            }
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //画线
        var PolyLinePrimitive10 = (function () {
            function execute(positions) {
                this.options = {
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.YELLOW,
                        width: 2,
                        clampToGround: true
                    },
                };
                this.positions = positions;
                this._init10();
            }

            execute.prototype._init10 = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                var polyline = _this._viewer.entities.add(this.options);
                _this.item = polyline;
                _this._tree.temporaryItem.obj.push(polyline);
                if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                    tree.selectedItem.id;
                var id = _this._core.getuid();
                var obj = {
                    id: id,
                    name: '新建剖面分析' + id,
                    pId: _this._core.isnull(objid) ? 0 : objid,
                    type: 'polyline',
                    item: _this
                };
                _this.setTreeobj(obj);
                tree.insertGroupId(obj, _this._core.isnull(objid) ? 0 : objid);
            };
            return execute;
        })();
        return this;
    };
    //三点角度测量
    Polyline.prototype.executeAngeSdcs = function (methond) {
        var _this = this;
        this._tree.removeHandler();
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var positions = [];
        var poly = null;
        var tempPoints = [];
        //导入tool提示框
        var tooltip = this._core.CreateTooltip();
        var dis = "";
        var cartesian = null;
        var floatingPoint;
        var angleOfLine = 0;
        //spot点坐标，distance距离，label距离对象数组
        var Distance = {
            spot: [],
            distance: 0,
            label: {},
            angle: 0
        };
        this._tree.handler.setInputAction(function (movement) {
            if (positions.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '再次点击结束绘制！');
            }
            _this._viewer.camera.getPickRay(movement.endPosition);
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive6(positions);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                }

                //distance = _this._core.getSpaceDistance(positions, _this._cesium);
                dis = _this._core.getSpaceDistance(positions, _this._cesium);
                if (dj >= 2) {
                    _this._viewer.entities.remove(floatingPoint);
                    var cartographic = _this._cesium.Cartographic.fromCartesian(positions[positions.length - 1]);
                    var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
                    var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
                    var heightString = cartographic.height;
                    var terp = {
                        lon: longitudeString,
                        lat: latitudeString,
                        hei: heightString
                    };
                    tempPoints[2] = terp;
                    angleOfLine = _this._core.Angle(tempPoints[0], tempPoints[1], tempPoints[2]).toFixed(1);
                    floatingPoint = _this._viewer.entities.add({
                        name: '三点角度测量',
                        // position: cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180,cartographic.height),
                        position: positions[positions.length - 1],
                        label: {
                            text: angleOfLine + "度",
                            font: '16px 宋体',
                            fillColor: Cesium.Color.GOLD,
                            verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                            pixelOffset: new Cesium.Cartesian2(20, -20),
                            showBackground: true,
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        }
                    });
                    _this._points.push(floatingPoint);
                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        var dj = 0;
        this._tree.handler.setInputAction(function (movement) {
            if (dj > 1) {
                _this._tree.handler.destroy(); //关闭事件句柄
                positions.pop(); //最后一个点无效
            }
            _this._viewer.camera.getPickRay(movement.position);
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            if (positions.length == 0) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);
            var cartographic = _this._cesium.Cartographic.fromCartesian(positions[positions.length - 1]);
            var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
            var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
            var heightString = cartographic.height;
            tempPoints.push({
                lon: longitudeString,
                lat: latitudeString,
                hei: heightString
            });
            Distance.spot.push(cartesian);
            Distance.distance = dis;
            if (dj == 2) {
                tooltip.show(false);
                Distance.label = floatingPoint;
                Distance.angle = angleOfLine;
                if (methond != "" && methond != null) {
                    if (typeof methond == 'function')
                        methond(Distance);
                }
            }
            dj = dj + 1;
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //画线
        var PolyLinePrimitive6 = (function () {
            function execute(positions) {
                this.options = {
                    name: '直线',
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.YELLOW,
                        width: 3,
                        clampToGround: false
                    },
                };
                this.positions = positions;
                this._init6();
            }

            execute.prototype._init6 = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                var polyline = _this._viewer.entities.add(this.options);
                _this.item = polyline;
                ///工程树添加
                //var GroupID = 0;
                //if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                //    GroupID = tree.selectedItem.id;
                //var id = _this._core.getuid();
                //tree.insertGroupId({
                //    id: _this.item.id,
                //    name: '新建角度测量' + id,
                //    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                //    type: 'polyline',
                //    item: _this
                //}, _this._core.isnull(GroupID) ? 0 : GroupID);
            };
            return execute;
        })();
        return this;
    };
    //角度测量之俯仰角测量
    Polyline.prototype.executeAngeSd = function (methond) {
        //创建线和可以创建在高程上
        this._tree.removeHandler();
        var polylines = [];
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        var _this = this;
        var labels = [];
        var firtP = undefined;
        var tempPoints = [];
        var angles = [];
        this._tree.starttemporaryItem(this._viewer);
        //导入tool提示框
        var tooltip = this._core.CreateTooltip();
        var PolyLinePrimitive = (function () {
            function execute(positionsp) {
                this.options = {
                    polyline: {
                        show: true,
                        positions: [],
                        material: _this._cesium.Color.YELLOW,
                        width: 3,
                        clampToGround: false
                    }
                };
                this.positionsp = positionsp;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positionsp;
                };
                //实时更新polyline.positions
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                this.polyline = _this._viewer.entities.add(this.options);
                _this._tree.temporaryItem.obj.push(this.polyline);
                _this.item = this.polyline;
            };
            return execute;
        })();
        this._tree.handler = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        ///存储点的数组 至多有两个点
        var positionsp = [];
        var poly = undefined;
        //删除所有通视结果
        if (this._points.length > 0) {
            for (var i = 0; i < this._points.length; i++) {
                this._viewer.entities.remove(this._points[i]);
            }
        }
        //鼠标左键单击画点
        this._tree.handler.setInputAction(function (movement) {
            //var cartesian = _this._viewer.scene.pickPosition(movement.position);
            var cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            tempPoints.push(cartesian);
            //存储坐标经纬度
            _this._cesium.Cartographic.fromCartesian(cartesian);
            if (positionsp.length == 0) {
                ///两个点画一条线
                positionsp.push(cartesian.clone());
                positionsp.push(cartesian.clone());
                ///存储第一个点
                firtP = cartesian.clone();

            } else {
                ///计算一次俯仰角
                var angle = _this._core.ElevationAngle(firtP, cartesian, _this._cesium);
                if (polylines.length == 1) {
                    angles.push('俯仰角1 ' + angle.toFixed(2));
                } else {
                    angles.push('俯仰角2 ' + angle.toFixed(2));
                }
                ///画一条线结束
                poly = undefined;
                ///清空存储点数组
                positionsp = [];
                //用第一个点的数组再次画线
                positionsp.push(firtP.clone());
                positionsp.push(firtP.clone());
                ///再画一条线
                poly = new PolyLinePrimitive(positionsp);
                polylines.push(poly.polyline);
            }
            if (angles.length >= 2) {
                tooltip.show(false);

                //方位角
                var azimuth = _this._core.ThreePointAzimuth(tempPoints[0], tempPoints[1], tempPoints[2], _this._cesium);

                angles.push('水平角 ' + azimuth.toFixed(2));
                // var text = angles[0] + '\n' +
                //     angles[1] + '\n' +
                //     angles[2];
                var floatingPoint1 = _this._viewer.entities.add({
                    name: '三点角度测量',
                    position: tempPoints[1],
                    label: {
                        text: angles[0],
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -20),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                });
                _this._tree.temporaryItem.obj.push(floatingPoint1);

                var floatingPoint2 = _this._viewer.entities.add({
                    name: '三点角度测量',
                    position: tempPoints[2],
                    label: {
                        text: angles[1],
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -20),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                });
                _this._tree.temporaryItem.obj.push(floatingPoint2);

                var floatingPoint3 = _this._viewer.entities.add({
                    name: '三点角度测量',
                    position: tempPoints[0],
                    label: {
                        text: angles[2],
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -20),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    }
                });
                _this._tree.temporaryItem.obj.push(floatingPoint3);
                labels.push(floatingPoint1);
                labels.push(floatingPoint2);
                labels.push(floatingPoint3);

                positionsp.pop();
                _this._tree.handler.destroy();
                //设置鼠标样式
                _this._core.mouse(_this._viewer.container, 0, "0");
                _this._tree.endtemporaryItem();
                _this._points = labels;
                _this._polylines = polylines;
                _this._polylines1 = polylines;
                //_this._labels = labels;
                if (methond != "" && methond != null) {
                    if (typeof methond == 'function')
                        methond({
                            polylines: polylines,
                            labels: labels,
                            angles: angles
                        });
                }
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        this._tree.handler.setInputAction(function (movement) {
            //var cartesian = _this._viewer.scene.pickPosition(movement.endPosition);
            var cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            if (positionsp.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else if (positionsp.length <= 3) {
                tooltip.showAt(movement.endPosition, '点击绘制目标点！');
            } else {
                tooltip.showAt(movement.endPosition, '再次点击结束绘制！');
            }
            if (positionsp.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive(positionsp);
                    polylines.push(poly.polyline);
                } else {
                    if (cartesian != undefined) {
                        positionsp.pop();
                        cartesian.y += (1 + Math.random());
                        positionsp.push(cartesian);
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return this;
    };

    /**
     * 删除polyline
     */
    Polyline.prototype.deleteObject = function () {
        if (this.item && this.item.item) {
            this._viewer.entities.remove(this.item.item);
        } else {
            this._viewer.entities.remove(this.item);
        }
        if (this._points && this._points.length > 0) {
            for (var i = 0; i < this._points.length; i++) {
                this._viewer.entities.remove(this._points[i]);
            }
            this._points = [];
        }
        if (this._polylines && this._polylines.length > 0) {
            for (var i = 0; i < this._polylines.length; i++) {
                this._viewer.entities.remove(this._polylines[i]);
            }
            this._polylines = [];
        }
        if (this.labels && this.labels.length > 0) {
            for (var i = 0; i < this.labels.length; i++) {
                this._viewer.entities.remove(this.labels[i]);
            }
            this.labels = [];
        }
        if (this.item && this.item._points && this.item._points.length > 0) {
            for (var i = 0; i < this.item._points.length; i++) {
                this._viewer.entities.remove(this.item._points[i]);
            }
            this.item._points = [];
        }
        if (this.item && this.item._polylines && this.item._polylines.length > 0) {
            for (var i = 0; i < this.item._polylines.length; i++) {
                this._viewer.entities.remove(this.item._polylines[i]);
            }
            this.item._polylines = [];
        }
        // this = null;
    };
    /**
     * 设置线的高度
     * @param {Object} [polyline] polyline对象
     * @param {double} [height] 高度
     * @returns {Object} 返回一个polyline对象。
     */
    //Polyline.prototype.setHeight = function (height) {
    //    try {
    //        this.item._polyline.height = height;
    //    } catch (ex) {
    //        console.log(ex);
    //    }
    //    return this;
    //}
    /**
     * 设置线的高度类型
     * @param {Object} [polyline] polyline对象
     * @param {int} [type] 1：该位置被夹在地形上。2：这个职位是绝对的。3：位置高度是地形上方的高度。
     * @returns {Object} 返回一个对象。
     */
    Polyline.prototype.setHeightType = function (type) {
        try {
            if (type == 1) {
                this.item._polyline.heightReference = this._cesium.HeightReference.CLAMP_TO_GROUND;
            } else if (type == 2) {
                this.item._polyline.heightReference = this._cesium.HeightReference.NONE;
            } else if (type == 3) {
                this.item._polyline.heightReference = this._cesium.HeightReference.RELATIVE_TO_GROUND;
            }
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * polyline导出工程数据
     */
    Polyline.prototype.export = function () {
        var show = this.item.show == undefined ? undefined : this.item.show._value;
        var positions = this.item.polyline.positions.getValue();
        var width = this.item.polyline.width == undefined ? undefined : this.item.polyline.width._value;
        var material = this.item.polyline.material;
        if (material != undefined) {
            material = {
                color: material.color == undefined ? undefined : 'rgba(' + material.color._value.red + ',' + material.color._value.green + ',' + material.color._value.blue + ',' + material.color._value.alpha + ')',
                image: material.image == undefined ? undefined : material.image._value,
                diffusemap: material.diffusemap == undefined ? undefined : material.diffusemap._value,
                alphamap: material.alphamap == undefined ? undefined : material.alphamap._value
            };
        }
        var clampToGround = this.item.polyline.clampToGround == undefined ? undefined : this.item.polyline.clampToGround._value;
        var distanceDisplayCondition = this.item.polyline.distanceDisplayCondition;
        var near = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.near;
        var far = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.far;
        return {
            type: 'polyline',
            treeobj: {
                name: this.treeobj.name
            },
            style: {
                show: show,
                positions: positions,
                width: width,
                material: material,
                clampToGround: clampToGround,
                near: near,
                far: far
            }
        };
    };
    /**
     * 设置polyline的显示隐藏
     * @param {boolean} [b] true|false
     */
    Polyline.prototype.setVisibility = function (b) {
        if (this.item && this.item.item) {
            this.item.item.show = b;
        } else {
            this.item.show = b;
        }
        if (this.item && this.item._points && this.item._points.length > 0) {
            for (var i = 0; i < this.item._points.length; i++) {
                this.item._points[i].show = b;
            }
        }
        if (this._polylines && this._polylines.length > 0) {
            for (var i = 0; i < this._polylines.length; i++) {
                this._polylines[i].show = b;
            }
        }
        if (this._points && this._points.length > 0) {
            for (var i = 0; i < this._points.length; i++) {
                this._points[i].show = b;
            }
        }
        if (this.item && this.item._polylines && this.item._polylines.length > 0) {
            for (var i = 0; i < this.item._polylines.length; i++) {
                this.item._polylines[i].show = b;
            }
        }
    };
    /**
     * 获取polyline的显示隐藏
     */
    Polyline.prototype.getVisibility = function () {
        return this.item.show;
    };
    /**
     *
     */
    Polyline.prototype.setOutlinewidth = function (width) {
        this.item._polyline.material.outlineWidth = width;
    };
    /**
     * 添加线的材料
     * @param {Object} [polyline] polyline对象
     * @param {Object} [material] 材料对象
     * @returns {Object} 返回一个Label对象。
     */
    Polyline.prototype.setMaterial = function (material) {
        try {
            var defaultOption = {
                //color: this._cesium.Color.YELLOW,
                outlineWidth: 3
                //outlineColor: Cesium.Color.BLACK
            };
            var options = this._core.extend(defaultOption, material, true);
            this.item._polyline.material = new this._cesium.PolylineGlowMaterialProperty(material);
            this.item.material = this.item._polyline.material;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 添加线的拉伸
     * @param {Object} [polyline] polyline对象
     * @param {duble} [height] 拉伸高度
     * @returns {Object} 返回一个Label对象。
     */
    Polyline.prototype.setPolylineWall = function (height) {
        try {
            var positions = [];
            var heights = [];
            var ps = this.item._polyline.positions.getValue();
            var ellipsoid = this._viewer.scene.globe.ellipsoid;
            for (var i = 0; i < ps.length; i++) {
                var cartesian3 = new this._cesium.Cartesian3(ps[i].x, ps[i].y, ps[i].z);
                var cartographic = ellipsoid.cartesianToCartographic(cartesian3);
                var lat = this._cesium.Math.toDegrees(cartographic.latitude);
                var lng = this._cesium.Math.toDegrees(cartographic.longitude);
                positions.push(lng);
                positions.push(lat);
                heights.push(height);
            }
            positions = this._cesium.Cartesian3.fromDegreesArray(positions);
            this.item.wall = new this._cesium.WallGraphics({
                positions: positions,
                minimumHeights: heights,
                material: this.item._polyline.material.color._value
            });
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置线的缓冲区添加
     * @param {Object} [polyline] polyline对象
     * @param {radius} 线宽。
     * @returns {Object} 返回一个polyline对象。
     */
    Polyline.prototype.setRadius = function (radius) {
        try {
            var positions = [];
            //var heights = [];
            var ps = this.item._polyline.positions.getValue();
            var ellipsoid = this._viewer.scene.globe.ellipsoid;
            for (var i = 0; i < ps.length; i++) {
                var cartesian3 = new this._cesium.Cartesian3(ps[i].x, ps[i].y, ps[i].z);
                var cartographic = ellipsoid.cartesianToCartographic(cartesian3);
                var lat = this._cesium.Math.toDegrees(cartographic.latitude);
                var lng = this._cesium.Math.toDegrees(cartographic.longitude);
                positions.push(lng);
                positions.push(lat);
                //heights.push(height);
            }
            positions = this._cesium.Cartesian3.fromDegreesArray(positions);
            this.item.corridor = new this._cesium.CorridorGraphics({
                positions: positions,
                width: radius,
                show: true,
                outline: true,
                material: this._cesium.Color.RED.withAlpha(0.4),
                heightReference: this._cesium.HeightReference.none
            });
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置线是否发光
     * @param {Object} [polyline] polyline对象
     * @param {bool} [glow] 是否
     * @returns {Object} 返回一个Label对象。
     */
    Polyline.prototype.setGlow = function (glow) {
        try {
            if (glow) {
                //this.item._polyline.material.glowPower = 0.5;
                //this.item._polyline.material.taperPower = 0.5;
                this.item._polyline.material = new this._cesium.PolylineGlowMaterialProperty({
                    glowPower: 0.2,
                    taperPower: 0.5,
                    color: this.item._polyline.material.color
                });
                this.item.material = this.item._polyline.material;
            } else {
                this.item._polyline.material = new this._cesium.PolylineOutlineMaterialProperty({
                    color: this.item._polyline.material.color,
                    outlineWidth: this.item._polyline.material.outlineWidth,
                    outlineColor: this.item._polyline.material.outlineColor
                });
                this.item.material = this.item._polyline.material;
            }
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置线段透明度
     * @param {Object} [polyline] polyline对象
     * @param {Float} [a] 透明度 0-1
     * @returns {Object} 返回一个Label对象。
     */
    Polyline.prototype.setMaterialAlpha = function (a) {
        try {
            this.item._polyline.material.color._value.alpha = a;
            this.item.material = this.item._polyline.material;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置线段类型
     * @param {Object} [polyline] polyline对象
     * @param {a} [a] 线段类型例如：PolylineGlowMaterialProperty，PolylineOutlineMaterialProperty，PolylineArrowMaterialProperty，PolylineDashMaterialProperty
     * @returns {Object} 返回一个Label对象。
     */
    Polyline.prototype.setType = function (a) {
        try {
            if (a == "PolylineDashMaterialProperty") {
                this.item._polyline.material = new this._cesium.PolylineDashMaterialProperty({
                    color: this.item._polyline.material.color
                });
            } else if (a == "PolylineArrowMaterialProperty") {
                this.item._polyline.material = new this._cesium.PolylineArrowMaterialProperty({
                    color: this.item._polyline.material.color
                });
            } else if (a == "PolylineOutlineMaterialProperty") {
                this.item._polyline.material = new this._cesium.PolylineOutlineMaterialProperty({
                    color: this.item._polyline.material.color
                });
            }
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置线段颜色
     * @param {Object} [polyline] polyline对象
     * @param {htmlColor} htmlColor颜色。
     * @returns {Object} 返回一个Label对象。
     */
    Polyline.prototype.setMaterialColor = function (htmlColor) {
        try {
            this.item._polyline.material.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置线段边框颜色
     * @param {Object} [polyline] polyline对象
     * @returns {htmlColor} htmlColor颜色。
     * @returns {Object} 返回一个Label对象。
     */
    Polyline.prototype.setOutlineColor = function (htmlColor) {
        try {
            this.item._polyline.material.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置线段是否贴地
     * @param {Object} [polyline] polyline对象
     * @param {bool} [clampToGround] 指定Polyline是否应该夹在地面上
     * @returns {Object} 返回一个polyline对象。
     */
    Polyline.prototype.setClampToGround = function (clampToGround) {
        try {
            this.item._polyline.clampToGround = clampToGround;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 修改线段的宽度
     * @param {Object} [polyline] polyline对象
     * @param {String} [width] 设置线段的宽度
     * @returns {Object} 返回一个polyline对象。
     */
    Polyline.prototype.setWidth = function (width) {
        try {
            this.item._polyline.width = width;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 修改线段的可视距离
     * @param {Object} [polyline] polyline对象
     * @param {String} [min, max] 设置线段的可视距离
     * @returns {Object} 返回一个polyline对象。
     */
    Polyline.prototype.setDistanceDisplayCondition = function (min, max) {
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        try {
            this.item._polyline.distanceDisplayCondition = distance;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };

    Object.defineProperties(Polyline.prototype, {
        /**
         * 设置矩形高亮
         */
        HighLight: {
            set: function (b) {
                if (b) {
                    this.item.material = this.item.polyline.material;
                }
                if (b) {
                    this.item.polyline.material = new this._cesium.PolylineGlowMaterialProperty({
                        glowPower: .8, //一个数字属性，指定发光强度，占总线宽的百分比。
                        color: this._cesium.Color.ORANGERED.withAlpha(.9)
                    });
                } else {
                    this.item.polyline.material = this.item.material;
                }
            }
        },
        /**
         * 设置geojson图层线的材质
         * @param {object} material
         */
        polylinemMterial: {
            set: lodash.debounce(function (material) {
                if (this._core.isnull(material)) return;
                if (!this._core.isnull(material)) {
                    if (this._core.isHtmlColor(material)) {
                        material = this._Color.colorFromHtmlColor(material);
                    } else {
                        if (/^rgb/.test(material)) {
                            material = this._Color.rgbaStringToRgbaObj(material);
                        }
                        if (material.r > 1) {
                            material.r = material.r / 255;
                        }
                        if (material.g > 1) {
                            material.g = material.g / 255;
                        }
                        if (material.b > 1) {
                            material.b = material.b / 255;
                        }
                        if (material.a > 1) {
                            material.a = material.a / 255;
                        }
                        material = this._Color.createColor(material.r, material.g, material.b, material.a);
                    }
                }
                this.item.polyline.material = material;
                this.item.material = this.item.polyline.material;
            }, 500),
            get: function () {
                var material = this.item.polyline.material;
                if (material)
                    try {
                        return this._Color.toHtmlColor('rgb(' + material._value.red * 255 + ',' + material._value.green * 255 + ',' + material._value.blue * 255 + ',' + material._value.alpha * 255 + ')');
                    } catch (ex) {
                    }
            }
        },
        /**
         * 设置geojson图层线的线型
         * @param {object} arcType
         */
        polylinemArcType: {
            set: lodash.debounce(function (arcType) {
                if (this._core.isnull(arcType)) return;
                this.item.polyline.arcType = arcType;
            }, 500),
            get: function () {
                var arcType = this.item.polyline.arcType;
                if (arcType) {
                    return arcType._value;
                }
                return undefined;
            }
        },
        /**
         * 设置geojson图层线的宽度
         * @param {Float} width
         */
        polylineWidth: {
            set: lodash.debounce(function (width) {
                if (this._core.isnull(width)) return;
                width = parseFloat(width);
                this.item.polyline.width = width;
            }, 500),
            get: function () {
                var width = this.item.polyline.width;
                if (width) {
                    return width._value;
                }
                return undefined;
            }
        },
    });
    Object.defineProperties(Polyline.prototype, {
        /**
         * 获取或设置矩形
         */
        rectangle: {
            get: function () {
                return this.item.rectangle;
            },
            set: function (rectangle) {
                this.item.rectangle = rectangle;
            }
        }
    });

    Object.defineProperties(Polyline.prototype, {
        /**
         * 获取或设置线条
         */
        polyline: {
            get: function () {
                return this.item.polyline;
            },
            set: function (polyline) {
                this.item.polyline = polyline;
            }
        }
    });

    Object.defineProperties(Polyline.prototype, {
        /**
         * 获取或设置面
         */
        polygon: {
            get: function () {
                return this.item.polygon;
            },
            set: function (polygon) {
                this.item.polygon = polygon;
            }
        }
    });

    Object.defineProperties(Polyline.prototype, {
        /**
         * 获取或设置点
         */
        point: {
            get: function () {
                return this.item.point;
            },
            set: function (point) {
                this.item.point = point;
            }
        }
    });
    Object.defineProperties(Polyline.prototype, {
        /**
         * 获取或设置标签
         */
        label: {
            get: function () {
                return this.item.label;
            },
            set: function (label) {
                this.item.label = label;
            }
        }
    });

    Object.defineProperties(Polyline.prototype, {
        /**
         * 获取或设置模型
         */
        model: {
            get: function () {
                return this.item.model;
            },
            set: function (model) {
                this.item.model = model;
            }
        }
    });
    Polyline.prototype.setItem = function (item) {
        this.item = item;
    };
    //工程树添加
    Polyline.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    Object.defineProperties(Polyline.prototype, {
        /**
         * 获取或设置墙
         */
        wall: {
            get: function () {
                return this.item.wall;
            },
            set: function (wall) {
                this.item.wall = wall;
            }
        }
    });
    Object.defineProperties(Polyline.prototype, {
        /**
         * 获取墙的模板属性
         */
        polylineTempOptions: {
            get: function () {
                return {
                    positions: [], //	Property		optional A Property specifying the array of Cartesian3 positions that define the line strip.
                    arcType: ArcType.GEODESIC, //	ArcType	ArcType.GEODESIC	optional The type of line the polyline segments must follow.
                    clampToGround: false, //	Property	false	optional A boolean Property specifying whether the Polyline should be clamped to the ground.
                    width: 1.0, //	Property	1.0	optional A numeric Property specifying the width in pixels.
                    show: true, //	Property	true	optional A boolean Property specifying the visibility of the polyline.
                    material: this._cesium.Color.WHITE
                }
            }
        }
    });
    Object.defineProperties(Polyline.prototype, {
        MaterialColor: {
            get: function () {
                return new Color(this._viewer, this._cesium).toHtmlColor('rgb(' + this.item._polyline.material.color._value.red * 255 + ',' + this.item._polyline.material.color._value.green * 255 + ',' + this.item._polyline.material.color._value.blue * 255 + ')');
            }
        },
        Height: {
            get: function () {
                return this.item._polyline.height
            }
        },
        Visibility: {
            get: function () {
                return this.item.show
            }
        },
        Outlinewidth: {
            get: function () {
                return this.item._polyline.material.outlineWidth._value
            }
        },
        OutlineColor: {
            get: function () {
                var colorPar = this.item._polyline.material.outlineColor;
                if (colorPar) {
                    colorPar = colorPar._value;
                    return new Color(this._viewer, this._cesium).toHtmlColor('rgb(' + colorPar.red * 255 + ',' + colorPar.green * 255 + ',' + colorPar.blue * 255 + ')');
                } else {
                    return '#ff0000'
                }
            }
        },
        ClampToGround: {
            get: function () {
                return this.item._polyline.clampToGround
            }
        },
        Width: {
            get: function () {
                return this.item._polyline.width._value
            }
        },
        Type: {
            get: function () {
                if (this.item._polyline.material instanceof this._cesium.PolylineDashMaterialProperty) {
                    return 'PolylineDashMaterialProperty'
                } else if (this.item._polyline.material instanceof this._cesium.PolylineArrowMaterialProperty) {
                    return 'PolylineArrowMaterialProperty'
                } else {
                    return 'PolylineOutlineMaterialProperty'
                }
            }
        },
        Glow: {
            get: function () {
                return (this.item._polyline.material instanceof this._cesium.PolylineGlowMaterialProperty)
            }
        },
        MaterialAlpha: {
            get: function () {
                return this.item._polyline.material.color._value.alpha * 100
            }
        }
    });

    /**
     *仿照te修改
     */
    Polyline.prototype.CreatePolyline = function (Geometry, LineColor, AltitudeType, GroupID, Description) {
        this._Geometry = Geometry;

        var defaultOption = {
            color: this._cesium.Color.YELLOW,
            outlineColor: this._cesium.Color.BLACK,
            width: 10,
            show: true,
            AltitudeType: this._cesium.defaultValue(AltitudeType, 999)
            //distanceDisplayCondition: new this._cesium.DistanceDisplayCondition(LabelStyle.MinViewingHeight, LabelStyle.MaxViewingHeight)
        };
        if (LineColor && LineColor !== '') {
            defaultOption.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(LineColor);
        }

        var pArray = [];
        for (var i = 0; i < Geometry.length; i++) {
            pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y));
        }


        this.item = this._viewer.entities.add({
            name: Description,
            polyline: {
                positions: pArray,
                width: defaultOption.width,
                material: new this._cesium.PolylineGlowMaterialProperty({
                    outlineColor: defaultOption.outlineColor,
                    color: defaultOption.color
                })
            }
        });

        var obj = {
            id: this.item.id,
            name: Description,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polyline',
            item: this
        };

        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    /**
     * 结束当前操作
     */
    Polyline.prototype.forceEndHanlder = function () {
        if (this.handler) {
            this.handler.destroy();
            this.handler = undefined;
        }
        if (this._tree.handler) {
            this._tree.handler.destroy();
            this._tree.handler = undefined;
        }
    };

    /**
     *
     * 添加面。
     *
     * @alias Polygon
     * @constructor
     *
     */
    function Polygon(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._Color = new Color(this._viewer, this._cesium);
        this._core = new Core();
        this._getPosition = new getPosition(this._viewer, this._cesium);
        this._tree = tree;
        this._points = [];
        this._lable = null;
        this._entity = null;
        this.polygon1;
        //材质扩散效果
        this.id = "0";
        this.curCanvas = "a";
    }

    /**
     * 向三维场景中添加面。
     * @param {Array} [Geometry] 一个经纬度数组 例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
     * @param {String} [fillColorOrOption] 填充颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Polygon.prototype.createPolygon = function (Geometry, fillColorOrOption, AltitudeType, GroupID, Description) {
        var pArray = [];
        var hierarchy;
        if (Geometry[0] instanceof Array) {
            if (Geometry[0].length === 2) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(Geometry[i][0], Geometry[i][1]);
                }
                hierarchy = this._cesium.Cartesian3.fromDegreesArray(pArray);
            } else if (Geometry[0].length === 3) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(Geometry[i][0], Geometry[i][1], Geometry[i][2]);
                }
                hierarchy = this._cesium.Cartesian3.fromDegreesArrayHeights(pArray);
            }
        } else {
            if (Geometry[0].z) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(Geometry[i].x, Geometry[i].y, Geometry[i].z);
                }
                hierarchy = this._cesium.Cartesian3.fromDegreesArrayHeights(pArray);
            } else {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(Geometry[i].x, Geometry[i].y);
                }
                hierarchy = this._cesium.Cartesian3.fromDegreesArray(pArray);
            }
        }
        var option = fillColorOrOption;
        if (typeof option === 'string') {
            option = {
                fillColor: option
            };
        }
        this.item = this._viewer.entities.add({
            name: Description,
            polygon: {
                //hierarchy: hierarchy,
                hierarchy: new this._cesium.PolygonHierarchy(hierarchy),
                material: new Color(this._viewer, this._cesium).colorFromHtmlColor(option.fillColor),
                heightReference: this._core.defaultValue(AltitudeType, 1),
                perPositionHeight: AltitudeType === 1 ? false : true,
                outline: true,
                outlineWidth: this._core.defaultValue(option.outlineWidth, 1),
                outlineColor: new Color(this._viewer, this._cesium).colorFromHtmlColor(this._core.defaultValue(option.outlineColor, option.fillColor)),
            }
        });
        var obj = {
            id: this.item.id,
            name: Description || "新建面" + this._core.getuid(),
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygon',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    /**
      * 获取polygon样式
      */
    Polygon.prototype.getstyles = function () {
        var styles = {};
        styles.show = this.item.polygon.show ? this.item.polygon.show._value : true;
        styles.hierarchy = this.item.polygon.hierarchy ? this.item.polygon.hierarchy.getValue().positions.toString() : null;
        styles.height = this.item.polygon.height ? this.item.polygon.height._value : null;
        styles.heightReference = this.item.polygon.heightReference ? this.item.polygon.heightReference._value : null;
        styles.extrudedHeight = this.item.polygon.extrudedHeight ? this.item.polygon.extrudedHeight.getValue() : null;
        styles.extrudedHeightReference = this.item.polygon.extrudedHeightReference ? this.item.polygon.extrudedHeightReference.toString() : null;
        styles.stRotation = this.item.polygon.stRotation ? this.item.polygon.stRotation._value : null;
        styles.granularity = this.item.polygon.granularity ? this.item.polygon.granularity._value : null;
        styles.fill = this.item.polygon.fill ? this.item.polygon.fill._value : null;
        styles.material = {};
        styles.material.color = this.item.polygon.material && this.item.polygon.material.color && this.item.polygon.material.color._value ? 'rgba' + this.item.polygon.material.color.toString() : null;
        styles.material.image = this.item.polygon.material && this.item.polygon.material.image ? this.item.polygon.material.image._value : null;
        styles.material.repeat = this.item.polygon.material && this.item.polygon.material.repeat && this.item.polygon.material.repeat._value ? this.item.polygon.material.repeat._value : null;
        styles.outline = this.item.polygon.outline ? this.item.polygon.outline._value : null;
        styles.outlineWidth = this.item.polygon.outlineWidth ? this.item.polygon.outlineWidth._value : null;
        styles.outlineColor = this.item.polygon.outlineColor && this.item.polygon.outlineColor._value ? 'rgba' + this.item.polygon.outlineColor.toString() + '' : null;
        styles.perPositionHeight = this.item.polygon.perPositionHeight ? this.item.polygon.perPositionHeight.toString() : null;
        styles.closeTop = this.item.polygon.closeTop ? this.item.polygon.closeTop.toString() : null;
        styles.closeBottom = this.item.polygon.closeBottom ? this.item.polygon.closeBottom.toString() : null;
        styles.arcType = this.item.polygon.arcType ? this.item.polygon.arcType.toString() : null;
        styles.classificationType = this.item.polygon.classificationType ? this.item.polygon.classificationType.toString() : null;
        styles.near = this.item.polygon.distanceDisplayCondition ? this.item.polygon.distanceDisplayCondition._value.near : null;
        styles.far = this.item.polygon.distanceDisplayCondition ? this.item.polygon.distanceDisplayCondition._value.far : null;
        // styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
     * 向三维场景中云图。
     * @param {String} [name] 名称。
     * @param {Object} [area] 区域范围：{
            minx:73.16895,
            miny:12.2023,
            maxx:134.86816,
            maxy:54.11485
     * }。
     * @param {Array} [CloudMap] 云图, 云图影像数组
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Polygon.prototype.createCloudMap = function (name, area, CloudMap, speed) {
        var pArray = [];
        var _this = this;
        pArray.push(area.minx, area.miny);
        pArray.push(area.maxx, area.miny);
        pArray.push(area.maxx, area.maxy);
        pArray.push(area.minx, area.maxy);
        var hierarchy = this._cesium.Cartesian3.fromDegreesArray(pArray);
        speed = this._core.defaultValue(speed, 1);
        var imageIndex = 0;
        var num = 0;
        this.item = this._viewer.entities.add({
            name: name,
            polygon: {
                hierarchy: new this._cesium.PolygonHierarchy(hierarchy),
                material: new Cesium.ImageMaterialProperty({
                    image: new this._cesium.CallbackProperty(function () {
                        num += speed;
                        if (num > 30) {
                            num = 0;
                            imageIndex++;
                            imageIndex > CloudMap.length - 1 && (imageIndex = 0);
                        }
                        return CloudMap[imageIndex];
                    }, false),
                    color: new this._cesium.CallbackProperty(function () {
                        //console.log(num < 15 ? 0.5 + num / 30 : 1.5 - num / 30);
                        return _this._cesium.Color.WHITE.withAlpha(num < 15 ? 0.5 + num / 30 : 1.5 - num / 30);
                    }, false),
                    repeat: new _this._cesium.Cartesian2(1, 1)
                })
            }
        });
        var obj = {
            id: this.item.id,
            name: name,
            pId: 0,
            type: 'polygon',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);
        return this;
    };
    //绘制扇形根据角度创建
    Polygon.prototype.createSector = function (posion, radius, angle, horizontal, pitch) {
        var color = {
            fillColor: this._cesium.Color.YELLOW.withAlpha(0.5),
            outlineColor: this._cesium.Color.YELLOW
        };
        var sectorPosition = [];
        //计算
        var radian = 2 * Math.PI / 360 * pitch;
        var a = Math.sin(radian) * radius;//对边
        var b = Math.cos(radian) * radius;//邻边
        var ty = destinationVincenty(posion, horizontal, b);
        //起始点坐标
        var firstPoint = {
            lon: posion.lon,
            lat: posion.lat,
            height: posion.height
        };
        //计算最后坐标
        var lastPoint = {
            lon: ty.lon,
            lat: ty.lat,
            height: posion.height + a
        };

        var Ea = 6378137.0;     //   赤道半径
        var Eb = 6356725.0;     //   极半径
        var that = this;
        sectorPosition = getSectorPosition(firstPoint, lastPoint);
        //添加高度
        //sectorPosition = getSectorPosition(firstPoint, lastPoint, height);
        //var material = this.setImageMaterialProperty();

        var canvas = document.createElement('canvas');
        canvas.id = "0-a";
        canvas.width = 800;
        canvas.height = 800;
        document.body.appendChild(canvas);

        var canvas1 = document.createElement('canvas');
        canvas1.id = "0-b";
        canvas1.width = 800;
        canvas1.height = 800;
        var curCanvas = "a";
        document.body.appendChild(canvas1);
        var lo = 1;
        //New color every time it's called
        var randomColor = new Cesium.CallbackProperty(function (time, result) {

            var canvas = document.getElementById("0-" + curCanvas);
            var ctx = canvas.getContext("2d");
            ctx.strokeStyle = 'red';
            ctx.lineWidth = 15;
            function drawArc(start, end, r) {
                ctx.beginPath();
                ctx.arc(400, 800, r, d2a(start), d2a(end), false);
                ctx.stroke();
            }
            function drawBak(start, end, r) {
                ctx.beginPath();
                ctx.arc(400, 800, r, d2a(start), d2a(end), false);
                ctx.stroke();
            }
            function d2a(n) {
                n -= 90;
                return n * Math.PI / 180;
            }


            ctx.clearRect(0, 0, 800, 800);

            var lineargradient = ctx.createLinearGradient(0, 800, 0, 0);
            lineargradient.addColorStop(0, 'rgba(255,0,0,0.6)');
            lineargradient.addColorStop(1, 'rgba(255,0,0,0)');

            //ctx.fillRect(0, 0, 800, 800);
            //线的颜色
            drawBak(-(angle / 2), angle / 2, lo + 600);
            ctx.lineTo(400, 800);
            // 闭合路径
            ctx.closePath();
            ctx.fillStyle = lineargradient;
            ctx.fill();
            /**获取画布上下文*/

            drawArc(-(angle / 2), angle / 2, lo + 100);
            drawArc(-(angle / 2), angle / 2, lo + 200);
            drawArc(-(angle / 2), angle / 2, lo + 300);
            drawArc(-(angle / 2), angle / 2, lo + 400);
            drawArc(-(angle / 2), angle / 2, lo + 500);
            drawArc(-(angle / 2), angle / 2, lo + 600);
            if (lo < 100) {
                lo = lo + 1;
            } else {
                lo = 1;
            }
            curCanvas = curCanvas === 'a' ? 'b' : 'a';

            return canvas;
        }, false);
        this.item = this._viewer.entities.add({
            polygon: {
                //hierarchy: new this._cesium.PolygonHierarchy(this._cesium.Cartesian3.fromDegreesArray(sectorPosition)),
                hierarchy: new this._cesium.PolygonHierarchy(this._cesium.Cartesian3.fromDegreesArrayHeights(sectorPosition)),
                //material: new this._cesium.ColorMaterialProperty(color.fillColor),
                material: new this._cesium.ImageMaterialProperty({
                    image: randomColor,
                    transparent: true
                }),
                perPositionHeight: true,
                outlineColor: color.outlineColor
            }
        });
        //通过角度和距离获取经纬度
        function GetPositionFromA_D(lat, lon, distance, anglew) {
            var dx = distance * Math.sin(anglew * Math.PI / 180.0);
            var dy = distance * Math.cos(anglew * Math.PI / 180.0);

            var ec = Eb + (Ea - Eb) * (90.0 - lat) / 90.0;
            var ed = ec * Math.cos(lat * Math.PI / 180);

            var newLon = (dx / ed + lon * Math.PI / 180.0) * 180.0 / Math.PI;
            var newLat = (dy / ec + lat * Math.PI / 180.0) * 180.0 / Math.PI;

            return [newLon, newLat];
        }

        //获取扇形点
        function getSectorPosition(firstPoint, lastPoint) {
            var points = [];
            var data = getDistanceAndAngle(firstPoint.lat, firstPoint.lon, lastPoint.lat, lastPoint.lon);
            var anglew = data.anglew;
            var distance = data.distance;
            points.push(firstPoint.lon, firstPoint.lat, firstPoint.height);
            for (var i = anglew - angle / 2, p = null; i < anglew + angle / 2; i++) {
                p = GetPositionFromA_D(firstPoint.lat, firstPoint.lon, distance, i);
                points.push(p[0], p[1], lastPoint.height + i * 10);
            }
            return points;
        }

        //根据两点经纬度测算距离和方位角
        function getDistanceAndAngle(lat1, lng1, lat2, lng2) {
            var radLat1 = getRad(lat1);
            var radLat2 = getRad(lat2);
            var a = getRad(lat2) - getRad(lat1);
            var b = getRad(lng2) - getRad(lng1);

            var distance = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) + Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
            distance = distance * Ea;
            distance = Math.round(distance * 10000) / 10000.0;

            return {
                anglew: that._core.TwoPointAzimuth(lng1, lat1, lng2, lat2),
                distance: distance
            };
        }

        function getRad(d) {
            return d * Math.PI / 180.0;
        }
        /**
        *Calculate destination point given start point lat/long (numeric degrees),
        * bearing (numeric degrees) & distance (in m).
        */
        function destinationVincenty(lonlat, brng, dist) {
            var VincentyConstants = {
                a: 6378137,
                b: 6356752.3142,
                f: 1 / 298.257223563
            };

            /**
            * 度换成弧度
            * @param  {Number} d  度
            * @return {Number}   弧度
            */
            function rad(d) {
                return d * Math.PI / 180.0;
            }

            /**
             * 弧度换成度
             * @param  {Number} x 弧度
             * @return {Number}   度
             */
            function deg(x) {
                return x * 180 / Math.PI;
            }
            var ct = VincentyConstants;
            var a = ct.a, b = ct.b, f = ct.f;

            var lon1 = lonlat.lon * 1;  //乘一（*1）是为了确保经纬度的数据类型为number
            var lat1 = lonlat.lat * 1;

            var s = dist;
            var alpha1 = rad(brng);
            var sinAlpha1 = Math.sin(alpha1);
            var cosAlpha1 = Math.cos(alpha1);

            var tanU1 = (1 - f) * Math.tan(rad(lat1));
            var cosU1 = 1 / Math.sqrt((1 + tanU1 * tanU1)), sinU1 = tanU1 * cosU1;
            var sigma1 = Math.atan2(tanU1, cosAlpha1);
            var sinAlpha = cosU1 * sinAlpha1;
            var cosSqAlpha = 1 - sinAlpha * sinAlpha;
            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 sigma = s / (b * A), sigmaP = 2 * Math.PI;
            while (Math.abs(sigma - sigmaP) > 1e-12) {
                var cos2SigmaM = Math.cos(2 * sigma1 + sigma);
                var sinSigma = Math.sin(sigma);
                var cosSigma = Math.cos(sigma);
                var deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) -
                    B / 6 * cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM)));
                sigmaP = sigma;
                sigma = s / (b * A) + deltaSigma;
            }

            var tmp = sinU1 * sinSigma - cosU1 * cosSigma * cosAlpha1;
            var lat2 = Math.atan2(sinU1 * cosSigma + cosU1 * sinSigma * cosAlpha1,
                (1 - f) * Math.sqrt(sinAlpha * sinAlpha + tmp * tmp));
            var lambda = Math.atan2(sinSigma * sinAlpha1, cosU1 * cosSigma - sinU1 * sinSigma * cosAlpha1);
            var C = f / 16 * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha));
            var L = lambda - (1 - C) * f * sinAlpha *
                (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));


            var lon_destina = lon1 * 1 + deg(L);

            //var num_lon_dest = lon_destina*1;

            //var lon_destina = new Number;

            var lonlat_destination = { lon: lon_destina, lat: deg(lat2) };

            return lonlat_destination;
        }
        return this;
    };
    //效果贴图
    Polygon.prototype.setImageMaterialProperty = function () {
        var that = this;
        var canvas = document.createElement('canvas');
        canvas.id = "0-a";
        canvas.width = 700;
        canvas.height = 100;

        var canvas1 = document.createElement('canvas');
        canvas1.id = "0-b";
        canvas1.width = 700;
        canvas1.height = 100;
        document.body.appendChild(canvas);
        document.body.appendChild(canvas1);
        var ima = new that._cesium.CallbackProperty(function (time, result) {
            var canvas = document.getElementById("0-" + that.curCanvas);
            var ctx = canvas.getContext("2d");
            //var grd = ctx.createLinearGradient(0, 100, 0, 0);
            canvas.strokeStyle = '1px solid red';
            //线的颜色
            ctx.strokeStyle = 'red'; //颜色
            ctx.fillStyle = "red";
            ctx.save();
            ctx.translate(100, 100);
            ctx.arc(0, 0, 100, 0, 180 * Math.PI / 180);
            ctx.restore();
            ctx.stroke();
            that.curCanvas = that.curCanvas === 'a' ? 'b' : 'a';
            return canvas;
        }, false);
        return new that._cesium.ImageMaterialProperty({
            image: ima,
            transparent: true
        })
    };
    //绘制扇形
    Polygon.prototype.executeSector = function (method, parameter) {
        var _this = this;
        this._tree.starttemporaryItem(this._viewer);
        this._tree.removeHandler();
        var Viewer = this._viewer;
        var clickNum = 0;
        var firstPoint, lastPoint;
        var color = {
            fillColor: _this._cesium.Color.YELLOW.withAlpha(0.5),
            outlineColor: _this._cesium.Color.YELLOW
        };
        if (parameter && parameter.fillColor) {
            color.fillColor = parameter.fillColor;
        }
        if (parameter && parameter.outlineColor) {
            color.outlineColor = parameter.outlineColor;
        }
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        var sectorPosition = [];
        var toolTip = this._core.CreateTooltip();
        this.item = undefined;
        var SectorAngle, SectorDistance;
        this.end = (type) => {
            _this._tree.handler.destroy();
            _this._tree.handler = null;
            toolTip.show(false);

            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0, "0");

            this.end = undefined;

            if (type === 'cancel') {
                _this.item && Viewer.entities.remove(_this.item);
                return;
            }

            _this.item && (_this.item.polygon.hierarchy = new _this._cesium.PolygonHierarchy(_this._cesium.Cartesian3.fromDegreesArray(sectorPosition)));
            if (typeof method == 'function') {
                method(_this.item, {
                    position: firstPoint,
                    angle: SectorAngle,
                    distance: SectorDistance
                });
            }
        };
        this._tree.handler.setInputAction(function (movement) {
            var degrees = _this._getPosition.getMouseDegrees(movement);

            if (clickNum === 0) {
                firstPoint = {
                    lon: degrees.lon,
                    lat: degrees.lat,
                    height: degrees.height
                };
                clickNum++;
            } else {
                _this.end && _this.end();
            }
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            _this.end && _this.end('cancel');
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            if (clickNum === 0) {
                toolTip.showAt(movement.endPosition, '点击开始绘制');
                return;
            } else {
                toolTip.showAt(movement.endPosition, '再次点击结束绘制，右键取消');
            }
            lastPoint = _this._getPosition.getMouseDegrees(movement);
            sectorPosition = getSectorPosition(firstPoint, lastPoint);
            if (!_this.item) {
                _this.item = Viewer.entities.add({
                    polygon: {
                        hierarchy: new _this._cesium.PolygonHierarchy(_this._cesium.Cartesian3.fromDegreesArray(sectorPosition)),
                        material: new _this._cesium.ColorMaterialProperty(color.fillColor),
                        outlineColor: color.outlineColor,
                        fill: true
                    }
                });
                _this.item.polygon.hierarchy = new _this._cesium.CallbackProperty(function () {
                    return new _this._cesium.PolygonHierarchy(_this._cesium.Cartesian3.fromDegreesArray(sectorPosition));
                }, false);
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        var Ea = 6378137.0;     //   赤道半径
        var Eb = 6356725.0;     //   极半径

        //通过角度和距离获取经纬度
        function GetPositionFromA_D(lat, lon, distance, angle) {
            var dx = distance * Math.sin(angle * Math.PI / 180.0);
            var dy = distance * Math.cos(angle * Math.PI / 180.0);

            var ec = Eb + (Ea - Eb) * (90.0 - lat) / 90.0;
            var ed = ec * Math.cos(lat * Math.PI / 180);

            var newLon = (dx / ed + lon * Math.PI / 180.0) * 180.0 / Math.PI;
            var newLat = (dy / ec + lat * Math.PI / 180.0) * 180.0 / Math.PI;

            return [newLon, newLat];
        }

        //获取扇形点
        function getSectorPosition(firstPoint, lastPoint) {
            var points = [];
            var data = getDistanceAndAngle(firstPoint.lat, firstPoint.lon, lastPoint.lat, lastPoint.lon);
            SectorAngle = data.angle;
            SectorDistance = data.distance;
            points.push(firstPoint.lon, firstPoint.lat);
            for (var i = SectorAngle - 30, p = null; i < SectorAngle + 30; i++) {
                p = GetPositionFromA_D(firstPoint.lat, firstPoint.lon, SectorDistance, i);
                points.push(p[0], p[1]);
            }
            return points;
        }

        //根据两点经纬度测算距离和方位角
        function getDistanceAndAngle(lat1, lng1, lat2, lng2) {
            var radLat1 = getRad(lat1);
            var radLat2 = getRad(lat2);
            var a = getRad(lat2) - getRad(lat1);
            var b = getRad(lng2) - getRad(lng1);

            var distance = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) + Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
            distance = distance * Ea;
            distance = Math.round(distance * 10000) / 10000.0;

            return {
                angle: _this._core.TwoPointAzimuth(lng1, lat1, lng2, lat2),
                distance: distance
            };
        }

        function getRad(d) {
            return d * Math.PI / 180.0;
        }
        return this;
    };
    //画面全操作
    //exe
    Polygon.prototype.executePolygon = function (parameter, method) {
        var _this = this;
        this._tree.starttemporaryItem(this._viewer);
        this._tree.removeHandler();
        var PolygonPrimitive = (function () {
            function execute(hierarch) {
                this.options = {
                    name: '',
                    polygon: {
                        hierarchy: [],
                        heightReference: _this._core.defaultValue(parameter.heightReference, 1),
                        perPositionHeight: parameter.heightReference === 0 ? true : false,
                        material: _this._core.defaultValue(parameter.material, _this._cesium.Color.YELLOW.withAlpha(0.5)),
                    }
                };
                this.hierarchy = hierarch;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.hierarchy;
                };
                //实时更新polygon.hierarchy
                this.options.polygon.hierarchy = new _this._cesium.CallbackProperty(_update, false);
                this.polygon = _this._viewer.entities.add(this.options);
                _this.item = this.polygon;
                _this._tree.temporaryItem.obj.push(this.polygon);
            };
            return execute;
        })();
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var positions = [];
        var hierarch = {};
        var poly = undefined;
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        var tooltip = this._core.CreateTooltip();
        //隐藏选中容器标识
        //鼠标单击画点
        this._tree.handler.setInputAction(function (movement) {
            var cartesian = _this._getPosition.getMousePosition(movement);
            if (positions.length == 0) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);
            hierarch = new _this._cesium.PolygonHierarchy(positions);
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        this._tree.handler.setInputAction(function (movement) {
            if (positions.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else if (positions.length <= 2) {
                tooltip.showAt(movement.endPosition, '点击继续绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束绘制！');
            }
            var cartesian = _this._getPosition.getMousePosition(movement);
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    hierarch = new _this._cesium.PolygonHierarchy(positions);
                    poly = new PolygonPrimitive(hierarch);
                } else {
                    if (cartesian != undefined) {
                        positions.pop();
                        cartesian.y += (1 + Math.random());
                        positions.push(cartesian);
                        hierarch = new _this._cesium.PolygonHierarchy(positions);
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //鼠标右键单击结束绘制
        this._tree.handler.setInputAction(function (movement) {
            _this._tree.endtemporaryItem();
            _this._tree.handler.destroy();
            tooltip.show(false);
            //创建面对象并返回面对象
            var ploylinejl = { polygon: {}, positions: [], area: [] };
            ploylinejl.polygon = poly;
            var positionsop = [];
            for (var j = 0; j < positions.length; j++) {
                var cartographicdr = _this._cesium.Cartographic.fromCartesian(positions[j]);
                var longitudeStringdr = _this._cesium.Math.toDegrees(cartographicdr.longitude);
                var latitudeStringdr = _this._cesium.Math.toDegrees(cartographicdr.latitude);
                var heightStringdr = cartographicdr.height;
                positionsop.push({ lon: longitudeStringdr, lat: latitudeStringdr, hei: heightStringdr });
            }
            ploylinejl.positions = positionsop;
            //var textArea = core.getArea(tempPoints, positions, cesium) + "平方公里";
            //  ploylinejl.area = core.getArea(tempPoints, positions, cesium);
            ///工程树添加
            //var GroupID = 0;
            //if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            //    GroupID = tree.selectedItem.id;
            //var id = _this._core.getuid();
            //var obj = {
            //    id: id,
            //    name: '新建面' + id,
            //    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
            //    type: 'polygon',
            //    item: _this
            //};
            //_this.setTreeobj(obj);
            //tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);

            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0, "0");
            if (typeof method == 'function') {
                method(ploylinejl);
            }
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        return this;
    };
    //面贴视频
    Polygon.prototype.executePolygonvideo = function (method, parameter) {
        var _this = this;
        this._tree.starttemporaryItem(this._viewer);
        this._tree.removeHandler();
        var PolygonPrimitive = (function () {
            function execute(hierarch) {
                this.options = {
                    name: '',
                    polygon: {
                        hierarchy: [],
                        heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND,
                        classificationType: _this._cesium.ClassificationType.BOTH,
                        material: _this._cesium.Color.YELLOW.withAlpha(0.5)
                    }
                };
                this.hierarchy = hierarch;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.hierarchy;
                };
                //实时更新polygon.hierarchy
                this.options.polygon.hierarchy = new _this._cesium.CallbackProperty(_update, false);
                this.polygon = _this._viewer.entities.add(this.options);
                //旋转
                vid.style.transform = 'rotate(' + parameter.angle + 'deg)';
                this.polygon.polygon.stRotation = _this._cesium.Math.toRadians(parameter.angle);
                _this.item = this.polygon;
                _this._tree.temporaryItem.obj.push(this.polygon);
            };
            return execute;
        })();
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var positions = [];
        var hierarch = {};
        var poly = undefined;
        var tooltip = this._core.CreateTooltip();
        var videoID = _this._core.getuid();
        //视频修改
        var toolbar = document.getElementById('videoToolbar');
        if (!toolbar) {
            var htmle = '<div id="videoToolbar"></div>';
            $('.cesium-viewer').append(htmle);
            toolbar = document.getElementById('videoToolbar');
        }
        var videoHtml = '<video id="video' + videoID + '"  style="display: none;" muted autoplay loop crossorigin controls><source src="' + parameter.url + '" type="video/mp4"></video>';
        $(toolbar).append(videoHtml);
        var vid = document.getElementById('video' + videoID);
        //旋转
        vid.style.transform = 'rotate(' + parameter.angle + 'deg)';

        let polyline;
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        //隐藏选中容器标识
        //鼠标单击画点
        this._tree.handler.setInputAction(function (movement) {
            // cartesian = _this._viewer.scene.pickPosition(movement.endPosition);
            var cartesian = _this._getPosition.getMousePosition(movement);
            if (positions.length == 0) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);
            if (positions.length === 2 && !polyline) {
                polyline = _this._viewer.entities.add({
                    name: '临时线',
                    polyline: {
                        positions: new Cesium.CallbackProperty(() => {
                            return positions;
                        }, false),
                        clampToGround: true,
                        material: new Cesium.ColorMaterialProperty(Cesium.Color.YELLOW.withAlpha(0.5)),
                        width: 3,
                    }
                });
            }
            if (positions.length >= 3 && !poly) {
                polyline && _this._viewer.entities.remove(polyline);
                hierarch = new _this._cesium.PolygonHierarchy(positions);
                poly = new PolygonPrimitive(hierarch);
                return;
            }
            hierarch = new _this._cesium.PolygonHierarchy(positions);
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        this._tree.handler.setInputAction(function (movement) {
            if (positions.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else if (positions.length <= 2) {
                tooltip.showAt(movement.endPosition, '点击继续绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束绘制！');
            }
            if (positions.length >= 2) {
                var cartesian = _this._getPosition.getMousePosition(movement);
                if (cartesian) {
                    positions.pop();
                    positions.push(cartesian);
                    hierarch = new _this._cesium.PolygonHierarchy(positions);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //鼠标右键单击结束绘制
        this._tree.handler.setInputAction(function (movement) {
            _this.end && _this.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        this.end = (type) => {
            _this._tree.endtemporaryItem();
            _this._tree.handler.destroy();
            tooltip.show(false);
            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0, "0");
            //创建面对象并返回面对象
            //var materials = Cesium.Material.fromType('Image');
            //materials.uniforms.image = vid;
            //var vid = document.getElementById('video');
            //var material = _this._cesium.Material.fromType('Image');
            //material.uniforms.image = vid;
            this.end = undefined;

            polyline && _this._viewer.entities.remove(polyline);
            if (type === 'cancel' || positions.length < 3) {
                _this.item && _this._viewer.entities.remove(_this.item);
                return;
            }
            vid.play();
            _this.item.polygon.material = vid;
            var ploylinejl = { polygon: {}, positions: [], area: [] };
            ploylinejl.polygon = _this.item;
            var positionsop = [];
            for (var j = 0; j < positions.length; j++) {
                var cartographicdr = _this._cesium.Cartographic.fromCartesian(positions[j]);
                var longitudeStringdr = _this._cesium.Math.toDegrees(cartographicdr.longitude);
                var latitudeStringdr = _this._cesium.Math.toDegrees(cartographicdr.latitude);
                var heightStringdr = cartographicdr.height;
                positionsop.push({ lon: longitudeStringdr, lat: latitudeStringdr, hei: heightStringdr });
            }
            ploylinejl.positions = positionsop;
            ploylinejl.id = videoID;
            ///工程树添加
            // var GroupID = parameter.pId;
            // if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            //     GroupID = tree.selectedItem.id;
            // var id = _this._core.getuid();
            // ploylinejl.id = id;
            // tree.insertGroupId({
            //     id: id,
            //     name: '视频投影' + id,
            //     pId: _this._core.isnull(GroupID) ? 0 : GroupID,
            //     type: 'polygon',
            //     item: _this
            // }, _this._core.isnull(GroupID) ? 0 : GroupID);
            if (typeof method == 'function') {
                method(ploylinejl);
            }
        };
        return this;
    };
    //添加面贴视频
    Polygon.prototype.addVideoPolygon = function (Geometry, option) {
        var pArray = [];
        var hierarchy;
        if (Geometry[0] instanceof Array) {
            if (Geometry[0].length === 2) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(Geometry[i][0], Geometry[i][1]);
                }
                hierarchy = this._cesium.Cartesian3.fromDegreesArray(pArray);
            } else if (Geometry[0].length === 3) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(Geometry[i][0], Geometry[i][1], Geometry[i][2]);
                }
                hierarchy = this._cesium.Cartesian3.fromDegreesArrayHeights(pArray);
            }
        } else {
            if (Geometry[0].z) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(Geometry[i].x, Geometry[i].y, Geometry[i].z);
                }
                hierarchy = this._cesium.Cartesian3.fromDegreesArrayHeights(pArray);
            } else {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(Geometry[i].x, Geometry[i].y);
                }
                hierarchy = this._cesium.Cartesian3.fromDegreesArray(pArray);
            }
        }

        //视频修改
        var toolbar = document.getElementById('videoToolbar');
        if (!toolbar) {
            var htmle = '<div id="videoToolbar"></div>';
            $('.cesium-viewer').append(htmle);
            toolbar = document.getElementById('videoToolbar');
        }
        var videoID = this._core.getuid();
        var videoHtml = '<video id="video' + videoID + '"  style="display: none;" muted autoplay loop crossorigin controls><source src="' + option.url + '" type="video/mp4"></video>';
        $(toolbar).append(videoHtml);
        var vid = document.getElementById('video' + videoID);
        vid.play();

        let heightReference = this._core.defaultValue(option.heightReference, 1);
        let color = this._core.defaultValue(option.color, '#FFFFFF');

        this.item = this._viewer.entities.add({
            name: '面贴视频',
            polygon: {
                hierarchy: new Cesium.PolygonHierarchy(hierarchy),
                material: new Cesium.ImageMaterialProperty({
                    image: vid,
                    color: Cesium.Color.fromCssColorString(color)
                }),
                heightReference: heightReference,
                perPositionHeight: heightReference === 1 ? false : true,
                stRotation: Cesium.Math.toRadians(option.angle || 0),
                rotation: Cesium.Math.toRadians(option.rotation || 0)
            }
        });
        return this;
    };
    //添加面贴视频
    Polygon.prototype.addVideoBox = function (Geometry, option) {
        var position;
        if (Geometry instanceof Array) {
            position = this._cesium.Cartesian3.fromDegrees(...Geometry);
        } else if (Geometry.x) {
            position = this._cesium.Cartesian3.fromDegrees(Geometry.x, Geometry.y, Geometry.z);
        } else if (Geometry.lon) {
            position = this._cesium.Cartesian3.fromDegrees(Geometry.lon, Geometry.lat, Geometry.height);
        }

        //视频修改
        var toolbar = document.getElementById('videoToolbar');
        if (!toolbar) {
            var htmle = '<div id="videoToolbar"></div>';
            $('.cesium-viewer').append(htmle);
            toolbar = document.getElementById('videoToolbar');
        }
        var videoID = this._core.getuid();
        var videoHtml = '<video id="video' + videoID + '"  style="display: none;" muted autoplay loop crossorigin controls><source src="' + option.url + '" type="video/mp4"></video>';
        $(toolbar).append(videoHtml);
        var vid = document.getElementById('video' + videoID);
        vid.play();

        let color = this._core.defaultValue(option.color, '#FFFFFF');

        this.item = this._viewer.entities.add({
            name: '盒子贴视频',
            position: position,
            orientation: Cesium.Transforms.headingPitchRollQuaternion(
                position,
                new Cesium.HeadingPitchRoll(
                    Cesium.Math.toRadians(option.heading || 0),
                    Cesium.Math.toRadians(option.pitch || 0),
                    Cesium.Math.toRadians(option.roll || 0)
                )
            ),
            box: {
                dimensions: new Cesium.Cartesian3(option.long || 100, option.width || 100, option.height || 100),
                material: new Cesium.ImageMaterialProperty({
                    image: vid,
                    color: Cesium.Color.fromCssColorString(color)
                }),
            }
        });
        return this;
    };
    //删除对象操作
    Polygon.prototype.deleteObject = function () {
        this._viewer.entities.remove(this.item);
        if (this._points.length > 0) {
            for (var i = 0; i < this._points.length; i++) {
                this._viewer.entities.remove(this._points[i]);
            }
            this._points = [];
        }
        try {
            this._viewer.scene.primitives.remove(this.item);
        } catch (ex) {
            console.log(ex);
        }
        this.item = undefined;
        // this = null;
    };
    //空间面积测量全操作(不包括地形)
    Polygon.prototype.executePolygoncl = function (method, parameter) {
        //空间面积测量
        // 取消双击事件-追踪该位置
        this._tree.removeHandler();
        this._tree.starttemporaryItem(this._viewer);
        var _this = this;
        var textareas = 0;
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        // 鼠标事件
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var tooltip = this._core.CreateTooltip();
        var positions = [];
        var hierarch = {};
        var tempPointsxp = [];
        var polygon = null;
        var cartesian = null;
        var we;
        var coloroptions = {
            "point": _this._cesium.Color.RED,
            "polyline": _this._cesium.Color.YELLOW,
            "polygon": _this._cesium.Color.YELLOW.withAlpha(0.5)
        };
        if (Object.keys(parameter).length > 0) {
            if (parameter.point != "" && parameter.point != undefined) {
                coloroptions.point = parameter.point;
            }
            if (parameter.polyline != "" && parameter.polyline != undefined) {
                coloroptions.polyline = parameter.polyline;
            }
            if (parameter.polygon != "" && parameter.polygon != undefined) {
                coloroptions.polygon = parameter.polygon;
            }
        }
        //返回对象
        var objkj = { mj: 0, label: [], polygon: [] };
        let polyline;
        this._tree.handler.setInputAction(function (movement) {
            if (positions.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else if (positions.length <= 3) {
                tooltip.showAt(movement.endPosition, '点击继续绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束绘制！');
            }
            //cartesian = _this._viewer.scene.pickPosition(movement.endPosition);
            cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) {
                return;
            }
            //xp修改
            var cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
            var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
            var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
            var heightString = cartographic.height;
            if (positions.length >= 2) {
                if (!_this._cesium.defined(polygon)) {
                    hierarch = new _this._cesium.PolygonHierarchy(positions);
                    polygon = new PolygonPrimitivecl(hierarch);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                    hierarch = new _this._cesium.PolygonHierarchy(positions);
                    tempPointsxp.pop();
                    tempPointsxp.push({ lon: longitudeString, lat: latitudeString, hei: heightString });
                }
                var textArea = _this._core.getArea(tempPointsxp, positions, _this._cesium);
                _this._viewer.entities.remove(we);
                we = _this._viewer.entities.add({
                    name: '多边形面积',
                    position: new Cesium.CallbackProperty(function () {
                        let p = new Cesium.Cartesian3();
                        positions.forEach(item => {
                            Cesium.Cartesian3.add(p, item, p);
                        });
                        return Cesium.Cartesian3.divideByScalar(p, positions.length, new Cesium.Cartesian3());
                    }, false),
                    label: {
                        text: textArea,
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -40),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND
                    }
                });
                _this._tree.temporaryItem.obj.push(we);
                objkj.label = we;
            }

        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        this._tree.handler.setInputAction(function (movement) {
            //cartesian = _this._viewer.scene.pickPosition(movement.position);
            cartesian = _this._getPosition.getMousePosition(movement);
            //cartesian = _this._viewer.scene.pickPosition(movement.endPosition);
            if (!cartesian) {
                return;
            }
            var cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
            var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
            var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
            var heightString = cartographic.height;
            if (positions.length == 0) {
                positions.push(cartesian.clone());
                tempPointsxp.push({ lon: longitudeString, lat: latitudeString, hei: heightString });
            }
            positions.push(cartesian);
            tempPointsxp.push({ lon: longitudeString, lat: latitudeString, hei: heightString });

            hierarch = new _this._cesium.PolygonHierarchy(positions);
            //在三维场景中添加点

            if (positions.length === 2) {
                polyline = _this._viewer.entities.add({
                    name: '临时线',
                    polyline: {
                        positions: new Cesium.CallbackProperty(() => {
                            return positions;
                        }, false),
                        clampToGround: false,
                        material: coloroptions.polygon,
                        width: 3,
                    }
                });
            }
            //兼容移动端移动事件未触发情况
            if (positions.length >= 3) {
                polyline && _this._viewer.entities.remove(polyline);
                if (!_this._cesium.defined(polygon)) {
                    hierarch = new _this._cesium.PolygonHierarchy(positions);
                    polygon = new PolygonPrimitivecl(hierarch);
                }
                var textArea = _this._core.getArea(tempPointsxp, positions, _this._cesium);
                _this._viewer.entities.remove(we);
                we = _this._viewer.entities.add({
                    name: '多边形面积',
                    position: new Cesium.CallbackProperty(function () {
                        let p = new Cesium.Cartesian3();
                        positions.forEach(item => {
                            Cesium.Cartesian3.add(p, item, p);
                        });
                        return Cesium.Cartesian3.divideByScalar(p, positions.length, new Cesium.Cartesian3());
                    }, false),
                    label: {
                        text: textArea,
                        font: '16px 宋体',
                        fillColor: Cesium.Color.GOLD,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        pixelOffset: new Cesium.Cartesian2(20, -40),
                        showBackground: true,
                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND
                    }
                });
                _this._tree.temporaryItem.obj.push(we);
                objkj.label = we;
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this._tree.handler.setInputAction(function (movement) {
            _this.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = function (type) {
            tooltip.show(false);
            _this._viewer.entities.remove(we);
            _this._tree.handler.destroy();
            _this.end = undefined;

            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0, "0");

            polyline && _this._viewer.entities.remove(polyline);
            if (type === 'cancel' || positions.length < 3) {
                _this.item && _this._viewer.entities.remove(_this.item);
                return;
            }
            //positions.pop();
            //tempPointsxp.pop();
            var textArea = _this._core.getArea(tempPointsxp, positions, _this._cesium);
            textareas = textArea;
            var obj = _this._viewer.entities.add({
                name: '多边形面积',
                position: new Cesium.CallbackProperty(function () {
                    let p = new Cesium.Cartesian3();
                    positions.forEach(item => {
                        Cesium.Cartesian3.add(p, item, p);
                    });
                    return Cesium.Cartesian3.divideByScalar(p, positions.length, new Cesium.Cartesian3());
                }, false),
                label: {
                    text: textArea,
                    font: '16px 宋体',
                    fillColor: Cesium.Color.GOLD,
                    verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                    pixelOffset: new Cesium.Cartesian2(20, -40),
                    showBackground: true,
                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND
                }
            });
            _this._tree.endtemporaryItem();
            _this._points.push(obj);
            _this._lable = obj;
            ///工程树添加
            //var GroupID = 0;
            //if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            //    GroupID = tree.selectedItem.id;
            //var id = _this._core.getuid();
            //tree.insertGroupId({
            //    id: _this.item.id,
            //    name: '空间测量' + id,
            //    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
            //    type: 'polygon',
            //    item: _this
            //}, _this._core.isnull(GroupID) ? 0 : GroupID);
            objkj.mj = textareas;
            objkj.label = obj;

            if (method != "" && method != null) {
                if (typeof method == 'function')
                    method(objkj);
            }
        };

        var PolygonPrimitivecl = (function () {
            function execute(hierarch) {
                this.options = {
                    name: '多边形',
                    polygon: {
                        hierarchy: [],
                        perPositionHeight: true,
                        // perPositionHeight : true,
                        material: coloroptions.polygon,
                        classificationType: _this._cesium.ClassificationType.BOTH
                        //heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND,
                        //extrudedHeightReference: _this._cesium.HeightReference.RELATIVE_TO_GROUND,
                        //extrudedHeight:100
                        // heightReference: _this._cesium.HeightReference.none
                        // heightReference:20000
                    }
                };

                this.hierarchy = hierarch;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.hierarchy;
                };
                //实时更新polygon.hierarchy
                //this.options.polygon.hierarchy = this.hierarchy;
                this.options.polygon.hierarchy = new _this._cesium.CallbackProperty(_update, false);
                this.polygon = _this._viewer.entities.add(this.options);
                _this.item = this.polygon;
                _this._entity = this.polygon;
                _this._tree.temporaryItem.obj.push(this.polygon);
                objkj.polygon = this.polygon;
            };

            return execute;
        })();
        return this;
    };
    //淹没分析
    Polygon.prototype.executePolygonym = function (method) {
        //淹没分析
        // 取消双击事件-追踪该位置
        var _this = this;
        this._tree.starttemporaryItem(this._viewer);
        this._tree.removeHandler();
        // 鼠标事件
        this._tree.handler = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var positions = [];
        var hierarch = {};
        var polygon = null;
        var cartesian = null;
        this._tree.handler.setInputAction(function (movement) {
            var ray = _this._viewer.camera.getPickRay(movement.endPosition);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            if (positions.length >= 2) {
                if (!_this._cesium.defined(polygon)) {
                    hierarch = new _this._cesium.PolygonHierarchy(positions);
                    polygon = new PolygonPrimitive(hierarch);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                    hierarch = new _this._cesium.PolygonHierarchy(positions);
                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        this._tree.handler.setInputAction(function (movement) {
            var ray = _this._viewer.camera.getPickRay(movement.position);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            if (positions.length == 0) {
                positions.push(cartesian.clone());
                hierarch = new _this._cesium.PolygonHierarchy(positions);
            }
            positions.push(cartesian);
            hierarch = new _this._cesium.PolygonHierarchy(positions);
            //在三维场景中添加点
            var cartographic = _this._cesium.Cartographic.fromCartesian(positions[positions.length - 1]);
            _this._cesium.Math.toDegrees(cartographic.longitude);
            _this._cesium.Math.toDegrees(cartographic.latitude);
            cartographic.height;
            var floatingPoint = _this._viewer.entities.add({
                name: '多边形面积',
                position: positions[positions.length - 1],
                point: {
                    pixelSize: 5,
                    color: _this._cesium.Color.RED,
                    outlineColor: _this._cesium.Color.WHITE,
                    outlineWidth: 2,
                    heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND
                }
            });
            _this._tree.temporaryItem.obj.push(floatingPoint);
            _this._points.push(floatingPoint);
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        this._tree.handler.setInputAction(function (movement) {
            _this._tree.handler.destroy();
            _this._tree.endtemporaryItem();
            positions.pop();
            hierarch = new _this._cesium.PolygonHierarchy(positions);
            var textArea = "平方千米";
            var obj = _this._viewer.entities.add({
                name: '多边形面积',
                position: new Cesium.CallbackProperty(function () {
                    let p = new Cesium.Cartesian3();
                    positions.forEach(item => {
                        Cesium.Cartesian3.add(p, item, p);
                    });
                    return Cesium.Cartesian3.divideByScalar(p, positions.length, new Cesium.Cartesian3());
                }, false),
                label: {
                    text: textArea,
                    font: '16px 宋体',
                    fillColor: Cesium.Color.GOLD,
                    verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                    pixelOffset: new Cesium.Cartesian2(20, -40),
                    showBackground: true,
                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
                    heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND
                }
            });
            _this._tree.temporaryItem.obj.push(obj);
            _this._points.push(obj);
            if (method != "" && method != null) {
                if (typeof method == 'function')
                    method(polygon);
            }
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        var PolygonPrimitive = (function () {
            function execute(hierarch) {
                this.options = {
                    name: '多边形',
                    polygon: {
                        hierarchy: [],
                        perPositionHeight: true,
                        material: _this._cesium.Color.SKYBLUE.withAlpha(0.4),
                        extrudedHeight: 0.0
                    }
                };

                this.hierarchy = hierarch;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.hierarchy;
                };
                //实时更新polygon.hierarchy
                this.options.polygon.hierarchy = new _this._cesium.CallbackProperty(_update, false);
                var polygon = _this._viewer.entities.add(this.options);
                _this._tree.temporaryItem.obj.push(polygon);
                _this.item = polygon;
            };
            ///工程树添加
            var GroupID = 0;
            if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                GroupID = tree.selectedItem.id;
            var id = _this._core.getuid();
            var obj = {
                id: id,
                name: '新建面' + id,
                pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'polygon',
                item: _this
            };
            _this.setTreeobj(obj);
            tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
            return execute;
        })();
        return this;
    };
    //淹没分析手动添加
    Polygon.prototype.executePolygonymsd = function (parameter = {}, method) {
        //淹没分析手动添加
        // 取消双击事件-追踪该位置
        this._tree.removeHandler();
        this._tree.starttemporaryItem(this._viewer);
        var _this = this;
        // 鼠标事件
        this._tree.handler = new _this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);

        //提示框
        var tooltip = this._core.CreateTooltip();

        var hierarch = {};
        var positions = [];
        var polygon = null;
        var polyline = null;
        var cartesian = null;
        var GroupID = "0";
        var waterHeight = 0;
        var targetHeight = 1000;
        var spood = 10;
        var selectWatherHeight = false;
        //线段集合
        var lines = [];
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        let startP, endP;
        //获取实时位置 实现拉伸效果 鼠标移动事件
        this._tree.handler.setInputAction(function (movement) {
            if (selectWatherHeight) {
                if (waterHeight === undefined) {
                    tooltip.showAt(movement.endPosition, '点击拾取初始水面高度');
                } else if (targetHeight === undefined) {
                    tooltip.showAt(movement.endPosition, '点击拾取最大淹没高度');
                }
                return;
            }

            if (positions.length >= 4) {
                tooltip.showAt(movement.endPosition, '右键结束绘制');
            } else {
                tooltip.showAt(movement.endPosition, '点击左键绘制淹没区域');
            }

            var ray = _this._viewer.camera.getPickRay(movement.endPosition);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            if (positions.length >= 2) {
                if (!_this._cesium.defined(polygon)) {
                    hierarch = new _this._cesium.PolygonHierarchy(positions);
                    polygon = new PolygonPrimitive(hierarch);
                } else if (parameter.rectangle) {
                    endP = _this._core.toDegrees(cartesian);
                    positions = [
                        Cesium.Cartesian3.fromDegrees(startP.lon, startP.lat),
                        Cesium.Cartesian3.fromDegrees(startP.lon, endP.lat),
                        Cesium.Cartesian3.fromDegrees(endP.lon, endP.lat),
                        Cesium.Cartesian3.fromDegrees(endP.lon, startP.lat)
                    ];
                    hierarch = new _this._cesium.PolygonHierarchy(positions);
                    polygon.hierarchy = hierarch;
                } else {

                    var position0 = positions[0];
                    var cartograhphic1 = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(position0);
                    var lat1 = Cesium.Math.toDegrees(cartograhphic1.latitude);
                    var lng1 = Cesium.Math.toDegrees(cartograhphic1.longitude);

                    var position1 = positions[positions.length - 2];
                    var cartograhphic2 = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(position1);
                    var lat2 = Cesium.Math.toDegrees(cartograhphic2.latitude);
                    var lng2 = Cesium.Math.toDegrees(cartograhphic2.longitude);

                    var cartograhphic3 = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(cartesian);
                    var lat3 = Cesium.Math.toDegrees(cartograhphic3.latitude);
                    var lng3 = Cesium.Math.toDegrees(cartograhphic3.longitude);

                    var line1 = Cesium.turf.lineString([[lng1, lat1], [lng3, lat3]]);
                    var line2 = Cesium.turf.lineString([[lng2, lat2], [lng3, lat3]]);
                    var iscontinue = true;
                    for (var index = 0; index < lines.length && lines.length >= 2; index++) {
                        var lineItem = lines[index];
                        if (index == 0) {
                            if (Cesium.turf.lineIntersect(line2, lineItem).features.length) {
                                iscontinue = false;
                                tooltip.innerHTML = '<span style="font-family:黑体;color:white;font-weight: bolder;font-size: 14px">不允许出现交叉面！</span>';
                                break;
                            }
                            continue;
                        }
                        if (index == lines.length - 1) {
                            if (Cesium.turf.lineIntersect(line1, lineItem).features.length) {
                                iscontinue = false;
                                tooltip.innerHTML = '<span style="font-family:黑体;color:white;font-weight: bolder;font-size: 14px">不允许出现交叉面！</span>';
                                break;
                            }
                            continue;
                        }

                        if (Cesium.turf.lineIntersect(line1, lineItem).features.length) {
                            iscontinue = false;
                            tooltip.innerHTML = '<span style="font-family:黑体;color:white;font-weight: bolder;font-size: 14px">不允许出现交叉面！</span>';
                            return;
                        }
                        if (Cesium.turf.lineIntersect(line2, lineItem).features.length) {
                            iscontinue = false;
                            tooltip.innerHTML = '<span style="font-family:黑体;color:white;font-weight: bolder;font-size: 14px">不允许出现交叉面！</span>';
                            break;
                        }
                    }

                    if (!iscontinue)
                        return;

                    positions.pop();
                    positions.push(cartesian);
                    hierarch = new _this._cesium.PolygonHierarchy(positions);
                }
                if (!polyline) {
                    polyline = _this._viewer.entities.add({
                        polyline: {
                            positions: new Cesium.CallbackProperty(function () {
                                return positions.concat([positions[0]]);
                            }, false),
                            clampToGround: true,
                            width: 3
                        }
                    });
                    _this._points.push(polyline);
                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //鼠标左键事件
        this._tree.handler.setInputAction(function (movement) {
            var cartesian = _this._getPosition.getMousePosition(movement);
            if (!cartesian) return;
            //拾取淹没高度
            if (selectWatherHeight) {
                let _cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
                if (waterHeight === undefined) {
                    waterHeight = _cartographic.height;
                } else if (targetHeight === undefined) {
                    targetHeight = _cartographic.height;
                    if (targetHeight < waterHeight) {
                        window.layuiLayer && window.layuiLayer.msg("最大淹没高度小于初始水面高度，请重新拾取");
                        targetHeight = undefined;
                        waterHeight = undefined;
                        return;
                    }
                    startFlood();
                }
                return;
            }

            if (positions.length == 0) {
                positions.push(cartesian.clone());
                hierarch = new _this._cesium.PolygonHierarchy(positions);
            }



            if (positions.length >= 2) {
                if (lines.length == 0) {
                    var position0 = positions[0];
                    var cartograhphic1 = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(position0);
                    var lat1 = Cesium.Math.toDegrees(cartograhphic1.latitude);
                    var lng1 = Cesium.Math.toDegrees(cartograhphic1.longitude);

                    var position1 = positions[1];
                    var cartograhphic2 = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(position1);
                    var lat2 = Cesium.Math.toDegrees(cartograhphic2.latitude);
                    var lng2 = Cesium.Math.toDegrees(cartograhphic2.longitude);

                    var line = Cesium.turf.lineString([[lng1, lat1], [lng2, lat2]]);
                    lines.push(line);
                }
                else {
                    if (lines.length >= 2) {
                        var position0 = positions[0];
                        var cartograhphic1 = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(position0);
                        var lat1 = Cesium.Math.toDegrees(cartograhphic1.latitude);
                        var lng1 = Cesium.Math.toDegrees(cartograhphic1.longitude);

                        var position1 = positions[positions.length - 2];
                        var cartograhphic2 = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(position1);
                        var lat2 = Cesium.Math.toDegrees(cartograhphic2.latitude);
                        var lng2 = Cesium.Math.toDegrees(cartograhphic2.longitude);

                        var cartograhphic3 = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(cartesian);
                        var lat3 = Cesium.Math.toDegrees(cartograhphic3.latitude);
                        var lng3 = Cesium.Math.toDegrees(cartograhphic3.longitude);

                        var line1 = Cesium.turf.lineString([[lng1, lat1], [lng3, lat3]]);
                        var line2 = Cesium.turf.lineString([[lng2, lat2], [lng3, lat3]]);
                        var iscontinue = true;
                        for (var index = 0; index < lines.length && lines.length >= 2; index++) {
                            var lineItem = lines[index];
                            if (index == 0) {
                                if (Cesium.turf.lineIntersect(line2, lineItem).features.length) {
                                    iscontinue = false;
                                    tooltip.innerHTML = '<span style="font-family:黑体;color:white;font-weight: bolder;font-size: 14px">不允许出现交叉面！</span>';
                                    break;
                                }
                                continue;
                            }
                            if (index == lines.length - 1) {
                                if (Cesium.turf.lineIntersect(line1, lineItem).features.length) {
                                    iscontinue = false;
                                    tooltip.innerHTML = '<span style="font-family:黑体;color:white;font-weight: bolder;font-size: 14px">不允许出现交叉面！</span>';
                                    break;
                                }
                                continue;
                            }

                            if (Cesium.turf.lineIntersect(line1, lineItem).features.length) {
                                iscontinue = false;
                                tooltip.innerHTML = '<span style="font-family:黑体;color:white;font-weight: bolder;font-size: 14px">不允许出现交叉面！</span>';
                                return;
                            }
                            if (Cesium.turf.lineIntersect(line2, lineItem).features.length) {
                                iscontinue = false;
                                tooltip.innerHTML = '<span style="font-family:黑体;color:white;font-weight: bolder;font-size: 14px">不允许出现交叉面！</span>';
                                break;
                            }
                        }

                        if (!iscontinue)
                            return;
                    }
                    var position0 = positions[positions.length - 2];
                    var cartograhphic1 = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(position0);
                    var lat1 = Cesium.Math.toDegrees(cartograhphic1.latitude);
                    var lng1 = Cesium.Math.toDegrees(cartograhphic1.longitude);

                    var cartograhphic2 = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(cartesian);
                    var lat2 = Cesium.Math.toDegrees(cartograhphic2.latitude);
                    var lng2 = Cesium.Math.toDegrees(cartograhphic2.longitude);

                    var line = Cesium.turf.lineString([[lng1, lat1], [lng2, lat2]]);
                    lines.push(line);
                }
            }


            positions.push(cartesian);
            hierarch = new _this._cesium.PolygonHierarchy(positions);
            if (parameter.rectangle) {
                if (!startP) {
                    startP = _this._core.toDegrees(cartesian);
                } else {
                    endP = _this._core.toDegrees(cartesian);
                    positions = [
                        Cesium.Cartesian3.fromDegrees(startP.lon, startP.lat),
                        Cesium.Cartesian3.fromDegrees(startP.lon, endP.lat),
                        Cesium.Cartesian3.fromDegrees(endP.lon, endP.lat),
                        Cesium.Cartesian3.fromDegrees(endP.lon, startP.lat)
                    ];
                    hierarch = new _this._cesium.PolygonHierarchy(positions);
                    polygon.hierarchy = hierarch;
                    if (parameter.pointSelect) {
                        waterHeight = undefined;
                        targetHeight = undefined;
                        selectWatherHeight = true;
                    } else {
                        startFlood();
                    }
                }
            }

            //在三维场景中添加点
            var cartographic = _this._cesium.Cartographic.fromCartesian(positions[positions.length - 1]);
            _this._cesium.Math.toDegrees(cartographic.longitude);
            _this._cesium.Math.toDegrees(cartographic.latitude);
            cartographic.height;
            var floatingPoint = _this._viewer.entities.add({
                name: '多边形',
                position: cartesian,
                point: {
                    pixelSize: 5,
                    color: _this._cesium.Color.RED,
                    outlineColor: _this._cesium.Color.WHITE,
                    outlineWidth: 1,
                    heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND
                }
            });
            _this._tree.temporaryItem.obj.push(floatingPoint);
            _this._points.push(floatingPoint);
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //右键结束事件
        this._tree.handler.setInputAction(function (movement) {
            if (selectWatherHeight || positions.length <= 3) {
                return;
            }
            tooltip.show(false);
            positions.pop();
            hierarch = new _this._cesium.PolygonHierarchy(positions);
            if (parameter.pointSelect) {
                waterHeight = undefined;
                targetHeight = undefined;
                selectWatherHeight = true;
            } else {
                startFlood();
            }
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = (type) => {
            tooltip.show(false);
            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0);
            _this._tree.handler.destroy();
            _this._tree.endtemporaryItem();
            _this.end = undefined;
            if (type === 'cancel' && !this.waterTimer) {
                _this.item && _this._viewer.entities.remove(_this.item);
                if (this._points.length > 0) {
                    for (var i = 0; i < this._points.length; i++) {
                        this._viewer.entities.remove(this._points[i]);
                    }
                    this._points = [];
                }
            }
        };

        //开始分析
        function startFlood() {
            _this.end();
            let speed = spood / 20;
            _this.waterTimer = setInterval(function () {
                if (waterHeight < targetHeight) {
                    waterHeight += speed;
                    _this.item._polygon.extrudedHeight.setValue(waterHeight);
                    if (waterHeight >= targetHeight) {
                        clearInterval(_this.waterTimer);
                        _this.waterTimer = undefined;
                        waterHeight = targetHeight;
                        //设置贴图水面
                        _this._viewer.entities.remove(_this.item);
                        _this.polygon1 = new _this._cesium.PolygonGeometry({
                            polygonHierarchy: new _this._cesium.PolygonHierarchy(positions),
                            extrudedHeight: targetHeight,
                            height: 0,
                            vertexFormat: _this._cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT
                        });
                        var River1 = new _this._cesium.Primitive({
                            geometryInstances: new _this._cesium.GeometryInstance({
                                geometry: _this.polygon1
                            }),
                            appearance: new Cesium.EllipsoidSurfaceAppearance({
                                material: new Cesium.Material({
                                    fabric: {
                                        type: 'Water',
                                        uniforms: {
                                            baseWaterColor: parameter.watherColor || Cesium.Color.SKYBLUE.withAlpha(0.6),
                                            blendColor: parameter.watherColor || Cesium.Color.SKYBLUE.withAlpha(0.6),
                                            normalMap: parameter.url,
                                            frequency: parameter.frequency || 1000.0,
                                            animationSpeed: parameter.watherSpeed || 0.01,
                                            amplitude: parameter.amplitude || 10.0
                                        }
                                    }
                                })
                            }),
                            show: true
                        });
                        var scene = _this._viewer.scene;
                        scene.primitives.add(River1);
                        _this.item = River1;
                        if (method != "" && method != null) {
                            if (typeof method == 'function')
                                method(waterHeight);
                        }
                        if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                            GroupID = tree.selectedItem.id;
                        var id = _this._core.getuid();
                        var obj = {
                            id: id,
                            name: '新建淹没分析' + id,
                            pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                            type: 'polygon',
                            item: _this
                        };
                        _this.setTreeobj(obj);
                        tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
                    }
                }
            }, 50);
        }

        var PolygonPrimitive = (function () {
            function execute(hierarch) {
                this.options = {
                    name: '多边形',
                    polygon: {
                        hierarchy: [],
                        material: _this._cesium.Color.SKYBLUE.withAlpha(0.5),
                        heightReference: _this._cesium.HeightReference.NONE,
                        extrudedHeight: 0.0
                    }
                };
                this.hierarchy = hierarch;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.hierarchy;
                };
                //实时更新polygon.hierarchy
                this.options.polygon.hierarchy = new _this._cesium.CallbackProperty(_update, false);
                var polygon = _this._viewer.entities.add(this.options);
                _this.item = polygon;
                _this._tree.temporaryItem.obj.push(polygon);
                ///工程树添加
                try {
                    if (parameter != null && parameter != "") {
                        if (parameter.waterHeight > 0) {
                            waterHeight = parameter.waterHeight;
                        }
                        if (parameter.targetHeight > 0) {
                            targetHeight = parameter.targetHeight;
                        }
                        if (parameter.spood > 0) {
                            spood = parameter.spood;
                        }
                        if (parameter.GroupID != "" && parameter.GroupID != undefined) {
                            GroupID = parameter.GroupID;
                        }
                    }
                } catch (ex) {
                    console.log(ex);
                }

            };
            return execute;
        })();
        return this;
    };

    //结束洪水淹没
    Polygon.prototype.endWater = function () {
        this.end && this.end();
        if (this.waterTimer) {
            clearInterval(this.waterTimer);
        }
        this._tree.endtemporaryItem();
        this.deleteObject();
    };

    //水面贴图
    Polygon.prototype.executePolygonymsdtt = function (parameter, method) {
        this._tree.removeHandler();
        var _this = this;
        this._tree.starttemporaryItem(this._viewer);
        // 鼠标事件
        this._tree.handler = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var positions = [];
        var polygon = null;
        var cartesian = null;
        this._tree.handler.setInputAction(function (movement) {
            var ray = _this._viewer.camera.getPickRay(movement.endPosition);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            if (positions.length >= 2) {
                if (!_this._cesium.defined(polygon)) {
                    polygon = new PolygonPrimitive(positions);
                    new _this._cesium.PolygonHierarchy(positions);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                    new _this._cesium.PolygonHierarchy(positions);
                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        this._tree.handler.setInputAction(function (movement) {
            var ray = _this._viewer.camera.getPickRay(movement.position);
            cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            if (positions.length == 0) {
                positions.push(cartesian.clone());
                new _this._cesium.PolygonHierarchy(positions);
            }
            positions.push(cartesian);
            new _this._cesium.PolygonHierarchy(positions);
            //在三维场景中添加点
            var cartographic = _this._cesium.Cartographic.fromCartesian(positions[positions.length - 1]);
            _this._cesium.Math.toDegrees(cartographic.longitude);
            _this._cesium.Math.toDegrees(cartographic.latitude);
            cartographic.height;
            var floatingPoint = _this._viewer.entities.add({
                name: '多边形面积',
                position: positions[positions.length - 1],
                point: {
                    pixelSize: 5,
                    color: _this._cesium.Color.RED,
                    outlineColor: _this._cesium.Color.WHITE,
                    outlineWidth: 2,
                    heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND
                }
            });
            _this._tree.temporaryItem.obj.push(floatingPoint);
            _this._points.push(floatingPoint);
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        this._tree.handler.setInputAction(function (movement) {
            _this._tree.handler.destroy();
            //objkj.label = obj;
            //设置贴图水面
            _this._viewer.entities.remove(_this.item);
            _this.polygon1 = new _this._cesium.PolygonGeometry({
                polygonHierarchy: new _this._cesium.PolygonHierarchy(positions),
                extrudedHeight: 0,
                height: 0,
                vertexFormat: _this._cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT
            });
            var River1 = new _this._cesium.Primitive({
                geometryInstances: new _this._cesium.GeometryInstance({
                    geometry: _this.polygon1
                }),
                appearance: new _this._cesium.EllipsoidSurfaceAppearance({
                    aboveGround: true
                }),
                show: true
            });
            var River1_Material = new _this._cesium.Material({
                fabric: {
                    type: 'Water',
                    uniforms: {
                        normalMap: parameter.url,
                        frequency: 100.0,
                        animationSpeed: 0.01,
                        amplitude: 10.0
                    }
                }
            });
            River1.appearance.material = River1_Material;
            var scene = _this._viewer.scene;
            //_this._viewer.entities.add(River1);
            _this.polygon1 = scene.primitives.add(River1);
            _this._tree.endtemporaryItem();
            // _this.polygon1.setEditable();
            positions.pop();
            new _this._cesium.PolygonHierarchy(positions);
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        var PolygonPrimitive = (function () {
            function execute(hierarch) {
                this.options = {
                    name: '多边形',
                    polygon: {
                        hierarchy: [],
                        material: _this._cesium.Color.SKYBLUE.withAlpha(0.4),
                        heightReference: _this._cesium.HeightReference.NONE,
                        extrudedHeight: 0.0
                    }
                };
                this.hierarchy = hierarch;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.hierarchy;
                };
                //实时更新polygon.hierarchy
                this.options.polygon.hierarchy = new _this._cesium.CallbackProperty(_update, false);
                var polygon = _this._viewer.entities.add(this.options);
                _this.item = polygon;
                _this._tree.temporaryItem.obj.push(polygon);
                ///工程树添加
                var GroupID = 0;
                if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                    GroupID = tree.selectedItem.id;
                var id = _this._core.getuid();
                var obj = {
                    id: id,
                    name: '新建水面' + id,
                    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                    type: 'polyline',
                    item: _this
                };
                _this.setTreeobj(obj);
                tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
            };
            return execute;
        })();
        return this;
    };
    //贴地面积测量
    Polygon.prototype.executePolygontdmj = function (method, parameter) {
        var _this = this;
        this._tree.starttemporaryItem(this._viewer);
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        this._tree.removeHandler();
        var objkj = { mj: 0, label: [], polygon: [] };
        var isDraw = true;
        var polygonPath = [];
        var hierarch = {};
        var polygon = undefined;
        var scene = this._viewer.scene;
        var ellipsoid = scene.globe.ellipsoid;
        var we;
        var coloroptions = {
            "point": _this._cesium.Color.RED,
            "polyline": _this._cesium.Color.YELLOW,
            "polygon": _this._cesium.Color.YELLOW.withAlpha(0.5)
        };
        if (Object.keys(parameter).length > 0) {
            if (parameter.point != "" && parameter.point != undefined) {
                coloroptions.point = parameter.point;
            }
            if (parameter.polyline != "" && parameter.polyline != undefined) {
                coloroptions.polyline = parameter.polyline;
            }
            if (parameter.polygon != "" && parameter.polygon != undefined) {
                coloroptions.polygon = parameter.polygon;
            }
        }
        var tooltip = this._core.CreateTooltip();
        //隐藏选中容器标识
        //$(".cesium-selection-wrapper").hide();
        this._tree.handler = new _this._cesium.ScreenSpaceEventHandler(scene.canvas);
        //新增部分
        var text = 0.0;
        this._tree.handler.setInputAction(function (movement) {
            if (polygonPath.length === 0) {
                tooltip.showAt(movement.endPosition, '左键开始绘制！');
            } else if (polygonPath.length <= 2) {
                tooltip.showAt(movement.endPosition, '点击继续绘制！');
            } else {
                tooltip.showAt(movement.endPosition, '右键结束绘制！');
            }
            we && (_this._viewer.entities.remove(we), we = undefined);
            var position1 = _this._getPosition.getMousePosition(movement, [objkj.polygon, objkj.label]);
            var cartographic;

            if (!position1) {
                return;
            }
            cartographic = _this._cesium.Ellipsoid.WGS84.cartesianToCartographic(position1);
            if (cartographic) {
                if (isDraw) {
                    polygonPath.pop();
                    polygonPath.push(position1);

                    if (polygonPath.length >= 3) {
                        var label = String(countAreaInCartesian3(polygon.path.positions));
                        label = label.substr(0, label.indexOf(".", 0));

                        if (label.length < 6)
                            text = label + "平方米";
                        else {
                            label = String(label / 1000000);
                            label = label.substr(0, label.indexOf(".", 0) + 3);
                            text = label + "平方千米";
                        }
                        //measureDisplayLabel.text = text;
                        objkj.mj = text;
                        //measureDisplayLabel.position = countCenter(polygon.path);
                        //_this._points.push(measureDisplayLabel
                        we = _this._viewer.entities.add({
                            name: '多边形面积',
                            position: new Cesium.CallbackProperty(function () {
                                let p = new Cesium.Cartesian3();
                                polygonPath.forEach(item => {
                                    Cesium.Cartesian3.add(p, item, p);
                                });
                                return Cesium.Cartesian3.divideByScalar(p, polygonPath.length, new Cesium.Cartesian3());
                            }, false),
                            label: {
                                text: text,
                                font: '16px 宋体',
                                fillColor: Cesium.Color.GOLD,
                                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                                pixelOffset: new Cesium.Cartesian2(20, -40),
                                showBackground: true,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                                heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND
                            }
                        });
                        _this._tree.temporaryItem.obj.push(we);
                        _this._points.push(we);
                        objkj.label = we;
                    }

                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        let polyline;
        this._tree.handler.setInputAction(function (movement) {
            var position1 = _this._getPosition.getMousePosition(movement, [objkj.polygon, objkj.label]);        if (position1) {
                if (isDraw) {
                    if (!polygonPath.length) {
                        polygonPath.push(position1.clone());
                    }
                    polygonPath.push(position1);
                    hierarch = new _this._cesium.PolygonHierarchy(polygonPath);


                    //兼容移动端移动事件未触发情况
                    we && (_this._viewer.entities.remove(we), we = undefined);
                    if (polygonPath.length === 2) {
                        polyline = _this._viewer.entities.add({
                            name: '临时线',
                            polyline: {
                                positions: new Cesium.CallbackProperty(() => {
                                    return polygonPath;
                                }, false),
                                clampToGround: true,
                                material: coloroptions.polygon,
                                width: 3,
                            }
                        });
                    }
                    if (polygonPath.length >= 3 && !_this._cesium.defined(polygon)) {
                        polyline && _this._viewer.entities.remove(polyline);

                        polygon = new CreatePolygon(hierarch, _this._cesium);
                    }

                    if (polygonPath.length >= 3) {
                        var label = String(countAreaInCartesian3(polygon.path.positions));
                        label = label.substr(0, label.indexOf(".", 0));

                        if (label.length < 6)
                            text = label + "平方米";
                        else {
                            label = String(label / 1000000);
                            label = label.substr(0, label.indexOf(".", 0) + 3);
                            text = label + "平方千米";
                        }
                        //measureDisplayLabel.text = text;
                        objkj.mj = text;
                        //measureDisplayLabel.position = countCenter(polygon.path);
                        //_this._points.push(measureDisplayLabel
                        we = _this._viewer.entities.add({
                            name: '多边形面积',
                            position: new Cesium.CallbackProperty(function () {
                                let p = new Cesium.Cartesian3();
                                polygonPath.forEach(item => {
                                    Cesium.Cartesian3.add(p, item, p);
                                });
                                return Cesium.Cartesian3.divideByScalar(p, polygonPath.length, new Cesium.Cartesian3());
                            }, false),
                            label: {
                                text: text,
                                font: '16px 宋体',
                                fillColor: Cesium.Color.GOLD,
                                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                                pixelOffset: new Cesium.Cartesian2(20, -40),
                                showBackground: true,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                                heightReference: _this._cesium.HeightReference.CLAMP_TO_GROUND
                            }
                        });
                        _this._tree.temporaryItem.obj.push(we);
                        _this._points.push(we);
                        objkj.label = we;
                    }
                }
            }
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        this._tree.handler.setInputAction(function () {
            _this.end && _this.end();
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = function (type) {
            _this._tree.handler.removeInputAction(_this._cesium.ScreenSpaceEventType.LEFT_CLICK);
            _this._tree.handler.removeInputAction(_this._cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
            _this._cesium.trackedEntity = undefined;
            _this.end = undefined;
            //objkj.label = polygonPath;
            _this._tree.endtemporaryItem();
            isDraw = false;
            tooltip.show(false);
            //关闭按钮执行事件
            _this._tree.handler.destroy();
            _this._core.mouse(_this._viewer.container, 0, "0");

            polyline && _this._viewer.entities.remove(polyline);

            if (type === 'cancel') {
                _this.deleteObject();
                return;
            }
            polygonPath.length < 3 && _this.deleteObject();
            //设置鼠标样式
            if (method != "" && method != null) {
                if (typeof method == 'function')
                    method(objkj);
            }
        };
        var countAreaInCartesian3 = function (pointsold) {
            var points = new Array(pointsold.length);
            for (var i = 0; i < pointsold.length; i++) {
                points[i] = PItoDU(ellipsoid.cartesianToCartographic(pointsold[i]));
            }
            var center = 0;
            for (var i = 0; i < points.length; i++)
                center += points[i].longitude;
            center = center / points.length;
            for (var i = 0; i < points.length; i++) {
                points[i] = _this._core.Gauss_to_XY(points[i].longitude, points[i].latitude, center, _this._cesium);
            }
            return Math.abs(countArea(points))
        };
        var PItoDU = function (location) {
            location.longitude = location.longitude / Math.PI * 180;
            location.latitude = location.latitude / Math.PI * 180;
            return location;
        };
        var countArea = function (ps) {
            var s = 0;
            for (var i = 0; i < ps.length; i++) {
                var p1 = ps[i];
                var p2;
                if (i < ps.length - 1)
                    p2 = ps[i + 1];
                else
                    p2 = ps[0];
                s += p1.x * p2.y - p2.x * p1.y;
            }
            return s / 2
        };
        //画面操作
        var CreatePolygon = (function () {
            function execute(positons, cesium) {
                if (!_this._cesium.defined(positons)) {
                    throw new _this._cesium.DeveloperError('positions is required!');
                }
                if (positons.length < 3) {
                    throw new _this._cesium.DeveloperError('positions 的长度必须大于等于3');
                }
                this.options = {
                    polygon: {
                        show: true,
                        hierarchy: undefined,
                        classificationType: _this._cesium.ClassificationType.BOTH,
                        material: coloroptions.polygon
                    }
                };
                this.path = positons;
                this._init(cesium);
            }

            execute.prototype._init = function (cesium) {
                var that = this;
                var positionCBP = function () {
                    return that.path;
                };
                this.options.polygon.hierarchy = new _this._cesium.CallbackProperty(positionCBP, false);
                this.polygonEntity = _this._viewer.entities.add(this.options);
                _this.item = this.polygonEntity;
                _this._tree.temporaryItem.obj.push(this.polygonEntity);
                objkj.polygon = this.polygonEntity;
                _this._entity = this.polygonEntity;
                ///工程树添加
                //var GroupID = 0;
                //if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                //    GroupID = tree.selectedItem.id;
                //var id = _this._core.getuid();
                //tree.insertGroupId({
                //    id: id,
                //    name: '新建面积' + id,
                //    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                //    type: 'polygon',
                //    item: _this
                //}, _this._core.isnull(GroupID) ? 0 : GroupID);
            };
            return execute;
        })();
        return this;
    };
    /**
     * 设置polygon的显示隐藏
     * @param {boolean} [b] true|false
     */
    Polygon.prototype.setVisibility = function (b) {
        if (this._points.length > 0) {
            for (var i = 0; i < this._points.length; i++) {
                this._points[i].show = b;
            }
        }
        if (this._lable) {
            this._lable.show = b;
        }
        this.item.show = b;
    };
    /**
     * 获取polygon的显示隐藏
     */
    Polygon.prototype.getVisibility = function () {

        return this.item.show;
    };
    /**
     * 设置面的缓冲区添加
     * @param {Object} [polygon] polygon对象
     * @param {radius} 面宽。
     * @returns {Object} 返回一个polygon对象。
     */
    Polygon.prototype.setRadius = function (radius) {
        try {
            var positions = [];
            var ps = this.item._polygon.hierarchy.getValue();
            var ellipsoid = this._viewer.scene.globe.ellipsoid;
            for (var i = 0; i < ps.length; i++) {
                var cartesian3 = new this._cesium.Cartesian3(ps[i].x, ps[i].y, ps[i].z);
                var cartographic = ellipsoid.cartesianToCartographic(cartesian3);
                var lat = this._cesium.Math.toDegrees(cartographic.latitude);
                var lng = this._cesium.Math.toDegrees(cartographic.longitude);
                positions.push(lng);
                positions.push(lat);
            }
            var cartesian3s = new this._cesium.Cartesian3(ps[0].x, ps[0].y, ps[0].z);
            var cartographics = ellipsoid.cartesianToCartographic(cartesian3s);
            var lat = this._cesium.Math.toDegrees(cartographics.latitude);
            var lng = this._cesium.Math.toDegrees(cartographics.longitude);
            positions.push(lng);
            positions.push(lat);
            positions = this._cesium.Cartesian3.fromDegreesArray(positions);
            this.item.corridor = new this._cesium.CorridorGraphics({
                positions: positions,
                width: radius,
                material: this._cesium.Color.RED.withAlpha(0.4)
            });
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 导出工程数据
     */
    Polygon.prototype.export = function () {
        var show = this.item.show == undefined ? undefined : this.item.show._value;
        var hierarchy = this.item.polygon.hierarchy.getValue();
        var height = this.item.polygon.height == undefined ? undefined : this.item.polygon.height._value;
        var extrudedHeight = this.item.polygon.extrudedHeight == undefined ? undefined : this.item.polygon.extrudedHeight._value;
        var stRotation = this.item.polygon.stRotation == undefined ? undefined : this.item.polygon.stRotation._value;
        var fill = this.item.polygon.fill == undefined ? undefined : this.item.polygon.fill._value;
        var material = this.item.polygon.material;
        if (material != undefined) {
            material = {
                color: material.color == undefined ? undefined : 'rgba(' + material.color._value.red + ',' + material.color._value.green + ',' + material.color._value.blue + ',' + material.color._value.alpha + ')',
                image: material.image == undefined ? undefined : material.image._value,
                diffusemap: material.diffusemap == undefined ? undefined : material.diffusemap._value,
                alphamap: material.alphamap == undefined ? undefined : material.alphamap._value
            };
        }
        var outline = this.item.polygon.outline == undefined ? undefined : this.item.polygon.outline._value;
        var outlineColor = this.item.polygon.outlineColor == undefined ? undefined : 'rgba(' + this.item.polygon.outlineColor._value.red + ',' + this.item.polygon.outlineColor._value.green + ',' + this.item.polygon.outlineColor._value.blue + ',' + this.item.polygon.outlineColor._value.alpha + ')';
        var outlineWidth = this.item.polygon.outlineWidth == undefined ? undefined : this.item.polygon.outlineWidth._value;
        var perPositionHeight = this.item.polygon.perPositionHeight == undefined ? undefined : this.item.polygon.perPositionHeight._value;
        var closeTop = this.item.polygon.closeTop == undefined ? undefined : this.item.polygon.closeTop._value;
        var closeBottom = this.item.polygon.closeBottom == undefined ? undefined : this.item.polygon.closeBottom._value;
        var distanceDisplayCondition = this.item.polygon.distanceDisplayCondition;
        var near = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.near;
        var far = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.far;
        return {
            type: 'polygon',
            treeobj: { id: this.treeobj.id, name: this.treeobj.name, pId: this.treeobj.pId, type: this.treeobj.type },
            style: {
                show: show,
                hierarchy: hierarchy,
                height: height,
                extrudedHeight: extrudedHeight,
                stRotation: stRotation,
                fill: fill,
                material: material,
                outline: outline,
                outlineColor: outlineColor,
                outlineWidth: outlineWidth,
                perPositionHeight: perPositionHeight,
                closeTop: closeTop,
                closeBottom: closeBottom,
                near: near,
                far: far
            }
        };
    };
    //工程树添加
    Polygon.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 修改面的可视距离
     * @param {Object} [polygon] polygon对象
     * @param {String} [min, max] 设置线段的可视距离
     * @returns {Object} 返回一个polyline对象。
     */
    Polygon.prototype.setDistanceDisplayCondition = function (min, max) {
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        try {
            this.item._polygon.distanceDisplayCondition = distance;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置面的填充透明度
     * @param {Object} [polygon] polygon对象
     * @param {Number} [a] 透明度 0-1
     * @returns {Object} 返回一个polygon对象。
     */
    Polygon.prototype.setPolygonAlpha = function (a) {
        try {
            this.item._polygon.material.color._value.alpha = a;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置面的填充颜色
     * @param {Object} [polygon] polygon对象
     * @param {htmlColor} htmlColor颜色。
     * @returns {Object} 返回一个polygon对象。
     */
    Polygon.prototype.setPolygonColor = function (htmlColor) {
        try {
            this.item._polygon.material.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 修改线段的可视距离
     * @param {Object} [polyline] polyline对象
     * @param {String} [min, max] 设置线段的可视距离
     * @returns {Object} 返回一个polyline对象。
     */
    Polygon.prototype.setDistanceDisplayCondition = function (min, max) {
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        try {
            this.item._polygon.distanceDisplayCondition = distance;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置面的贴图
     * @param {Object} [polygon] polygon对象
     * @param {url} 图片路径。
     * @returns {Object} 返回一个polygon对象。
     */
    Polygon.prototype.setPolygonImage = function (url) {
        try {
            this.item._polygon.material = new this._cesium.ImageMaterialProperty({
                image: url  //可以为url、canvas、video      
            });
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置面的贴图一个Cartesian2属性，指定图像在每个方向上重复的次数。
     * @param {Object} [polygon] polygon对象
     * @param {Object} x和y上的比例。
     * @returns {Object} 返回一个polygon对象。
     */
    Polygon.prototype.setPolygonRepeat = function (x, y) {
        try {
            this.item._polygon.material.repeat = new this._cesium.Cartesian2(x, y);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置面的轮廓颜色
     * @param {Object} [polygon] polygon对象
     * @param {htmlColor} htmlColor
     * @returns {Object} 返回一个polygon对象。
     */
    Polygon.prototype.setOutlineColor = function (htmlColor) {
        try {
            this.item._polygon.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置面的是否显示轮廓
     * @param {Object} [polygon] polygon对象
     * @param {bool} 是否
     * @returns {Object} 返回一个polygon对象。
     */
    Polygon.prototype.setOutline = function (outline) {
        try {
            this.item._polygon.outline = outline;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };

    /**
     * 设置面的拉伸高度
     * @param {Object} [polygon] polygon对象
     * @param {double} [height] 高度
     * @returns {Object} 返回一个polygon对象。
     */
    Polygon.prototype.setExtrudedHeight = function (height) {
        try {
            this.item._polygon.extrudedHeight = height;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置面的高度
     * @param {Object} [polygon] polygon对象
     * @param {double} [height] 高度
     * @returns {Object} 返回一个polygon对象。
     */
    Polygon.prototype.setHeight = function (height) {
        try {
            this.item._polygon.height = height;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置面的高度类型
     * @param {Object} [polygon] polygon对象
     * @param {int} [type] 1：该位置被夹在地形上。2：这个职位是绝对的。3：位置高度是地形上方的高度。
     * @returns {Object} 返回一个对象。
     */
    Polygon.prototype.setHeightType = function (type) {
        try {
            if (type == 1) {
                this.item._polygon.heightReference = this._cesium.HeightReference.CLAMP_TO_GROUND;
            } else if (type == 2) {
                this.item._polygon.heightReference = this._cesium.HeightReference.NONE;
            } else if (type == 3) {
                this.item._polygon.heightReference = this._cesium.HeightReference.RELATIVE_TO_GROUND;
            }
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    Object.defineProperties(Polygon.prototype, {
        /**
         * 获取或设置矩形
         */
        rectangle: {
            get: function () {
                return this.item.rectangle;
            },
            set: function (rectangle) {
                this.item.rectangle = rectangle;
            }
        }
    });
    Object.defineProperties(Polygon.prototype, {
        /**
         * 获取或设置面高亮
         */
        HighLight: {
            set: function (b) {
                if (b) {
                    this.item.material = this.item.polygon.material;
                }
                if (b) {
                    this.item.polygon.material = new Color(this._viewer, this._cesium).colorFromHtmlColor(this._core.selectedColor);
                } else {
                    this.item.polygon.material = this.item.material;
                }
            }
        },
        /**
         * 设置geojson图层面的显示隐藏
         * @param {boolean} b
         */
        polygonShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                this.item.polygon.show = b;
            }, 500),
            get: function () {
                return this.item.polygon.b;
            }
        },
        /**
         * 设置geojson图层面的显示高度
         * @param {Number} height [height]
         */
        polygonHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                if (/^\[/.test(height)) {
                    height = height.replace(/\[/, '').replace(/\]/, '');
                }
                this.item.polygon.height = height;
            }, 500),
            get: function () {
                var height = this.item.polygon.height;
                if (height) {
                    return height._value;
                }
                return undefined;
            }
        },
        /**
         * 设置geojson图层面的高度类型
         * @param {object} heightReference
         */
        polygonHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                this.item.polygon.heightReference = heightReference;
            }, 500),
            get: function () {
                var heightReference = this.item.polygon.heightReference;
                if (heightReference) {
                    return heightReference._value;
                }
                return undefined;
            }
        },
        /**
         * 设置geojson图层面的拉伸高度ht
         * @param {Number} extrudedHeight [extrudedHeight]
         */
        polygonExtrudedHeight: {
            set: lodash.debounce(function (extrudedHeight) {
                if (this._core.isnull(extrudedHeight)) return;

                if (/^\[/.test(extrudedHeight)) {
                    extrudedHeight = extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                }
                this.item.polygon.extrudedHeight = extrudedHeight;
            }, 500),
            get: function () {
                var extrudedHeight = this.item.polygon.extrudedHeight;
                if (extrudedHeight) {
                    return extrudedHeight._value;
                }
                return undefined;
            }
        },
        /**
         * 设置geojson图层面的拉伸高度ht
         * @param {Number} extrudedHeightReference
         */
        polygonExtrudedHeightReference: {
            set: lodash.debounce(function (extrudedHeightReference) {
                if (this._core.isnull(extrudedHeightReference)) return;
                this.item.polygon.extrudedHeightReference = extrudedHeightReference;
            }, 500),
            get: function () {
                var extrudedHeightReference = this.item.polygon.extrudedHeightReference;
                if (extrudedHeightReference) {
                    return extrudedHeightReference._value;
                }
                return undefined;
            }
        },
        /**
         * 设置geojson图层面是否填充
         * @param {boolean} fill
         */
        polygonFill: {
            set: lodash.debounce(function (fill) {
                // if (this._core.isnull(fill)) return;

                this.item.polygon.fill = fill;
            }, 500),
            get: function () {
                var fill = this.item.polygon.fill;
                if (fill) {
                    return fill._value;
                }
                return undefined;
            }
        },
        /**
         * 设置geojson图层面材质
         * @param {object|string} color
         */
        polygonMaterial: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._Color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._Color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._Color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                this.item.polygon.material = color;
                this.item.material = this.item.polygon.material;
            }, 500),
            get: function () {
                var material = this.item.polygon.material;
                try {
                    return this._Color.toHtmlColor('rgb(' + material._value.red * 255 + ',' + material._value.green * 255 + ',' + material._value.blue * 255 + ',' + material._value.alpha * 255 + ')');
                } catch (ex) {
                }
            }
        },

        /**
         * 设置geojson图层面材质
         * @param {object|string} color
         */
        polygonMaterialAlpha: {
            set: lodash.debounce(function (a) {
                if (this._core.isnull(a)) return;
                this.item.polygon.material.color.alpha = a;
            }, 500),
            get: function () {
                this.item.polygon.material;
                try {
                    return this.item.polygon.material.color.alpha;
                } catch (ex) {
                }
            }
        },
        /**
         * 设置geojson图层面是否显示边框
         * @param {boolean} outline
         */
        polygonOutline: {
            set: lodash.debounce(function (outline) {
                if (this._core.isnull(outline)) return;
                this.item.polygon.outline = outline;
            }, 500),
            get: function () {
                var outline = this.item.polygon.outline;
                if (outline) {
                    return outline._value;
                }
                return undefined;
            }
        },
        /**
         * 设置geojson图层面边框颜色
         * @param {object|string} color
         */
        polygonOutlineColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._Color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._Color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._Color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                this.item.polygon.outlineColor = color;
            }, 500),
            get: function () {
                var outlineColor = this.item.polygon.outlineColor;
                return this._Color.toHtmlColor('rgb(' + outlineColor._value.red * 255 + ',' + outlineColor._value.green * 255 + ',' + outlineColor._value.blue * 255 + ',' + outlineColor._value.alpha * 255 + ')');
            }
        },
        /**
         * 设置geojson图层面边框宽度
         * @param {Number} outlineWidth [outlineWidth]
         */
        polygonOutlineWidth: {
            set: lodash.debounce(function (outlineWidth) {
                if (this._core.isnull(outlineWidth)) return;

                if (/^\[/.test(outlineWidth)) {
                    outlineWidth = outlineWidth.replace(/\[/, '').replace(/\]/, '');
                }
                this.item.polygon.outlineWidth = outlineWidth;
            }, 500),
            get: function () {
                var outlineWidth = this.item.polygon.outlineWidth;
                if (outlineWidth) {
                    return outlineWidth._value;
                }
                return undefined;
            }
        },
    });


    Polygon.prototype.setItem = function (item) {
        this.item = item;
    };
    Object.defineProperties(Polygon.prototype, {
        /**
         * 获取或设置线条
         */
        polyline: {
            get: function () {
                return this.item.polyline;
            },
            set: function (polyline) {
                this.item.polyline = polyline;
            }
        }
    });

    Object.defineProperties(Polygon.prototype, {
        /**
         * 获取或设置面
         */
        polygon: {
            get: function () {
                return this.item.polygon;
            },
            set: function (polygon) {
                this.item.polygon = polygon;
            }
        }
    });

    Object.defineProperties(Polygon.prototype, {
        /**
         * 获取或设置点
         */
        point: {
            get: function () {
                return this.item.point;
            },
            set: function (point) {
                this.item.point = point;
            }
        }
    });

    Object.defineProperties(Polygon.prototype, {
        /**
         * 获取或设置标签
         */
        label: {
            get: function () {
                return this.item.label;
            },
            set: function (label) {
                this.item.label = label;
            }
        }
    });

    Object.defineProperties(Polygon.prototype, {
        /**
         * 获取或设置模型
         */
        model: {
            get: function () {
                return this.item.model;
            },
            set: function (model) {
                this.item.model = model;
            }
        }
    });

    Object.defineProperties(Polygon.prototype, {
        /**
         * 获取或设置墙
         */
        wall: {
            get: function () {
                return this.item.wall;
            },
            set: function (wall) {
                this.item.wall = wall;
            }
        }
    });
    Object.defineProperties(Polygon.prototype, {
        /**
         * 获取墙的模板属性
         */
        polygonTempOptions: {
            get: function () {
                return {
                    height: 0,//	Property	0	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
                    extrudedHeight: 0,//	Property		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
                    show: true,//	Property	true	optional A boolean Property specifying the visibility of the polygon.
                    fill: true,//	Property	true	optional A boolean Property specifying whether the polygon is filled with the provided material.
                    material: this._cesium.Color.WHITE,//	MaterialProperty	Color.WHITE	optional A Property specifying the material used to fill the polygon.
                    outline: false,//	Property	false	optional A boolean Property specifying whether the polygon is outlined.
                    outlineColor: this._cesium.Color.BLACK,//	Property	Color.BLACK	optional A Property specifying the Color of the outline.
                    outlineWidth: 1.0,//	Property	1.0	optional A numeric Property specifying the width of the outline.
                    stRotation: 1.0,//	Property	0.0	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
                    granularity: this._cesium.Math.RADIANS_PER_DEGREE,//	Property	Cesium.Math.RADIANS_PER_DEGREE	optional A numeric Property specifying the angular distance between each latitude and longitude point.
                    perPositionHeight: false,//	Property	false	optional A boolean specifying whether or not the the height of each position is used.
                    closeTop: true,//	Boolean	true	optional When false, leaves off the top of an extruded polygon open.
                    closeBottom: true,//	Boolean	true	optional When false, leaves off the bottom of an extruded polygon open.
                    shadows: ShadowMode.DISABLED,//	Property	ShadowMode.DISABLED	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
                    classificationType: ClassificationType.BOTH,//	Property	ClassificationType.BOTH	optional An enum Property specifying whether this polygon will classify terrain, 3D Tiles, or both when on the ground.
                    arcType: ArcType.GEODESIC	//zIndex	ConstantProperty	0	optional A property specifying the zIndex used for ordering ground geometry. Only has an effect if the polygon is constant and neither height or extrudedHeight are specified.
                }
            }
        }
    });
    Object.defineProperties(Polygon.prototype, {
        Visibility: {
            get: function () {
                return this.item.show;
            }
        },
        PolygonColor: {
            get: function () {
                var colorPar = this.item._polygon.material.color._value;
                if (colorPar) {
                    return new Color(this._viewer, this._cesium).toHtmlColor('rgb(' + colorPar.red * 255 + ',' + colorPar.green * 255 + ',' + colorPar.blue * 255 + ')');
                }
            }
        },
        PolygonAlpha: {
            get: function () {
                if (this.item._polygon.material.color) {
                    return this.item._polygon.material.color._value.alpha || 1;
                }
            }
        },
        Outline: {
            get: function () {
                if (this.item._polygon.outline) {
                    return this.item._polygon.outline._value;
                }
            }
        },
        OutlineColor: {
            get: function () {
                var colorPar = this.item._polygon.outlineColor;
                if (this.item._polygon.outlineColor) {
                    colorPar = colorPar._value;
                    return new Color(this._viewer, this._cesium).toHtmlColor('rgb(' + colorPar.red * 255 + ',' + colorPar.green * 255 + ',' + colorPar.blue * 255 + ')');
                }
            }
        },
        ExtrudedHeight: {
            get: function () {
                if (this.item._polygon.extrudedHeight) {
                    return this.item._polygon.extrudedHeight._value;
                }
            }
        },
        Height: {
            get: function () {
                return this.item._polygon.height;
            }
        },
        PolygonImage: {
            get: function () {
                if (this.item._polygon.material.uniforms) {
                    return this.item._polygon.material.uniforms.image
                }
            }
        },
        PolygonRepeat: {
            get: function () {
                if (this.item._polygon.material.uniforms) {
                    return this.item._polygon.material.repeat
                }
            }
        }
    });
    /**
     * 结束当前操作
     */
    Polygon.prototype.forceEndHanlder = function () {
        if (this._tree.handler) {
            this._tree.handler.destroy();
            this._tree.handler = undefined;
        }
    };

    /**
     *
     * 创建长方体。
     *
     * @alias Box
     * @constructor
     *
     */
    function Box(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 这个方法用于创建长方体
     * @param {Array} [position] 一个经纬度数组 例如：[-114.0, 40.0, 300000.0]。
     * @param {object} [box] 对象。对象{
        dimensions: new this._cesium.Cartesian3(400000.0, 300000.0, 500000.0),
        material: this._cesium.Color.RED.withAlpha(0.5),
        fill: false,
        outline: true,
        outlineColor: this._cesium.Color.BLACK
    }
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Box.prototype.createBox = function (position, box, name, GroupID) {
        var defaultOption = {
            id: this._core.getuid(),//获取或设置拾取标签时返回的用户定义值。
            dimensions: new this._cesium.Cartesian3(400000.0, 300000.0, 500000.0),
            material: this._cesium.Color.RED.withAlpha(0.5),
            fill: true,
            outline: true,
            outlineColor: this._cesium.Color.BLACK
        };
        var options = this._core.extend(defaultOption, box, true);
        this.item = this._viewer.entities.add({
            name: name,
            //中心的位置（长、宽、高）
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]),
            box: options
        });
        var obj = {
            id: this.item.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'box',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
    * 获取box样式
    */
    Box.prototype.getstyles = function () {
        var styles = {};
        styles.show = this.item.box.show ? this.item.box.show._value : true;
        styles.heightReference = this.item.box.heightReference ? this.item.box.heightReference : undefined;
        styles.fill = this.item.box.fill && this.item.box.fill._value ? this.item.box.fill._value : undefined;
        styles.dimensions = this.item.box.dimensions ? this.item.box.dimensions.getValue() : undefined;
        styles.shadows = this.item.box.shadows && this.item.box.shadows._value ? this.item.box.shadows._value : undefined;
        styles.material = {};
        styles.material.color = this.item.box.material && this.item.box.material.color._value ? 'rgba' + this.item.box.material.color.toString() : undefined;
        styles.material.image = this.item.box.material && this.item.box.material.image._value ? this.item.box.material.image._value : undefined;
        styles.material.repeat = this.item.box.material && this.item.box.material.repeat ? this.item.box.material.repeat._value : undefined;
        styles.outline = this.item.box.outline && this.item.box.outline._value ? this.item.box.outline._value : undefined;
        styles.outlineColor = this.item.box.outlineColor && this.item.box.outlineColor._value ? 'rgba' + this.item.box.outlineColor.toString() + '' : undefined;
        styles.outlineWidth = this.item.box.outlineWidth && this.item.box.outlineWidth._value ? this.item.box.outlineWidth._value : undefined;
        styles.near = this.item.box.distanceDisplayCondition ? this.item.box.distanceDisplayCondition._value.near : undefined;
        styles.far = this.item.box.distanceDisplayCondition ? this.item.box.distanceDisplayCondition._value.far : undefined;
        styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
     * 向三维场景中添加立方体。
     * @param {object} [method] 回调函数
     *
     */
    Box.prototype.executeBox = function (method) {
        var _this = this;
        _this.shape = {
            tempPoints: [],
            button: 0,
            position: {}
        };
        var handle = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var tempPoints = [];
        //鼠标左键单击画点
        handle.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.position, _this._viewer.scene.globe.ellipsoid);
            var cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
            var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
            var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
            tempPoints.push({ lon: longitudeString, lat: latitudeString });
            if (_this.shape.button == 0) {
                _this.box = _this._viewer.entities.add({
                    name: "",
                    //position: _this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[1]),
                    position: _this._cesium.Cartesian3.fromDegrees(tempPoints[0].lon, tempPoints[0].lat),
                    box: {
                        id: _this._core.getuid(),//获取或设置拾取标签时返回的用户定义值。
                        dimensions: new _this._cesium.Cartesian3(400000.0, 300000.0, 500000.0),
                        material: _this._cesium.Color.RED.withAlpha(0.5),
                        fill: true,
                        outline: true,
                        outlineColor: _this._cesium.Color.RED
                    }
                });
                _this.item = _this.box;
            }
            ///工程树添加
            var ploylinejl = { polyline: {}, positions: [], distance: [] };
            var GroupID = 0;
            if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                GroupID = tree.selectedItem.id;
            var id = _this._core.getuid();
            var obj = {
                id: id,
                name: '新建立方体' + id,
                pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'box',
                item: _this
            };
            _this.setTreeobj(obj);
            _this._tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
            if (typeof method == 'function') {
                method(ploylinejl);
            }
            handle.destroy();

        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        return this;
    };
    /**
     * 向三维场景中地形开挖。
     * @param {object} [method] 回调函数
     *
     */
    Box.prototype.executeExcavation = function (parameter, method) {
        var _this = this;
        _this.shape = {
            tempPoints: [],
            button: 0,
            position: {}
        };
        var handle = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var tempPoints = [];
        //鼠标左键单击画点
        handle.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.position, _this._viewer.scene.globe.ellipsoid);
            var cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
            var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
            var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
            tempPoints.push({ lon: longitudeString, lat: latitudeString });
            var gd = -(parameter.z / 2);
            if (_this.shape.button == 0) {
                _this.box = _this._viewer.entities.add({
                    name: "",
                    //position: _this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[1]),
                    position: _this._cesium.Cartesian3.fromDegrees(tempPoints[0].lon, tempPoints[0].lat, gd),
                    box: {
                        id: _this._core.getuid(),//获取或设置拾取标签时返回的用户定义值。
                        dimensions: new _this._cesium.Cartesian3(parameter.x, parameter.y, parameter.z),
                        material: _this._cesium.Color.WHITE.withAlpha(0.5),
                        outline: true,
                        outlineColor: _this._cesium.Color.WHITE
                    }
                });
                _this.item = _this.box;
                var globe = _this._viewer.scene.globe;
                var cd = -(parameter.x / 2);
                var kd = -(parameter.y / 2);
                globe.depthTestAgainstTerrain = true;
                globe.clippingPlanes = new _this._cesium.ClippingPlaneCollection({
                    modelMatrix: _this.box.computeModelMatrix(_this._cesium.JulianDate.now()),
                    planes: [
                        new _this._cesium.Plane(new _this._cesium.Cartesian3(1.0, 0.0, 0.0), cd),
                        new _this._cesium.Plane(new _this._cesium.Cartesian3(-1.0, 0.0, 0.0), cd),
                        new _this._cesium.Plane(new _this._cesium.Cartesian3(0.0, 1.0, 0.0), kd),
                        new _this._cesium.Plane(new _this._cesium.Cartesian3(0.0, -1.0, 0.0), kd)
                    ],
                    edgeWidth: 1.0,
                    edgeColor: _this._cesium.Color.WHITE
                });
            }
            ///工程树添加
            var ploylinejl = { polyline: {}, positions: [], distance: [] };
            var GroupID = 0;
            if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                GroupID = tree.selectedItem.id;
            var id = _this._core.getuid();
            var obj = {
                id: id,
                name: '新建立方体' + id,
                pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'box',
                item: _this
            };
            _this.setTreeobj(obj);
            tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
            if (typeof method == 'function') {
                method(ploylinejl);
            }
            handle.destroy();

        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        return this;
    };
    /**
     * 向三维场景中添加立方体。
     * @param {object} [method] 回调函数
     *
     */
    Box.prototype.executeBox1 = function (method) {
        var _self = this;
        var _this = this;
        _self.shape = {
            points: [],
            button: 0,
            rect: null,
            entity: null
        };
        var tempPosition;
        //var handle = new Cesium.ScreenSpaceEventHandler(_self.viewer.scene.canvas);
        var handle = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        //鼠标左键单击画点
        handle.setInputAction(function (click) {
            tempPosition = _this._core.getPointFromWindowPoint(click.position, _this._viewer);
            //选择的点在球面上
            if (_self.shape.button >= 2) {
                handle.removeInputAction(_this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
                handle.removeInputAction(_this._cesium.ScreenSpaceEventType.LEFT_CLICK);
            }
            _self.shape.button = _self.shape.button + 1;
            if (tempPosition) {
                if (_self.shape.points.length == 0) {
                    _self.shape.points.push(_this._viewer.scene.globe.ellipsoid.cartesianToCartographic(tempPosition));
                    // var cartographicPosition = Cesium.Ellipsoid.WGS84.cartesianToCartographic(_self.shape.points);
                    _self.shape.rect = _this._cesium.Rectangle.fromCartographicArray(_self.shape.points);
                    _self.shape.rect.east += 0.000001;
                    _self.shape.rect.north += 0.000001;
                    _self.shape.entity = _this._viewer.entities.add({
                        rectangle: {
                            coordinates: _self.shape.rect,
                            material: _this._cesium.Color.BLACK.withAlpha(0.4),
                            outline: true,
                            outlineWidth: 2,
                            outlineColor: _this._cesium.Color.RED,
                            height: 0
                        }
                    });
                    _self.bufferEntity = _self.shape.entity;
                } else if (_self.shape.points.length == 2) ; else {
                    handle.removeInputAction(_this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
                    handle.removeInputAction(_this._cesium.ScreenSpaceEventType.LEFT_CLICK);
                }
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        handle.setInputAction(function (movement) {
            if (_self.shape.points.length == 0) {
                return;
            }
            var moveEndPosition = _this._core.getPointFromWindowPoint(movement.endPosition, _this._viewer);
            //选择的点在球面上
            if (moveEndPosition) {
                var ray = _this._viewer.camera.getPickRay(movement.endPosition);
                var se = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
                _self.shape.points[1] = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(moveEndPosition);
                _self.shape.rect = _this._cesium.Rectangle.fromCartographicArray(_self.shape.points);
                if (_self.shape.button == 2) {
                    _self.shape.entity.rectangle.extrudedHeight = se.z;
                } else {
                    if (_self.shape.rect.west == _self.shape.rect.east)
                        _self.shape.rect.east += 0.000001;
                    if (_self.shape.rect.south == _self.shape.rect.north)
                        _self.shape.rect.north += 0.000001;
                    _self.shape.entity.rectangle.coordinates = _self.shape.rect;
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return this;
    };
    /**
     * box导出工程数据
     */
    Box.prototype.export = function () {
        var show = this.item.show == undefined ? undefined : this.item.show._value;
        var dimensions = this.item.box.dimensions == undefined ? undefined : this.item.box.dimensions.getValue();
        var fill = this.item.box.fill == undefined ? undefined : this.item.box.fill._value;
        var material = this.item.box.material;
        if (material != undefined) {
            material = {
                color: material.color._value == undefined ? undefined : 'rgba(' + material.color._value.red + ',' + material.color._value.green + ',' + material.color._value.blue + ',' + material.color._value.alpha + ')',
                image: material.image == undefined ? undefined : material.image._value,
                diffusemap: material.diffusemap == undefined ? undefined : material.diffusemap._value,
                alphamap: material.alphamap == undefined ? undefined : material.alphamap._value
            };
        }
        var outline = this.item.box.outline == undefined ? undefined : this.item.box.outline._value;
        var outlineColor = this.item.box.outlineColor == undefined ? undefined : 'rgba(' + this.item.box.outlineColor._value.red + ',' + this.item.box.outlineColor._value.green + ',' + this.item.box.outlineColor._value.blue + ',' + this.item.box.outlineColor._value.alpha + ')';
        var outlineWidth = this.item.box.outlineWidth == undefined ? undefined : this.item.box.outlineWidth._value;
        var distanceDisplayCondition = this.item.box.distanceDisplayCondition;
        var near = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.near;
        var far = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.far;

        var catographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
        var longitude = this._cesium.Math.toDegrees(catographic.longitude);
        var latitude = this._cesium.Math.toDegrees(catographic.latitude);
        var height = this._cesium.Math.toDegrees(catographic.height);
        return {
            type: 'box',
            position: {
                x: longitude,
                y: latitude,
                z: height
            },
            treeobj: { id: this.treeobj.id, name: this.treeobj.name, pId: this.treeobj.pId, type: this.treeobj.type },
            style: {
                show: show,
                dimensions: dimensions,
                fill: fill,
                material: material,
                outline: outline,
                outlineColor: outlineColor,
                outlineWidth: outlineWidth,
                near: near,
                far: far
            }
        };
    };
    //工程树添加
    Box.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    Box.prototype.setVisibility = function (b) {
        this.item.show = b;
    };
    /**
     * 设置box的显示或隐藏
     * @param {Object} [Box] Box对象
     * @param {define} [show] 是否显示。
     * @returns {Object} 返回一个Box对象。
     */
    Box.prototype.setShow = function (show) {
        try {
            this.item._box.show = show;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 获取体积
     * @param {Object} [Box] Box对象
     * @returns {m3} 返回体积。
     */
    Box.prototype.getVolume = function () {
        try {
            var ckg = this.item._box.dimensions._value;
            var tj = ckg.x * ckg.y * ckg.z;
            //this.item._box.show = show;
        } catch (ex) {
            console.log(ex);
        }
        return tj;
    };
    /**
     * 设置立方体的贴图
     * @param {Object} [box] box对象
     * @param {url} 图片路径。
     * @returns {Object} 返回一个box对象。
     */
    Box.prototype.setBoxImage = function (url) {
        try {
            this.item._box.material = new this._cesium.ImageMaterialProperty({
                image: url  //可以为url、canvas、video      
            });
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置立方体的贴图一个Cartesian2属性，指定图像在每个方向上重复的次数。
     * @param {Object} [box] box对象
     * @param {Object} x和y上的比例。
     * @returns {Object} 返回一个Ellipsoid对象。
     */
    Box.prototype.setBoxRepeat = function (x, y) {
        try {
            //new Cesium.CallbackProperty
            this.item._box.material.repeat = new this._cesium.Cartesian2(x, y);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置立方体的高度类型
     * @param {Object} [box] box对象
     * @param {int} [type] 1：该位置被夹在地形上。2：这个职位是绝对的。3：位置高度是地形上方的高度。
     * @returns {Object} 返回一个对象。
     */
    Box.prototype.setHeightType = function (type) {
        try {
            if (type == 1) {
                this.item._box.heightReference = this._cesium.HeightReference.CLAMP_TO_GROUND;
            } else if (type == 2) {
                this.item._box.heightReference = this._cesium.HeightReference.NONE;
            } else if (type == 3) {
                this.item._box.heightReference = this._cesium.HeightReference.RELATIVE_TO_GROUND;
            }
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 修改面的可视距离
     * @param {Object} [box] box对象
     * @param {String} [min, max] 设置线段的可视距离
     * @returns {Object} 返回一个box对象。
     */
    Box.prototype.setDistanceDisplayCondition = function (min, max) {
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        try {
            this.item._box.distanceDisplayCondition = distance;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置box的是否s
     * @param {Object} [Box] Box对象
     * @param {define} [fill] 是否显示。
     * @returns {Object} 返回一个Box对象。
     */
    Box.prototype.setFill = function (fill) {
        try {
            this.item._box.fill = fill;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置box的填充透明度
     * @param {Object} [Box] Box对象
     * @param {Float} [a] 透明度 0-1
     * @returns {Object} 返回一个Box对象。
     */
    Box.prototype.setMaterialAlpha = function (a) {
        try {
            this.item._box.material.color._value.alpha = a;
            this.item._box.show = true;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置box的线的颜色
     * @param {Object} [Box] Box对象
     * @param {htmlColor} htmlColor颜色
     * @returns {Object} 返回一个Box对象。
     */
    Box.prototype.setOutlineColor = function (htmlColor) {
        try {
            this.item._box.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置box的填充颜色
     * @param {Object} [Box] Box对象
     * @param {htmlColor} htmlColor颜色
     * @returns {Object} 返回一个Box对象。
     */
    Box.prototype.setMaterial = function (htmlColor) {
        try {
            this.item._box.material.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    Box.prototype.setItem = function (item) {
        this.item = item;
    };
    //删除矩形对象
    Box.prototype.deleteObject = function () {
        this._viewer.entities.remove(this.item);
        // this = null;
    };
    Object.defineProperties(Box.prototype, {
        /**
         * 透明度
         */
        ColorAlpha: {
            get: function () {
                return this.item._box.color._value.alpha;
            }
        },
        /**
         * 显示比例
         */
        Scale: {
            get: function () {
                return this.item._box.scale;
            }
        },
        /**
         * 旋转角度
         */
        Rotation: {
            get: function () {
                return this.item._box.rotation;
            }
        },
        /**
         * 宽度
         */
        Width: {
            get: function () {
                return this.item._box.width;
            }
        },
        /**
         * 高度
         */
        Height: {
            get: function () {
                return this.item._box.heightReference;
            }
        },
        /**
         * 颜色
         */
        Color: {
            get: function () {
                return this._color.toHtmlColor('rgb(' + this.item._box.backgroundColor._value.red * 255 + ',' + this.item._box.backgroundColor._value.green * 255 + ',' + this.item._box.backgroundColor._value.blue * 255 + ',' + this.item._box.backgroundColor._value.alpha * 255 + ')')
            }
        }
    });

    /**
     *
     * 仿照te修改
     *
     * 这个方法用于创建长方体
     * @param {Object} [Position] Position表示地面对象的位置和方向。对象{
        Altitude:高度。
        AltitudeType:枚举确定高度如何解译。
        Cartesian:一个布尔值，决定是否基于直角坐标系计算。
        Distance:从摄像机到位置的距离。
        Pitch:相机或对象的倾斜角度。
        Roll:对象的滚动角。
        X:X坐标。
        Y:Y坐标。
        Yaw:该相机或对象的方向角。
    }
     * @param {number} [ObjectWidth] 长方体的宽度（单位：米）。
     * @param {number} [ObjectDepth] 长方体的深度（单位：米）。
     * @param {number} [ObjectHeight] 长方体的高度（单位：米）。
     * @param {String} [LineColor] 组成长方体的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 长方体的填充色。颜色值由RGB定义。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中长方体的名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Box.prototype.CreateBox = function (Position, ObjectWidth, ObjectDepth, ObjectHeight, LineColor, FillColor, GroupID, Description) {
        this._postion = Position;

        var defaultOption = {
            dimensions: new this._cesium.Cartesian3(ObjectHeight, ObjectWidth, ObjectDepth),
            material: this._cesium.Color.YELLOW,
            outline: true,
            outlineColor: this._cesium.Color.RED,
        };

        if (LineColor && LineColor !== '') {
            defaultOption.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(LineColor);
        }
        if (FillColor && FillColor !== '') {
            defaultOption.material = new Color(this._viewer, this._cesium).colorFromHtmlColor(FillColor);
        }

        var orientation;
        if (Position.Yaw || Position.Pitch || Position.Roll) {
            orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
                new this._cesium.HeadingPitchRoll(
                    this._cesium.Math.toRadians(Position.Yaw),
                    this._cesium.Math.toRadians(Position.Pitch),
                    this._cesium.Math.toRadians(Position.Roll)
                )
            );
        }
        this.item = this._viewer.entities.add({
            name: Description,
            //中心的位置
            position: this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
            box: defaultOption,
            orientation: orientation
        });
        var obj = {
            id: this.item.id,
            name: Description,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'box',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    Object.defineProperties(Box.prototype, {
        Position: {
            Altitude: {
                get: function () {
                    return this._postion.Altitude
                },
                set: function (Altitude) {
                    try {
                        // 赋值
                        this._postion.Altitude = Altitude;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            AltitudeType: {
                get: function () {
                    return this._postion.AltitudeType
                },
                set: function (AltitudeType) {
                    try {
                        this._postion.AltitudeType = AltitudeType;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Cartesian: {
                get: function () {
                    return this._postion.Cartesian
                },
                set: function (Cartesian) {
                    try {
                        this._postion.Cartesian = Cartesian;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Distance: {
                get: function () {
                    return this._postion.Distance
                },
                set: function (Distance) {
                    try {
                        this._postion.Distance = Distance;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Pitch: {
                get: function () {
                    return this._postion.Pitch
                },
                set: function (Pitch) {
                    try {
                        this._postion.Pitch = Pitch;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Roll: {
                get: function () {
                    return this._postion.Roll
                },
                set: function (Roll) {
                    try {
                        this._postion.Roll = Roll;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            X: {
                get: function () {
                    return this._postion.X
                },
                set: function (X) {
                    try {
                        // 赋值
                        this._postion.X = X;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Y: {
                get: function () {
                    return this._postion.Y
                },
                set: function (Y) {
                    try {
                        // 赋值
                        this._postion.Y = Y;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Yaw: {
                get: function () {
                    return this._postion.Yaw
                },
                set: function (Yaw) {
                    try {
                        this._postion.Yaw = Yaw;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            }
        }
    });

    /**
     *
     * 这个方法用于创建球。
     *
     * @alias Ellipsoid
     * @constructor
     *
     */
    function Ellipsoid(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 这个方法用于创建球
     * @param {Array} [position] 一个经纬度数组。
     * @param {object} [cylinder] 对象。对象{
        length: 400000.0,
        topRadius: 0.0,
        bottomRadius: 200000.0,
        material: this._cesium.Color.GREEN
    }
     * @param {String} [name] 圆锥显示的文字。
     * @param {String} [GroupID] 圆锥显示的文字。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Ellipsoid.prototype.createEllipsoid = function (position, ellipsoid, name, GroupID) {
        var defaultOption = {
            radii: new this._cesium.Cartesian3(60.0, 60.0, 60.0),
            material: this._cesium.Color.YELLOW
        };
        var options = this._core.extend(defaultOption, ellipsoid, true);
        this.item = this._viewer.entities.add({
            name: name,
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[1]),
            ellipsoid: options
        });
        var obj = {
            id: this.item.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ellipsoid',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
      * 获取ellipsoid样式
      */
    Ellipsoid.prototype.getstyles = function () {
        var styles = {};
        styles.show = this.item.ellipsoid.show ? this.item.ellipsoid.show._value : true;
        styles.radii = this.item.ellipsoid.radii ? this.item.ellipsoid.radii.getValue() : undefined;
        styles.innerRadii = this.item.ellipsoid.innerRadii ? this.item.ellipsoid.innerRadii.getValue() : undefined;
        styles.minimumClock = this.item.ellipsoid.minimumClock ? this.item.ellipsoid.minimumClock._value : undefined;
        styles.maximumClock = this.item.ellipsoid.maximumClock ? this.item.ellipsoid.maximumClock._value : undefined;
        styles.minimumCone = this.item.ellipsoid.minimumCone ? this.item.ellipsoid.minimumCone._value : undefined;
        styles.maximumCone = this.item.ellipsoid.maximumCone ? this.item.ellipsoid.maximumCone._value : undefined;
        styles.heightReference = this.item.ellipsoid.heightReference && this.item.ellipsoid.heightReference._value ? this.item.ellipsoid.heightReference._value : null;
        styles.fill = this.item.ellipsoid.fill ? this.item.ellipsoid.fill._value : undefined;
        styles.material = {};
        styles.material.color = this.item.ellipsoid.material && this.item.ellipsoid.material.color && this.item.ellipsoid.material.color._value ? 'rgba' + this.item.ellipsoid.material.color.toString() : null;
        styles.material.image = this.item.ellipsoid.material && this.item.ellipsoid.material.image ? this.item.ellipsoid.material.image._value : undefined;
        styles.material.repeat = this.item.ellipsoid.material && this.item.ellipsoid.material.repeat && this.item.ellipsoid.material.repeat._value ? this.item.ellipsoid.material.repeat._value : null;
        styles.outline = this.item.ellipsoid.outline ? this.item.ellipsoid.outline._value : undefined;
        styles.outlineWidth = this.item.ellipsoid.outlineWidth && this.item.ellipsoid.outlineWidth._value ? this.item.ellipsoid.outlineWidth._value : undefined;
        styles.outlineColor = this.item.ellipsoid.outlineColor && this.item.ellipsoid.outlineColor._value ? 'rgba' + this.item.ellipsoid.outlineColor.toString() + '' : null;
        styles.stackPartitions = this.item.ellipsoid.stackPartitions && this.item.ellipsoid.stackPartitions._value ? this.item.ellipsoid.stackPartitions._value : undefined;
        styles.slicePartitions = this.item.ellipsoid.slicePartitions && this.item.ellipsoid.slicePartitions._value ? this.item.ellipsoid.slicePartitions._value : undefined;
        styles.subdivisions = this.item.ellipsoid.subdivisions && this.item.ellipsoid.subdivisions._value ? this.item.ellipsoid.subdivisions._value : undefined;
        styles.near = this.item.ellipsoid.distanceDisplayCondition ? this.item.ellipsoid.distanceDisplayCondition._value.near : undefined;
        styles.far = this.item.ellipsoid.distanceDisplayCondition ? this.item.ellipsoid.distanceDisplayCondition._value.far : undefined;
        styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
     * 向三维场景中添加球。
     * @param {object} [method] 回调函数
     *
     */
    Ellipsoid.prototype.executeEllipsoid = function (method) {
        //创建球和可以创建在高程上
        //var polylines = {};
        var _this = this;
        _this.shape = {
            tempPoints: [],
            button: 0,
            position: {}
        };
        var handler = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var positions = [];
        var tempPoints = [];
        //鼠标左键单击画点
        handler.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.position, _this._viewer.scene.globe.ellipsoid);
            var cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
            var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
            var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
            tempPoints.push({ lon: longitudeString, lat: latitudeString });
            var ploylinejl = { polyline: {}, positions: [], distance: [] };
            if (_this.shape.button == 0) {
                positions.push(cartesian.clone());
                positions.push(cartesian);
                _this.shape.position = cartesian;
                _this.ellipsoid = _this._viewer.entities.add({
                    name: "",
                    //position: _this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[1]),
                    position: _this._cesium.Cartesian3.fromDegrees(tempPoints[0].lon, tempPoints[0].lat),
                    ellipsoid: {
                        radii: new _this._cesium.Cartesian3(67500.0, 67500.0, 67500.0),
                        material: _this._cesium.Color.fromRandom({ alpha: 1.0 })
                    }
                });
                _this.item = _this.ellipsoid;
            } else if (_this.shape.button == 1) {
                var distance = Cdcl(tempPoints[0].lat, tempPoints[0].lon, tempPoints[1].lat, tempPoints[1].lon);
                _this.item.ellipsoid.radii = new _this._cesium.Cartesian3(distance, distance, distance);
                handler.destroy();
            }
            //工程树
            var GroupID = 0;
            if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                GroupID = tree.selectedItem.id;
            var id = _this._core.getuid();
            var obj = {
                id: id,
                name: '新建球' + id,
                pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'ellipsoid',
                item: _this
            };
            _this.setTreeobj(obj);
            tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
            if (typeof method == 'function') {
                method(ploylinejl);
            }
            _this.shape.button = _this.shape.button + 1;
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        handler.setInputAction(function (movement) {
            //得到当前三维场景的椭球体
            if (_this.shape.button == 1) {
                var cartesian = _this._viewer.camera.pickEllipsoid(movement.endPosition, _this._viewer.scene.globe.ellipsoid);
                if (cartesian) {
                    var cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
                    //将笛卡尔坐标转换为地理坐标
                    //var cartographic = ellipsoid.cartesianToCartographic(cartesian);
                    //将弧度转为度的十进制度表示
                    var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
                    var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
                    //获取相机高度
                    Math.ceil(_this._viewer.camera.positionCartographic.height);
                    tempPoints.push({ lon: longitudeString, lat: latitudeString });
                    var distance = Cdcl(tempPoints[0].lat, tempPoints[0].lon, tempPoints[tempPoints.length - 1].lat, tempPoints[tempPoints.length - 1].lon);
                    _this.item.ellipsoid.radii = new _this._cesium.Cartesian3(distance, distance, distance);
                }
            }

        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return this;
    };
    /**
     * 设置球的填充颜色
     * @param {Object} [ellipsoid] ellipsoid对象
     * @returns {htmlColor} htmlColor颜色。
     * @returns {Object} 返回一个ellipsoid对象。
     */
    Ellipsoid.prototype.setMaterialColor = function (htmlColor) {
        try {
            this.item._ellipsoid.material.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * ellise导出工程数据
     */
    Ellipsoid.prototype.export = function () {
        var show = this.item.show == undefined ? undefined : this.item.show;
        var radii = this.item.ellipsoid.radii == undefined ? undefined : this.item.ellipsoid.radii.getValue();
        var fill = this.item.ellipsoid.fill == undefined ? undefined : this.item.ellipsoid.fill.getValue();
        var material = this.item.ellipsoid.material;
        if (material != undefined) {
            material = {
                color: material.color._value == undefined ? undefined : 'rgba(' + material.color._value.red + ',' + material.color._value.green + ',' + material.color._value.blue + ',' + material.color._value.alpha + ')',
                image: material.image == undefined ? undefined : material.image._value,
                diffusemap: material.diffusemap == undefined ? undefined : material.diffusemap._value,
                alphamap: material.alphamap == undefined ? undefined : material.alphamap._value
            };
        }
        var outline = this.item.ellipsoid.outline == undefined ? undefined : this.item.ellipsoid.outline._value;
        var outlineColor = this.item.ellipsoid.outlineColor == undefined ? undefined : 'rgba(' + this.item.ellipsoid.outlineColor._value.red + ',' + this.item.ellipsoid.outlineColor._value.green + ',' + this.item.ellipsoid.outlineColor._value.blue + ',' + this.item.ellipsoid.outlineColor._value.alpha + ')';
        var outlineWidth = this.item.ellipsoid.outlineWidth == undefined ? undefined : this.item.ellipsoid.outlineWidth.getValue();
        var distanceDisplayCondition = this.item.ellipsoid.distanceDisplayCondition;
        var near = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.near;
        var far = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.far;

        var catographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
        var longitude = this._cesium.Math.toDegrees(catographic.longitude);
        var latitude = this._cesium.Math.toDegrees(catographic.latitude);
        var height = this._cesium.Math.toDegrees(catographic.height);
        return {
            type: 'ellipsoid',
            position: {
                x: longitude,
                y: latitude,
                z: height
            },
            treeobj: { id: this.treeobj.id, name: this.treeobj.name, pId: this.treeobj.pId, type: this.treeobj.type },
            style: {
                show: show,
                radii: radii,
                fill: fill,
                material: material,
                outline: outline,
                outlineColor: outlineColor,
                outlineWidth: outlineWidth,
                near: near,
                far: far
            }
        };
    };
    //工程树添加
    Ellipsoid.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 设置polygon的显示隐藏
     * @param {boolean} [b] true|false
     */
    Ellipsoid.prototype.setVisibility = function (b) {
        this.item.show = b;
    };
    //删除矩形对象
    Ellipsoid.prototype.deleteObject = function () {
        this._viewer.entities.remove(this.item);
        // this = null;
    };
    /**
     * 设置球的高度类型
     * @param {Object} [ellipsoid] ellipsoid对象
     * @param {int} [type] 1：该位置被夹在地形上。2：这个职位是绝对的。3：位置高度是地形上方的高度。
     * @returns {Object} 返回一个对象。
     */
    Ellipsoid.prototype.setHeightType = function (type) {
        try {
            if (type == 1) {
                this.item._ellipsoid.heightReference = this._cesium.HeightReference.CLAMP_TO_GROUND;
            } else if (type == 2) {
                this.item._ellipsoid.heightReference = this._cesium.HeightReference.NONE;
            } else if (type == 3) {
                this.item._ellipsoid.heightReference = this._cesium.HeightReference.RELATIVE_TO_GROUND;
            }
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置球的填充透明度
     * @param {Object} [ellipsoid] ellipsoid对象
     * @param {Float} [a] 透明度 0-1
     * @returns {Object} 返回一个ellipsoid对象。
     */
    Ellipsoid.prototype.setEllipsoidAlpha = function (a) {
        try {
            this.item._ellipsoid.material.color._value.alpha = a;
            this.item._ellipsoid.show = true;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 修改球的可视距离
     * @param {Object} [ellipsoid] ellipsoid对象
     * @param {String} [min, max] 设置球的可视距离
     * @returns {Object} 返回一个ellipsoid对象。
     */
    Ellipsoid.prototype.setDistanceDisplayCondition = function (min, max) {
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        try {
            this.item._ellipsoid.distanceDisplayCondition = distance;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置面的贴图
     * @param {Object} [Ellipsoid] Ellipsoid对象
     * @param {url} 图片路径。
     * @returns {Object} 返回一个Ellipsoid对象。
     */
    Ellipsoid.prototype.setEllipsoidImage = function (url) {
        try {
            this.item._ellipsoid.material = new this._cesium.ImageMaterialProperty({
                image: url  //可以为url、canvas、video
            });

        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置球的贴图一个Cartesian2属性，指定图像在每个方向上重复的次数。
     * @param {Object} [Ellipsoid] Ellipsoid对象
     * @param {Object} x和y上的比例。
     * @returns {Object} 返回一个Ellipsoid对象。
     */
    Ellipsoid.prototype.setEllipsoidRepeat = function (x, y) {
        try {
            //new Cesium.CallbackProperty
            this.item._ellipsoid.material.repeat = new this._cesium.Cartesian2(x, y);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置CylinderGraphics的用于填充球的是否显示。
     * @param {bool} [show]是否显示
     * @returns {Object} 返回一个CylinderGraphics对象。
     */
    Ellipsoid.prototype.setMaterial = function (show) {
        try {
            this.item._ellipsoid.show = show;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置球的半径。
     * @param {douuble} [x] 半径
     * @returns {Object} 返回一个CylinderGraphics对象。
     */
    Ellipsoid.prototype.setRadii = function (x) {
        try {
            this.item._ellipsoid.radii = new this._cesium.Cartesian3(x, x, x);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    Ellipsoid.prototype.setItem = function (item) {
        this.item = item;
    };
    /**
     * 仿照te修改
     *
     * 这个方法用于创建球
     * @param {Object} [Position] Position表示地面对象的位置和方向。对象{
        Altitude:高度。
        AltitudeType:枚举确定高度如何解译。
        Cartesian:一个布尔值，决定是否基于直角坐标系计算。
        Distance:从摄像机到位置的距离。
        Pitch:相机或对象的倾斜角度。
        Roll:对象的滚动角。
        X:X坐标。
        Y:Y坐标。
        Yaw:该相机或对象的方向角。
    }
     * @param {number} [Radius] 球的半径。
     * @param {number} [Style] 一个枚举值，定义了球的哪个部分是可见的。
     * @param {String} [LineColor] 组成球的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 球的填充色。颜色值由RGB定义。
     * @param {number} [SegmentDensity] 定义组成球的格网密度。密度值范围1-10，缺省值为4。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中球名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Ellipsoid.prototype.CreateSphere = function (Position, Radius, Style, LineColor, FillColor, SegmentDensity, GroupID, Description) {
        this._postion = Position;

        var defaultOption = {
            radii: this._cesium.defaultValue(new this._cesium.Cartesian3(Radius, Radius, Radius), new this._cesium.Cartesian3(60.0, 60.0, 60.0)),
            material: this._cesium.Color.RED,
            outline: false,
            outlineColor: undefined,
        };

        if (LineColor && LineColor !== '') {
            defaultOption.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(LineColor);
            defaultOption.outline = true;
        }
        if (FillColor && FillColor !== '') {
            defaultOption.material = new Color(this._viewer, this._cesium).colorFromHtmlColor(FillColor);
        }

        var orientation;
        if (Position.Yaw || Position.Pitch || Position.Roll) {
            orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
                new this._cesium.HeadingPitchRoll(
                    this._cesium.Math.toRadians(Position.Yaw),
                    this._cesium.Math.toRadians(Position.Pitch),
                    this._cesium.Math.toRadians(Position.Roll)
                )
            );
        }

        this.item = this._viewer.entities.add({
            name: Description,
            position: this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
            ellipsoid: defaultOption,
            orientation: orientation
        });
        var obj = {
            id: this.item.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ellipsoid',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    Object.defineProperties(Ellipsoid.prototype, {
        Position: {
            Altitude: {
                get: function () {
                    return this._postion.Altitude
                },
                set: function (Altitude) {
                    try {
                        // 赋值
                        this._postion.Altitude = Altitude;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            AltitudeType: {
                get: function () {
                    return this._postion.AltitudeType
                },
                set: function (AltitudeType) {
                    try {
                        this._postion.AltitudeType = AltitudeType;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Cartesian: {
                get: function () {
                    return this._postion.Cartesian
                },
                set: function (Cartesian) {
                    try {
                        this._postion.Cartesian = Cartesian;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Distance: {
                get: function () {
                    return this._postion.Distance
                },
                set: function (Distance) {
                    try {
                        this._postion.Distance = Distance;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Pitch: {
                get: function () {
                    return this._postion.Pitch
                },
                set: function (Pitch) {
                    try {
                        this._postion.Pitch = Pitch;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Roll: {
                get: function () {
                    return this._postion.Roll
                },
                set: function (Roll) {
                    try {
                        this._postion.Roll = Roll;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            X: {
                get: function () {
                    return this._postion.X
                },
                set: function (X) {
                    try {
                        // 赋值
                        this._postion.X = X;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Y: {
                get: function () {
                    return this._postion.Y
                },
                set: function (Y) {
                    try {
                        // 赋值
                        this._postion.Y = Y;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Yaw: {
                get: function () {
                    return this._postion.Yaw
                },
                set: function (Yaw) {
                    try {
                        this._postion.Yaw = Yaw;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            }
        }
    });

    /**
     *
     * 向三维场景中添加矩形。
     *
     * @alias Rectangle
     * @constructor
     *
     */
    function Rectangle$1(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
        this._viewEvent = null;
        //动态绘制矩形
        this.positions = [];
        this._getPosition = new getPosition(this._viewer, this._cesium);
        this.objId = Number((new Date()).getTime() + "" + Number(Math.random() * 1000).toFixed(0));
        this.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        this.modifyHandler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        this.style = null;
        this.state = 0; //1为新增 2为编辑 0为清除
        this.gonRectangleArr = [];
    }

    /**
     * 向三维场景中添加矩形。
     * @param {Object} [option] 矩形参数
     * @param {function} [method] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Rectangle$1.prototype.createRectangle = function (option, method) {
        var _self = this;
        var _this = this;
        this._tree.removeHandler();
        !option && (option = {});
        _self.shape = {
            points: [],
            button: 0,
            rect: null,
            entity: null
        };
        var tempPosition;
        var color = {
            fillColor: this._cesium.Color.YELLOW.withAlpha(0.4),
            outlineColor: this._cesium.Color.RED
        };
        if (option && option.fillColor) {
            color.fillColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(fillColor);
        }
        if (option && option.outlineColor) {
            color.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(outlineColor);
        }
        //var handle = new Cesium.ScreenSpaceEventHandler(_self.viewer.scene.canvas);
        this._tree.handler = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        //鼠标左键单击画点
        var pointerOne = null, pointerTwo = null;
        this._tree.handler.setInputAction(function (click) {
            //var ray = _this._viewer.camera.getPickRay(click.position);
            //var cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            tempPosition = _this._getPosition.getMousePosition(click, [_self.shape.entity]);
            var cartesian = _this._getPosition.getMouseDegrees(click, [_self.shape.entity]);
            //选择的点在球面上
            if (_self.shape.button >= 1) {
                pointerTwo = cartesian;
                var data = {
                    'obj1': pointerOne,
                    'obj2': pointerTwo
                };
                var originalCameraLocation = {
                    position: _this._viewer.camera.position.clone(),
                    orientation: {
                        heading: _this._viewer.camera.heading,
                        pitch: _this._viewer.camera.pitch,
                        roll: _this._viewer.camera.roll,
                    }
                };
                var sessionStorage = {
                    originalCameraLocation: originalCameraLocation,
                    pointes: data,
                    terrainExaggeration: "5",
                    zj: "true"
                };
                if (typeof method == 'function') {
                    method(sessionStorage);
                }
                _this._tree.handler.removeInputAction(_this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
                _this._tree.handler.removeInputAction(_this._cesium.ScreenSpaceEventType.LEFT_CLICK);
            } else {
                pointerOne = cartesian;
            }
            _self.shape.button = _self.shape.button + 1;
            if (tempPosition) {
                if (_self.shape.points.length == 0) {
                    _self.shape.points.push(_this._viewer.scene.globe.ellipsoid.cartesianToCartographic(tempPosition));
                    // var cartographicPosition = Cesium.Ellipsoid.WGS84.cartesianToCartographic(_self.shape.points);
                    _self.shape.rect = _this._cesium.Rectangle.fromCartographicArray(_self.shape.points);
                    _self.shape.rect.east += 0.000001;
                    _self.shape.rect.north += 0.000001;
                    _self.shape.entity = _this._viewer.entities.add({
                        rectangle: {
                            coordinates: _self.shape.rect,
                            material: color.fillColor,
                            outline: true,
                            outlineWidth: 2,
                            outlineColor: color.outlineColor,
                            height: (option && option.height),
                            heightReference: (option && option.heightReference)
                        }
                    });
                    _self.shape.entity.rectangle.coordinates = new _this._cesium.CallbackProperty(function () {
                        return _self.shape.rect;
                    }, false);
                    _self.bufferEntity = _self.shape.entity;
                    _this.item = _self.shape.entity;
                } else {
                    //设置鼠标样式
                    _this._core.mouse(_this._viewer.container, 0, "0");
                    _self.shape.entity.rectangle.coordinates = _this._cesium.Rectangle.clone(_self.shape.rect);
                    _this._tree.handler.removeInputAction(_this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
                    _this._tree.handler.removeInputAction(_this._cesium.ScreenSpaceEventType.LEFT_CLICK);
                }
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        _this._tree.handler.setInputAction(function (movement) {
            if (_self.shape.points.length == 0) {
                return;
            }
            var moveEndPosition = _this._getPosition.getMousePosition(movement, [_self.shape.entity]);
            //选择的点在球面上
            if (moveEndPosition) {
                _self.shape.points[1] = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(moveEndPosition);
                _self.shape.rect = _this._cesium.Rectangle.fromCartographicArray(_self.shape.points);
                if (_self.shape.rect.west == _self.shape.rect.east)
                    _self.shape.rect.east += 0.000001;
                if (_self.shape.rect.south == _self.shape.rect.north)
                    _self.shape.rect.north += 0.000001;

            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        ///工程树添加
        var GroupID = 0;
        if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        var id = _this._core.getuid();
        var obj = {
            id: id,
            name: '新建矩形' + id,
            pId: _this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'rectangle',
            item: _this
        };
        _this.setTreeobj(obj);
        tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    /**
      * 获取Rectangle样式
      */
    Rectangle$1.prototype.getstyles = function () {
        var styles = {};
        styles.show = this.item.rectangle.show ? this.item.rectangle.show._value : true;
        styles.coordinates = this.item.rectangle.coordinates ? { east: this.item.rectangle.coordinates.getValue().east, north: this.item.rectangle.coordinates.getValue().north, south: this.item.rectangle.coordinates.getValue().south, west: this.item.rectangle.coordinates.getValue().west } : [];
        styles.height = this.item.rectangle.height ? this.item.rectangle.height.toString() : 0;
        styles.heightReference = this.item.rectangle.heightReference ? this.item.rectangle.heightReference.toString() : 0;
        styles.extrudedHeight = this.item.rectangle.extrudedHeight ? this.item.rectangle.extrudedHeight.getValue().toString() : 0;
        styles.extrudedHeightReference = this.item.rectangle.extrudedHeightReference ? this.item.rectangle.extrudedHeightReference.toString() : 0;
        styles.rotation = this.item.rectangle.rotation ? this.item.rectangle.rotation.toString() : 0;
        styles.stRotation = this.item.rectangle.stRotation ? this.item.rectangle.stRotation.toString() : 0;
        styles.granularity = this.item.rectangle.granularity && this.item.rectangle.granularity._value ? this.item.rectangle.granularity._value : undefined;
        styles.fill = this.item.rectangle.fill ? this.item.rectangle.fill._value : 0;
        styles.outline = this.item.rectangle.outline ? this.item.rectangle.outline._value : 0;
        styles.outlineWidth = this.item.rectangle.outlineWidth && this.item.rectangle.outlineWidth._value ? this.item.rectangle.outlineWidth._value.toString() : 1;
        styles.outlineColor = this.item.rectangle.outlineColor && this.item.rectangle.outlineColor._value ? 'rgba' + this.item.rectangle.outlineColor.toString() + '' : null;
        styles.material = {};
        styles.material.color = this.item.rectangle.material && this.item.rectangle.material.color && this.item.rectangle.material.color._value ? 'rgba' + this.item.rectangle.material.color.toString() : null;
        styles.material.image = this.item.rectangle.material && this.item.rectangle.material.image && this.item.rectangle.material.image._value ? this.item.rectangle.material.image.toString() : null;
        styles.material.repeat = this.item.rectangle.material && this.item.rectangle.material.repeat && this.item.rectangle.material.repeat._value ? this.item.rectangle.material.repeat._value : null;
        styles.classificationType = this.item.rectangle.classificationType ? this.item.rectangle.classificationType.toString() : null;
        styles.near = this.item.rectangle.distanceDisplayCondition ? this.item.rectangle.distanceDisplayCondition._value.near : null;
        styles.far = this.item.rectangle.distanceDisplayCondition ? this.item.rectangle.distanceDisplayCondition._value.far : null;
        // styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
    * 向三维场景中添加矩形(可编辑，升级版)。
    * @param {Object} [option] 矩形参数
    * @param {function} [method] 回调函数
    * @returns {Promise.<Object>} 返回一个Cesium的对象。
    *
    */
    Rectangle$1.prototype.createRectangleOptimization = function (option, method) {
        var that = this;
        this._tree.removeHandler();
        that.shape = {
            points: [],
            button: 0,
            rect: null,
            entity: null
        };
        var tempPosition;
        var color = {
            fillColor: this._cesium.Color.YELLOW.withAlpha(0.4),
            outlineColor: this._cesium.Color.RED
        };
        if (option && option.fillColor) {
            color.fillColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(fillColor);
        }
        if (option && option.outlineColor) {
            color.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(outlineColor);
        }
        this.handler = new this._cesium.ScreenSpaceEventHandler(that._viewer.scene.canvas);
        //鼠标左键单击画点
        var pointerOne = null, pointerTwo = null;
        this.handler.setInputAction(function (click) {
            tempPosition = that._core.getPointFromWindowPoint(click.position, that._viewer);
            var cartesian = that._viewer.camera.pickEllipsoid(click.position, that._viewer.scene.globe.ellipsoid);
            //var cartesian = that.getCatesian3FromPX(click.position, $this.viewer, []);
            //选择的点在球面上
            if (that.shape.button >= 1) {
                pointerTwo = cartesian;
                var data = {
                    'obj1': pointerOne,
                    'obj2': pointerTwo
                };
                var originalCameraLocation = {
                    position: that._viewer.camera.position.clone(),
                    orientation: {
                        heading: that._viewer.camera.heading,
                        pitch: that._viewer.camera.pitch,
                        roll: that._viewer.camera.roll,
                    }
                };
                var sessionStorage = {
                    originalCameraLocation: originalCameraLocation,
                    pointes: data,
                    terrainExaggeration: "5",
                    zj: "true"
                };
                if (typeof method == 'function') {
                    method(sessionStorage);
                }
                that.handler.removeInputAction(that._cesium.ScreenSpaceEventType.MOUSE_MOVE);
                that.handler.removeInputAction(that._cesium.ScreenSpaceEventType.LEFT_CLICK);
            } else {
                pointerOne = cartesian;
            }
            that.shape.button = that.shape.button + 1;
            if (tempPosition) {
                if (that.shape.points.length == 0) {
                    that.shape.points.push(that._viewer.scene.globe.ellipsoid.cartesianToCartographic(tempPosition));
                    that.shape.rect = that._cesium.Rectangle.fromCartographicArray(that.shape.points);
                    that.shape.rect.east += 0.000001;
                    that.shape.rect.north += 0.000001;
                    that.shape.entity = that._viewer.entities.add({
                        rectangle: {
                            coordinates: that.shape.rect,
                            material: color.fillColor,
                            outline: true,
                            outlineWidth: 2,
                            outlineColor: color.outlineColor,
                            height: (option && option.height),
                            heightReference: (option && option.heightReference) || 1
                        }
                    });
                    that.shape.entity.objId = that.objId;
                    that.shape.entity.rectangle.coordinates = new that._cesium.CallbackProperty(function () {
                        return that.shape.rect;
                    }, false);
                    that._core.Entityadd(that);
                    that.bufferEntity = that.shape.entity;
                    that.item = that.shape.entity;
                } else {
                    that.state = 1;
                    //that.shape.entity.rectangle.coordinates = that._cesium.Rectangle.clone(that.shape.rect);
                    that.handler.removeInputAction(that._cesium.ScreenSpaceEventType.MOUSE_MOVE);
                    that.handler.removeInputAction(that._cesium.ScreenSpaceEventType.LEFT_CLICK);
                }
                //添加点
                var point = that.createPoint(tempPosition, false);
                point.wz = that.gonRectangleArr.length;
                that.gonRectangleArr.push(point);
                that.positions.push(tempPosition);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        this.handler.setInputAction(function (movement) {
            if (that.shape.points.length == 0) {
                return;
            }
            var moveEndPosition = that._core.getPointFromWindowPoint(movement.endPosition, that._viewer);
            //选择的点在球面上
            if (moveEndPosition) {
                var ray = that._viewer.camera.getPickRay(movement.endPosition);
                that._viewer.scene.globe.pick(ray, that._viewer.scene);
                that.shape.points[1] = that._viewer.scene.globe.ellipsoid.cartesianToCartographic(moveEndPosition);
                that.shape.rect = that._cesium.Rectangle.fromCartographicArray(that.shape.points);
                if (that.shape.rect.west == that.shape.rect.east)
                    that.shape.rect.east += 0.000001;
                if (that.shape.rect.south == that.shape.rect.north)
                    that.shape.rect.north += 0.000001;

            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        ///工程树添加
        var GroupID = 0;
        if (!that._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        var id = that._core.getuid();
        var obj = {
            id: id,
            name: '新建矩形' + id,
            pId: that._core.isnull(GroupID) ? 0 : GroupID,
            type: 'rectangle',
            item: that
        };
        that.setTreeobj(obj);
        tree.insertGroupId(obj, that._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
    *动态标会
    *绑定鼠标
    */
    Rectangle$1.prototype.startModify = function () {
        var tooltip = "拖动修改位置,右击删除该点";
        if (this.state != 1 && this.state != 2) return; //表示还没绘制完成
        if (!this.modifyHandler) this.modifyHandler = new Cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var $this = this;
        for (var i = 0; i < $this.gonRectangleArr.length; i++) {
            var point = $this.gonRectangleArr[i];
            if (point) point.show = true;
        }
        this.modifyHandler.setInputAction(function (evt) {
            var pick = $this._viewer.scene.pick(evt.position);
            if (Cesium.defined(pick) && pick.id) {
                if (!pick.id.objId) {
                    $this.modifyPoint = pick.id;
                    tooltip = "释放后完成修改";
                }
                $this.forbidDrawWorld(true);
            } else {
                for (var i = 0; i < $this.gonRectangleArr.length; i++) {
                    var point = $this.gonRectangleArr[i];
                    if (point) point.show = false;
                }
                if ($this.modifyHandler) {
                    $this.modifyHandler.destroy();
                    $this.modifyHandler = null;
                }
            }
            //$this.state = 2;
        }, Cesium.ScreenSpaceEventType.LEFT_DOWN);
        this.modifyHandler.setInputAction(function (evt) { //移动时绘制面
            //提示框
            var pick = $this._viewer.scene.pick(evt.endPosition);
            //$this._core.CreateTooltip(tooltip, evt.endPosition, false);
            $this._core.CreateTooltip(tooltip, evt.endPosition, false);
            if (!$this.modifyPoint) {
                if ($this._cesium.defined(pick) && pick.id) {
                    if (pick.id.objId) {
                        $this._core.CreateTooltip("拖动修改位置", evt.endPosition, true);
                    }
                }
                return;
            }
            //
            if ($this.positions.length < 1 || !$this.modifyPoint) return;
            var cartesian = $this.getCatesian3FromPX(evt.endPosition, $this._viewer, [$this.shape.entity, $this.modifyPoint]);
            if (cartesian) {
                $this.modifyPoint.position.setValue(cartesian);
                $this.shape.points[$this.modifyPoint.wz] = $this._viewer.scene.globe.ellipsoid.cartesianToCartographic(cartesian);
                $this.shape.rect = $this._cesium.Rectangle.fromCartographicArray($this.shape.points);
                $this.shape.rect.east += 0.000001;
                $this.shape.rect.north += 0.000001;
                //$this.positions[$this.modifyPoint.wz] = cartesian;
            }
            $this._core.CreateTooltip(tooltip, evt.endPosition, true);
        }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.modifyHandler.setInputAction(function (evt) {
            $this.forbidDrawWorld(false);
            if (!$this.modifyPoint) return;
            var cartesian = $this.getCatesian3FromPX(evt.position, $this._viewer, [$this.shape.entity, $this.modifyPoint]);
            $this.modifyPoint.position.setValue(cartesian);
            //$this.modifyPoint = null;
            $this.shape.points[$this.modifyPoint.wz] = $this._viewer.scene.globe.ellipsoid.cartesianToCartographic(cartesian);
            $this.shape.rect = $this._cesium.Rectangle.fromCartographicArray($this.shape.points);
            $this.shape.rect.east += 0.000001;
            $this.shape.rect.north += 0.000001;
            $this.modifyPoint = null;
            $this.forbidDrawWorld(false);
            tooltip = "拖动修改位置";
        }, Cesium.ScreenSpaceEventType.LEFT_UP);
    };
    //动态绘制矩形点
    Rectangle$1.prototype.createPoint = function (position, show) {
        if (!position) return;
        return this._viewer.entities.add({
            position: position,
            point: {
                pixelSize: 10,
                color: this._cesium.Color.ROYALBLUE,
                outlineWidth: 2,
                outlineColor: this._cesium.Color.WHITE,
                heightReference: this._cesium.HeightReference.CLAMP_TO_GROUND,
                disableDepthTestDistance: Number.POSITIVE_INFINITY
            },
            show: show
        });
    };
    //动态绘制判断点坐标
    Rectangle$1.prototype.getCatesian3FromPX = function (px, viewer, entitys) {
        var pick = viewer.scene.pick(px);
        var cartesian;
        var drillPick = viewer.scene.drillPick(px);
        var truePick = null;
        if (entitys) {
            for (var i = 0; i < drillPick.length; i++) {
                if (drillPick[i].id._id != entitys[0].id && drillPick[i].id._id != entitys[1].id) {
                    truePick = drillPick[i].id;
                    break;
                }
            }
        } else {
            truePick = pick;
        }
        if (viewer.scene.pickPositionSupported && this._cesium.defined(truePick)) {
            cartesian = viewer.scene.pickPosition(px);
        } else {
            var ray = viewer.camera.getPickRay(px);
            if (!ray) return;
            cartesian = viewer.scene.globe.pick(ray, viewer.scene);
        }
        return cartesian;
    };
    Rectangle$1.prototype.forbidDrawWorld = function (isForbid) {
        this._viewer.scene.screenSpaceCameraController.enableRotate = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableTilt = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableTranslate = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableInputs = !isForbid;
    };
    /**
     * 向三维场景中添加矩形。
     * @param {String} [name] 名称
     * @param {Array} [position] 位置
     * @param {Object} [option] 矩形参数
     * @param {String} [GroupID] GroupID
     * @param {function} [method] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Rectangle$1.prototype.CreateRectangle = function (name, position, option, GroupID, method) {
        var _this = this;
        var id = _this._core.getuid();
        var options = {
            outlineColor: this._cesium.Color.RED,
            material: this._cesium.Color.YELLOW.withAlpha(0.5),
        };
        if (option && option.fillColor) {
            options.material = new Color(this._viewer, this._cesium).colorFromHtmlColor(option.fillColor);
        }
        if (option && option.outlineColor) {
            options.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(option.outlineColor);
        }
        options = this._core.extend(options, option, false);

        options.coordinates = this.getCoordinates(position);
        this.item = _this._viewer.entities.add({
            id: id,
            name: name || '新建矩形',
            rectangle: options
        });
        if (typeof method == 'function') {
            method(this.item);
        }
        if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        var obj = {
            id: id,
            name: '新建矩形' + id,
            pId: _this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'rectangle',
            item: this.item
        };
        _this.setTreeobj(obj);
        tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    Rectangle$1.prototype.getCoordinates = function (positions) {
        var west, east, north, south;
        if (positions[0].lon > positions[1].lon) {
            west = positions[1].lon;
            east = positions[0].lon;
        } else {
            west = positions[0].lon;
            east = positions[1].lon;
        }
        if (positions[0].lat > positions[1].lat) {
            north = positions[0].lat;
            south = positions[1].lat;
        } else {
            north = positions[1].lat;
            south = positions[0].lat;
        }
        return new this._cesium.Rectangle.fromDegrees(west, south, east, north);
    };
    /**
     * 向三维场景中添加浏览边界
     * @param {object} [method] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Rectangle$1.prototype.createRectanglelbj = function (parameter, method) {
        var _self = this;
        var _this = this;
        _self.shape = {
            points: [],
            button: 0,
            rect: null,
            entity: null
        };
        this._tree.removeHandler();
        this.closeBrowseBorder();
        var tempPosition;
        var opid = 0;
        if (parameter != null && parameter != undefined && parameter.id != undefined) {
            opid = parameter.id;
        }
        var tooltip = this._core.CreateTooltip();
        _this._tree.handler = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        //鼠标左键单击画点
        var pointerOne = null, pointerTwo = null;
        _this._tree.handler.setInputAction(function (click) {
            //var ray = _this._viewer.camera.getPickRay(click.position);
            //var cartesian = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            tempPosition = _this._core.getPointFromWindowPoint(click.position, _this._viewer);
            var cartesian = _this._viewer.camera.pickEllipsoid(click.position, _this._viewer.scene.globe.ellipsoid);
            //选择的点在球面上
            if (_self.shape.button >= 1) {
                pointerTwo = cartesian;
                var data = {
                    'obj1': pointerOne,
                    'obj2': pointerTwo
                };
                var originalCameraLocation = {
                    position: _this._viewer.camera.position.clone(),
                    orientation: {
                        heading: _this._viewer.camera.heading,
                        pitch: _this._viewer.camera.pitch,
                        roll: _this._viewer.camera.roll,
                    }
                };
                var sessionStorage = {
                    originalCameraLocation: originalCameraLocation,
                    pointes: data,
                    terrainExaggeration: "5",
                    zj: "true"
                };
                _this.llbj(sessionStorage, _self.shape.entity);
                if (typeof method == 'function') {
                    method(_self.shape.entity);
                }
                _this._tree.handler.removeInputAction(_this._cesium.ScreenSpaceEventType.LEFT_CLICK);
            } else {
                pointerOne = cartesian;
            }
            _self.shape.button = _self.shape.button + 1;
            if (tempPosition) {
                if (_self.shape.points.length == 0) {
                    _self.shape.points.push(_this._viewer.scene.globe.ellipsoid.cartesianToCartographic(tempPosition));
                    // var cartographicPosition = Cesium.Ellipsoid.WGS84.cartesianToCartographic(_self.shape.points);
                    _self.shape.rect = _this._cesium.Rectangle.fromCartographicArray(_self.shape.points);
                    _self.shape.rect.east += 0.000001;
                    _self.shape.rect.north += 0.000001;
                    _self.shape.entity = _this._viewer.entities.add({
                        rectangle: {
                            coordinates: _self.shape.rect,
                            material: _this._cesium.Color.YELLOW.withAlpha(0),
                            outline: true,
                            outlineWidth: 10,
                            outlineColor: _this._cesium.Color.YELLOW,
                            height: 0
                        }
                    });
                    _self.shape.entity.rectangle.coordinates = new _this._cesium.CallbackProperty(function () {
                        return _self.shape.rect;
                    }, false);
                    _this.item = _self.shape.entity;
                } else if (_self.shape.points.length == 2) ; else {
                    _this._tree.handler.removeInputAction(_this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

                }
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        _this._tree.handler.setInputAction(function (movement) {
            if (_self.shape.points.length == 0) {
                tooltip.showAt(movement.endPosition, '点击左键在球面上绘制矩形！');
            } else if (pointerTwo) {
                tooltip.showAt(movement.endPosition, '请将视野缩放到范围内以开启边界浏览');
            }
            if (_self.shape.points.length == 0 || pointerTwo) {
                return;
            }
            tooltip.showAt(movement.endPosition, '再次点击结束绘制！');
            var moveEndPosition = _this._core.getPointFromWindowPoint(movement.endPosition, _this._viewer);
            //选择的点在球面上
            if (moveEndPosition) {
                var ray = _this._viewer.camera.getPickRay(movement.endPosition);
                _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
                _self.shape.points[1] = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(moveEndPosition);
                _self.shape.rect = _this._cesium.Rectangle.fromCartographicArray(_self.shape.points);
                if (_self.shape.rect.west == _self.shape.rect.east)
                    _self.shape.rect.east += 0.000001;
                if (_self.shape.rect.south == _self.shape.rect.north)
                    _self.shape.rect.north += 0.000001;
                //_self.shape.entity.rectangle.coordinates = _self.shape.rect;

            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            tree.selectedItem.id;
        var id = _this._core.getuid();
        var obj = {
            id: id,
            name: '新建浏览边界' + id,
            pId: _this._core.isnull(opid) ? 0 : opid,
            type: 'rectangle',
            item: _this
        };
        _this.setTreeobj(obj);
        tree.insertGroupId(obj, _this._core.isnull(opid) ? 0 : opid);
        return this;
    };
    /**
     * rectangle导出工程数据
     */
    Rectangle$1.prototype.export = function () {
        var show = this.item.show == undefined ? undefined : this.item.show._value;
        var coordinates = this.item.rectangle.coordinates == undefined ? undefined : this.item.rectangle.coordinates._value;
        if (coordinates != undefined) {
            coordinates = {
                east: coordinates.east,
                north: coordinates.north,
                south: coordinates.south,
                west: coordinates.west
            };
        }
        var height = this.item.rectangle.height == undefined ? undefined : this.item.rectangle.height._value;
        var extrudedHeight = this.item.rectangle.extrudedHeight == undefined ? undefined : this.item.rectangle.extrudedHeight._value;
        var rotation = this.item.rectangle.rotation == undefined ? undefined : this.item.rectangle.rotation._value;
        var stRotation = this.item.rectangle.stRotation == undefined ? undefined : this.item.rectangle.stRotation._value;
        var fill = this.item.rectangle.fill == undefined ? undefined : this.item.rectangle.fill._value;
        var material = this.item.rectangle.material;
        if (material != undefined) {
            material = {
                color: material.color._value == undefined ? undefined : 'rgba(' + material.color._value.red + ',' + material.color._value.green + ',' + material.color._value.blue + ',' + material.color._value.alpha + ')',
                image: material.image == undefined ? undefined : material.image._value,
                diffusemap: material.diffusemap == undefined ? undefined : material.diffusemap._value,
                alphamap: material.alphamap == undefined ? undefined : material.alphamap._value
            };
        }
        var outline = this.item.rectangle.outline == undefined ? undefined : this.item.rectangle.outline._value;
        var outlineColor = this.item.rectangle.outlineColor == undefined ? undefined : 'rgba(' + this.item.rectangle.outlineColor._value.red + ',' + this.item.rectangle.outlineColor._value.green + ',' + this.item.rectangle.outlineColor._value.blue + ',' + this.item.rectangle.outlineColor._value.alpha + ')';
        var outlineWidth = this.item.rectangle.outlineWidth == undefined ? undefined : this.item.rectangle.outlineWidth._value;
        var distanceDisplayCondition = this.item.rectangle.distanceDisplayCondition;
        var near = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.near;
        var far = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.far;

        //var catographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
        //var longitude = this._cesium.Math.toDegrees(catographic.longitude);
        //var latitude = this._cesium.Math.toDegrees(catographic.latitude);
        //var height = this._cesium.Math.toDegrees(catographic.height);
        return {
            type: 'rectangle',
            treeobj: { id: this.treeobj.id, name: this.treeobj.name, pId: this.treeobj.pId, type: this.treeobj.type },
            style: {
                show: show,
                coordinates: coordinates,
                height: height,
                extrudedHeight: extrudedHeight,
                rotation: rotation,
                stRotation: stRotation,
                fill: fill,
                material: material,
                outline: outline,
                outlineColor: outlineColor,
                outlineWidth: outlineWidth,
                near: near,
                far: far
            }
        };
    };
    //工程树添加
    Rectangle$1.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    //浏览边界
    Rectangle$1.prototype.llbj = function (data, drawBrowseBorder) {
        var tooltip = document.getElementById('toolTip');
        tooltip.innerHTML = "请将视野缩放到范围内以开启边界浏览";

        var rectangle = drawBrowseBorder.rectangle;
        rectangle.height = undefined;
        rectangle.heightReference = undefined;
        rectangle.perPositionHeight = false;

        var points = data.pointes;
        var position = [];
        position.push(points.obj1);
        position.push(points.obj2);

        var _polygonPosition = {};

        for (var j = 0, cartographic, longitude, latitude; j < position.length; j++) {
            cartographic = this._cesium.Cartographic.fromCartesian(position[j]);
            longitude = this._cesium.Math.toDegrees(cartographic.longitude);
            latitude = this._cesium.Math.toDegrees(cartographic.latitude);
            if (j === 0) {
                _polygonPosition.west = longitude;
                _polygonPosition.north = latitude;
                _polygonPosition.east = longitude;
                _polygonPosition.south = latitude;
            } else {
                if (longitude > _polygonPosition.west) {
                    _polygonPosition.east = longitude;
                } else {
                    _polygonPosition.west = longitude;
                }
                if (latitude > _polygonPosition.south) {
                    _polygonPosition.north = latitude;
                } else {
                    _polygonPosition.south = latitude;
                }
            }
        }
        ({
            destination: {
                x: (position[0].x + position[1].x) / 2,
                y: (position[0].y + position[1].y) / 2,
                z: position[0].z + 500
            },
            orientation: {
                heading: this._viewer.camera.heading,
                pitch: this._viewer.camera.pitch,
                roll: this._viewer.camera.roll,
            }
        });
        //this._viewer.camera.setView({
        //    orientation: {
        //        roll: 0.0   // 垂直指北
        //    }
        //});
        var heading = this._viewer.camera.heading;
        var pitch = this._viewer.camera.pitch;
        var roll = this._viewer.camera.roll;
        var _position = this._viewer.camera.position.clone();
        var viewPoint = { "orientation": { "heading": heading, "pitch": pitch, "roll": roll }, "position": _position };
        var _this = this;
        _this.flyListener = function () {
            var rectangle = _this._viewer.camera.computeViewRectangle();
            // 弧度转为经纬度，west为左（西）侧边界的经度，以下类推
            var west = rectangle.west / Math.PI * 180;
            var north = rectangle.north / Math.PI * 180;
            var east = rectangle.east / Math.PI * 180;
            var south = rectangle.south / Math.PI * 180;
            // 鉴于高德、leaflet获取的边界都是southwest和northeast字段来表示，本例保持一致性
            var point = {
                west: west,
                north: north,
                east: east,
                south: south
            };
            var isIn = _this.isInArea(point, _polygonPosition);
            if (isIn) {
                _this._tree.removeHandler();
                tooltip.style.left = "50%";
                tooltip.style.top = "50%";
                tooltip.innerHTML = "边界浏览已开启，右键结束边界浏览";
                setTimeout(function () {
                    tooltip.style.display = "none";
                }, 2000);
                _this._viewer.scene.camera.changed.removeEventListener(_this.flyListener);
                _this.flyListener = undefined;
                _this._tree.handler = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
                _this._viewEvent = function (e) {
                    viewPoint = _this.limitView(_polygonPosition, viewPoint);
                };
                // //鼠标移动
                //_this._tree.handler.setInputAction(viewEvent, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
                _this._viewer.scene.camera.percentageChanged = 0.001;
                _this._viewer.scene.camera.changed.addEventListener(_this._viewEvent);
                //鼠标右键结束
                _this._tree.handler.setInputAction(function (e) {
                    _this.closeBrowseBorder();
                }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
            } else {
                heading = _this._viewer.camera.heading;
                pitch = _this._viewer.camera.pitch;
                roll = _this._viewer.camera.roll;
                _position = _this._viewer.camera.position.clone();
                viewPoint = { "orientation": { "heading": heading, "pitch": pitch, "roll": roll }, "position": _position };
            }
        };

        this._viewer.scene.camera.percentageChanged = 0.001;
        //监听视野是否进入绘制范围
        this._viewer.scene.camera.changed.addEventListener(_this.flyListener);
    };
    //限制视野
    Rectangle$1.prototype.closeBrowseBorder = function () {
        var tooltip = document.getElementById('toolTip');
        this._tree.endtemporaryItem();
        if (this._tree.handler) {
            this._tree.handler.destroy();
        }
        if (this.flyListener) {
            this._viewer.scene.camera.changed.removeEventListener(this.flyListener);
            this.flyListener = undefined;
        }
        if (this._viewEvent) {
            this._viewer.scene.camera.changed.removeEventListener(this._viewEvent);
            this._viewEvent = undefined;
            tooltip.style.display = "block";
            tooltip.innerHTML = '取消边界浏览';
            setTimeout(function () {
                tooltip.style.display = "none";
            }, 1000);
        } else {
            if (tooltip) {
                tooltip.style.display = "none";
            }
        }
    };
    //限制视野
    Rectangle$1.prototype.limitView = function (_polygonPosition, viewPoint) {
        var rectangle = this._viewer.camera.computeViewRectangle();
        // 弧度转为经纬度，west为左（西）侧边界的经度，以下类推
        var west = rectangle.west / Math.PI * 180;
        var north = rectangle.north / Math.PI * 180;
        var east = rectangle.east / Math.PI * 180;
        var south = rectangle.south / Math.PI * 180;
        // 鉴于高德、leaflet获取的边界都是southwest和northeast字段来表示，本例保持一致性
        var point = {
            west: west,
            north: north,
            east: east,
            south: south
        };
        var isIn = this.isInArea(point, _polygonPosition);
        if (!isIn) {
            if (viewPoint !== null) {
                this._viewer.camera.setView({
                    // Cesium的坐标是以地心为原点，一向指向南美洲，一向指向亚洲，一向指向北极州
                    // fromDegrees()方法，将经纬度和高程转换为世界坐标
                    //destination: _this._cesium.Cartesian3.fromDegrees(117.48, 30.67, 15000.0),
                    destination: viewPoint.position,
                    orientation: viewPoint.orientation
                });
            }
        } else {
            var heading = this._viewer.camera.heading;
            var pitch = this._viewer.camera.pitch;
            var roll = this._viewer.camera.roll;
            var _position = this._viewer.camera.position.clone();
            viewPoint = { "orientation": { "heading": heading, "pitch": pitch, "roll": roll }, "position": _position };
        }
        return viewPoint;
    };
    //计算视野是否在范围内
    Rectangle$1.prototype.isInArea = function (point, area) {
        var inside = false;
        if (point.south > area.south && point.east < area.east && point.north < area.north && point.west > area.west) {
            inside = true;
        }
        return inside;
    };
    /**
     * 向三维场景中地形夸张显示。
     * @param {object} [method] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Rectangle$1.prototype.createRectangledxkz = function (method) {
        var _this = this;
        var _self = this;
        _self.shape = {
            points: [],
            rect: null,
            entity: null
        };
        var pointerOne = null;
        var pointerTwo = null;
        var tempPosition;
        var handle = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        //鼠标左键单击画点
        handle.setInputAction(function (click) {
            tempPosition = getPointFromWindowPoint(click.position);
            var cartesian = _this._viewer.camera.pickEllipsoid(click.position, _this._viewer.scene.globe.ellipsoid);
            if (pointerOne == null) {
                pointerOne = cartesian;
            }
            if (pointerOne.x == cartesian.x && pointerOne.y == cartesian.y && pointerOne.z == cartesian.z) ; else {
                pointerTwo = cartesian;
            }
            //选择的点在球面上
            if (tempPosition) {
                if (_self.shape.points.length == 0) {
                    _self.shape.points.push(_this._viewer.scene.globe.ellipsoid.cartesianToCartographic(tempPosition));
                    _self.shape.rect = _this._cesium.Rectangle.fromCartographicArray(_self.shape.points);
                    _self.shape.rect.east += 0.000001;
                    _self.shape.rect.north += 0.000001;
                    _self.shape.entity = _this._viewer.entities.add({
                        rectangle: {
                            coordinates: _self.shape.rect,
                            material: _this._cesium.Color.BLACK.withAlpha(0.4),
                            outline: true,
                            outlineWidth: 2,
                            outlineColor: _this._cesium.Color.RED,
                            height: 0
                        }
                    });
                    _self.bufferEntity = _self.shape.entity;
                } else {
                    handle.removeInputAction(_this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
                    handle.removeInputAction(_this._cesium.ScreenSpaceEventType.LEFT_CLICK);
                    //结果处理
                    var data = {
                        'obj1': pointerOne,
                        'obj2': pointerTwo
                    };
                    var originalCameraLocation = {
                        position: _this._viewer.camera.position.clone(),
                        orientation: {
                            heading: _this._viewer.camera.heading,
                            pitch: _this._viewer.camera.pitch,
                            roll: _this._viewer.camera.roll,
                        }
                    };
                    var cjdx = { pointes: data, originalCameraLocation: originalCameraLocation };
                    //sessionStorage.setItem('pointes', JSON.stringify(data));
                    //sessionStorage.setItem('W_point_Array', null);
                    //sessionStorage.setItem('minData', null);//保存数据
                    //sessionStorage.setItem('maxData', null);//保存数据
                    //sessionStorage.setItem('terrainExaggeration', 5);
                    //sessionStorage.setItem('originalCameraLocation', JSON.stringify(originalCameraLocation));
                    if (method != "" && method != null) {
                        if (typeof method == 'function')
                            method(cjdx);
                    }
                }
            }
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        handle.setInputAction(function (movement) {
            if (_self.shape.points.length == 0) {
                return;
            }
            var moveEndPosition = getPointFromWindowPoint(movement.endPosition);
            //选择的点在球面上
            if (moveEndPosition) {
                _self.shape.points[1] = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(moveEndPosition);
                _self.shape.rect = _this._cesium.Rectangle.fromCartographicArray(_self.shape.points);
                if (_self.shape.rect.west == _self.shape.rect.east)
                    _self.shape.rect.east += 0.000001;
                if (_self.shape.rect.south == _self.shape.rect.north)
                    _self.shape.rect.north += 0.000001;
                _self.shape.entity.rectangle.coordinates = _self.shape.rect;
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        function getPointFromWindowPoint(point) {
            if (_this._viewer.scene.terrainProvider.constructor.name == "EllipsoidTerrainProvider") {
                return _this._viewer.camera.pickEllipsoid(point, _this._viewer.scene.globe.ellipsoid);
            } else {
                var ray = _this._viewer.scene.camera.getPickRay(point);
                return _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            }
        }

        return this;
    };
    /**
     * 地形开挖。xpdsde
     * @param {object} [method] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Rectangle$1.prototype.executeExcavation = function (method) {
        var _self = this;
        var _this = this;
        _self.shape = {
            points: [],
            button: 0,
            rect: null,
            entity: null
        };
        var tempPosition;
        //var handle = new Cesium.ScreenSpaceEventHandler(_self.viewer.scene.canvas);
        var handle = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var tempPoints = [];
        //鼠标左键单击画点
        handle.setInputAction(function (click) {
            tempPosition = _this._core.getPointFromWindowPoint(click.position, _this._viewer);
            //选择的点在球面上
            if (_self.shape.button >= 2) {
                var globe = _self._viewer.scene.globe;
                _self.shape.box = _this._viewer.entities.add({
                    position: _this._cesium.Cartesian3.fromDegrees(tempPoints[0].lon, tempPoints[0].lat, 100),
                    box: {
                        dimensions: new _this._cesium.Cartesian3(10000, 10000, 10000),
                        material: _this._cesium.Color.WHITE.withAlpha(0.5),
                        outline: true,
                        outlineColor: _this._cesium.Color.WHITE
                    }
                });
                globe.depthTestAgainstTerrain = true;
                globe.clippingPlanes = new _self._cesium.ClippingPlaneCollection({
                    modelMatrix: _self.shape.box.computeModelMatrix(_this._cesium.JulianDate.now()),
                    planes: [
                        new _this._cesium.Plane(new _this._cesium.Cartesian3(1.0, 0.0, 0.0), -700.0),
                        new _this._cesium.Plane(new _this._cesium.Cartesian3(-1.0, 0.0, 0.0), -700.0),
                        new _this._cesium.Plane(new _this._cesium.Cartesian3(0.0, 1.0, 0.0), -700.0),
                        new _this._cesium.Plane(new _this._cesium.Cartesian3(0.0, -1.0, 0.0), -700.0)
                    ],
                    edgeWidth: 1.0,
                    edgeColor: _this._cesium.Color.WHITE
                });
                handle.removeInputAction(_this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
                handle.removeInputAction(_this._cesium.ScreenSpaceEventType.LEFT_CLICK);
            }
            _self.shape.button = _self.shape.button + 1;
            if (tempPosition) {
                if (_self.shape.points.length == 0) {
                    _self.shape.points.push(_this._viewer.scene.globe.ellipsoid.cartesianToCartographic(tempPosition));

                    var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.position, _this._viewer.scene.globe.ellipsoid);
                    var cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
                    var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
                    var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
                    tempPoints.push({ lon: longitudeString, lat: latitudeString });
                    // var cartographicPosition = Cesium.Ellipsoid.WGS84.cartesianToCartographic(_self.shape.points);
                    _self.shape.rect = _this._cesium.Rectangle.fromCartographicArray(_self.shape.points);
                    _self.shape.rect.east += 0.000001;
                    _self.shape.rect.north += 0.000001;
                    _self.shape.entity = _this._viewer.entities.add({
                        rectangle: {
                            coordinates: _self.shape.rect,
                            material: _this._cesium.Color.BLACK.withAlpha(0.4),
                            outline: true,
                            outlineWidth: 2,
                            outlineColor: _this._cesium.Color.RED,
                            height: 0
                        }
                    });
                    _self.bufferEntity = _self.shape.entity;
                    _this.item = _self.shape.entity;
                } else if (_self.shape.points.length == 2) ; else {
                    handle.removeInputAction(_this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
                    handle.removeInputAction(_this._cesium.ScreenSpaceEventType.LEFT_CLICK);
                }
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        handle.setInputAction(function (movement) {
            if (_self.shape.points.length == 0) {
                return;
            }
            var moveEndPosition = _this._core.getPointFromWindowPoint(movement.endPosition, _this._viewer);
            //选择的点在球面上
            if (moveEndPosition) {
                var ray = _this._viewer.camera.getPickRay(movement.endPosition);
                _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
                _self.shape.points[1] = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(moveEndPosition);
                _self.shape.rect = _this._cesium.Rectangle.fromCartographicArray(_self.shape.points);
                if (_self.shape.rect.west == _self.shape.rect.east)
                    _self.shape.rect.east += 0.000001;
                if (_self.shape.rect.south == _self.shape.rect.north)
                    _self.shape.rect.north += 0.000001;
                _self.shape.entity.rectangle.coordinates = _self.shape.rect;

            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        ///工程树添加
        var GroupID = 0;
        if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        var id = _this._core.getuid();
        var obj = {
            id: id,
            name: '新建矩形' + id,
            pId: _this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'rectangle',
            item: _this
        };
        _this.setTreeobj(obj);
        tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
        if (typeof method == 'function') {
            method(ploylinejl);
        }
        return this;
    };
    //删除矩形对象
    Rectangle$1.prototype.deleteObject = function () {
        this._viewer.entities.remove(this.item);
        if (this._viewEvent != null) {
            this._tree.handler.destroy();
            this._viewer.scene.camera.changed.removeEventListener(this._viewEvent);
        }
        // this = null;
    };
    /**
     * 设置rectangle的显示隐藏
     * @param {boolean} [b] true|false
     */
    Rectangle$1.prototype.setVisibility = function (b) {
        this.item.show = b;
    };
    /**
     * 获取rectangle的显示隐藏
     */
    Rectangle$1.prototype.getVisibility = function () {
        return this.item.show;
    };
    /**
     * 修改矩形的可视距离
     * @param {Object} [rectangle] rectangle对象
     * @param {String} [min, max] 设置线段的可视距离
     * @returns {Object} 返回一个rectangle对象。
     */
    Rectangle$1.prototype.setDistanceDisplayCondition = function (min, max) {
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        try {
            this.item._rectangle.distanceDisplayCondition = distance;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置矩形的填充透明度
     * @param {Object} [rectangle] rectangle对象
     * @param {Float} [a] 透明度 0-1
     * @returns {Object} 返回一个rectangle对象。
     */
    Rectangle$1.prototype.setRectangleAlpha = function (a) {
        try {
            this.item._rectangle.material.color._value.alpha = a;
            this.item._rectangle.show = true;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置矩形的填充颜色
     * @param {Object} [rectangle] rectangle对象
     * @param {htmlColor} htmlColor颜色。
     * @returns {Object} 返回一个rectangle对象。
     */
    Rectangle$1.prototype.setRectangleColor = function (htmlColor) {
        try {
            this.item._rectangle.material.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 修改矩形的可视距离
     * @param {Object} [rectangle] rectangle对象
     * @param {String} [min, max] 设置线段的可视距离
     * @returns {Object} 返回一个polyline对象。
     */
    Rectangle$1.prototype.setDistanceDisplayCondition = function (min, max) {
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        try {
            this.item._rectangle.distanceDisplayCondition = distance;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置矩形的贴图
     * @param {Object} [rectangle] rectangle对象
     * @param {url} 图片路径。
     * @returns {Object} 返回一个polygon对象。
     */
    Rectangle$1.prototype.setPolygonImage = function (url) {
        try {
            //this.item._polygon.material = url;
            // this.item.polygon.material = new this._cesium.Material({
            //     fabric : {
            //       type : 'Image',
            //       uniforms : {
            //         image : url
            //       }
            //     }
            //   });
            this.item._rectangle.material = new this._cesium.ImageMaterialProperty({
                image: url  //可以为url、canvas、video      
            });

        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置矩形的贴图一个Cartesian2属性，指定图像在每个方向上重复的次数。
     * @param {Object} [rectangle] rectangle对象
     * @param {Object} x和y上的比例。
     * @returns {Object} 返回一个polygon对象。
     */
    Rectangle$1.prototype.setRectangleRepeat = function (x, y) {
        try {
            this.item._rectangle.material.repeat = new this._cesium.Cartesian2(x, y);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置矩形的轮廓颜色
     * @param {Object} [polygon] polygon对象
     * @param {htmlColor} htmlColor
     * @returns {Object} 返回一个polygon对象。
     */
    Rectangle$1.prototype.setOutlineColor = function (htmlColor) {
        try {
            this.item._rectangle.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置矩形的是否显示轮廓
     * @param {Object} [rectangle] rectangle对象
     * @param {bool} 是否
     * @returns {Object} 返回一个rectangle对象。
     */
    Rectangle$1.prototype.setOutline = function (outline) {
        try {
            this.item._rectangle.outline = outline;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };

    /**
     * 设置矩形的拉伸高度
     * @param {Object} [polygon] polygon对象
     * @param {double} [height] 高度
     * @returns {Object} 返回一个polygon对象。
     */
    Rectangle$1.prototype.setExtrudedHeight = function (height) {
        try {
            this.item._rectangle.extrudedHeight = height;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置矩形的高度
     * @param {Object} [polygon] polygon对象
     * @param {double} [height] 高度
     * @returns {Object} 返回一个polygon对象。
     */
    Rectangle$1.prototype.setHeight = function (height) {
        try {
            this.item._rectangle.height = height;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    //设置对象属性
    Object.defineProperties(Rectangle$1.prototype, {
        /**
         * 获取或设置矩形
         */
        rectangle: {
            get: function () {
                return this.item.rectangle;
            },
            set: function (rectangle) {
                this.item.rectangle = rectangle;
            }
        }
    });


    Rectangle$1.prototype.setItem = function (item) {
        this.item = item;
    };

    Object.defineProperties(Rectangle$1.prototype, {
        /**
         * 获取或设置线条
         */
        polyline: {
            get: function () {
                return this.item.polyline;
            },
            set: function (polyline) {
                this.item.polyline = polyline;
            }
        }
    });

    Object.defineProperties(Rectangle$1.prototype, {
        /**
         * 获取或设置面
         */
        polygon: {
            get: function () {
                return this.item.polygon;
            },
            set: function (polygon) {
                this.item.polygon = polygon;
            }
        }
    });

    Object.defineProperties(Rectangle$1.prototype, {
        /**
         * 获取或设置点
         */
        point: {
            get: function () {
                return this.item.point;
            },
            set: function (point) {
                this.item.point = point;
            }
        }
    });

    Object.defineProperties(Rectangle$1.prototype, {
        /**
         * 获取或设置标签
         */
        label: {
            get: function () {
                return this.item.label;
            },
            set: function (label) {
                this.item.label = label;
            }
        }
    });

    Object.defineProperties(Rectangle$1.prototype, {
        /**
         * 获取或设置模型
         */
        model: {
            get: function () {
                return this.item.model;
            },
            set: function (model) {
                this.item.model = model;
            }
        }
    });

    Object.defineProperties(Rectangle$1.prototype, {
        /**
         * 获取或设置墙
         */
        wall: {
            get: function () {
                return this.item.wall;
            },
            set: function (wall) {
                this.item.wall = wall;
            }
        }
    });
    Object.defineProperties(Rectangle$1.prototype, {
        /**
         * 获取墙的模板属性
         */
        polygonTempOptions: {
            get: function () {
                return {
                    height: 0,//	Property	0	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
                    extrudedHeight: 0,//	Property		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
                    show: true,//	Property	true	optional A boolean Property specifying the visibility of the polygon.
                    fill: true,//	Property	true	optional A boolean Property specifying whether the polygon is filled with the provided material.
                    material: this._cesium.Color.WHITE,//	MaterialProperty	Color.WHITE	optional A Property specifying the material used to fill the polygon.
                    outline: false,//	Property	false	optional A boolean Property specifying whether the polygon is outlined.
                    outlineColor: this._cesium.Color.BLACK,//	Property	Color.BLACK	optional A Property specifying the Color of the outline.
                    outlineWidth: 1.0,//	Property	1.0	optional A numeric Property specifying the width of the outline.
                    stRotation: 1.0,//	Property	0.0	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
                    granularity: this._cesium.Math.RADIANS_PER_DEGREE,//	Property	Cesium.Math.RADIANS_PER_DEGREE	optional A numeric Property specifying the angular distance between each latitude and longitude point.
                    perPositionHeight: false,//	Property	false	optional A boolean specifying whether or not the the height of each position is used.
                    closeTop: true,//	Boolean	true	optional When false, leaves off the top of an extruded polygon open.
                    closeBottom: true,//	Boolean	true	optional When false, leaves off the bottom of an extruded polygon open.
                    shadows: ShadowMode.DISABLED,//	Property	ShadowMode.DISABLED	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
                    classificationType: ClassificationType.BOTH,//	Property	ClassificationType.BOTH	optional An enum Property specifying whether this polygon will classify terrain, 3D Tiles, or both when on the ground.
                    arcType: ArcType.GEODESIC	//zIndex	ConstantProperty	0	optional A property specifying the zIndex used for ordering ground geometry. Only has an effect if the polygon is constant and neither height or extrudedHeight are specified.
                }
            }
        }
    });

    /**
     *
     * 这个方法用于创建圆。
     *
     * @alias Circle
     * @constructor
     *
     */
    function Circle(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._getPosition = new getPosition(this._viewer, this._cesium);
        this._tree = tree;
        //对象
        this._postion = {
            Altitude: 0.0,
            AltitudeType: 0,
            Cartesian: true,
            Distance: 0.0,
            Pitch: 0.0,
            Roll: 0.0,
            X: 0.0,
            Y: 0.0,
            Yaw: 0.0
        };
        //动态绘制矩形
        this.positions = [];
        this.objId = Number((new Date()).getTime() + "" + Number(Math.random() * 1000).toFixed(0));
        this.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        this.modifyHandler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        this.style = null;
        this.state = 0; //1为新增 2为编辑 0为清除
        this.gonCircleArr = [];
        this.radius = 0;
    }

    /**
     * 这个方法用于创建圆
     * @param {Array} [position] 一个经纬度数组例如：[-114.0, 40.0, 300000.0]。
     * @param {object} [Circle] 对象。对象{
        semiMinorAxis: 300000.0,
        semiMajorAxis: 300000.0,
        height: 200000.0,
        material: this._cesium.Color.GREEN,
        outline: true,
    }
     * @param {String} [name] 圆的文字。
     * @param {String} [GroupID] 组。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Circle.prototype.createCircle = function (position, Circle, name, GroupID) {
        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
            semiMinorAxis: 300000.0,
            semiMajorAxis: 300000.0,
            height: 200000.0,
            material: this._cesium.Color.GREEN,
            outline: true,
            //outlineColor: new Color(this._viewer, this._cesium).createColor(FillColor[0], FillColor[1], FillColor[2], FillColor[3]),
            //extrudedHeight: 200000.0
            //rotation: Cesium.Math.toRadians(45)
        };
        var options = this._Core.extend(defaultOption, Circle, true);
        this.item = this._viewer.entities.add({
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]),
            name: name,
            ellipse: options
        });
        var obj = {
            id: this.item.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'circle',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return greenCircle;
    };
    /**
    * 获取circle样式
    */
    Circle.prototype.getstyles = function () {
        var styles = {};
        styles.show = this.item.ellipse.show ? this.item.ellipse.show._value : true;
        styles.height = this.item.ellipse.height && this.item.ellipse.height._value ? this.item.ellipse.height._value : undefined;
        styles.semiMajorAxis = this.item.ellipse.semiMajorAxis && this.item.ellipse.semiMajorAxis.getValue() ? this.item.ellipse.semiMajorAxis.getValue() : undefined,
            styles.semiMinorAxis = this.item.ellipse.semiMinorAxis && this.item.ellipse.semiMinorAxis.getValue() ? this.item.ellipse.semiMinorAxis.getValue() : undefined,
            styles.heightReference = this.item.ellipse.heightReference && this.item.ellipse.heightReference._value ? this.item.ellipse.heightReference._value : undefined;
        styles.extrudedHeight = this.item.ellipse.extrudedHeight && this.item.ellipse.extrudedHeight.getValue() ? this.item.ellipse.extrudedHeight.getValue() : undefined;
        styles.extrudedHeightReference = this.item.ellipse.extrudedHeightReference && this.item.ellipse.extrudedHeightReference._value ? this.item.ellipse.extrudedHeightReference._value : undefined;
        styles.rotation = this.item.ellipse.rotation && this.item.ellipse.rotation._value ? this.item.ellipse.rotation._value : undefined;
        styles.stRotation = this.item.ellipse.stRotation && this.item.ellipse.stRotation._value ? this.item.ellipse.stRotation._value : undefined;
        styles.granularity = this.item.ellipse.granularity && this.item.ellipse.granularity._value ? this.item.ellipse.granularity._value : undefined;
        styles.fill = this.item.ellipse.fill ? this.item.ellipse.fill._value : undefined;
        styles.material = {};
        styles.material.color = this.item.ellipse.material && this.item.ellipse.material.color && this.item.ellipse.material.color._value ? 'rgba' + this.item.ellipse.material.color.toString() : undefined;
        styles.material.image = this.item.ellipse.material && this.item.ellipse.material.image ? this.item.ellipse.material.image._value : undefined;
        styles.material.repeat = this.item.ellipse.material && this.item.ellipse.material.repeat._value ? this.item.ellipse.material.repeat._value : undefined;
        styles.outline = this.item.ellipse.outline ? this.item.ellipse.outline._value : undefined;
        styles.outlineWidth = this.item.ellipse.outlineWidth && this.item.ellipse.outlineWidth._value ? this.item.ellipse.outlineWidth._value : undefined;
        styles.outlineColor = this.item.ellipse.outlineColor && this.item.ellipse.outlineColor._value ? 'rgba' + this.item.ellipse.outlineColor.toString() + '' : undefined;
        styles.numberOfVerticalLines = this.item.ellipse.numberOfVerticalLines && this.item.ellipse.numberOfVerticalLines._value ? this.item.ellipse.numberOfVerticalLines._value : undefined;
        styles.classificationType = this.item.ellipse.classificationType && this.item.ellipse.classificationType._value ? this.item.ellipse.classificationType._value : undefined;
        styles.near = this.item.ellipse.distanceDisplayCondition ? this.item.ellipse.distanceDisplayCondition._value.near : undefined;
        styles.far = this.item.ellipse.distanceDisplayCondition ? this.item.ellipse.distanceDisplayCondition._value.far : undefined;
        styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
    * 向三维场景中添加圆(可编辑，升级版)。
    * @param {Object} [option] 矩形参数
    * @param {function} [method] 回调函数
    * @returns {Promise.<Object>} 返回一个Cesium的对象。
    *
    */
    Circle.prototype.createCircleOptimization = function (option, method) {
        this.style = option;
        var that = this;
        this.handler.setInputAction(function (evt) { //单机开始绘制
            var cartesian = that.getCatesian3FromPX(evt.position, that._viewer, [that.circle]);
            if (that.positions.length == 0) {
                that.positions.push(cartesian.clone());
            }
            that.positions.push(cartesian);
            var point = that.createPoint(cartesian, false);
            if (that.gonCircleArr.length > 0) {
                that.positions.pop();
                that.state = 1;
                that.handler.destroy();
            }
            point.wz = that.gonCircleArr.length;
            that.gonCircleArr.push(point);
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        this.handler.setInputAction(function (evt) { //移动时绘制面
            if (that.positions.length < 1) return;
            var cartesian = that.getCatesian3FromPX(evt.endPosition, that._viewer, [that.circle]);
            if (that.positions.length == 2) {
                if (!that._cesium.defined(that.circle)) {
                    //计算距离
                    var cartographic1 = that._cesium.Cartographic.fromCartesian(that.positions[0]);
                    var lon1 = that._cesium.Math.toDegrees(cartographic1.longitude);
                    var lat1 = that._cesium.Math.toDegrees(cartographic1.latitude);
                    var cartographic2 = that._cesium.Cartographic.fromCartesian(that.positions[1]);
                    var lon2 = that._cesium.Math.toDegrees(cartographic2.longitude);
                    var lat2 = that._cesium.Math.toDegrees(cartographic2.latitude);
                    that.radius = Cdcl(lat1, lon1, lat2, lon2);
                    that.circle = that.createCircle(that.style);
                    that._core.Entityadd(that);
                    that.circle.objId = that.objId;
                }
            }
            if (that.circle) {
                that.positions.pop();
                that.positions.push(cartesian);
                var cartographic1 = that._cesium.Cartographic.fromCartesian(that.positions[0]);
                var lon1 = that._cesium.Math.toDegrees(cartographic1.longitude);
                var lat1 = that._cesium.Math.toDegrees(cartographic1.latitude);
                var cartographic2 = that._cesium.Cartographic.fromCartesian(that.positions[1]);
                var lon2 = that._cesium.Math.toDegrees(cartographic2.longitude);
                var lat2 = that._cesium.Math.toDegrees(cartographic2.latitude);
                that.radius = Cdcl(lat1, lon1, lat2, lon2);
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
    };
    /**
     *动态标会
     *绑定鼠标
     */
    Circle.prototype.startModify = function () {
        var tooltip = "拖动修改位置";
        if (this.state != 2 && this.state != 1) return; //表示还没绘制完成
        if (!this.modifyHandler) this.modifyHandler = new Cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var $this = this;
        for (var i = 0; i < $this.gonCircleArr.length; i++) {
            var point = $this.gonCircleArr[i];
            if (point) point.show = true;
        }
        this.modifyHandler.setInputAction(function (evt) {
            var pick = $this._viewer.scene.pick(evt.position);
            if (Cesium.defined(pick) && pick.id) {
                if (!pick.id.objId) {
                    $this.modifyPoint = pick.id;
                    tooltip = "释放后完成修改";
                }
                $this.forbidDrawWorld(true);
            } else {
                for (var i = 0; i < $this.gonCircleArr.length; i++) {
                    var point = $this.gonCircleArr[i];
                    if (point) point.show = false;
                }
                if ($this.modifyHandler) {
                    $this.modifyHandler.destroy();
                    $this.modifyHandler = null;
                }
            }
            $this.state = 2;
        }, Cesium.ScreenSpaceEventType.LEFT_DOWN);
        this.modifyHandler.setInputAction(function (evt) { //移动时绘制线
            //提示框
            var pick = $this._viewer.scene.pick(evt.endPosition);
            $this._core.CreateTooltip(tooltip, evt.endPosition, false);
            if (Cesium.defined(pick) && pick.id) {
                if (!pick.id.objId) {
                    $this._core.CreateTooltip(tooltip, evt.endPosition, true);
                }
            }
            //
            if ($this.positions.length < 1 || !$this.modifyPoint) return;
            var cartesian = $this.getCatesian3FromPX(evt.endPosition, $this._viewer, [$this.circle, $this.modifyPoint]);
            if (cartesian) {
                $this.modifyPoint.position.setValue(cartesian);
                $this.positions[$this.modifyPoint.wz] = cartesian;
                if ($this.modifyPoint.wz == 0) {
                    //var cartographic1 = $this._cesium.Cartographic.fromCartesian($this.positions[0]);
                    //var lon1 = $this._cesium.Math.toDegrees(cartographic1.longitude + $this.radius);
                    //var lat1 = $this._cesium.Math.toDegrees(cartographic1.latitude);
                    $this.gonCircleArr[1].position = { x: $this.positions[0].x + $this.radius, y: $this.positions[0].y, z: $this.positions[0].z };
                } else {
                    var cartographic1 = $this._cesium.Cartographic.fromCartesian($this.positions[0]);
                    var lon1 = $this._cesium.Math.toDegrees(cartographic1.longitude);
                    var lat1 = $this._cesium.Math.toDegrees(cartographic1.latitude);
                    var cartographic2 = $this._cesium.Cartographic.fromCartesian($this.positions[$this.modifyPoint.wz]);
                    var lon2 = $this._cesium.Math.toDegrees(cartographic2.longitude);
                    var lat2 = $this._cesium.Math.toDegrees(cartographic2.latitude);
                    $this.radius = Cdcl(lat1, lon1, lat2, lon2);
                }
            }
            $this._core.CreateTooltip(tooltip, evt.endPosition, true);
        }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
        this.modifyHandler.setInputAction(function (evt) {
            if (!$this.modifyPoint) return;
            var cartesian = $this.getCatesian3FromPX(evt.position, $this._viewer, [$this.circle, $this.modifyPoint]);
            $this.modifyPoint.position.setValue(cartesian);
            $this.positions[$this.modifyPoint.wz] = cartesian;
            if ($this.modifyPoint.wz == 0) {
                //var cartographic1 = $this._cesium.Cartographic.fromCartesian($this.positions[0]);
                //var lon1 = $this._cesium.Math.toDegrees(cartographic1.longitude + $this.radius);
                //var lat1 = $this._cesium.Math.toDegrees(cartographic1.latitude);
                //$this.gonCircleArr[1].position = $this._cesium.Cartesian3.fromDegrees(lon1, lat1);
                $this.gonCircleArr[1].position = { x: $this.positions[0].x + $this.radius, y: $this.positions[0].y, z: $this.positions[0].z };
            } else {
                var cartographic1 = $this._cesium.Cartographic.fromCartesian($this.positions[0]);
                var lon1 = $this._cesium.Math.toDegrees(cartographic1.longitude);
                var lat1 = $this._cesium.Math.toDegrees(cartographic1.latitude);
                var cartographic2 = $this._cesium.Cartographic.fromCartesian($this.positions[$this.modifyPoint.wz]);
                var lon2 = $this._cesium.Math.toDegrees(cartographic2.longitude);
                var lat2 = $this._cesium.Math.toDegrees(cartographic2.latitude);
                $this.radius = Cdcl(lat1, lon1, lat2, lon2);
            }
            $this.modifyPoint = null;
            $this.forbidDrawWorld(false);
            tooltip = "拖动修改位置";
        }, Cesium.ScreenSpaceEventType.LEFT_UP);
    };
    Circle.prototype.forbidDrawWorld = function (isForbid) {
        this._viewer.scene.screenSpaceCameraController.enableRotate = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableTilt = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableTranslate = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableInputs = !isForbid;
    };
    Circle.prototype.getCatesian3FromPX = function (px, viewer, entitys) {
        var pick = viewer.scene.pick(px);
        var cartesian;
        var drillPick = viewer.scene.drillPick(px);
        var truePick = null;
        if (entitys) {
            for (var i = 0; i < drillPick.length; i++) {
                if (drillPick[i].id._id != entitys[0].id && drillPick[i].id._id != entitys[1].id) {
                    truePick = drillPick[i].id;
                    break;
                }
            }
        } else {
            truePick = pick;
        }
        if (viewer.scene.pickPositionSupported && Cesium.defined(truePick)) {
            cartesian = viewer.scene.pickPosition(px);
        } else {
            var ray = viewer.camera.getPickRay(px);
            if (!ray) return;
            cartesian = viewer.scene.globe.pick(ray, viewer.scene);
        }
        return cartesian;
    };
    //创建对象
    Circle.prototype.createCircle = function (obj) {
        var $this = this;
        return this._viewer.entities.add({
            position: new $this._cesium.CallbackProperty(function () {
                //圆半径
                return $this.positions[0];
            }, false),
            ellipse: {
                semiMinorAxis: new $this._cesium.CallbackProperty(function () {
                    //半径 两点间距离
                    return $this.radius;
                }, false),
                semiMajorAxis: new $this._cesium.CallbackProperty(function () {
                    return $this.radius;
                }, false),
                material: $this._cesium.Color.BLUE.withAlpha(0.5),
                outline: obj.outline || true,
            }

        });
    };
    //动态绘制矩形点
    Circle.prototype.createPoint = function (position, show) {
        if (!position) return;
        return this._viewer.entities.add({
            position: position,
            point: {
                pixelSize: 10,
                color: this._cesium.Color.ROYALBLUE,
                outlineWidth: 2,
                outlineColor: this._cesium.Color.WHITE,
                heightReference: this._cesium.HeightReference.CLAMP_TO_GROUND,
                disableDepthTestDistance: Number.POSITIVE_INFINITY
            },
            show: show
        });
    };
    /**
     * 向三维场景中添加圆。
     * @param {object} [method] 回调函数
     *
     */
    Circle.prototype.executeClircle = function (method) {
        var tempPoints = [];
        var _this = this;
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        var handler = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        handler.setInputAction(function (click) {
            var cartesian = _this._getPosition.getMousePosition(click, [_this.item]);
            if (cartesian) {
                var cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
                var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
                var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
                tempPoints.push({
                    lon: longitudeString,
                    lat: latitudeString
                });
                var tempLength = tempPoints.length;
                if (tempLength == 1) {
                    //drawPoint(tempPoints[0]);
                    tempPoints.push({
                        lon: longitudeString,
                        lat: latitudeString
                    });
                    var entity = _this._viewer.entities.add({
                        position: _this._cesium.Cartesian3.fromDegrees(tempPoints[0].lon, tempPoints[0].lat),
                        ellipse: {
                            semiMinorAxis: 0,
                            semiMajorAxis: 0,
                            material: _this._cesium.Color.fromRandom({
                                alpha: 0.8
                            })
                        }
                    });
                    entity.ellipse.semiMinorAxis = new _this._cesium.CallbackProperty(getDistance, false);
                    entity.ellipse.semiMajorAxis = new _this._cesium.CallbackProperty(getDistance, false);
                    //tempEntities.push(entity);
                    _this.item = entity;
                } else {
                    //drawPoint(tempPoints[1]);
                    //drawLine(tempPoints[0], tempPoints[1], true);
                    //算两点间距离
                    var distance = getDistance();
                    //设置鼠标样式
                    _this._core.mouse(_this._viewer.container, 0, "0");
                    _this.item.ellipse.semiMinorAxis = distance;
                    _this.item.ellipse.semiMajorAxis = distance;
                    handler.destroy();
                    handler = undefined;
                    tempPoints = [];
                }
            }
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        handler.setInputAction(function (click) {
            if (!tempPoints.length) return;
            var cartesian = _this._getPosition.getMousePosition(click, [_this.item]);
            if (cartesian) {
                var cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
                var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
                var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
                tempPoints[1] = {
                    lon: longitudeString,
                    lat: latitudeString
                };
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        function getDistance() {
            return Cdcl(tempPoints[0].lat, tempPoints[0].lon, tempPoints[1].lat, tempPoints[1].lon);
        }
        return this;
    };
    /**
     * 向三维场景中添加圆完善。
     * @param {object} [method] 回调函数
     *
     */
    Circle.prototype.executeClirclews = function (method) {
        var _this = this;
        var material = this._cesium.Material.fromType(this._cesium.Material.ColorType);
        material.uniforms.color = new this._cesium.Color(1.0, 1.0, 0.0, 0.5);
        var ellipsoid = this._cesium.Ellipsoid.WGS84;
        var _self = this;
        var scene = this._viewer.scene;
        var primitives = this._viewer.scene.primitives;
        var circle = null;
        var mouseHandler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
        // Now wait for start画圆操作
        mouseHandler.setInputAction(function (movement) {
            if (movement.position != null) {
                var cartesian = scene.camera.pickEllipsoid(movement.position, ellipsoid);
                if (cartesian) {
                    if (circle == null) {
                        // create the circle
                        circle = new CirclePrimitive({
                            center: cartesian,
                            radius: 0,
                            asynchronous: false,
                            material: _this._cesium.Color.RED
                        });
                        primitives.add(circle);
                        //markers = new Circle.BillboardGroup(_self, defaultBillboard);
                        //markers.addBillboards([cartesian]);
                    } else {
                        //if (typeof options.callback == 'function') {
                        //    options.callback(circle.getCenter(), circle.getRadius());
                        //}
                        _self.stopDrawing();
                    }
                }
            }
        }, _this._cesium.ScreenSpaceEventType.LEFT_DOWN);
        mouseHandler.setInputAction(function (movement) {
            var position = movement.endPosition;
            if (position != null) {
                if (circle == null) ; else {
                    var cartesian = scene.camera.pickEllipsoid(position, ellipsoid);
                    if (cartesian) {
                        circle.setRadius(_this._cesium.Cartesian3.distance(circle.getCenter(), cartesian));
                        //markers.updateBillboardsPositions(cartesian);
                    }
                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        var CirclePrimitive = (function () {
            function execute(options) {
                if (!(_this._cesium.defined(options.center) && _this._cesium.defined(options.radius))) {
                    throw new _this._cesium.DeveloperError('Center and radius are required');
                }
                options = copyOptions(options, defaultSurfaceOptions);
                this.initialiseOptions(options);
                this.setRadius(options.radius);
            }

            execute.prototype = new ChangeablePrimitive();
            execute.prototype.setCenter = function (center) {
                this.setAttribute('center', center);
            };
            execute.prototype.setRadius = function (radius) {
                this.setAttribute('radius', Math.max(0.1, radius));
            };
            execute.prototype.getCenter = function () {
                return this.getAttribute('center');
            };
            execute.prototype.getRadius = function () {
                return this.getAttribute('radius');
            };
            execute.prototype.getGeometry = function () {
                if (!(_this._cesium.defined(this.center) && _this._cesium.defined(this.radius))) {
                    return;
                }
                return new _this._cesium.CircleGeometry({
                    center: this.center,
                    radius: this.radius,
                    height: this.height,
                    vertexFormat: _this._cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT,
                    stRotation: this.textureRotationAngle,
                    ellipsoid: this.ellipsoid,
                    granularity: this.granularity
                });
            };
            execute.prototype.getOutlineGeometry = function () {
                return new _this._cesium.CircleOutlineGeometry({
                    center: this.getCenter(),
                    radius: this.getRadius()
                });
            };
            return execute;
        });
        var ChangeablePrimitive = (function () {
            function Circle() {
            }

            Circle.prototype.initialiseOptions = function (options) {

                fillOptions(this, options);

                this._ellipsoid = undefined;
                this._granularity = undefined;
                this._height = undefined;
                this._textureRotationAngle = undefined;
                this._id = undefined;

                // set the flags to initiate a first drawing
                this._createPrimitive = true;
                this._primitive = undefined;
                this._outlinePolygon = undefined;

            };

            Circle.prototype.setAttribute = function (name, value) {
                this[name] = value;
                this._createPrimitive = true;
            };

            Circle.prototype.getAttribute = function (name) {
                return this[name];
            };

            /**
             * @private
             */
            Circle.prototype.update = function (context, frameState, commandList) {

                if (!_this._cesium.defined(this.ellipsoid)) {
                    throw new _this._cesium.DeveloperError('this.ellipsoid must be defined.');
                }

                if (!_this._cesium.defined(this.appearance)) {
                    throw new _this._cesium.DeveloperError('this.material must be defined.');
                }

                if (this.granularity < 0.0) {
                    throw new _this._cesium.DeveloperError('this.granularity and scene2D/scene3D overrides must be greater than zero.');
                }

                if (!this.show) {
                    return;
                }

                if (!this._createPrimitive && (!_this._cesium.defined(this._primitive))) {
                    // No positions/hierarchy to draw
                    return;
                }

                if (this._createPrimitive ||
                    (this._ellipsoid !== this.ellipsoid) ||
                    (this._granularity !== this.granularity) ||
                    (this._height !== this.height) ||
                    (this._textureRotationAngle !== this.textureRotationAngle) ||
                    (this._id !== this.id)) {

                    var geometry = this.getGeometry();
                    if (!geometry) {
                        return;
                    }

                    this._createPrimitive = false;
                    this._ellipsoid = this.ellipsoid;
                    this._granularity = this.granularity;
                    this._height = this.height;
                    this._textureRotationAngle = this.textureRotationAngle;
                    this._id = this.id;

                    this._primitive = this._primitive && this._primitive.destroy();

                    this._primitive = new _this._cesium.Primitive({
                        geometryInstances: new _this._cesium.GeometryInstance({
                            geometry: geometry,
                            id: this.id,
                            pickPrimitive: this
                        }),
                        appearance: this.appearance,
                        asynchronous: this.asynchronous
                    });

                    this._outlinePolygon = this._outlinePolygon && this._outlinePolygon.destroy();
                    if (this.strokeColor && this.getOutlineGeometry) {
                        // create the highlighting frame
                        this._outlinePolygon = new _this._cesium.Primitive({
                            geometryInstances: new _this._cesium.GeometryInstance({
                                geometry: this.getOutlineGeometry(),
                                attributes: {
                                    color: _this._cesium.ColorGeometryInstanceAttribute.fromColor(this.strokeColor)
                                }
                            }),
                            appearance: new _this._cesium.PerInstanceColorAppearance({
                                flat: true,
                                renderState: {
                                    depthTest: {
                                        enabled: true
                                    },
                                    //lineWidth : Math.min(this.strokeWidth || 4.0, context._aliasedLineWidthRange[1])
                                    lineWidth: Math.min(this.strokeWidth)
                                }
                            })
                        });
                    }
                }

                var primitive = this._primitive;
                primitive.appearance.material = this.material;
                primitive.debugShowBoundingVolume = this.debugShowBoundingVolume;
                primitive.update(context, frameState, commandList);
                this._outlinePolygon && this._outlinePolygon.update(context, frameState, commandList);

            };

            Circle.prototype.isDestroyed = function () {
                return false;
            };

            Circle.prototype.destroy = function () {
                this._primitive = this._primitive && this._primitive.destroy();
                return _this._cesium.destroyObject(this);
            };

            Circle.prototype.setStrokeStyle = function (strokeColor, strokeWidth) {
                if (!this.strokeColor || !this.strokeColor.equals(strokeColor) || this.strokeWidth != strokeWidth) {
                    this._createPrimitive = true;
                    this.strokeColor = strokeColor;
                    this.strokeWidth = strokeWidth;
                }
            };

            return Circle;
        })();
    };
    //Circle.prototype.BillboardGroup = function (drawHelper, options) {
    //    this._drawHelper = drawHelper;
    //    this._scene = drawHelper._scene;
    //    this._options = copyOptions(options, defaultBillboard);
    //    // create one common billboard collection for all billboards
    //    var b = new Cesium.BillboardCollection();
    //    this._scene.primitives.add(b);
    //    this._billboards = b;
    //    // keep an ordered list of billboards
    //    this._orderedBillboards = [];
    //}

    /**
     * 设置Ellipse的半长轴的数字属性。
     * @param {Object} [ellipse] ellipse对象
     * @param {Property} [length] 长度。
     * @returns {Ellipse} 返回一个Ellipse对象。
     */
    Circle.prototype.setSemiMajorAxis = function (length) {
        try {
            this.item._ellipse.semiMajorAxis = length;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置Ellipse的半短轴的数字属性。
     * @param {Object} [ellipse] ellipse对象
     * @param {Property} [length] 长度。
     * @returns {Ellipse} 返回一个Ellipse对象。
     */
    Circle.prototype.setSemiMinorAxis = function (length) {
        try {
            this.item._ellipse.semiMinorAxis = length;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 圆导出工程数据
     */
    Circle.prototype.export = function () {
        //var positions=this.item.position._value;
        var show = this.item.show == undefined ? undefined : this.item.show._value;
        var semiMajorAxis = this.item.ellipse.semiMajorAxis == undefined ? undefined : this.item.ellipse.semiMajorAxis._value;
        var semiMinorAxis = this.item.ellipse.semiMinorAxis == undefined ? undefined : this.item.ellipse.semiMinorAxis._value;
        var height = this.item.ellipse.height == undefined ? undefined : this.item.ellipse.height._value;
        var extrudedHeight = this.item.ellipse.extrudedHeight == undefined ? undefined : this.item.ellipse.extrudedHeight._value;
        var rotation = this.item.ellipse.rotation == undefined ? undefined : this.item.ellipse.rotation._value;
        var stRotation = this.item.ellipse.stRotation == undefined ? undefined : this.item.ellipse.stRotation._value;
        var fill = this.item.ellipse.fill == undefined ? undefined : this.item.ellipse.fill._value;
        var material = this.item.ellipse.material;
        if (material != undefined) {
            material = {
                color: material.color == undefined ? undefined : 'rgba(' + material.color._value.red + ',' + material.color._value.green + ',' + material.color._value.blue + ',' + material.color._value.alpha + ')',
                image: material.image == undefined ? undefined : material.image._value,
                diffusemap: material.diffusemap == undefined ? undefined : material.diffusemap._value,
                alphamap: material.alphamap == undefined ? undefined : material.alphamap._value
            };
        }
        var outline = this.item.ellipse.outline == undefined ? undefined : this.item.ellipse.outline._value;
        var outlineColor = this.item.ellipse.outlineColor == undefined ? undefined : 'rgba(' + this.item.ellipse.outlineColor._value.red + ',' + this.item.ellipse.outlineColor._value.green + ',' + this.item.ellipse.outlineColor._value.blue + ',' + this.item.ellipse.outlineColor._value.alpha + ')';
        var outlineWidth = this.item.ellipse.outlineWidth == undefined ? undefined : this.item.ellipse.outlineWidth._value;
        var numberOfVerticalLines = this.item.ellipse.numberOfVerticalLines == undefined ? undefined : this.item.ellipse.numberOfVerticalLines._value;
        var distanceDisplayCondition = this.item.ellipse.distanceDisplayCondition;
        var near = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.near;
        var far = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.far;

        var catographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
        var longitude = this._cesium.Math.toDegrees(catographic.longitude);
        var latitude = this._cesium.Math.toDegrees(catographic.latitude);
        var height = this._cesium.Math.toDegrees(catographic.height);
        return {
            type: 'circle',
            position: {
                x: longitude,
                y: latitude,
                z: height
            },
            treeobj: {
                name: this.treeobj.name
            },
            style: {
                show: show,
                semiMajorAxis: semiMajorAxis,
                semiMinorAxis: semiMinorAxis,
                height: height,
                extrudedHeight: extrudedHeight,
                rotation: rotation,
                stRotation: stRotation,
                fill: fill,
                material: material,
                outline: outline,
                outlineColor: outlineColor,
                outlineWidth: outlineWidth,
                numberOfVerticalLines: numberOfVerticalLines,
                near: near,
                far: far
            }
        };
    };
    //工程树添加
    Circle.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 设置Ellipse的相对于椭球面的高度
     * @param {Object} [ellipse] ellipse对象
     * @param {Property} [length] 长度。
     * @returns {Ellipse} 返回一个Ellipse对象。
     */
    Circle.prototype.setHeight = function (length) {
        try {
            this.item._ellipse.heightReference = this._cesium.HeightReference.RELATIVE_TO_GROUND;
            this.item._ellipse.height = length;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置ellipse的高度类型
     * @param {Object} [ellipse] ellipse对象
     * @param {int} [type] 1：该位置被夹在地形上。2：这个职位是绝对的。3：位置高度是地形上方的高度。
     * @returns {Object} 返回一个对象。
     */
    Circle.prototype.setHeightType = function (type) {
        try {
            if (type == 1) {
                this.item._ellipse.heightReference = this._cesium.HeightReference.CLAMP_TO_GROUND;
            } else if (type == 2) {
                this.item._ellipse.heightReference = this._cesium.HeightReference.NONE;
            } else if (type == 3) {
                this.item._ellipse.heightReference = this._cesium.HeightReference.RELATIVE_TO_GROUND;
            }
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 修改圆的可视距离
     * @param {Object} [ellipse] ellipse对象
     * @param {String} [min, max] 设置线段的可视距离
     * @returns {Object} 返回一个ellipse对象。
     */
    Circle.prototype.setDistanceDisplayCondition = function (min, max) {
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        try {
            this.item._ellipse.distanceDisplayCondition = distance;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置圆的贴图
     * @param {Object} [ellipse] ellipse对象
     * @param {url} 图片路径。
     * @returns {Object} 返回一个ellipse对象。
     */
    Circle.prototype.setEllipseImage = function (url) {
        try {
            this.item._ellipse.material.uniforms.image = url;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置Ellipse的Color轮廓的属性
     * @param {Object} [ellipse] ellipse对象
     * @param {Property} [htmlColor] 。
     * @returns {Ellipse} 返回一个Ellipse对象。
     */
    Circle.prototype.setOutlineColor = function (htmlColor) {
        try {
            this.item._ellipse.outlineWidth = 5;
            this.item._ellipse.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置Ellipse的填充颜色
     * @param {Object} [ellipse] ellipse对象
     * @param {Property} [htmlColor] 。
     * @returns {Ellipse} 返回一个Ellipse对象。
     */
    Circle.prototype.setMaterial = function (htmlColor) {
        try {
            this.item._ellipse.material.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置Ellipse的透明度
     * @param {Object} [ellipse] ellipse对象
     * @param {Float} [a] 透明度 0-1
     * @returns {Ellipse} 返回一个Ellipse对象。
     */
    Circle.prototype.setMaterialAlpha = function (a) {
        try {
            this.item._ellipse.material.color._value.alpha = a;
            this.item._ellipse.show = true;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    Circle.prototype.setItem = function (item) {
        this.item = item;
    };
    /**
     * 设置Ellipse圆柱
     * @param {Object} [ellipse] ellipse对象
     * @param {Float} [height] height
     * @returns {Ellipse} 返回一个Ellipse对象。
     */
    Circle.prototype.setExtrudedHeight = function (height) {
        try {
            this.item._ellipse.extrudedHeight = height;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };

    /**
     * 删除圆
     */
    Circle.prototype.deleteObject = function () {
        this._viewer.entities.remove(this.item);
    };

    /**
     *
     * 仿照te修改
     *
     * 这个方法用于创建圆
     * @param {Object} [Position] Position表示地面对象的位置和方向。对象{
        Altitude:高度。
        AltitudeType:枚举确定高度如何解译。
        Cartesian:一个布尔值，决定是否基于直角坐标系计算。
        Distance:从摄像机到位置的距离。
        Pitch:相机或对象的倾斜角度。
        Roll:对象的滚动角。
        X:X坐标。
        Y:Y坐标。
        Yaw:该相机或对象的方向角。
    }
     * @param {number} [Radius] 对象的半径（单位：米）。
     * @param {String} [LineColor] 组成圆的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 圆的填充色。颜色值由RGB定义。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中圆的名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Circle.prototype.CreateCircle = function (Position, Radius, LineColor, FillColor, GroupID, Description) {
        this._postion = Position;
        var defaultOption = {
            semiMinorAxis: this._cesium.defaultValue(Radius, 300000.0),
            semiMajorAxis: this._cesium.defaultValue(Radius, 300000.0),
            material: this._cesium.Color.YELLOW,
            outline: true,
            outlineColor: this._cesium.Color.WHITE,
        };

        if (LineColor && LineColor !== '') {
            defaultOption.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(LineColor);
        }
        if (FillColor && FillColor !== '') {
            defaultOption.material = new Color(this._viewer, this._cesium).colorFromHtmlColor(FillColor);
        }

        var orientation;
        if (Position.Yaw || Position.Pitch || Position.Roll) {
            orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
                new this._cesium.HeadingPitchRoll(
                    this._cesium.Math.toRadians(Position.Yaw),
                    this._cesium.Math.toRadians(Position.Pitch),
                    this._cesium.Math.toRadians(Position.Roll)
                )
            );
        }

        this.item = this._viewer.entities.add({
            name: Description,
            position: this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
            ellipse: defaultOption,
            orientation: orientation
        });
        var obj = {
            id: this.item.id,
            name: Description,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'circle',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     *
     * 仿照te修改
     *
     * 这个方法用于创建椭圆
     * @param {Object} [Position] Position表示地面对象的位置和方向。对象{
        Altitude:高度。
        AltitudeType:枚举确定高度如何解译。
        Cartesian:一个布尔值，决定是否基于直角坐标系计算。
        Distance:从摄像机到位置的距离。
        Pitch:相机或对象的倾斜角度。
        Roll:对象的滚动角。
        X:X坐标。
        Y:Y坐标。
        Yaw:该相机或对象的方向角。
    }
     * @param {number} [RadiusX] 椭圆沿X轴半径。
     * @param {number} [RadiusY] 椭圆沿Y轴半径。
     * @param {String} [LineColor] 组成椭圆的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 椭圆的填充色。颜色值由RGB定义。
     * * @param {number} [NumOfSegments] 组成圆锥体的部分数目。部分数据越多，圆锥体越圆滑。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中椭圆的名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Circle.prototype.CreateEllipse = function (Position, RadiusX, RadiusY, LineColor, FillColor, NumOfSegments, GroupID, Description) {
        this._postion = Position;
        var defaultOption = {
            semiMinorAxis: this._cesium.defaultValue(RadiusX, 300000.0),
            semiMajorAxis: this._cesium.defaultValue(RadiusY, 100000.0),
            numberOfVerticalLines: this._cesium.defaultValue(NumOfSegments, 16),
            material: this._cesium.Color.YELLOW,
            outline: true,
            outlineColor: this._cesium.Color.WHITE,
        };

        if (LineColor && LineColor !== '') {
            defaultOption.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(LineColor);
        }
        if (FillColor && FillColor !== '') {
            defaultOption.material = new Color(this._viewer, this._cesium).colorFromHtmlColor(FillColor);
        }

        var orientation;
        if (Position.Yaw || Position.Pitch || Position.Roll) {
            orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
                new this._cesium.HeadingPitchRoll(
                    this._cesium.Math.toRadians(Position.Yaw),
                    this._cesium.Math.toRadians(Position.Pitch),
                    this._cesium.Math.toRadians(Position.Roll)
                )
            );
        }

        this.item = this._viewer.entities.add({
            name: Description,
            position: this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
            ellipse: defaultOption,
            orientation: orientation
        });
        var obj = {
            id: this.item.id,
            name: Description,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ellipse',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    Object.defineProperties(Circle.prototype, {
        Position: {
            Altitude: {
                get: function () {
                    return this._postion.Altitude
                },
                set: function (Altitude) {
                    try {
                        // 赋值
                        this._postion.Altitude = Altitude;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            AltitudeType: {
                get: function () {
                    return this._postion.AltitudeType
                },
                set: function (AltitudeType) {
                    try {
                        this._postion.AltitudeType = AltitudeType;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Cartesian: {
                get: function () {
                    return this._postion.Cartesian
                },
                set: function (Cartesian) {
                    try {
                        this._postion.Cartesian = Cartesian;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Distance: {
                get: function () {
                    return this._postion.Distance
                },
                set: function (Distance) {
                    try {
                        this._postion.Distance = Distance;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Pitch: {
                get: function () {
                    return this._postion.Pitch
                },
                set: function (Pitch) {
                    try {
                        this._postion.Pitch = Pitch;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Roll: {
                get: function () {
                    return this._postion.Roll
                },
                set: function (Roll) {
                    try {
                        this._postion.Roll = Roll;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            X: {
                get: function () {
                    return this._postion.X
                },
                set: function (X) {
                    try {
                        // 赋值
                        this._postion.X = X;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Y: {
                get: function () {
                    return this._postion.Y
                },
                set: function (Y) {
                    try {
                        // 赋值
                        this._postion.Y = Y;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Yaw: {
                get: function () {
                    return this._postion.Yaw
                },
                set: function (Yaw) {
                    try {
                        this._postion.Yaw = Yaw;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            }
        }
    });

    /**
     *
     * 创建点。
     *
     * @alias Point
     * @constructor
     *
     */
    function Point(viewer, cesium) {
        this.objId = Number((new Date()).getTime() + "" + Number(Math.random() * 1000).toFixed(0));
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._getPosition = new getPosition(this._viewer, this._cesium);
        //this._drawHelper = new DrawHelper(this._viewer, this._cesium);
        this._tree = tree;
        this.modifyPoint = null;
        this._color = new Color(this._viewer, this._cesium);
        this.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        this.modifyHandler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        this._position = undefined;
        this._points = [];
        this._listeners = {};
        this._point = null;
    }

    /**
     * 向三维场景中添加一个点。
     * @param {Array} [position] 一个经纬度数组 例如：[x, y, z]。
     * @param {String} [fillColor] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Point.prototype.createPoint = function (name, position, fillColor, option, GroupID, Description) {
        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
            show: true,
            pixelSize: 10,
            // color: this._cesium.Color.ALICEBLUE,
            color: this._cesium.Color.RED,
            clampToGround: true
            //heightReference: this._cesium.HeightReference.CLAMP_TO_GROUND
        };
        if (!option) {
            option = {};
        }
        defaultOption = this._core.extend(defaultOption, option, true);
        if (fillColor) {
            if (this._core.isHtmlColor(fillColor)) {
                fillColor = this._color.colorFromHtmlColor(fillColor);
            } else {
                if (/^rgb/.test(fillColor)) {
                    fillColor = this._Color.rgbaStringToRgbaObj(fillColor);
                }
                if (fillColor.r > 1) {
                    fillColor.r = fillColor.r / 255;
                }
                if (fillColor.g > 1) {
                    fillColor.g = fillColor.g / 255;
                }
                if (fillColor.b > 1) {
                    fillColor.b = fillColor.b / 255;
                }
                if (fillColor.a > 1) {
                    fillColor.a = fillColor.a / 255;
                }
                if (fillColor.r)
                    fillColor = this._color.createColor(fillColor.r, fillColor.g, fillColor.b, fillColor.a);
            }
            defaultOption.color = fillColor;
        }
        this._position = position;
        this.item = this._viewer.entities.add({
            name: name,
            //中心的位置（长、宽、高）
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2] || 0),
            point: defaultOption
        });
        var obj = {
            id: this.item.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'Point',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 获取point样式
     */
    Point.prototype.getstyles = function () {
        var styles = {};
        styles.show = this.item.point.show ? this.item.point.show._value : true;
        styles.pixelSize = this.item.point.pixelSize ? this.item.point.pixelSize.toString() : null;
        styles.heightReference = this.item.point.heightReference && this.item.point.heightReference._value ? this.item.point.heightReference.toString() : null;
        styles.color = this.item.point.color && this.item.point.color._value ? 'rgba' + this.item.point.color.toString() : null;
        styles.outlineColor = this.item.point.outlineColor && this.item.point.outlineColor._value ? 'rgba' + this.item.point.outlineColor.toString() : null;
        styles.outlineWidth = this.item.point.outlineWidth && this.item.point.outlineWidth._value ? this.item.point.outlineWidth.toString() : null;
        styles.near = this.item.point.distanceDisplayCondition ? this.item.point.distanceDisplayCondition._value.near : null;
        styles.far = this.item.point.distanceDisplayCondition ? this.item.point.distanceDisplayCondition._value.far : null;
        styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
     * 点击获取坐标点的经纬度。
     *
     */
    Point.prototype.createLonlat = function (method) {
        var that = this;
        var handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        handler.setInputAction(function (event) {
            var earthPosition = that._viewer.camera.pickEllipsoid(event.position, that._viewer.scene.globe.ellipsoid);
            var cartographic = that._cesium.Cartographic.fromCartesian(earthPosition, that._viewer.scene.globe.ellipsoid, new that._cesium.Cartographic());
            var lat = that._cesium.Math.toDegrees(cartographic.latitude);
            var lng = that._cesium.Math.toDegrees(cartographic.longitude);
            var height = cartographic.height;
            var obj = {
                lng: lng,
                lat: lat,
                height: height
            };
            if (typeof method == 'function') {
                method(obj);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        handler.setInputAction(function (movement) {
            handler.destroy();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
    };


    /**
     * 向三维场景中添加一个富文本点。
     * @param {String} [Content] 内容。
     * @param {Array|Object} [position] 一个经纬度数组或对象 例如：[112, 32, 50]或{x:112,y:32,z:50}。
     * @param {Object} [option] 参数。
     * @param {String} [option.url] 背景图。
     * @param {String} [option.GroupID='0'] GroupID。
     * @param {String} [option.fontColor='#fff'] 字体颜色。
     * @param {Number} [option.fontSize=15] 字体大小。
     * @param {Number} [option.near=0] 最小可视距离。
     * @param {Number} [option.far=Number.MAX_VALUE] 最大可视距离。
     * @param {Object} [option.data] 自定义参数
     * @returns {Point} 返回一个Point的对象。
     *
     */
    Point.prototype.createRichTextPoint = function (Content, position, option = {}) {
        var _this = this;
        var id = this._core.getuid();
        var GroupID = option.GroupID;
        var Cartesian3;
        if (position.length !== undefined) {
            if (position.length === 2) {
                Cartesian3 = this._cesium.Cartesian3.fromDegrees(position[0], position[1]);
            } else if (position.length === 3) {
                Cartesian3 = this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]);
            }
        } else {
            if (position.z) {
                Cartesian3 = this._cesium.Cartesian3.fromDegrees(position.x, position.y, position.z);
            } else {
                Cartesian3 = this._cesium.Cartesian3.fromDegrees(position.x, position.y);
            }
        }
        this._position = Cartesian3;
        var defaultOption = {
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER,
            verticalOrigin: this._cesium.VerticalOrigin.BOTTOM,
            show: true,
            distanceDisplayCondition: new this._cesium.DistanceDisplayCondition(_this._core.defaultValue(option.near, 0), _this._core.defaultValue(option.far, Number.MAX_VALUE))
        };
        var options = this._core.extend(defaultOption, option, true);

        var color = '';
        var size = 15;
        option && option.fontColor && (color = option.fontColor);
        option && option.fontSize && (size = option.fontSize);
        //绘制标签
        drawCanvas(Content, size, color, function (canvas) {
            options.image = canvas;
            _this.item = _this._viewer.entities.add({
                id: id,
                name: Content,
                position: _this._position,
                billboard: options
            });
            _this.item.degrees = position;
            _this.item.type = 'RichPoint';
            _this.item.data = option.data;
        });

        var obj = {
            id: id,
            name: '新建富文本点' + id,
            pId: _this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'Imagelabel',
            item: _this
        };
        _this.setTreeobj(obj);
        _this._tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);

        //绘制图片标签
        function drawCanvas(textArr, fontsize, color, callback) {
            var img = document.createElement("img");
            img.src = _this._core.defaultValue(options.url, window.SmartEarthRootUrl + configData$1.richtextpoint);
            fontsize = parseFloat(fontsize);
            img.crossOrigin = "Anonymous";
            img.onload = function () {
                var canvas = document.createElement('canvas'); //创建canvas标签
                var ctx = canvas.getContext('2d');

                var width = img.width;
                var height = img.height;
                canvas.width = width;
                canvas.height = height;
                ctx.drawImage(img, 0, 0, width, height);

                ctx.shadowOffsetX = 1; //阴影往左边偏，横向位移量
                ctx.shadowOffsetY = 0; //阴影往左边偏，纵向位移量
                ctx.shadowColor = "#fff"; //阴影颜色
                ctx.shadowBlur = 1; //阴影的模糊范围
                if (/^\</.test(textArr) && /\>$/.test(textArr)) {
                    var data = '<svg xmlns="http://www.w3.org/2000/svg" width="' + width + '" height="60">' +
                        '<foreignObject width="100%" height="100%">' +
                        textArr +
                        '</foreignObject>' +
                        '</svg>';

                    var DOM_URL = window.URL || window.webkitURL || window;
                    var _img = document.createElement("img");
                    var svg = new Blob([data], {
                        type: 'image/svg+xml;charset=utf-8'
                    });
                    var url = DOM_URL.createObjectURL(svg);
                    _img.crossOrigin = "Anonymous";
                    _img.src = url;
                    _img.onload = function () {
                        ctx.drawImage(_img, 0, 0, _img.width, _img.height);
                        DOM_URL.revokeObjectURL(url);
                    };
                    callback(canvas);
                } else {
                    ctx.fillStyle = color || '#fff';
                    ctx.font = fontsize + "px Calibri,sans-serif";
                    if (textArr.length * fontsize > width) {
                        var textArr1 = textArr.substring(0, Math.ceil((textArr.length / 2)));
                        var textArr2 = textArr.substring(Math.floor((textArr.length / 2)), textArr.length);
                        var y1 = (height - 100 - (2 * fontsize)) / 2;
                        var y2 = y1 + fontsize;
                        var x = (width - textArr1.length * fontsize) / 2;
                        ctx.fillText(textArr1, x, y1);
                        ctx.fillText(textArr2, x, y2);
                    } else {
                        var y = (height - 100 - fontsize) / 2;
                        var _x = (width - textArr.length * fontsize) / 2;
                        ctx.fillText(textArr, _x, y);
                    }
                    callback(canvas);
                }
            };
        }

        return this;
    };
    /**
     * 向三维场景中添加一个点。
     * @param {Array} [position] 一个经纬度数组 例如：[x, y, z]。
     * @param {String} [fillColor] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Point.prototype.createPoints = function (option, GroupID) {
        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
            show: true,
            pixelSize: 10,
            // color: this._cesium.Color.ALICEBLUE,
            color: this._cesium.Color.RED,
            heightReference: this._cesium.HeightReference.CLAMP_TO_GROUND
        };
        var options = this._core.extend(defaultOption, option, true);
        if (!this._core.isnull(text)) {
            options.text = text;
        }
        this._position = position;
        this.item = this._viewer.entities.add({
            name: name,
            //中心的位置（长、宽、高）
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1]),
            point: options
        });
        var obj = {
            id: this.item.id,
            name: options.text,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'Point',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 向三维场景中添加一个兴趣点。
     * @param {String} [name] 名称
     * @param {Array} [position] 一个经纬度数组 例如：[x, y, z]。
     * @param {String|Int} [GroupID] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Point.prototype.createLocations = function (name, position, GroupID) {
        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
            show: true,
            pixelSize: 10,
            // color: this._cesium.Color.ALICEBLUE,
            color: this._cesium.Color.TRANSPARENT,
            heightReference: this._cesium.HeightReference.CLAMP_TO_GROUND
        };
        this._position = position;
        if (this._core.isnull(name)) {
            name = "新建兴趣点";
        }
        this.item = this._viewer.entities.add({
            name: name,
            //中心的位置（长、宽、高）
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]),
            point: defaultOption
        });
        var obj = {
            id: defaultOption.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'Location',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 向三维场景中添加一个兴趣点。
     * @param {String} [name] 名称
     * @param {Array} [position] 一个经纬度数组 例如：[x, y, z]。
     * @param {String|Int} [GroupID] 线的颜色。
     *
     */
    Point.prototype.createLocation = function (name, position, GroupID) {
        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
            show: true,
            pixelSize: 10,
            // color: this._cesium.Color.ALICEBLUE,
            color: this._cesium.Color.TRANSPARENT,
            heightReference: this._cesium.HeightReference.CLAMP_TO_GROUND
        };
        var originalCameraLocation = {
            destination: position.position,
            orientation: {
                heading: position.orientation.heading,
                pitch: position.orientation.pitch,
                roll: position.orientation.roll,
            }
        };
        this._position = position;
        if (this._core.isnull(name)) {
            name = "新建兴趣点";
        }
        var id = this._core.getuid();
        this.item = this._viewer.entities.add({
            name: name,
            //中心的位置（长、宽、高）
            position: position.position,
            point: defaultOption
        });
        this.item.originalCameraLocation = originalCameraLocation;
        var _this = this;

        //this._tree.insertGroupId({
        //    id: defaultOption.id,
        //    name: name + id,
        //    pId: this._core.isnull(GroupID) ? 0 : GroupID,
        //    type: 'Location',
        //    item: this
        //}, this._core.isnull(GroupID) ? 0 : GroupID);
        setTimeout(function () {
            var obj = {
                id: id,
                name: name + id,
                pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'Location',
                item: _this
            };
            _this.setTreeobj(obj);
            _this._tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
        });
        return this;
    };
    /**
     * 向三维场景中添加一个点动态创建（优化）。
     * @param {object} [method] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Point.prototype.createPointOptimization = function (entity, parameter) {
        var that = this;
        var positions = [];
        var options = this._core.StyleContrastGeoJson(entity, this._cesium);
        //单击鼠标左键画点
        this.handler.setInputAction(function (movement) {
            var ray = that._viewer.scene.camera.getPickRay(movement.position);
            var position1, cartographic;
            if (ray) {
                position1 = that._viewer.scene.globe.pick(ray, that._viewer.scene);
            }
            if (!position1) {
                return;
            }
            cartographic = that._cesium.Ellipsoid.WGS84.cartesianToCartographic(position1);
            var height = that._viewer.scene.globe.getHeight(cartographic);
            //地理坐标（弧度）转经纬度坐标 this._point
            that._point = that._cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180, height);
            options.position = new that._cesium.CallbackProperty(function () {
                return that._point
            }, false);
            that.objId = Number((new Date()).getTime() + "" + Number(Math.random() * 1000).toFixed(0));
            var entity = that._viewer.entities.add(options);
            entity.objId = that.objId;
            entity.obj = that;
            //that._tree.temporaryItem.obj.push(entity);
            that._core.Entityadd(that);
            var dx = {
                point: entity
            };
            positions.push(dx);
            that.state = 1;
            that.handler.destroy();
            if (typeof method == 'function') {
                method(positions);
            }
            that.item = entity;
        }, that._cesium.ScreenSpaceEventType.LEFT_CLICK);
        return this;
    };
    /**
     *动态标会
     *绑定鼠标
     */
    Point.prototype.startModify = function () {
        var tooltip = "拖动修改位置";
        if (this.state != 2 && this.state != 1) return; //表示还没绘制完成
        this._tree.starttemporaryItem(this._viewer);
        if (!this.modifyHandler) this.modifyHandler = new this._cesium.ScreenSpaceEventHandler(this.viewer.scene.canvas);
        var that = this;
        this.modifyHandler.setInputAction(function (evt) {
            var pick = that._viewer.scene.pick(evt.position);
            if (that._cesium.defined(pick) && pick.id && that._cesium.defined(pick) && pick.id && pick.id.objId && pick.id.objId == that.objId) {
                that.modifyPoint = pick.id;
                tooltip = "释放后完成修改";
                that.forbidDrawWorld(true);
            }
            that.state = 2;
        }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);
        this.modifyHandler.setInputAction(function (evt) { //移动时绘制线
            //提示框
            var pick = that._viewer.scene.pick(evt.endPosition);
            that._core.CreateTooltip(tooltip, evt.endPosition, false);
            //
            if (!that.modifyPoint) {
                if (that._cesium.defined(pick) && pick.id) {
                    if (pick.id.objId) {
                        that._core.CreateTooltip("拖动修改位置", evt.endPosition, true);
                    }
                }
                return;
            }
            if (!that.modifyPoint) return;
            var cartesian = that.getCatesian3FromPX(evt.endPosition, that._viewer, [that.modifyPoint]);
            if (cartesian) {
                that._point = cartesian;
                that.modifyPoint.position = cartesian;
            }
            that._core.CreateTooltip(tooltip, evt.endPosition, true);
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        this.modifyHandler.setInputAction(function (evt) {
            var cartesian = that.getCatesian3FromPX(evt.position, that._viewer, [that.modifyPoint]);
            if (!that.modifyPoint) return;
            if (cartesian) {
                that._point = cartesian;
            }
            that.modifyPoint.position = cartesian;
            that.modifyPoint = null;
            that.forbidDrawWorld(false);
            tooltip = "拖动修改位置";
        }, this._cesium.ScreenSpaceEventType.LEFT_UP);
    };
    //坐标解析
    Point.prototype.getCatesian3FromPX = function (px, viewer, entitys) {
        var pick = viewer.scene.pick(px);
        var cartesian;
        var drillPick = viewer.scene.drillPick(px);
        var truePick = null;
        if (entitys.length > 0) {
            for (var i = 0; i < drillPick.length; i++) {
                if (drillPick[i].id._id != entitys[0].id && drillPick[i].id._id != entitys[1].id) {
                    truePick = drillPick[i].id;
                    break;
                }
            }
        } else {
            truePick = pick;
        }
        if (viewer.scene.pickPositionSupported && this._cesium.defined(truePick)) {
            cartesian = viewer.scene.pickPosition(px);
        } else {
            var ray = viewer.camera.getPickRay(px);
            if (!ray) return;
            cartesian = viewer.scene.globe.pick(ray, viewer.scene);
        }
        return cartesian;
    };
    /**
     *
     */
    Point.prototype.forbidDrawWorld = function (isForbid) {
        this._viewer.scene.screenSpaceCameraController.enableRotate = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableTilt = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableTranslate = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableInputs = !isForbid;
    };
    /**
     * 向三维场景中添加一个点动态创建。
     * @param {object} [method] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Point.prototype.executePoint = function (method, parameter) {
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        var _this = this;
        this._tree.starttemporaryItem(this._viewer);
        var colorOptions = {
            "point": _this._cesium.Color.RED
        };
        if (Object.keys(parameter).length > 0) {
            if (parameter.point != "" && parameter.point != undefined) {
                colorOptions.point = parameter.point;
            }
        }
        this._tree.removeHandler();

        let tooltip = this._core.CreateTooltip();
        this._tree.handler = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        //单击鼠标左键画点
        this._tree.handler.setInputAction(function (movement) {
            var ray = _this._viewer.scene.camera.getPickRay(movement.position);
            var position1, cartographic;
            if (ray) {
                position1 = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
            }
            if (!position1) {
                return;
            }
            cartographic = _this._cesium.Ellipsoid.WGS84.cartesianToCartographic(position1);
            //海拔
            var height = _this._viewer.scene.globe.getHeight(cartographic);
            //地理坐标（弧度）转经纬度坐标
            var point = _this._cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180, height);

            var heightText;
            if (height >= 1000) {
                heightText = (height / 1000).toFixed(2) + "千米";
            } else {
                heightText = (height.toFixed(2)) + "米";
            }
            var Point = _this._viewer.entities.add({
                name: '高度',
                // position: Cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180,cartographic.height),
                position: point,
                point: {
                    color: colorOptions.point,
                    pixelSize: 5,
                    outlineColor: _this._cesium.Color.WHITE,
                    outlineWidth: 2,
                    heightReference: _this._cesium.HeightReference.none,
                    disableDepthTestDistance: Number.POSITIVE_INFINITY
                },
                label: {
                    text: "海拔高度：" + heightText,
                    show: true,
                    font: '26px 楷体',
                    fillColor: _this._cesium.Color.WHITE,
                    style: _this._cesium.LabelStyle.FILL_AND_OUTLINE,
                    outlineWidth: 2,
                    verticalOrigin: _this._cesium.VerticalOrigin.BOTTOM,
                    pixelOffset: new _this._cesium.Cartesian2(20, -20),
                    disableDepthTestDistance: Number.POSITIVE_INFINITY
                }
            });
            _this._tree.temporaryItem.obj.push(Point);
            var dx = {
                point: Point,
                height: heightText
            };
            _this._tree.endtemporaryItem();
            _this._core.mouse(_this._viewer.container, 0, "0");
            _this._tree.handler.destroy();
            tooltip.show(false);
            if (typeof method == 'function') {
                method(dx);
            }
            _this.item = Point;
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        this._tree.handler.setInputAction(function (movement) {
            tooltip.showAt(movement.endPosition, "点击拾取高度！");
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return this;
    };

    /**
     * 向三维场景中添加一个点动态创建。
     * @param {object} [method] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Point.prototype.executePointp = function (method, parameter) {
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        var _this = this;
        this._tree.starttemporaryItem(this._viewer);
        var colorOptions = {
            "point": _this._cesium.Color.RED
        };
        if (Object.keys(parameter).length > 0) {
            if (parameter.point != "" && parameter.point != undefined) {
                colorOptions.point = parameter.point;
            }
        }
        this._tree.removeHandler();
        this._tree.handler = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        //单击鼠标左键画点
        this._tree.handler.setInputAction(function (movement) {
            var position1 = _this._getPosition.getMousePosition(movement);
            if (!position1) {
                return;
            }

            var Point = _this._viewer.entities.add({
                name: '高度',
                // position: Cesium.Cartesian3.fromDegrees(cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180,cartographic.height),
                position: position1,
                point: {
                    color: colorOptions.point,
                    pixelSize: 5,
                    outlineColor: _this._cesium.Color.WHITE,
                    outlineWidth: 2,
                    heightReference: _this._cesium.HeightReference.none
                }
                // ,
                // label: {
                //     text: "海拔高度：" + heightText,
                //     show: true,
                //     font: '26px 楷体',
                //     fillColor: _this._cesium.Color.WHITE,
                //     style: _this._cesium.LabelStyle.FILL_AND_OUTLINE,
                //     outlineWidth: 2,
                //     verticalOrigin: _this._cesium.VerticalOrigin.BOTTOM,
                //     pixelOffset: new _this._cesium.Cartesian2(20, -20),
                // }
            });
            _this._tree.temporaryItem.obj.push(Point);
            //_this._tree.temporaryItem.obj.push(lab);
            //_this._points.push(lab);
            // var dx = {
            //     point: Point,
            //     height: heightText
            // };
            // positions.push(dx);
            //_this._points.push(lab);
            _this._tree.endtemporaryItem();
            _this._core.mouse(_this._viewer.container, 0, "0");
            _this._tree.handler.destroy();
            if (typeof method == 'function') {
                method(Point);
            }
            _this.item = Point;
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        return this;
    };
    /**
     * 删除Point
     */
    Point.prototype.deleteObject = function () {
        try {
            this._viewer.entities.remove(this.item);
            if (this._points.length > 0) {
                for (var i = 0; i < this._points.length; i++) {
                    this._viewer.entities.remove(this._points[i]);
                }
            }
        } catch (ex) { }
        // this = null;
    };
    /**
     * 设置Point的显示隐藏
     * @param {boolean} [b] true|false
     */
    Point.prototype.setVisibility = function (b) {
        if (this._points.length > 0) {
            for (var i = 0; i < this._points.length; i++) {
                this._points[i].show = b;
            }
        }
        this.item.show = b;
    };
    /**
     * 获取Point的显示隐藏
     */
    Point.prototype.getVisibility = function () {
        return this.item.show;
    };
    /**
     * 设置点的填充透明度
     * @param {Object} [point] point对象
     * @param {Float} [a] 透明度 0-1
     * @returns {Object} 返回一个point对象。
     */
    Point.prototype.setPointAlpha = function (a) {
        try {
            this.item._point.material._value.alpha = a;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * point导出工程数据
     */
    Point.prototype.export = function () {
        //var positions=this.item.position._value;
        var show = this.item.point.show == undefined ? undefined : this.item.point.show._value;
        var pixelSize = this.item.point.pixelSize == undefined ? undefined : this.item.point.pixelSize._value;
        var color = this.item.point.color == undefined ? undefined : 'rgba(' + this.item.point.color._value.red + ',' + this.item.point.color._value.green + ',' + this.item.point.color._value.blue + ',' + this.item.point.color._value.alpha + ')';
        var outlineColor = this.item.point.outlineColor == undefined ? undefined : 'rgba(' + this.item.point.outlineColor._value.red + ',' + this.item.point.outlineColor._value.green + ',' + this.item.point.outlineColor._value.blue + ',' + this.item.point.outlineColor._value.alpha + ')';
        var outlineWidth = this.item.point.outlineWidth == undefined ? undefined : this.item.point.outlineWidth._value;
        var distanceDisplayCondition = this.item.point.distanceDisplayCondition;
        var near = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.near;
        var far = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.far;

        var catographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
        var longitude = this._cesium.Math.toDegrees(catographic.longitude);
        var latitude = this._cesium.Math.toDegrees(catographic.latitude);
        var height = this._cesium.Math.toDegrees(catographic.height);
        return {
            type: 'point',
            position: {
                x: longitude,
                y: latitude,
                z: height
            },
            treeobj: {
                name: this.treeobj.name
            },
            style: {
                show: show,
                pixelSize: pixelSize,
                color: color,
                outlineColor: outlineColor,
                outlineWidth: outlineWidth,
                near: near,
                far: far
            }
        };
    };
    //工程树添加
    Point.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 设置点的填充颜色
     * @param {Object} [point] point对象
     * @param {htmlColor} htmlColor颜色。
     * @returns {Object} 返回一个point对象。
     */
    Point.prototype.setPointColor = function (htmlColor) {
        try {
            this.item._point.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
            this.item.fillColor = this.item._point.color;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置点的缓冲区添加
     * @param {Object} [point] point对象
     * @param {radius} 线宽。
     * @returns {Object} 返回一个point对象。
     */
    Point.prototype.setRadius = function (radius) {
        try {
            //this.item._point.outlineColor = this._cesium.Color.RED.withAlpha(0.4);
            //this.item._point.outlineWidth = radius;
            //var positions = [];
            ////var heights = [];
            //var ps = this.item.position.getValue();
            //var ellipsoid = this._viewer.scene.globe.ellipsoid;
            //var cartesian3 = new this._cesium.Cartesian3(ps.x, ps.y, ps.z);
            //var cartographic = ellipsoid.cartesianToCartographic(cartesian3);
            //var lat = this._cesium.Math.toDegrees(cartographic.latitude);
            //var lng = this._cesium.Math.toDegrees(cartographic.longitude);
            //positions.push(lng);
            //positions.push(lat);
            //    //heights.push(height);
            //positions = this._cesium.Cartesian3.fromDegreesArray(positions);
            this.item.ellipse = new this._cesium.EllipseGraphics({
                semiMinorAxis: radius,
                semiMajorAxis: radius,
                material: this._cesium.Color.RED.withAlpha(0.4)
            });
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置点的轮廓颜色
     * @param {Object} [point] point对象
     * @param {htmlColor} htmlColor
     * @returns {Object} 返回一个point对象。
     */
    Point.prototype.setOutlineColor = function (htmlColor) {
        try {
            this.item._point.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };

    Object.defineProperties(Point.prototype, {
        HighLight: {
            set: function (b) {
                if (b) {
                    this.item.fillColor = this.item.point._color;
                    //this.item.pixelSize = parseFloat(this.pixelSize);
                }
                if (b) {
                    this.item._point.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(this._core.selectedColor);
                    //this.pixelSize = this.item.pixelSize + 10;
                } else {
                    this.item.point._color = this.item.fillColor;
                    //this.pixelSize = this.item.pixelSize;
                }
            }
        }
    });
    Object.defineProperties(Point.prototype, {
        /**
         * 获取或设置点的显示颜色
         */
        pointColor: {
            get: function () {
                if (!this.item.point._color._value) return;
                return this._color.toHtmlColor('rgb(' + this.item.point._color._value.red * 255 + ',' + this.item.point._color._value.green * 255 + ',' + this.item.point._color._value.blue * 255 + ',' + this.item.point._color._value.alpha * 255 + ')')
            },
            set: function (color) {
                try {
                    if (/^rgb/.test(color)) {
                        color = this._color.rgbaStringToRgbaObj(color);
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                        this.item._point.color = color;
                        this.item.fillColor = this.item._point.color;
                    } else {
                        this.item._point.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(color);
                        this.item.fillColor = this.item._point.color;
                    }
                } catch (ex) { }
            }
        },
        /**
         * 获取点的边框填充色
         */
        pointOutlineColor: {
            get: function () {
                if (this.item._point._outlineColor == undefined) return;
                return this._color.toHtmlColor('rgb(' + this.item._point.outlineColor._value.red * 255 + ',' + this.item._point.outlineColor._value.green * 255 + ',' + this.item._point.outlineColor._value.blue * 255 + ',' + this.item._point.outlineColor._value.alpha * 255 + ')')
            },
            set: function (color) {
                try {
                    if (/^rgb/.test(color)) {
                        color = this._color.rgbaStringToRgbaObj(color);
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                        this.item._point.outlineColor = color;
                    } else {
                        this.item._point.outlineColor = this._color.colorFromHtmlColor(color);
                    }
                } catch (ex) {
                    console.log(ex);
                }
            }
        },
        /**
         * 获取或设置点边框宽度
         */
        pointOutlineWidth: {
            get: function () {
                if (this.item.point.outlineWidth == undefined) return undefined;
                return this.item.point.outlineWidth._value;
            },
            set: function (width) {
                this.item.point.outlineWidth = width;
            }
        },
        /**
         * 获取或设置点的填充色
         */
        pointAlpha: {
            get: function () {
                if (this.item._point._color == undefined) return undefined;
                return this.item._point._color._value.alpha;
            },
            set: function (alpha) {
                this.item._point._color._value.alpha = alpha;
            }
        },
        /**
         * 获取或设置点的填充色
         */
        pointOutlineAlpha: {
            get: function () {
                if (this.item._point.outlineColor == undefined) return undefined;
                return this.item._point.outlineColor._value.alpha;
            },
            set: function (alpha) {
                try {
                    this.item._point.outlineColor._value.alpha = alpha;
                } catch (ex) { }
            }
        },
        /**
         * 设置点的显示高度
         */
        pointHeight: {
            set: function (height) {
                height = parseFloat(height);
                var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                // longitude = this._cesium.Math.toDegrees(longitude);
                // latitude = this._cesium.Math.toDegrees(latitude);
                //// 转回去
                var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                this.item.position._value = position;
            },
            get: function () {
                var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                // var longitude = this._cesium.Math.toDegrees(Cartographic.longitude)
                // var latitude = this._cesium.Math.toDegrees(Cartographic.latitude)
                var height = this._cesium.Math.toDegrees(Cartographic.height);
                // longitude = this._cesium.Math.toDegrees(longitude);
                // latitude = this._cesium.Math.toDegrees(latitude);
                //// 转回去
                return height;
            }
        },
        /**
         * 设置点的显示经度
         */
        pointX: {
            set: function (x) {
                var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                this._cesium.Math.toDegrees(Cartographic.longitude);
                var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                var height = this._cesium.Math.toDegrees(Cartographic.height);
                // longitude = this._cesium.Math.toDegrees(longitude);
                // latitude = this._cesium.Math.toDegrees(latitude);
                //// 转回去
                var position = this._cesium.Cartesian3.fromDegrees(x, latitude, height);
                this.item.position.position = position;
            },
            get: function () {
                var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                // var latitude = this._cesium.Math.toDegrees(Cartographic.latitude)
                //var height = this._cesium.Math.toDegrees(Cartographic.height)
                // longitude = this._cesium.Math.toDegrees(longitude);
                // latitude = this._cesium.Math.toDegrees(latitude);
                //// 转回去
                return longitude;
            }
        },
        /**
         * 设置点的显示纬度
         */
        pointY: {
            set: function (y) {
                var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                this._cesium.Math.toDegrees(Cartographic.latitude);
                var height = this._cesium.Math.toDegrees(Cartographic.height);
                // longitude = this._cesium.Math.toDegrees(longitude);
                // latitude = this._cesium.Math.toDegrees(latitude);
                //// 转回去
                var position = this._cesium.Cartesian3.fromDegrees(longitude, y, height);
                this.item.position.position = position;
            },
            get: function () {
                var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                //var longitude = this._cesium.Math.toDegrees(Cartographic.longitude)
                var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                //var height = this._cesium.Math.toDegrees(Cartographic.height)
                // longitude = this._cesium.Math.toDegrees(longitude);
                // latitude = this._cesium.Math.toDegrees(latitude);
                //// 转回去
                return latitude;
            }
        }
    });
    Object.defineProperties(Point.prototype, {
        /**
         * 获取或设置点的大小
         */
        pixelSize: {
            get: function () {
                return this.item.point.pixelSize._value;
            },
            set: function (pixelSize) {
                this.item.point.pixelSize = pixelSize;
            }
        }
    });
    Object.defineProperties(Point.prototype, {
        /**
         * 获取或设置矩形
         */
        rectangle: {
            get: function () {
                return this.item.rectangle;
            },
            set: function (rectangle) {
                this.item.rectangle = rectangle;
            }
        }
    });

    Point.prototype.setItem = function (item) {
        this.item = item;
    };

    Object.defineProperties(Point.prototype, {
        /**
         * 获取或设置线条
         */
        polyline: {
            get: function () {
                return this.item.polyline;
            },
            set: function (polyline) {
                this.item.polyline = polyline;
            }
        }
    });

    Object.defineProperties(Point.prototype, {
        /**
         * 获取或设置面
         */
        polygon: {
            get: function () {
                return this.item.polygon;
            },
            set: function (polygon) {
                this.item.polygon = polygon;
            }
        }
    });

    Object.defineProperties(Point.prototype, {
        /**
         * 获取或设置点
         */
        point: {
            get: function () {
                return this.item.point;
            },
            set: function (point) {
                this.item.point = point;
            }
        }
    });

    Object.defineProperties(Point.prototype, {
        /**
         * 获取或设置标签
         */
        label: {
            get: function () {
                return this.item.label;
            },
            set: function (label) {
                this.item.label = label;
            }
        }
    });
    Object.defineProperties(Point.prototype, {
        /**
         * 获取或设置标签
         */
        position: {
            get: function () {
                if (this._position) {
                    return this._position;
                }
                return this.item.position;
            }
        }
    });

    Object.defineProperties(Point.prototype, {
        /**
         * 获取或设置模型
         */
        model: {
            get: function () {
                return this.item.model;
            },
            set: function (model) {
                this.item.model = model;
            }
        }
    });

    Object.defineProperties(Point.prototype, {
        /**
         * 获取或设置墙
         */
        wall: {
            get: function () {
                return this.item.wall;
            },
            set: function (wall) {
                this.item.wall = wall;
            }
        }
    });
    Object.defineProperties(Point.prototype, {
        /**
         * 获取墙的模板属性
         */
        pointTempOptions: {
            get: function () {
                return {
                    color: this._cesium.Color.WHITE, //	optional A Property specifying the Color of the point.
                    pixelSize: 1, //optional A numeric Property specifying the size in pixels.
                    outlineColor: Color.BLACK, //	optional A Property specifying the Color of the outline.
                    outlineWidth: 0, //	optional A numeric Property specifying the the outline width in pixels.
                    show: true, //	optional A boolean Property specifying the visibility of the point.
                    scaleByDistance: null, //Property		optional A NearFarScalar Property used to scale the point based on distance.
                    translucencyByDistance: null, //	Property		optional A NearFarScalar Property used to set translucency based on distance from the camera.
                    heightReference: null, //	Property	HeightReference.NONE	optional A Property specifying what the height is relative to.
                    distanceDisplayCondition: null, //	Property		optional A Property specifying at what distance from the camera that this point will be displayed.
                    disableDepthTestDistance: null //	Property	
                }
            }
        }
    });

    /**
     *
     * 创建添加文本点。
     *
     * @alias Label
     * @constructor
     *
     * @param {Viewer} Viewer Cesium的viewer对象。
     * @param {obj} 返回对象，对象例如：lable={cesium:label},其中lable具有方法。
     *
     *
     *
     */
    function Label(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree;
        this._core = new Core();
        this._Color = new Color(this._viewer, this._cesium);
        //对象
        this._postion = {
            Altitude: 0.0,
            AltitudeType: 0,
            Cartesian: true,
            Distance: 0.0,
            Pitch: 0.0,
            Roll: 0.0,
            X: 0.0,
            Y: 0.0,
            Yaw: 0.0
        };
    }

    /**
     * 创建label标签
     * @param {Array} [position] 一个经纬度数组[x,y]。
     * @param {String} [text] 文本。
     * @param {Object} [labelStyle] 标签样式（例如，颜色，字体和可视距离属性）。
     * @param {String} [GroupID] 所在组编号
     * @param {String} [Description] 描述
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Label.prototype.createLabel = function (position, text, labelStyle, GroupID, Description) {
        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
            text: 'default text', //文本
            backgroundColor: new Color(this._viewer, this._cesium).createColor(0.165, 0.165, 0.165, 1), //获取或设置此标签的背景色。
            fillColor: new Color(this._viewer, this._cesium).createColor(0.9411764705882353, 0.9725490196078431, 1, 1),
            font: "30px sans-serif",
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER,
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,
            show: true,
            scale: 1,
            showBackground: false,
            distanceDisplayCondition: new this._cesium.DistanceDisplayCondition(0, Number.MAX_VALUE)
            //scaleByDistance: new Cesium.NearFarScalar(0, 1, 10000000, 0)

        };
        var options = this._core.extend(defaultOption, labelStyle, true);
        if (!this._core.isnull(text)) {
            options.text = text;
        }
        //填充颜色设置
        if (options.fillColor) {
            if (!this._core.isnull(options) && !this._core.isnull(options.fillColor)) {
                if (options.fillColor.toString().charAt(0) == "[" && options.fillColor.toString().charAt(options.fillColor.length - 1) == "]") ; else {
                    if (this._core.isHtmlColor(options.fillColor) && /^#/.test(options.fillColor.toString())) {
                        options.fillColor = this._Color.colorFromHtmlColor(options.fillColor);
                    } else {
                        if (/^rgb/.test(options.fillColor)) {
                            options.fillColor = this._Color.rgbaStringToRgbaObj(options.fillColor);
                        }
                        if (options.fillColor.r > 1) {
                            options.fillColor.r = options.fillColor.r / 255;
                        }
                        if (options.fillColor.g > 1) {
                            options.fillColor.g = options.fillColor.g / 255;
                        }
                        if (options.fillColor.b > 1) {
                            options.fillColor.b = options.fillColor.b / 255;
                        }
                        if (options.fillColor.a > 1) {
                            options.fillColor.a = options.fillColor.a / 255;
                        }
                        if (options.fillColor.r)
                            options.fillColor = this._Color.createColor(options.fillColor.r, options.fillColor.g, options.fillColor.b, options.fillColor.a);
                    }
                }
            }
        }

        //背景颜色设置
        if (options.backgroundColor) {
            if (!this._core.isnull(options) && !this._core.isnull(options.backgroundColor)) {
                if (options.backgroundColor.toString().charAt(0) == "[" && options.backgroundColor.toString().charAt(options.backgroundColor.length - 1) == "]") ; else {
                    if (this._core.isHtmlColor(options.backgroundColor) && /^#/.test(options.backgroundColor.toString())) {
                        options.backgroundColor = this._Color.colorFromHtmlColor(options.backgroundColor);
                    } else {
                        if (/^rgb/.test(options.backgroundColor)) {
                            options.backgroundColor = this._Color.rgbaStringToRgbaObj(options.backgroundColor);
                        }
                        if (options.backgroundColor.r > 1) {
                            options.backgroundColor.r = options.backgroundColor.r / 255;
                        }
                        if (options.backgroundColor.g > 1) {
                            options.backgroundColor.g = options.backgroundColor.g / 255;
                        }
                        if (options.backgroundColor.b > 1) {
                            options.backgroundColor.b = options.backgroundColor.b / 255;
                        }
                        if (options.backgroundColor.a > 1) {
                            options.backgroundColor.a = options.backgroundColor.a / 255;
                        }
                        if (options.backgroundColor.r)
                            options.backgroundColor = this._Color.createColor(options.backgroundColor.r, options.backgroundColor.g, options.backgroundColor.b, options.backgroundColor.a);
                    }
                }
            }
        }

        //边框颜色设置
        if (options.outlineColor) {
            if (!this._core.isnull(options) && !this._core.isnull(options.outlineColor)) {
                if (options.outlineColor.toString().charAt(0) == "[" && options.outlineColor.toString().charAt(options.outlineColor.length - 1) == "]") ; else {
                    if (this._core.isHtmlColor(options.outlineColor) && /^#/.test(options.outlineColor.toString())) {
                        options.outlineColor = this._Color.colorFromHtmlColor(options.outlineColor);
                    } else {
                        if (/^rgb/.test(options.outlineColor)) {
                            options.outlineColor = this._Color.rgbaStringToRgbaObj(options.outlineColor);
                        }
                        if (options.outlineColor.r > 1) {
                            options.outlineColor.r = options.outlineColor.r / 255;
                        }
                        if (options.outlineColor.g > 1) {
                            options.outlineColor.g = options.outlineColor.g / 255;
                        }
                        if (options.outlineColor.b > 1) {
                            options.outlineColor.b = options.outlineColor.b / 255;
                        }
                        if (options.outlineColor.a > 1) {
                            options.outlineColor.a = options.outlineColor.a / 255;
                        }
                        if (options.outlineColor.r)
                            options.outlineColor = this._Color.createColor(options.outlineColor.r, options.outlineColor.g, options.outlineColor.b, options.outlineColor.a);
                    }
                }
            }
        }

        if (options.near && options.far) {
            options.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(options.near, options.far);
        }
        this.item = this._viewer.entities.add({
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]),
            label: options
        });
        var obj = {
            id: this.item.id,
            name: options.text,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'label',
            item: this
        };
        //BackgroundColorAlpha
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    /**
     * 获取label样式
     */
    Label.prototype.getstyles = function () {
        var styles = {};
        styles.backgroundColor = 'rgba' + this.item.label._backgroundColor.toString() + '';
        styles.fillColor = 'rgba' + this.item.label._fillColor.toString() + '';
        styles.text = this.item.label.text.toString();
        styles.show = this.item.label.show ? this.item.label.show._value : true;
        styles.font = this.item.label.font ? this.item.label.font.toString() : null;
        styles.style = this.item.label.style ? this.item.label.style.toString() == "null" ? null : this.item.label.style.toString() : null;
        styles.scale = this.item.label.scale ? this.item.label.scale.toString() : null;
        styles.showBackground = this.item.label.showBackground ? this.item.label.showBackground._value : null;
        styles.horizontalOrigin = this.item.label.horizontalOrigin ? this.item.label.horizontalOrigin.toString() : null;
        styles.verticalOrigin = this.item.label.verticalOrigin ? this.item.label.verticalOrigin.toString() : null;
        styles.heightReference = this.item.label.heightReference ? this.item.label.heightReference.toString() : null;
        styles.outlineColor = this.item.label.outlineColor ? 'rgba' + this.item.label.outlineColor.toString() + '' : null;
        styles.outlineWidth = this.item.label.outlineWidth ? this.item.label.outlineWidth._value : null;
        styles.near = this.item.label.distanceDisplayCondition ? this.item.label.distanceDisplayCondition._value.near : null;
        styles.far = this.item.label.distanceDisplayCondition ? this.item.label.distanceDisplayCondition._value.far : null;
        styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
     * 向三维场景中添加一个点动态创建。
     * @param {object} [method] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Label.prototype.executeLabel = function (method) {
        var _this = this;
        var handler = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        //单击鼠标左键画点
        handler.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.position, _this._viewer.scene.globe.ellipsoid);
            var label = _this._viewer.entities.add({
                position: cartesian,
                label: {
                    id: _this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
                    text: '', //文本
                    font: "30px sans-serif",
                    horizontalOrigin: _this._cesium.HorizontalOrigin.CENTER,
                    verticalOrigin: _this._cesium.VerticalOrigin.CENTER,
                    show: true,
                    showBackground: true
                }
            });
            _this.item = label;
            var GroupID = 0;
            if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                GroupID = tree.selectedItem.id;
            var id = _this._core.getuid();
            var obj = {
                id: id,
                name: "",
                pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'Point',
                item: _this
            };
            _this.setTreeobj(obj);
            _this._tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        //单击鼠标右键结束画点
        handler.setInputAction(function (movement) {
            handler.destroy();
            //callback(positions);
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
        return this;
    };
    /**
     * 删除label标签
     */
    Label.prototype.deleteObject = function () {
        try {
            if (this.item.type === 'DivPoint') {
                this.pointPrimitive.remove(this.item);
                var divPoint = document.getElementById(this.item.id);
                divPoint && divPoint.remove();
                return;
            }
            this._viewer.entities.remove(this.item);
        } catch (ex) {
        }
        // this = null;
    };
    /**
     * 设置label文本的透明度
     * @param {boolean} [b] true|false
     */
    Label.prototype.setVisibility = function (b) {
        this.item.show = b;
    };
    /**
     * 设置富文本
     * @param {boolean} [b] true|false
     */
    Label.prototype.setRichtext = function (html) {
        var id = this._core.getuid();
        if (this.item.position._value != undefined) {
            this._position = this.item.position._value;
        } else {
            this._position = this.item.position;
        }
        var GroupID = this.treeobj.pId;
        this.deleteObject();
        if (!this.pointPrimitive) {
            this.pointPrimitive = this._viewer.scene.primitives.add(new this._cesium.PointPrimitiveCollection());
            var divPoint, CanvasCoordinates, pointPosition;
            var _this = this;
            this.pointPrimitive.update = function () {
                for (var i = 0, item, divPointHtml; i < _this.pointPrimitive.length; i++) {
                    item = _this.pointPrimitive.get(i);
                    pointPosition = item.position;
                    CanvasCoordinates = _this._viewer.scene.cartesianToCanvasCoordinates(pointPosition);
                    if (!CanvasCoordinates) return;
                    divPoint = document.getElementById(item.id);
                    if (!item.name) {
                        item.name = '泰瑞';
                    }
                    if (!divPoint) {
                        if (item.description) {
                            divPointHtml = '<div id="' + item.id + '" style="position: absolute; width: 200px; height: 157px;left: 0px; top: 0px; pointer-events:none; background: url(' + window.SmartEarthRootUrl + configData$1.divpoint + ');transform: matrix(1, 0, 0, 1, 0, 0); transform-origin: left bottom 0px;">\n' +
                                '                   <div class="title" style="position: inherit;top: 22px;left: 70px;font-size: 14px;text-align: left;color: rgba(255,255,255,1);text-shadow: 0 0 9px rgba(0,0,0,.75)"></div>\n' +
                                '                   <div class="content" style="position: inherit;font-size: 14px;top: 50px;left: 50px;width: 140px;text-align: left;color: rgba(255,255,255,1);">' + item.description + '</div> \n' +
                                '           </div>';
                            $('.cesium-viewer').append(divPointHtml);
                            divPoint = document.getElementById(item.id);
                        } else {
                            divPointHtml = '<div id="' + item.id + '" style="position: absolute; width: 200px; height: 134px;left: 0px; top: 0px; pointer-events:none; background: url(' + window.SmartEarthRootUrl + configData$1.divpoint1 + ');transform: matrix(1, 0, 0, 1, 0, 0); transform-origin: left bottom 0px;">\n' +
                                '                   <div class="title" style="position: inherit;top: 22px;left: 70px;font-size: 14px;text-align: left;color: rgba(255,255,255,1);text-shadow: 0 0 9px rgba(0,0,0,.75)">' + item.name + '</div>\n' +
                                '           </div>';
                            $('.cesium-viewer').append(divPointHtml);
                            divPoint = document.getElementById(item.id);
                        }
                    }
                    if (item.description) {
                        divPoint.style.transform = 'matrix(1, 0, 0, 1, ' + (CanvasCoordinates.x) + ', ' + (CanvasCoordinates.y - 157) + ')';
                    } else {
                        divPoint.style.transform = 'matrix(1, 0, 0, 1, ' + (CanvasCoordinates.x) + ', ' + (CanvasCoordinates.y - 134) + ')';
                    }

                }
            };
        }

        this.item = this.pointPrimitive.add({
            id: 'DivPoint' + id,
            position: this._position,
            color: this._cesium.Color.YELLOW
        });
        this.item.type = 'DivPoint';
        this.item.name = name;
        this.item.description = html;
        var obj = {
            id: this.item.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'Point',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this.item;
    };
    /**
     * 获取label的显示与隐藏
     */
    Label.prototype.getVisibility = function () {
        return this.item.show;
    };
    /**
     * 设置点的缓冲区添加
     * @param {Object} [label] lable对象
     * @param {radius} 线宽。
     * @returns {Object} 返回一个lable对象。
     */
    Label.prototype.setRadius = function (radius) {
        try {

            this.item._label.outlineWidth = radius;
            this.item._label.outlineColor = this._cesium.Color.RED.withAlpha(0.4);
            //var positions = [];
            //var heights = [];
            //var ps = this.item.position.getValue();
            //var ellipsoid = this._viewer.scene.globe.ellipsoid;
            //for (var i = 0; i < ps.length; i++) {
            //    var cartesian3 = new this._cesium.Cartesian3(ps[i].x, ps[i].y, ps[i].z);
            //    var cartographic = ellipsoid.cartesianToCartographic(cartesian3);
            //    var lat = this._cesium.Math.toDegrees(cartographic.latitude);
            //    var lng = this._cesium.Math.toDegrees(cartographic.longitude);
            //    positions.push(lng);
            //    positions.push(lat);
            //    //heights.push(height);
            //}
            //positions = this._cesium.Cartesian3.fromDegreesArray(positions);
            //this.item.corridor = new this._cesium.CorridorGraphics({
            //    positions: positions,
            //    width: radius,
            //    material: this._cesium.Color.RED.withAlpha(0.4)
            //});
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置label的文本
     * @param {Object} [label] label对象
     * @param {String} [text] 文本。
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setText = function (text) {
        try {
            this.item._label.text = text;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置lable的高度类型
     * @param {Object} [label] lable对象
     * @param {int} [type] 1：该位置被夹在地形上。2：这个职位是绝对的。3：位置高度是地形上方的高度。
     * @returns {Object} 返回一个对象。
     */
    Label.prototype.setHeightType = function (type) {
        try {
            if (type == 1) {
                this.item._label.heightReference = this._cesium.HeightReference.CLAMP_TO_GROUND;
            } else if (type == 2) {
                this.item._label.heightReference = this._cesium.HeightReference.NONE;
            } else if (type == 3) {
                this.item._label.heightReference = this._cesium.HeightReference.RELATIVE_TO_GROUND;
            }
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置label的image
     * @param {Object} [label] label对象
     * @param {String} [url] image路径。
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setUrl = function (url) {
        try {
            this.item.billboard = new this._cesium.BillboardGraphics({
                id: this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
                image: url,
                show: true // default
            });
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };

    /**
     * 设置label的字体颜色
     * @param {Object} [label] label对象
     * @param {Float} [r] r 0-1
     * @param {Float} [g] g 0-1
     * @param {Float} [b] b 0-1
     * @param {Float} [a] a 0-1
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setFillColorRgba = function (r, g, b, a) {
        try {
            this.item._label.fillColor = new Color(this._viewer, this._cesium).createColor(r, g, b, a);
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label的字体颜色
     * @param {Object} [label] label对象
     * @returns {htmlColor} 返回一个Label对象。
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setFillColorHtml = function (htmlColor) {
        try {
            this.item._label.fillColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
            this.item.fillColor = this.item._label.fillColor;
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label文本填充色的透明度
     * @param {Object} [label] label对象
     * @param {Float} [a] 透明度 0-1
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setFillColorAlpha = function (a) {

        try {
            this.item._label.fillColor._value.alpha = a;
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label的背景颜色
     * @param {Object} [label] label对象
     * @param {Float} [r] r 0-1
     * @param {Float} [g] g 0-1
     * @param {Float} [b] b 0-1
     * @param {Float} [a] a 0-1
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setBackgroundColorRgba = function (r, g, b, a) {

        try {
            this.item._label.backgroundColor = new Color(this._viewer, this._cesium).createColor(r, g, b, a);
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label的背景颜色
     * @param {Object} [label] label对象
     * @returns {htmlColor} htmlColor颜色。
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setBackgroundColorHtml = function (htmlColor) {
        try {
            this.item._label.backgroundColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label文本背景色的透明度
     * @param {Object} [label] label对象
     * @param {Float} [a] 透明度 0-1
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setBackgroundColorAlpha = function (a) {
        try {
            this.item._label.backgroundColor._value.alpha = a;
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label的文本
     * @param {Object} [label] label对象
     * @param {String} [text] 文本。
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setFontSize = function (fontsize) {
        try {
            this.item._label.font = parseFloat(fontsize) + "px sans-serif";
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label文本的透明度
     * @param {Object} [label] label对象
     * @param {Float} [a] 透明度 0-1
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setFillColorAlpha = function (a) {
        try {
            this.item._label.fillColor._value.alpha = a;
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label文本的透明度
     * @param {Object} [label] label对象
     * @param {boolean} [isShow] 透明度 0-1
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.showBackground = function (isShow) {
        try {
            this.item._label.showBackground = isShow;
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label文本的透明度
     * @param {Object} [label] label对象
     * @param {Float} [width] 透明度 0-1
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setOutlineWidth = function (width) {
        try {
            this.item._label.outlineWidth = width;
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label边框的背景颜色
     * @param {Object} [label] label对象
     * @param {Float} [r] r 0-1
     * @param {Float} [g] g 0-1
     * @param {Float} [b] b 0-1
     * @param {Float} [a] a 0-1
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setOutlineColorRgba = function (r, g, b, a) {
        try {
            this.item._label.outlineColor = new this._cesium.Color(r, g, b, a);
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label边框的背景颜色
     * @param {Object} [label] label对象
     * @returns {htmlColor} 返回一个Label对象。
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setOutlineColorHtml = function (htmlColor) {
        try {
            this.item._label.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label文本的透明度
     * @param {Object} [label] label对象
     * @param {Float} [a] 透明度 0-1
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setOutlineColorAlpha = function (a) {
        try {
            this.item._label.outlineColor._value.alpha = a;
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label的显示样式
     * @param {Object} [label] label对象
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setStyle_LabelStyle_FILL = function (a) {
        try {
            this.item._label.style = this.LabelStyle_FILL;
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 设置label的显示样式
     * @param {Object} [label] label对象
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setStyle_LabelStyle_FILL_AND_OUTLINE = function () {
        try {
            this.item._label.style = this.LabelStyle_FILL_AND_OUTLINE;
        } catch (ex) {
            console.log(ex);
        }
    };
    /**
     * 修改线段的可视距离
     * @param {Object} [label] label对象
     * @param {String} [min, max] 设置线段的可视距离
     * @returns {Object} 返回一个label对象。
     */
    Label.prototype.setDistanceDisplayCondition = function (min, max) {
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        try {
            this.item._label.distanceDisplayCondition = distance;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置label的显示样式
     * @param {Object} [label] label对象
     * @returns {Object} 返回一个Label对象。
     */
    Label.prototype.setStyle_LabelStyle_OUTLINE = function () {
        try {
            this.item._label.style = this.LabelStyle_OUTLINE;
        } catch (ex) {
            console.log(ex);
        }
    };

    Label.prototype.setItem = function (item) {
        this.item = item;
    };

    /**
     *仿照te修改
     */
    Label.prototype.CreateLabel = function (positions, Texts, ImageFileName, LabelStyle, GroupID, Description) {
        this._postion = positions;
        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
            text: Texts, //文本
            backgroundColor: LabelStyle.BackgroundColor, //获取或设置此标签的背景色。
            font: LabelStyle.FontName,
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER,
            verticalOrigin: this._cesium.VerticalOrigin.BOTTOM,
            show: true,
            scale: LabelStyle.Scale,
            showBackground: false,
            distanceDisplayCondition: new this._cesium.DistanceDisplayCondition(LabelStyle.MinViewingHeight, LabelStyle.MaxViewingHeight)
        };
        if (LabelStyle.Italic) {
            defaultOption.font = "italic " + defaultOption.font;
        }
        if (LabelStyle.Bold) {
            defaultOption.font = "Bold " + defaultOption.font;
        }
        if (!this._core.isnull(LabelStyle) && !this._core.isnull(LabelStyle.IconColor)) {
            if (LabelStyle.IconColor.toString().charAt(0) == "[" && LabelStyle.IconColor.toString().charAt(LabelStyle.IconColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(LabelStyle.IconColor)) {
                    defaultOption.fillColor = this._Color.colorFromHtmlColor(LabelStyle.IconColor);
                } else {
                    if (/^rgb/.test(LabelStyle.IconColor)) {
                        defaultOption.fillColor = this._Color.rgbaStringToRgbaObj(LabelStyle.IconColor);
                    }
                    if (defaultOption.fillColor.r > 1) {
                        defaultOption.fillColor.r = defaultOption.fillColor.r / 255;
                    }
                    if (defaultOption.fillColor.g > 1) {
                        defaultOption.fillColor.g = defaultOption.fillColor.g / 255;
                    }
                    if (defaultOption.fillColor.b > 1) {
                        defaultOption.fillColor.b = defaultOption.fillColor.b / 255;
                    }
                    if (defaultOption.fillColor.a > 1) {
                        defaultOption.fillColor.a = defaultOption.fillColor.a / 255;
                    }
                    defaultOption.fillColor = this._Color.createColor(defaultOption.fillColor.r, defaultOption.fillColor.g, defaultOption.fillColor.b, defaultOption.fillColor.a);
                }
            }
        }
        if (!this._core.isnull(LabelStyle) && !this._core.isnull(LabelStyle.LineColor)) {
            if (LabelStyle.LineColor.toString().charAt(0) == "[" && LabelStyle.LineColor.toString().charAt(LabelStyle.LineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(LabelStyle.LineColor)) {
                    defaultOption.outlineColor = this._Color.colorFromHtmlColor(LabelStyle.LineColor);
                } else {
                    if (/^rgb/.test(LabelStyle.LineColor)) {
                        defaultOption.outlineColor = this._Color.rgbaStringToRgbaObj(LabelStyle.LineColor);
                    }
                    if (defaultOption.outlineColor.r > 1) {
                        defaultOption.outlineColor.r = defaultOption.outlineColor.r / 255;
                    }
                    if (defaultOption.outlineColor.g > 1) {
                        defaultOption.outlineColor.g = defaultOption.outlineColor.g / 255;
                    }
                    if (defaultOption.outlineColor.b > 1) {
                        defaultOption.outlineColor.b = defaultOption.outlineColor.b / 255;
                    }
                    if (defaultOption.outlineColor.a > 1) {
                        defaultOption.outlineColor.a = defaultOption.outlineColor.a / 255;
                    }
                    defaultOption.outlineColor = this._Color.createColor(defaultOption.outlineColor.r, defaultOption.outlineColor.g, defaultOption.outlineColor.b, defaultOption.outlineColor.a);
                }
            }
        }
        defaultOption = this._core.extend(defaultOption, LabelStyle, true);
        var options = {
            position: this._cesium.Cartesian3.fromDegrees(positions.X, positions.Y, positions.Altitude),
            label: defaultOption
        };
        if (ImageFileName && ImageFileName !== '') {
            options.label.pixelOffset = this._cesium.defaultValue(LabelStyle.pixelOffset, {
                x: 30 * (Texts.length / 2 + 1),
                y: -30
            });
            var billboardOption = {
                image: ImageFileName,
                fillColor: defaultOption.fillColor,
                horizontalOrigin: this._cesium.defaultValue(LabelStyle.ImageHorizontal, this._cesium.HorizontalOrigin.CENTER),
                verticalOrigin: this._cesium.defaultValue(LabelStyle.ImageVertical, this._cesium.VerticalOrigin.BOTTOM),
                outlineColor: defaultOption.outlineColor,
                show: true,
                scale: LabelStyle.ImageScale || 1,
                showBackground: false,
                distanceDisplayCondition: new this._cesium.DistanceDisplayCondition(LabelStyle.ImageMinViewingHeight || 0, LabelStyle.ImageMaxViewingHeight || 99999999999999)
            };
            LabelStyle.pixelOffset = {
                x: 0,
                y: 0
            };
            billboardOption = this._core.extend(billboardOption, LabelStyle, false);
            options.billboard = billboardOption;
        }

        this.item = this._viewer.entities.add(options);
        var obj = {
            id: this.item.id,
            name: defaultOption.text,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'label',
            item: this
        };
        //BackgroundColorAlpha
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //return this;
        return this;
    };
    /**
     * 导出工程数据
     */
    Label.prototype.export = function () {
        var show = this.item.label.show == undefined ? undefined : this.item.label.show._value;
        var text = this.item.label.text == undefined ? undefined : this.item.label.text._value;
        var font = this.item.label.font == undefined ? undefined : this.item.label.font._value;
        var style = this.item.label.style == undefined ? undefined : this.item.label.style._value;
        var scale = this.item.label.scale == undefined ? undefined : this.item.label.scale._value;
        var showBackground = this.item.label.showBackground == undefined ? undefined : this.item.label.showBackground._value;
        var backgroundColor = this.item.label.backgroundColor == undefined ? undefined : 'rgba(' + this.item.label.backgroundColor._value.red + ',' + this.item.label.backgroundColor._value.green + ',' + this.item.label.backgroundColor._value.blue + ',' + this.item.label.backgroundColor._value.alpha + ')';
        var horizontalOrigin = this.item.label.horizontalOrigin == undefined ? undefined : this.item.label.horizontalOrigin._value;
        var verticalOrigin = this.item.label.verticalOrigin == undefined ? undefined : this.item.label.verticalOrigin._value;
        var heightReference = this.item.label.heightReference == undefined ? undefined : this.item.label.heightReference._value;
        var fillColor = this.item.label.fillColor == undefined ? undefined : 'rgba(' + this.item.label.fillColor._value.red + ',' + this.item.label.fillColor._value.green + ',' + this.item.label.fillColor._value.blue + ',' + this.item.label.fillColor._value.alpha + ')';
        var outlineColor = this.item.label.outlineColor == undefined ? undefined : 'rgba(' + this.item.label.outlineColor._value.red + ',' + this.item.label.outlineColor._value.green + ',' + this.item.label.outlineColor._value.blue + ',' + this.item.label.outlineColor._value.alpha + ')';
        var outlineWidth = this.item.label.outlineWidth == undefined ? undefined : this.item.label.outlineWidth._value;
        var distanceDisplayCondition = this.item.label.distanceDisplayCondition;
        var near = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.near;
        var far = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.far;
        var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
        var height = this._cesium.Math.toDegrees(Cartographic.height);
        return {
            type: 'label',
            position: {
                x: longitude,
                y: latitude,
                z: height
            },
            treeobj: { id: this.treeobj.id, name: this.treeobj.name, pId: this.treeobj.pId, type: this.treeobj.type },
            style: {
                show: show,
                text: text,
                font: font,
                style: style,
                scale: scale,
                showBackground: showBackground,
                backgroundColor: backgroundColor,
                horizontalOrigin: horizontalOrigin,
                verticalOrigin: verticalOrigin,
                heightReference: heightReference,
                fillColor: fillColor,
                outlineColor: outlineColor,
                outlineWidth: outlineWidth,
                near: near,
                far: far
            }
        };
    };
    //工程树添加
    Label.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    Object.defineProperties(Label.prototype, {
        position: {
            Altitude: {
                get: function () {
                    return this._postion.Altitude
                },
                set: function (Altitude) {
                    try {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        var height = this._cesium.Math.toDegrees(Cartographic.height);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, Altitude);
                        this.item.position.position = position;
                        this._postion.Altitude = Altitude;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            AltitudeType: {
                get: function () {
                    return this._postion.AltitudeType
                },
                set: function (AltitudeType) {
                    try {
                        this._postion.AltitudeType = AltitudeType;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Cartesian: {
                get: function () {
                    return this._postion.Cartesian
                },
                set: function (Cartesian) {
                    try {
                        this._postion.Cartesian = Cartesian;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Distance: {
                get: function () {
                    return this._postion.Distance
                },
                set: function (Distance) {
                    try {
                        this._postion.Distance = Distance;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Pitch: {
                get: function () {
                    return this._postion.Pitch
                },
                set: function (Pitch) {
                    try {
                        this._postion.Pitch = Pitch;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Roll: {
                get: function () {
                    return this._postion.Roll
                },
                set: function (Roll) {
                    try {
                        this._postion.Roll = Roll;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            X: {
                get: function () {
                    return this._postion.X
                },
                set: function (X) {
                    try {
                        this._postion.X = X;
                        var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        var height = this._cesium.Math.toDegrees(Cartographic.height);
                        // 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(X, latitude, height);
                        this.item.position.position = position;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Y: {
                get: function () {
                    return this._postion.Y
                },
                set: function (Y) {
                    try {
                        this._postion.Y = Y;
                        var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        var height = this._cesium.Math.toDegrees(Cartographic.height);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, Y, height);
                        this.item.position.position = position;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Yaw: {
                get: function () {
                    return this._postion.Yaw
                },
                set: function (Yaw) {
                    try {
                        this._postion.Yaw = Yaw;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            }
        },
        LabelStyle: {
            BackgroundColor: {
                set: lodash.debounce(function (color) {
                    if (this._core.isnull(color)) return;
                    if (!this._core.isnull(color)) {
                        if (this._core.isHtmlColor(color)) {
                            color = this._Color.colorFromHtmlColor(color);
                        } else {
                            if (/^rgb/.test(color)) {
                                color = this._Color.rgbaStringToRgbaObj(color);
                            }
                            if (color.r > 1) {
                                color.r = color.r / 255;
                            }
                            if (color.g > 1) {
                                color.g = color.g / 255;
                            }
                            if (color.b > 1) {
                                color.b = color.b / 255;
                            }
                            if (color.a > 1) {
                                color.a = color.a / 255;
                            }
                            color = this._Color.createColor(color.r, color.g, color.b, color.a);
                        }
                    }
                    this.item.label.backgroundColor = color;
                    this.item.backgroundColor = color;
                }, 500),
                get: function () {
                    var color = this.item.label.backgroundColor;
                    return this._Color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            },
            Bold: {
                get: function () {
                    var font = this.item._label.font.getValue();
                    return font.indexOf("bold") != -1;
                },
                set: function () {
                    var font = "bold " + this.item._label.font.getValue();
                    this.item._label.font.setValue(font);
                }
            },
            FontName: {
                get: function () {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i] != "bold" && sz[i].indexOf("px") == -1 && sz[i].indexOf("PX") == -1) {
                            return sz[i];
                        }
                    }
                },
                set: function (fontq) {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    var fonts = fontq;
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i] != "bold" && sz[i].indexOf("px") == -1 && sz[i].indexOf("PX") == -1) ; else {
                            fonts = fonts + " " + sz[i];
                        }
                    }
                    this.item._label.font.setValue(fonts);
                }
            },
            FontSize: {
                get: function () {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i].indexOf("px") != -1) {
                            return sz[i];
                        }
                    }
                },
                set: function (fontq) {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    var fonts = fontq;
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i].indexOf("px") == -1) ; else {
                            fonts = fonts + " " + sz[i];
                        }
                    }
                    this.item._label.font.setValue(fonts);
                }
            },
            FrameFileName: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            IconColor: {
                set: lodash.debounce(function (color) {
                    if (this._core.isnull(color)) return;
                    if (!this._core.isnull(color)) {
                        if (this._core.isHtmlColor(color)) {
                            color = this._Color.colorFromHtmlColor(color);
                        } else {
                            if (/^rgb/.test(color)) {
                                color = this._Color.rgbaStringToRgbaObj(color);
                            }
                            if (color.r > 1) {
                                color.r = color.r / 255;
                            }
                            if (color.g > 1) {
                                color.g = color.g / 255;
                            }
                            if (color.b > 1) {
                                color.b = color.b / 255;
                            }
                            if (color.a > 1) {
                                color.a = color.a / 255;
                            }
                            color = this._Color.createColor(color.r, color.g, color.b, color.a);
                        }
                    }
                    this.item.label.fillColor = color;
                    //this.item.fillColor = color;
                }, 500),
                get: function () {
                    var color = this.item.label.fillColor;
                    return this._Color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            },
            Italic: {
                get: function () {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i].indexOf("italic") != -1) {
                            return sz[i];
                        }
                    }
                },
                set: function (fontq) {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    var fonts = fontq;
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i].indexOf("italic") == -1) ; else {
                            fonts = fonts + " " + sz[i];
                        }
                    }
                    this.item._label.font.setValue(fonts);
                }
            },
            LimitScreenSize: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            LineColor: {
                set: lodash.debounce(function (color) {
                    if (this._core.isnull(color)) return;
                    if (!this._core.isnull(color)) {
                        if (this._core.isHtmlColor(color)) {
                            color = this._Color.colorFromHtmlColor(color);
                        } else {
                            if (/^rgb/.test(color)) {
                                color = this._Color.rgbaStringToRgbaObj(color);
                            }
                            if (color.r > 1) {
                                color.r = color.r / 255;
                            }
                            if (color.g > 1) {
                                color.g = color.g / 255;
                            }
                            if (color.b > 1) {
                                color.b = color.b / 255;
                            }
                            if (color.a > 1) {
                                color.a = color.a / 255;
                            }
                            color = this._Color.createColor(color.r, color.g, color.b, color.a);
                        }
                    }
                    this.item.label.outlineColor = color;
                    //this.item.fillColor = color;
                }, 500),
                get: function () {
                    var color = this.item.label.outlineColor;
                    return this._Color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            },
            LineToGround: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            LockMode: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            MaxImageSize: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            MaxViewingHeight: {
                get: function () {
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        return this.item._label.distanceDisplayCondition._value.far;
                    }
                },
                set: function (far) {
                    var near = 0;
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        near = this.item._label.distanceDisplayCondition._value.near;
                    }
                    this.item._label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                }
            },
            MinViewingHeight: {
                get: function () {
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        return this.item._label.distanceDisplayCondition._value.near;
                    }
                },
                set: function (near) {
                    var far = 0;
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        far = this.item._label.distanceDisplayCondition._value.far;
                    }
                    this.item._label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                }
            },
            MultilineJustification: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            PivotAlignment: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            Scale: {
                get: function () {
                    if (this.item._label.scale != undefined) {
                        return this.item.label.scale.getValue();
                    }
                },
                set: function (fontq) {
                    this.item.label.scale.setValue(fontq);
                }
            },
            TextAlignment: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            TextColor: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            TextOnImage: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            Underline: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            }
        }
    });

    /**
     *
     * 创建浏览对象。
     *
     * @alias dynamicObject
     * @constructor
     *
     */
    function dynamicObject(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._getPosition = new getPosition(this._viewer, this._cesium);
        this._tree = tree;
        this._entityFly = null;

    }
    dynamicObject.prototype.executeFlycesium = function (method) {
        var _this = this;
        var PolyLinePrimitive = (function () {
            function execute(positions) {
                this.options = {
                    polyline: {
                        show: true,
                        positions: [],
                        material: new _this._cesium.PolylineGlowMaterialProperty({
                            glowPower: 0.1,
                            color: _this._cesium.Color.YELLOW
                        }),
                        width: 10,
                        clampToGround: true,
                    }
                };
                this.positions = positions;
                this._init();
            }

            execute.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    return _self.positions;
                };
                //实时更新polyline.positions
                this.options.polyline.positions = new _this._cesium.CallbackProperty(_update, false);
                this.flycesium = _this._viewer.entities.add(this.options);
                _this.item = this.flycesium;
            };
            return execute;
        })();
        var handler = this.handler = new _this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var positions = [];
        var distance = 0;
        var poly = undefined;
        var ploylinejl = {
            polyline: {},
            cameraRoll: null,
            cameraPitch: null,
            cameraPosition: null,
            cameraHeading: null,
            positions: [],
            distance: [],
            Totaltime: ""
        };
        //导入tool提示框
        var tooltip = this._core.CreateTooltip();
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);
        handler.setInputAction(function (movement) {
            var cartesian = _this._getPosition.getMousePosition(movement);
            if (_this._core.getBrowser().pc === 'pc' && positions.length == 0) {
                positions.push(cartesian.clone());
            }
            positions.push(cartesian);
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive(positions);
                }
                distance = _this._core.getSpaceDistancem(positions, _this._cesium);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        handler.setInputAction(function (movement) {
            tooltip.showAt(movement.endPosition, "左键开始,右键结束！");
            var cartesian = _this._getPosition.getMousePosition(movement);
            if (positions.length >= 2) {
                if (!_this._cesium.defined(poly)) {
                    poly = new PolyLinePrimitive(positions);
                } else {
                    if (cartesian) {
                        positions.pop();
                        //cartesian.y += (1 + Math.random());
                        positions.push(cartesian);
                    }
                }
                distance = _this._core.getSpaceDistancem(positions, _this._cesium);
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //单击鼠标右键结束画线
        handler.setInputAction(function (movement) {
            _this.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);

        this.end = function (type) {
            handler.destroy();
            tooltip.show(false);
            //设置鼠标样式
            _this._core.mouse(_this._viewer.container, 0);

            _this.end = undefined;
            _this._viewer.entities.remove(_this.item);

            if (type === 'cancel' || positions.length < 2) {
                return;
            }
            distance = _this._core.getSpaceDistancem(positions, _this._cesium);

            ploylinejl.polyline = poly;
            ploylinejl.positions = positions;
            ploylinejl.distance = parseFloat(distance);
            //转化成浏览对象
            _this.setFlycesium(ploylinejl, function (flyceium) {
                _this.flyceium = flyceium;
                _this.ploylinejl = ploylinejl;
                if (typeof method == 'function') {
                    method(flyceium);
                }
            });
        };
        return this;
    };
    /**
     * 设置获取浏览对象
     */
    dynamicObject.prototype.setFlycesium = function (drawHelper, callback) {
        var _this = this;
        var coordinates = [];
        var maxHeight = 0;
        for (var i = 0; i < drawHelper.positions.length; i++) {
            var cartographic = _this._cesium.Cartographic.fromCartesian(drawHelper.positions[i]);//世界坐标转地理坐标（弧度）
            var point = [cartographic.longitude / Math.PI * 180, cartographic.latitude / Math.PI * 180, cartographic.height];//地理坐标（弧度）转经纬度坐标
            //console.log(point);
            coordinates.push(point);
        }
        this._core.getPmfxPro(drawHelper.positions, 25, 0, _this._cesium, _this._viewer, (data) => {
            maxHeight = data.max;
            var time;
            time = (drawHelper.distance / 50).toFixed(1);
            var pathsData = {
                id: _this._core.getuid(),
                name: '新建路线',
                distance: drawHelper.distance,
                showPoint: false,
                showLine: true,
                showModel: true,
                isLoop: false,
                Totaltime: Math.round(time),
                height: (maxHeight + 100).toFixed(2),
                pitch: -20,
                range: 100,
                mode: 0,
                url: window.SmartEarthRootUrl + configData$1.testModel,
                geojson: {
                    // orientation: {heading: heading, pitch: pitch, roll: roll},
                    // position: position,
                    geometry: { type: "LineString", coordinates: coordinates }
                }
            };
            callback && callback(pathsData);
        });
    };
    /**
     * 开始浏览
     */
    dynamicObject.prototype.Start = function (data, url, funs) {
        var _this = this;
        data.geojson;
        if (!data.Totaltime) {
            data.Totaltime = 3000;
        }
        if (_this._entityFly) {
            _this.exit();
        }
        // _this._viewer.camera.setView({
        //     destination: pathsData.position,
        //     orientation: pathsData.orientation,
        // });
        fun = funs;
        setTimeout(function () {
            _this.executeFly3D(data, url);
        }, 200);
        return this;
    };
    var entityFly = null;
    var entityModel = null;
    //var start;
    var fun = null;
    var entityhd = {
        start: null,
        time: null,
        longitude: 0,
        latitude: 0,
        cameraHeight: 100,
        //timedifference: null,
        speed: null,

        position: 0
    };
    var velocityVector, velocityVectorProperty, velocityOrientationProperty;
    var AngleProperty, property;
    var wheelAngle = 0;
    dynamicObject.prototype.executeFly3D = function (data, url) {
        var _this = this;
        var pathsData = data.geojson;
        velocityVector = new _this._cesium.Cartesian3();
        AngleProperty = new _this._cesium.SampledProperty(Number);
        property = new _this._cesium.SampledPositionProperty();

        if (pathsData && pathsData.geometry) {
            var positionA = pathsData.geometry.coordinates;
            var position = [];
            var position1 = [];
            if (positionA.length > 0) {
                for (var i = 0; i < positionA.length; i++) {
                    var x = positionA[i][0];
                    var y = positionA[i][1];
                    var z = positionA[i][2];
                    data.lineHeight !== void 0 && (z = data.lineHeight);
                    position1.push(x, y, z);
                    position.push({ x: x, y: y, z: z });
                }
            } else {
                return;
            }
            entityhd.start = _this._cesium.JulianDate.fromDate(new Date());
            entityhd.stop = _this._cesium.JulianDate.addSeconds(entityhd.start, data.Totaltime, new _this._cesium.JulianDate());
            //Make sure viewer is at the desired time.
            _this._viewer.clock.startTime = entityhd.start.clone();
            _this._viewer.clock.stopTime = entityhd.stop.clone();
            _this._viewer.clock.currentTime = entityhd.start.clone();
            _this._viewer.clock.clockRange = data.isLoop ? _this._cesium.ClockRange.LOOP_STOP : _this._cesium.ClockRange.CLAMPED; //Loop at the end
            _this._viewer.clock.multiplier = 1;
            _this._viewer.clock.canAnimate = false;
            _this._viewer.clock.shouldAnimate = true;//设置时间轴动态效果
            entityhd.Totaltime = data.Totaltime;
            entityhd.distance = data.distance;
            entityhd.cameraHeight = data.height;
            entityhd.lineHeight = data.lineHeight;
            entityhd.pitch = data.pitch;
            entityhd.range = data.range;

            var _position = _this.computeCirclularFlight(position);
            entityhd.position = _position;
            entityhd.degrees = position;
            velocityOrientationProperty = new _this._cesium.VelocityOrientationProperty(_position);

            var mode = {};
            if (url !== "") {
                mode = {
                    show: _this._cesium.defaultValue(data.showModel, true),
                    scale: _this._cesium.defaultValue(data.modelScale, 1),
                    uri: url
                };
            } else {
                mode = {
                    show: _this._cesium.defaultValue(data.showModel, true),
                    scale: _this._cesium.defaultValue(data.modelScale, 1)
                };
            }
            if (data.modelData) {
                mode = _this._core.extend(mode, data.modelData);
            }
            changeFlyView = function () {

            };
            entityFly = _this._viewer.entities.add({
                //Set the entity availability to the same interval as the simulation time.
                availability: new _this._cesium.TimeIntervalCollection([new _this._cesium.TimeInterval({
                    start: entityhd.start,
                    stop: entityhd.stop
                })]),
                position: _position,
                //Show the path as a pink line sampled in 1 second increments.
                polyline: {
                    clampToGround: entityhd.lineHeight === void 0,
                    positions: Cesium.Cartesian3.fromDegreesArrayHeights(position1),
                    show: _this._cesium.defaultValue(data.showLine, true),
                    material: new _this._cesium.PolylineGlowMaterialProperty({
                        glowPower: 0.1,
                        color: _this._cesium.Color.YELLOW
                    }),
                    width: 10
                },
                label: {
                    text: new _this._cesium.CallbackProperty(updateSpeedLabel, false),
                    font: '20px sans-serif',
                    showBackground: false,
                    distanceDisplayCondition: new _this._cesium.DistanceDisplayCondition(0.0, 100.0),
                    eyeOffset: new _this._cesium.Cartesian3(0, 3.5, 0)
                }
            });

            entityModel = _this._viewer.entities.add({
                availability: new _this._cesium.TimeIntervalCollection([new _this._cesium.TimeInterval({
                    start: entityhd.start,
                    stop: entityhd.stop
                })]),
                position: _position,
                orientation: velocityOrientationProperty,
                point: {
                    show: _this._cesium.defaultValue(data.showPoint, false),
                    color: _this._cesium.Color.RED,
                    outlineColor: _this._cesium.Color.WHITE,
                    outlineWidth: 2,
                    pixelSize: 10,
                },
                model: mode,
                billboard: data.image,
                viewFrom: data.viewFrom || new _this._cesium.Cartesian3(500.0, 500.0, 500.0)
            });
            entitymodels = entityFly;
            _this._viewer.trackedEntity = entityModel;
            _this._entityFly = entityFly;

            data.speed && _this.setSpeed(data.speed);
            data.mode && _this.changeFlyMode(data.mode);

            // setTimeout(function () {
            //     // _this._viewer.camera.zoomOut(500.0);//缩小地图，避免底图没有数据
            //     _this._viewer.camera.zoomOut(300.0);//缩小地图，避免底图没有数据
            // }, 100);
        } else {
            return;
        }

        function updateSpeedLabel(time, result) {
            _this._viewer.camera;
            if (_this._viewer.clock.clockRange !== 2 && Cesium.JulianDate.equals(_this._viewer.clock.currentTime, _this._viewer.clock.stopTime)) {
                entityFly.label.text = '';
                _this.exit();
                if (fun != null && typeof fun === 'function') {
                    fun('end');
                }
                changeFlyView = function () {

                };
                return;
            }
            try {
                var position = entitymodels.position.getValue(_this._viewer.clock.currentTime);
                var cartographic = _this._cesium.Cartographic.fromCartesian(position);
                //经度
                entityhd.longitude = _this._cesium.Math.toDegrees(cartographic.longitude);
                //纬度
                entityhd.latitude = _this._cesium.Math.toDegrees(cartographic.latitude);
                if (entityhd.lineHeight === void 0) {
                    let height1 = _this._viewer.scene.sampleHeight(cartographic, [entityModel, entitymodels]);
                    let height2 = _this._viewer.scene.globe.getHeight(cartographic);
                    entityModel.position = _this._cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, height2 > height1 ? height2 : height1);
                }
            } catch (ex) {
            }
            try {
                velocityVectorProperty.getValue(time, velocityVector);
                changeFlyView(time);
                var metersPerSecond = _this._cesium.Cartesian3.magnitude(velocityVector);
                var kmPerHour = Math.round(metersPerSecond * 3.6);
                kmPerHour += ' km/h';
                //已漫游时间
                entityhd.time = _this._cesium.JulianDate.secondsDifference(time, entityhd.start);
                //已漫游比例
                entityhd.ratio = entityhd.time / entityhd.Totaltime;
                //已漫游距离
                entityhd.distanceTraveled = entityhd.ratio * entityhd.distance;
                //运行速度
                entityhd.speed = kmPerHour;
                //漫游高程
                entityhd.height = cartographic.height;
                //地面高程
                entityhd.globeHeight = _this._viewer.scene.globe.getHeight(cartographic);

                if (fun != null && typeof fun === 'function') {
                    fun(entityhd);
                }
            } catch (ex) {
            }
            return "";
        }
    };

    // var hpr = new Cesium.HeadingPitchRoll();
    var flyPosition;
    // var Quaternion = new Cesium.Quaternion();
    // var _heading = 0;
    var entitymodels = null;

    //改变视角
    var changeFlyView;

    function getHeading(time) {
        wheelAngle = AngleProperty.getValue(time);
        entityhd.heading = wheelAngle;
    }

    function getFlyPosition(position) {
        var cartographic = Cesium.Cartographic.fromCartesian(position);
        var lon = Cesium.Math.toDegrees(cartographic.longitude);
        var lat = Cesium.Math.toDegrees(cartographic.latitude);
        return Cesium.Cartesian3.fromDegrees(lon, lat, entityhd.cameraHeight || 100);
    }

    /**
     * 显示点
     */
    dynamicObject.prototype.showPoint = function (isShow) {
        entityModel && entityModel.point && (entityModel.point.show = isShow);
    };

    /**
     * 显示线
     */
    dynamicObject.prototype.showLine = function (isShow) {
        entityFly && entityFly.polyline && (entityFly.polyline.show = isShow);
    };

    /**
     * 显示模型
     */
    dynamicObject.prototype.showModel = function (isShow) {
        entityModel && entityModel.model && (entityModel.model.show = isShow);
    };

    //飞行高度
    dynamicObject.prototype.setFlyHeight = function (height) {
        entityhd.cameraHeight = height;
    };

    //飞行距离
    dynamicObject.prototype.setFlyDistance = function (distance) {
        entityhd.range = distance;
    };

    //飞行俯仰角
    dynamicObject.prototype.setFlyPitch = function (pitch) {
        entityhd.pitch = pitch;
    };

    //飞行模式
    dynamicObject.prototype.changeFlyMode = function (index) {
        var _this = this;
        switch (index) {
            case 0:
                changeFlyView = function () {

                };
                _this.BindingModel(true);
                break;
            case 1:
                this.BindingModel(false);
                changeFlyView = function (time) {
                    getHeading(time);
                    _this.exeuteVisualAngle(_this._cesium.Math.toRadians(entityhd.heading), _this._cesium.Math.toRadians(entityhd.pitch), entityhd.range);
                };
                break;
            case 2:
                this.BindingModel(false);
                changeFlyView = function (time) {
                    getHeading(time);
                    flyPosition = _this._entityFly.position.getValue(_this._viewer.clock.currentTime);
                    if (!flyPosition) return;
                    flyPosition = getFlyPosition(flyPosition);
                    _this._viewer.camera.setView({
                        destination: flyPosition,
                        orientation: {
                            heading: _this._cesium.Math.toRadians(entityhd.heading),
                            pitch: _this._cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    });
                };
                break;
        }
    };

    /**
     * 加速
     */
    dynamicObject.prototype.faster = function () {
        this._viewer.animation.viewModel.faster();
    };

    /**
     * 减速
     */
    dynamicObject.prototype.slower = function () {
        // 倍率减
        this._viewer.animation.viewModel.slower();
    };

    /**
     * 设置速度
     */
    dynamicObject.prototype.setSpeed = function (speed) {
        this._viewer.clock.multiplier = parseFloat(speed);
    };

    /**
     * 是否暂停
     */
    dynamicObject.prototype.isPause = function (isPause) {
        var clockViewModel = this._viewer.clockViewModel;
        clockViewModel.shouldAnimate = !isPause;
    };

    /**
     * 结束飞行
     */
    dynamicObject.prototype.exit = function () {
        this.isPause(true);
        this._viewer.clock.multiplier = 1;
        this.executeSignout();
        this.BindingModel(false);
        this._viewer.entities.remove(entityFly);
        this._viewer.entities.remove(entityModel);
        entityFly = null;
        entityModel = null;
        this._entityFly = null;
    };

    //lable回调函数
    dynamicObject.prototype.updateSpeedLabel = function (time, result) {
        //if (fun && typeof fun === 'function') {
        //    fun(_this._entityFly);
        //}
        //this.entityhd = {
        //    start: null,
        //    time: null
        //};
        //this.entityhd.time = time;
        //if (this.fun != null && typeof fun === 'function') {
        //    fun(_this._entityFly);
        //}
        //return "";
    };

    //添加时间位置样本
    dynamicObject.prototype.computeCirclularFlight = function (position) {
        var _this = this;
        velocityVectorProperty = new _this._cesium.VelocityVectorProperty(property, false);
        var _time, time, _position, _position1;
        for (var i = 0; i < position.length; i++) {
            if (i === 0) {
                //起点
                time = _this._cesium.JulianDate.addSeconds(entityhd.start, 0, new _this._cesium.JulianDate());
                _position = _this._cesium.Cartesian3.fromDegrees(position[0].x, position[0].y, entityhd.lineHeight);

                property.addSample(time, _position);
                //计算两点方位角
                wheelAngle = _this._core.TwoPointAzimuth(position[0].x, position[0].y, position[1].x, position[1].y);
                AngleProperty.addSample(time, wheelAngle);
            }
            try {
                if (i > 0 && i != position.length - 1) {
                    _position = new _this._cesium.Cartesian3(property._property._values[i * 3 - 3], property._property._values[i * 3 - 2], property._property._values[i * 3 - 1]);
                    _position1 = _this._cesium.Cartesian3.fromDegrees(position[i].x, position[i].y, _this._cesium.defaultValue(entityhd.lineHeight, position[i].z));

                    var positions = [_this._cesium.Cartographic.fromCartesian(_position), _this._cesium.Cartographic.fromCartesian(_position1)];
                    var a = new _this._cesium.EllipsoidGeodesic(positions[0], positions[1]);
                    var long = a.surfaceDistance;
                    time = _this._cesium.JulianDate.addSeconds(property._property._times[i - 1], 0.5, new _this._cesium.JulianDate());
                    _time = _this._cesium.JulianDate.addSeconds(property._property._times[i - 1], long / 50, new _this._cesium.JulianDate());

                    property.addSample(_time, _position1);
                    //计算两点方位角
                    wheelAngle = _this._core.TwoPointAzimuth(position[i - 1].x, position[i - 1].y, position[i].x, position[i].y);
                    AngleProperty.addSample(time, wheelAngle);
                    AngleProperty.addSample(_time, wheelAngle);
                }
            } catch (e) {
                console.log(e);
            }
        }
        return property;
    };
    /**
     * 暂停浏览
     */
    dynamicObject.prototype.executePauseFly3DPaths = function () {
        var clockViewModel = this._viewer.clockViewModel;
        if (clockViewModel.shouldAnimate) {
            clockViewModel.shouldAnimate = false;
        } else if (this._viewer.clockViewModel.canAnimate) {
            clockViewModel.shouldAnimate = true;
        }
    };

    /**
     * 添加对象
     */
    dynamicObject.prototype.changeModel = function (url) {
        entityModel.model.uri = url;
    };
    //浏览方式飞向视点
    /**
     * 获取视野点
     */
    dynamicObject.prototype.PointView = function () {
        var originalCameraLocation = {
            position: Viewer.camera.position.clone(),
            orientation: {
                heading: Viewer.camera.heading,
                pitch: Viewer.camera.pitch,
                roll: Viewer.camera.roll,
            }
        };
        return originalCameraLocation;
    };
    /**
     * 开始浏览。
     * @param {Paths}
     * @returns {Object} 返回一个json对象。
     */
    dynamicObject.prototype.PlayPaths = function (Paths) {
        var that = this;
        setInterval(function () {
            viewer.camera.setView({
                // Cesium的坐标是以地心为原点，一向指向南美洲，一向指向亚洲，一向指向北极州
                // fromDegrees()方法，将经纬度和高程转换为世界坐标
                destination: that._cesium.Cartesian3.fromDegrees(117.48, 30.67, 15000.0),
                orientation: {
                    // 指向
                    heading: that._cesium.Math.toRadians(90, 0),
                    // 视角
                    pitch: that._cesium.Math.toRadians(-90),
                    roll: 0.0
                }
            });
        }, 2000);
    };
    /**
     * 绑定模型
     * @param {binding} 是否绑定。
     */
    dynamicObject.prototype.BindingModel = function (binding) {
        if (binding) {
            this._viewer.trackedEntity = entityModel;
        } else {
            this._viewer.trackedEntity = undefined;
            this._viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
        }
    };
    /**
     * 改变视角
     * @returns {Object} 返回一个json对象。
     */
    dynamicObject.prototype.exeuteVisualAngle = function (viewHeading, viewPitch, viewRange) {
        var hpRange = { heading: null, pitch: null, range: null };
        hpRange.heading = viewHeading || this._cesium.Math.toRadians(90);
        hpRange.pitch = viewPitch || this._cesium.Math.toRadians(0);
        hpRange.range = viewRange || 1000;
        var center = this._entityFly.position.getValue(this._viewer.clock.currentTime);
        if (!center) return;
        center = getFlyPosition(center);
        var hpRanges = new this._cesium.HeadingPitchRange(hpRange.heading, hpRange.pitch, hpRange.range);
        //if (center) this._viewer.camera.lookAt(center, hpRange);
        this._viewer.camera.lookAt(center, hpRanges);
    };
    /**
     * 是否显示路线
     * @returns {Object} 返回一个json对象。
     */
    dynamicObject.prototype.Pathshow = function (route) {
        this._entityFly.polyline.show = route;
    };
    /**
     * 是否显示点
     * @returns {Object} 返回一个json对象。
     */
    dynamicObject.prototype.Pointshow = function (route) {
        entityModel._point.show = route;
    };
    /**
     * 是否显示模型
     * @returns {Object} 返回一个json对象。
     */
    dynamicObject.prototype.Modelshow = function (route) {
        entityModel._model.show = route;
    };
    /**
     * 向前飞行漫游路径
     * @returns {Object} 返回一个json对象。
     */
    dynamicObject.prototype.executePlayForwardFly3DPaths = function () {
        var clockViewModel = this._viewer.clockViewModel;
        var multiplier = clockViewModel.multiplier;
        if (multiplier < 0) {
            clockViewModel.multiplier = -multiplier;
        }
        clockViewModel.shouldAnimate = true;
    };
    /**
     * 向后飞行漫游路径
     */
    dynamicObject.prototype.executePlayReverseFly3DPaths = function () {
        var clockViewModel = this._viewer.clockViewModel;
        var multiplier = clockViewModel.multiplier;
        if (multiplier > 0) {
            clockViewModel.multiplier = -multiplier;
        }
        clockViewModel.shouldAnimate = true;
    };
    /**
     * 退出飞行漫游路径
     */
    dynamicObject.prototype.executeSignout = function () {
        var start = this._cesium.JulianDate.fromDate(new Date());
        this._viewer.clock.startTime = start.clone();
        var stop = this._cesium.JulianDate.addSeconds(start, 86400, new this._cesium.JulianDate());
        this._viewer.clock.stopTime = stop.clone();
        //this.cesiumViewer.entities.remove(this.entityFly);
    };

    /**
     * 结束当前操作
     */
    dynamicObject.prototype.forceEndHanlder = function () {
        if (this.handler) {
            this.handler.destroy();
            this.handler = undefined;
        }
    };

    /**
     *
     * 这个方法用于创建圆锥。
     *
     * @alias Cone
     * @constructor
     *
     */
    function Cone(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
        //动态绘制圆柱及圆锥
        this.positions = [];
        this.objId = Number((new Date()).getTime() + "" + Number(Math.random() * 1000).toFixed(0));
        this.handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        this.modifyHandler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        this.style = null;
        this.state = 0; //1为新增 2为编辑 0为清除
        this.gonCircleArr = [];
        //顶部点
        this.gonPointStretchingArr = [];
        this.topRadius = 0;
        this.bottomRadius = 0;
        this.length = 50;
    }

    /**
     * 这个方法用于创建圆锥
     * @param {Array} [position] 一个经纬度数组。
     * @param {object} [cylinder] 对象。对象{
        length: 400000.0,
        topRadius: 0.0,
        bottomRadius: 200000.0,
        material: this._cesium.Color.GREEN
    }
     * @param {String} [name] 圆锥显示的文字。
     * @param {String} [GroupID] 圆锥显示的文字。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Cone.prototype.createCone = function (position, cylinder, name, GroupID) {
        var defaultOption = {
            length: 400000.0,
            topRadius: 0.0,
            bottomRadius: 200000.0,
            material: this._cesium.Color.GREEN
        };
        var options = this._core.extend(defaultOption, cylinder, true);
        this.item = this._viewer.entities.add({
            name: name,
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[1]),
            cylinder: options
        });
        var obj = {
            id: this.item.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'cylinder',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    /**
    * 获取cylinder样式
    */
    Cone.prototype.getstyles = function () {
        var styles = {};
        styles.show = this.item.cylinder.show ? this.item.cylinder.show._value : true;
        styles.length = this.item.cylinder.length ? this.item.cylinder.length.getValue() : undefined;
        styles.topRadius = this.item.cylinder.topRadius ? this.item.cylinder.topRadius.getValue() : undefined;
        styles.bottomRadius = this.item.cylinder.bottomRadius ? this.item.cylinder.bottomRadius.getValue() : undefined;
        styles.heightReference = this.item.cylinder.heightReference && this.item.cylinder.heightReference._value ? this.item.cylinder.heightReference._value : undefined;
        styles.fill = this.item.cylinder.fill && this.item.cylinder.fill._value ? this.item.cylinder.fill._value : undefined;
        styles.material = {};
        styles.material.color = this.item.cylinder.material && this.item.cylinder.material.color && this.item.cylinder.material.color._value ? 'rgba' + this.item.cylinder.material.color.toString() : undefined;
        styles.material.image = this.item.cylinder.material && this.item.cylinder.material.image && this.item.cylinder.material.image._value ? this.item.cylinder.material.image._value : undefined;
        styles.material.repeat = this.item.cylinder.material && this.item.cylinder.material.repeat && this.item.cylinder.material.repeat._value ? this.item.cylinder.material.repeat._value : undefined;
        styles.outline = this.item.cylinder.outline ? this.item.cylinder.outline._value : undefined;
        styles.outlineWidth = this.item.cylinder.outlineWidth && this.item.cylinder.outlineWidth._value ? this.item.cylinder.outlineWidth._value : undefined;
        styles.outlineColor = this.item.cylinder.outlineColor && this.item.cylinder.outlineColor && this.item.cylinder.outlineColor._value ? 'rgba' + this.item.cylinder.outlineColor.toString() + '' : undefined;
        styles.near = this.item.cylinder.distanceDisplayCondition ? this.item.cylinder.distanceDisplayCondition._value.near : undefined;
        styles.far = this.item.cylinder.distanceDisplayCondition ? this.item.cylinder.distanceDisplayCondition._value.far : undefined;
        styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
     * 雷达遮罩动态扫描(半球)
     * @param {Array} [position] 一个经纬度数组。
     * @param {object} [cylinder] 对象。对象{
        radius: 100,  //半径
        angle: 30,  //扫描角度（可选）
        speed: 1,  //倍速（可选）
        stackPartitions: 64,  //横向网格数（可选）
        slicePartitions: 64,  //纵向网格数（可选）
        color: 'rgba(255,255,255,0.5)',  //球颜色（可选）
        outlineColor: 'rgba(255,255,255,0.5)',  //球边框线颜色（可选）
        wallColor: 'rgba(255,255,255,0.5)',   //扫描墙颜色（可选）
        wallOutlineColor: 'rgba(255,0,0,0.5)',   //扫描墙颜色（可选）
        surfaceColor: 'rgba(255,0,0,0.5)',   //扫描夹角颜色（可选）
    }
     * @param {String} [name] 圆锥显示的文字。
     * @param {String} [GroupID] 圆锥显示的文字。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Cone.prototype.createRectangularSensor = function (position, cylinder, name, GroupID) {
        var that = this;
        !cylinder && (cylinder = {});
        var radius = this._core.defaultValue(cylinder.radius, 100);
        var defaultOption = {
            radii: new this._cesium.Cartesian3(radius, radius, radius),
            maximumCone: this._cesium.Math.toRadians(90),
            material: this._cesium.Color.AQUAMARINE.withAlpha(0.3),
            outline: true,
            outlineColor: this._cesium.Color.AQUAMARINE.withAlpha(0.5),
            outlineWidth: 1
        };
        var options = this._core.extend(defaultOption, cylinder, true);
        if (typeof cylinder.color === 'string') {
            options.material = this._cesium.Color.fromCssColorString(cylinder.color);
        }
        if (typeof cylinder.outlineColor === 'string') {
            options.outlineColor = this._cesium.Color.fromCssColorString(cylinder.outlineColor);
        }
        var heading = 0;
        var positionArr1 = this.calcPoints(position[0], position[1], position[2], radius, heading);
        this.wall = [];
        var wall1 = this._viewer.entities.add({
            polygon: {
                hierarchy: new this._cesium.CallbackProperty(function () {
                    return new that._cesium.PolygonHierarchy(that._cesium.Cartesian3.fromDegreesArrayHeights(positionArr1));
                }, false),
                perPositionHeight: true,
                material: this._core.defaultValue(cylinder.wallColor && this._cesium.Color.fromCssColorString(cylinder.wallColor), this._cesium.Color.AQUAMARINE.withAlpha(0.5)),
                outline: true,
                outlineColor: this._core.defaultValue(cylinder.wallOutlineColor && this._cesium.Color.fromCssColorString(cylinder.wallOutlineColor), this._cesium.Color.RED.withAlpha(0.5))
            }
        });
        this.wall.push(wall1);
        if (options.angle) {
            var positionArr2 = this.calcPoints(position[0], position[1], position[2], radius, heading + options.angle);
            var wall2 = this._viewer.entities.add({
                polygon: {
                    hierarchy: new this._cesium.CallbackProperty(function () {
                        return new that._cesium.PolygonHierarchy(that._cesium.Cartesian3.fromDegreesArrayHeights(positionArr2));
                    }, false),
                    perPositionHeight: true,
                    material: this._core.defaultValue(cylinder.wallColor && this._cesium.Color.fromCssColorString(cylinder.wallColor), this._cesium.Color.AQUAMARINE.withAlpha(0.5)),
                    outline: true,
                    outlineColor: this._core.defaultValue(cylinder.wallOutlineColor && this._cesium.Color.fromCssColorString(cylinder.wallOutlineColor), this._cesium.Color.RED.withAlpha(0.5))
                }
            });
            this.wall.push(wall2);
            var surface = this._viewer.entities.add({
                position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]),
                ellipsoid: {
                    radii: options.radii,
                    minimumClock: this._cesium.Math.toRadians(0.0),
                    maximumClock: this._cesium.Math.toRadians(options.angle),
                    maximumCone: this._cesium.Math.toRadians(90.0),
                    material: this._core.defaultValue(cylinder.surfaceColor && this._cesium.Color.fromCssColorString(cylinder.surfaceColor), this._cesium.Color.RED.withAlpha(0.5))
                },
                orientation: new that._cesium.CallbackProperty(function () {
                    return that._cesium.Transforms.headingPitchRollQuaternion(
                        that._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]),
                        new that._cesium.HeadingPitchRoll(
                            that._cesium.Math.toRadians(-heading),
                            0,
                            0
                        )
                    );
                }, false),
            });
            this.wall.push(surface);
        }
        this.item = this._viewer.entities.add({
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]),
            ellipsoid: options
        });
        var speed = this._core.defaultValue(options.speed, 1);
        // 执行动画效果
        this._viewer.clock.onTick.addEventListener(function () {
            heading += 0.1 * speed;
            positionArr1 = that.calcPoints(position[0], position[1], position[2], radius, heading);
            positionArr2 && (positionArr2 = that.calcPoints(position[0], position[1], position[2], radius, heading + options.angle));
        });
        var obj = {
            id: this.item.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'cylinder',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    // 根据两个点 开始角度、夹角度 求取立面的扇形
    Cone.prototype.computeCirclularFlight = function (x1, y1, x2, y2, height, fx, angle) {
        var positionArr = [];
        positionArr.push(x1);
        positionArr.push(y1);
        positionArr.push(height);
        var radius = this._cesium.Cartesian3.distance(this._cesium.Cartesian3.fromDegrees(x1, y1, height), this._cesium.Cartesian3.fromDegrees(x2, y2, height));
        for (var i = fx; i <= fx + angle; i++) {
            var h = radius * Math.sin(i * Math.PI / 180.0);
            var r = Math.cos(i * Math.PI / 180.0);
            var x = (x2 - x1) * r + x1;
            var y = (y2 - y1) * r + y1;
            positionArr.push(x);
            positionArr.push(y);
            positionArr.push(h + height);
        }
        return positionArr;
    };
    // 根据第一个点 偏移距离 角度 求取第二个点的坐标
    Cone.prototype.calcPoints = function (x1, y1, z1, radius, heading) {
        var m = this._cesium.Transforms.eastNorthUpToFixedFrame(this._cesium.Cartesian3.fromDegrees(x1, y1, z1));
        var rx = radius * Math.cos(heading * Math.PI / 180.0);
        var ry = radius * Math.sin(heading * Math.PI / 180.0);
        var translation = this._cesium.Cartesian3.fromElements(rx, ry, 0);
        var d = this._cesium.Matrix4.multiplyByPoint(m, translation, new this._cesium.Cartesian3());
        var c = this._cesium.Cartographic.fromCartesian(d);
        var x2 = this._cesium.Math.toDegrees(c.longitude);
        var y2 = this._cesium.Math.toDegrees(c.latitude);
        return this.computeCirclularFlight(x1, y1, x2, y2, z1, 0, 90);
    };
    /**
     * 雷达遮罩动态扫描(自定义)
     * @param {String} [name] 雷达显示的文字。
     * @param {Array} [position] 一个经纬度数组。
     * @param {object} [option] 雷达参数。对象{
        radius: 100,  //半径
        yaw: 0,  //雷达方向（可选）
        angle: 60,  //雷达夹角（可选）
        scanAngle: 15,  //扫描夹角（可选）
        speed: 1,  //倍速（可选）
        maxLat: 105,  //下维度（可选）
        minLat: 75,  //上维度（可选）
        stackPartitions: 64,  //横向网格数（可选）
        slicePartitions: 64,  //纵向网格数（可选）
        color: 'rgba(255,255,255,0.5)',  //雷达遮罩颜色（可选）
        outlineColor: 'rgba(255,255,255,0.5)',  //雷达遮罩边框线颜色（可选）
        scanColor: 'rgba(255,0,0,0.5)',   //扫描颜色（可选）
     }
     * @param {String} [GroupID] GroupID。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Cone.prototype.createRadarMaskScan = function (name, position, option, GroupID) {
        !option && (option = {});
        var radius = this._core.defaultValue(option.radius, 100);
        var yaw = this._core.defaultValue(option.yaw, 0);
        var angle = this._core.defaultValue(option.angle, 60);

        var innerOutline = option.innerOutline;
        var defaultOption = {
            innerRadii: new this._cesium.Cartesian3(2.0, 2.0, 2.0),
            radii: new Cesium.CallbackProperty(function () {
                return new Cesium.Cartesian3(radius, radius, radius);
            }, false),
            maximumCone: this._cesium.Math.toRadians(this._core.defaultValue(option.maxLat, 105)),
            minimumCone: this._cesium.Math.toRadians(this._core.defaultValue(option.minLat, 75)),
            minimumClock: new Cesium.CallbackProperty(function () {
                return Cesium.Math.toRadians(yaw);
            }, false),
            maximumClock: new Cesium.CallbackProperty(function () {
                return Cesium.Math.toRadians(yaw + angle);
            }, false),
            material: this._cesium.Color.AQUAMARINE.withAlpha(0.3),
            outline: !innerOutline,
            outlineColor: this._cesium.Color.AQUAMARINE.withAlpha(0.5),
            outlineWidth: 1
        };
        var options = this._core.extend(defaultOption, option, true);
        if (typeof option.color === 'string') {
            options.material = this._cesium.Color.fromCssColorString(option.color);
        }
        if (typeof option.outlineColor === 'string') {
            options.outlineColor = this._cesium.Color.fromCssColorString(option.outlineColor);
        }

        var heading = 0;
        var scanAngle = this._core.defaultValue(option.scanAngle, 15);
        this._scan = this._viewer.entities.add({
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]),
            ellipsoid: {
                ...options,
                minimumClock: new Cesium.CallbackProperty(function () {
                    return Cesium.Math.toRadians(yaw + heading);
                }, false),
                maximumClock: new Cesium.CallbackProperty(function () {
                    return Cesium.Math.toRadians(yaw + heading + scanAngle);
                }, false),
                outline: innerOutline,
                material: this._core.defaultValue(option.scanColor && this._cesium.Color.fromCssColorString(option.scanColor), this._cesium.Color.RED.withAlpha(0.5))
            }
        });

        this.item = this._viewer.entities.add({
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]),
            ellipsoid: options
        });
        var speed = this._core.defaultValue(options.speed, 1);
        // 执行动画效果
        function RadarMaskEvent() {
            heading += 0.1 * speed;
            if (heading <= 0 && speed < 0) {
                heading = 0;
                speed = -speed;
            } else if (heading >= angle - scanAngle && speed > 0) {
                heading = angle - scanAngle;
                speed = -speed;
            }
        }
        this._viewer.clock.onTick.addEventListener(RadarMaskEvent);
        this.setRadarMaskValue = (type, value) => {
            if (type === "yaw") {
                yaw = value;
            } else if (type === "angle") {
                angle = value > 360 ? 360 : value;
            } else if (type === "radius") {
                radius = value;
            } else if (type === "scanAngle") {
                scanAngle = value > angle ? angle : value;
            } else if (type === "speed") {
                speed = value;
            }
        };
        this.deleteObject = () => {
            let _viewer = this._viewer;
            _viewer.entities.remove(this.item);
            _viewer.entities.remove(this._scan);
            this._viewer.clock.onTick.removeEventListener(RadarMaskEvent);
        };
        var obj = {
            id: this.item.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ellipsoid',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 雷达视角(自定义)
     * @param {String} [name] 雷达显示的文字。
     * @param {Array} [position] 一个经纬度数组。
     * @param {object} [option] 雷达参数。对象{
        radius: 100,  //半径
        yaw: 0,  //雷达方向（可选）
        angle: 60,  //雷达夹角（可选）
        scanAngle: 15,  //扫描夹角（可选）
        speed: 1,  //倍速（可选）
        maxLat: 105,  //下维度（可选）
        minLat: 75,  //上维度（可选）
        stackPartitions: 64,  //横向网格数（可选）
        slicePartitions: 64,  //纵向网格数（可选）
        color: 'rgba(255,255,255,0.5)',  //雷达遮罩颜色（可选）
        outlineColor: 'rgba(255,255,255,0.5)',  //雷达遮罩边框线颜色（可选）
        scanColor: 'rgba(255,0,0,0.5)',   //扫描颜色（可选）
     }
     * @param {String} [GroupID] GroupID。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Cone.prototype.createRadarMask = function (name, position, option, GroupID) {
        !option && (option = {});
        var radius = this._core.defaultValue(option.radius, 100);
        var yaw = this._core.defaultValue(option.yaw, 0);
        var angle = this._core.defaultValue(option.angle, 60);

        var defaultOption = {
            innerRadii: new this._cesium.Cartesian3(2.0, 2.0, 2.0),
            radii: new this._cesium.Cartesian3(radius, radius, radius),
            maximumCone: this._cesium.Math.toRadians(this._core.defaultValue(option.maxLat, 105)),
            minimumCone: this._cesium.Math.toRadians(this._core.defaultValue(option.minLat, 75)),
            minimumClock: this._cesium.Math.toRadians(yaw),
            maximumClock: this._cesium.Math.toRadians(yaw + angle),
            material: this._cesium.Color.AQUAMARINE.withAlpha(0.3),
            outline: false,
            outlineColor: this._cesium.Color.AQUAMARINE.withAlpha(0.5),
            outlineWidth: 1
        };
        var options = this._core.extend(defaultOption, option, true);
        if (typeof option.color === 'string') {
            options.material = this._cesium.Color.fromCssColorString(option.color);
        }
        if (typeof option.outlineColor === 'string') {
            options.outlineColor = this._cesium.Color.fromCssColorString(option.outlineColor);
        }

        this.item = this._viewer.entities.add({
            position: position,
            ellipsoid: options
        });

        var obj = {
            id: this.item.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ellipsoid',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
    * 这个方法用于创建雷达
    * @param {Array} [position] 一个经纬度数组。
    * @param {object} [cylinder] 对象。对象{
       length: 400000.0,
       topRadius: 0.0,
       bottomRadius: 200000.0,
       material: this._cesium.Color.GREEN
    }
    * @param {String} [name] 圆锥显示的文字。
    * @param {String} [GroupID] 圆锥显示的文字。
    * @returns {Promise.<Object>} 返回一个Cesium的对象。
    */
    Cone.prototype.createConeRadar = function (position, option) {
        !option && (option = {});
        var that = this;
        that.lon = position[0];
        that.lat = position[1];
        that.height = this._core.defaultValue(position[2], 3000);
        //创建雷达所需参数
        this.planePosition = null;
        this.halfLen = that.height / 2;
        this.lengthl = that.height;
        //根据圆锥中心点位置动态计算朝向、圆锥体长度
        this.geoD = new this._cesium.EllipsoidGeodesic();
        //顶点经纬度
        this.startPt = this._cesium.Cartographic.fromDegrees(that.lon, that.lat, 0);
        this.changenum = 0;
        this.curCanvas = 'a';
        var globeheight = this._viewer.scene.globe.getHeight(this.startPt) || 0;
        this._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, "#0000ff"));
        //改变圆锥体位置，循环画矩形
        function changePosition() {
            if (that.lon > position[0] + 0.01 && that.lat < position[1] + 0.005) {
                that.lat += 0.00001;
            } else if (that.lat > position[1] + 0.005 && that.lon > position[0]) {
                that.lon -= 0.00001;
            } else if (that.lon <= position[0] && that.lat > position[1]) {
                that.lat -= 0.00001;
            } else {
                that.lon += 0.00001;
            }
            that.planePosition = that._cesium.Cartesian3.fromDegrees(that.lon, that.lat, that.height / 2);
            return that.planePosition;
        }
        function changeOrientation() {
            //计算经度方向的夹角
            var endX = Cesium.Cartographic.fromDegrees(that.lon, position[1], 0);
            that.geoD.setEndPoints(that.startPt, endX);
            var innerS = that.geoD.surfaceDistance;
            var angleX = Math.atan(innerS / that.halfLen);

            //计算圆锥体长度
            var end = Cesium.Cartographic.fromDegrees(that.lon, that.lat, 0);
            that.geoD.setEndPoints(that.startPt, end);
            innerS = that.geoD.surfaceDistance;
            that.lengthl = Math.sqrt(innerS * innerS + that.halfLen * that.halfLen);

            //计算纬度方向的夹角
            var endY = Cesium.Cartographic.fromDegrees(position[0], that.lat, 0);
            that.geoD.setEndPoints(that.startPt, endY);
            innerS = that.geoD.surfaceDistance;
            var angleY = Math.asin(innerS / that.lengthl);

            //计算朝向
            var hpr = new Cesium.HeadingPitchRoll(0.0, angleX, angleY);
            var orientation = Cesium.Transforms.headingPitchRollQuaternion(that.planePosition, hpr);

            return orientation
        }
        function changeLength() {
            return 2 * that.lengthl;
        }

        //创建圆锥实体
        this.item = this._viewer.entities.add({
            name: 'Red cone',
            position: option.rotate ? new this._cesium.CallbackProperty(changePosition, false) : that._cesium.Cartesian3.fromDegrees(that.lon, that.lat, (that.height + globeheight) / 2),
            orientation: option.rotate ? new this._cesium.CallbackProperty(changeOrientation, false) : undefined,
            cylinder: {
                length: option.rotate ? new that._cesium.CallbackProperty(changeLength, false) : that.height - globeheight,
                topRadius: 0.0,
                bottomRadius: that._core.defaultValue(option.radius, 300.0),
                //topSurface: false,    //新增参数，控制顶部是否渲染
                bottomSurface: false,    //新增参数，控制底部是否渲染
                material: that._core.getConeRadarMaterial(option.color)
            }
        });

        var obj = {
            id: this._core.getuid(),
            name: '新建卫星雷达',
            pId: 0,
            type: 'ConeRadar',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);
        return this;
    };
    /**
     * 设置CylinderGraphics的圆柱长度的数字属性
     * @param {Object} [CylinderGraphics] CylinderGraphics对象
     * @param {String} [length] 长度。
     * @returns {Object} 返回一个CylinderGraphics对象。
     */
    Cone.prototype.setLength = function (length) {
        try {
            this.item._cylinder.length = length;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 向三维场景中添加圆柱(可编辑，升级版)。
     * @param {Object} [option] 圆柱参数
     * @param {function} [method] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Cone.prototype.createCylinderOptimization = function (option, method) {
        this.style = option;
        var that = this;
        this.handler.setInputAction(function (evt) { //单机开始绘制
            var cartesian = that.getCatesian3FromPX(evt.position, that._viewer, [that.circle]);
            if (that.positions.length == 0) {
                that.positions.push(cartesian.clone());
            }
            that.positions.push(cartesian);
            var point = that.createPoint(cartesian, false);
            if (that.gonCircleArr.length > 0) {
                that.positions.pop();
                that.state = 1;
                that.handler.destroy();
            }
            //if (this.topRadius==0) {
            //创建体
            var pointStretching = that.createPointStretching(cartesian, false);
            pointStretching.wq = that.gonCircleArr.length;
            that.gonPointStretchingArr.push(pointStretching);
            //}
            point.wz = that.gonCircleArr.length;
            that.gonCircleArr.push(point);
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        this.handler.setInputAction(function (evt) { //移动时绘制面
            if (that.positions.length < 1) return;
            var cartesian = that.getCatesian3FromPX(evt.endPosition, that._viewer, [that.circle]);
            if (that.positions.length == 2) {
                if (!that._cesium.defined(that.circle)) {
                    //计算距离
                    var cartographic1 = that._cesium.Cartographic.fromCartesian(that.positions[0]);
                    var lon1 = that._cesium.Math.toDegrees(cartographic1.longitude);
                    var lat1 = that._cesium.Math.toDegrees(cartographic1.latitude);
                    var cartographic2 = that._cesium.Cartographic.fromCartesian(that.positions[1]);
                    var lon2 = that._cesium.Math.toDegrees(cartographic2.longitude);
                    var lat2 = that._cesium.Math.toDegrees(cartographic2.latitude);
                    that.topRadius = Cdcl(lat1, lon1, lat2, lon2);
                    that.bottomRadius = Cdcl(lat1, lon1, lat2, lon2);
                    that.circle = that.createCylinder(that.style);
                    that._core.Entityadd(that);
                    that.circle.objId = that.objId;
                }
            }
            if (that.circle) {
                that.positions.pop();
                that.positions.push(cartesian);
                var cartographic1 = that._cesium.Cartographic.fromCartesian(that.positions[0]);
                var lon1 = that._cesium.Math.toDegrees(cartographic1.longitude);
                var lat1 = that._cesium.Math.toDegrees(cartographic1.latitude);
                var cartographic2 = that._cesium.Cartographic.fromCartesian(that.positions[1]);
                var lon2 = that._cesium.Math.toDegrees(cartographic2.longitude);
                var lat2 = that._cesium.Math.toDegrees(cartographic2.latitude);
                that.topRadius = Cdcl(lat1, lon1, lat2, lon2);
                that.bottomRadius = Cdcl(lat1, lon1, lat2, lon2);
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
    };
    /**
     *动态标会
     *绑定鼠标
     */
    Cone.prototype.startModify = function () {
        var tooltip = "拖动修改位置";
        if (this.state != 2 && this.state != 1) return; //表示还没绘制完成
        if (!this.modifyHandler) this.modifyHandler = new Cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        var $this = this;
        for (var i = 0; i < $this.gonCircleArr.length; i++) {
            var point = $this.gonCircleArr[i];
            if (point) point.show = true;
        }
        //体点
        if ($this.gonPointStretchingArr.length > 0) {
            for (var i = 0; i < $this.gonPointStretchingArr.length; i++) {
                var point = $this.gonPointStretchingArr[i];
                if (point) point.show = true;
            }
        }
        this.modifyHandler.setInputAction(function (evt) {
            var pick = $this._viewer.scene.pick(evt.position);
            if (Cesium.defined(pick) && pick.id) {
                if (!pick.id.objId) {
                    $this.modifyPoint = pick.id;
                    tooltip = "释放后完成修改";
                }
                $this.forbidDrawWorld(true);
            } else {
                for (var i = 0; i < $this.gonCircleArr.length; i++) {
                    var point = $this.gonCircleArr[i];
                    if (point) point.show = false;
                }
                //体点
                if ($this.gonPointStretchingArr.length > 0) {
                    for (var i = 0; i < $this.gonPointStretchingArr.length; i++) {
                        var point = $this.gonPointStretchingArr[i];
                        if (point) point.show = false;
                    }
                }
                if ($this.modifyHandler) {
                    $this.modifyHandler.destroy();
                    $this.modifyHandler = null;
                }
            }
            $this.state = 2;
        }, Cesium.ScreenSpaceEventType.LEFT_DOWN);
        this.modifyHandler.setInputAction(function (evt) { //移动时绘制线
            //提示框
            var pick = $this._viewer.scene.pick(evt.endPosition);
            $this._core.CreateTooltip(tooltip, evt.endPosition, false);
            if (Cesium.defined(pick) && pick.id) {
                if (!pick.id.objId) {
                    $this._core.CreateTooltip(tooltip, evt.endPosition, true);
                }
            }
            //
            if ($this.positions.length < 1 || !$this.modifyPoint) return;
            var cartesian = $this.getCatesian3FromPX(evt.endPosition, $this._viewer, [$this.circle, $this.modifyPoint]);
            if (cartesian) {
                if ($this.modifyPoint.wq != undefined) {
                    var position = { x: cartesian.x, y: cartesian.y, z: cartesian.z + +$this.length };
                    $this.positions[$this.modifyPoint.wq] = cartesian;
                    if ($this.modifyPoint.wq == 0) {
                        $this.modifyPoint.position.setValue(position);
                        $this.gonCircleArr[$this.modifyPoint.wq].position = cartesian;
                        //var cartesians1 = { x: cartesian.x, y: cartesian.y, z: cartesian.z + $this.length };
                        //$this.modifyPoint.position.setValue(cartesians1);
                        //$this.gonCircleArr[1].position = { x: $this.positions[0].x + $this.radius, y: $this.positions[0].y, z: $this.positions[0].z };
                        //$this.gonPointStretchingArr[1].position = { x: $this.positions[0].x + $this.radius, y: $this.positions[0].y, z: $this.positions[0].z + $this.length };
                    } else {
                        var endcartesians = $this._viewer.scene.pickPosition(evt.endPosition);
                        var cartographic1 = $this._cesium.Cartographic.fromCartesian(endcartesians);
                        var lon1 = $this._cesium.Math.toDegrees(cartographic1.longitude);
                        var lat1 = $this._cesium.Math.toDegrees(cartographic1.latitude);
                        var cartographic2 = $this._cesium.Cartographic.fromCartesian($this.positions[1]);
                        var lon2 = $this._cesium.Math.toDegrees(cartographic2.longitude);
                        var lat2 = $this._cesium.Math.toDegrees(cartographic2.latitude);
                        $this.length = Cdcl(lat1, lon1, lat2, lon2);
                        var cartographicx1 = $this._cesium.Cartographic.fromCartesian($this.gonCircleArr[0].position.getValue());
                        var lonx1 = $this._cesium.Math.toDegrees(cartographicx1.longitude);
                        var latx1 = $this._cesium.Math.toDegrees(cartographicx1.latitude);
                        var heightx1 = cartographicx1.height + $this.length;
                        var positionPont1 = $this._cesium.Cartesian3.fromDegrees(lonx1, latx1, heightx1);

                        var cartographicx2 = $this._cesium.Cartographic.fromCartesian($this.gonCircleArr[1].position.getValue());
                        var lonx2 = $this._cesium.Math.toDegrees(cartographicx2.longitude);
                        var latx2 = $this._cesium.Math.toDegrees(cartographicx2.latitude);
                        var heightx2 = cartographicx2.height + $this.length;
                        var positionPont2 = $this._cesium.Cartesian3.fromDegrees(lonx2, latx2, heightx2);
                        $this.gonPointStretchingArr[0].position.setValue(positionPont1);
                        $this.gonPointStretchingArr[1].position.setValue(positionPont2);
                    }

                } else {
                    $this.modifyPoint.position.setValue(cartesian);
                    $this.positions[$this.modifyPoint.wz] = cartesian;
                    $this.gonPointStretchingArr[$this.modifyPoint.wz].position = { x: cartesian.x, y: cartesian.y, z: cartesian.z + $this.length };
                    if ($this.modifyPoint.wz && $this.modifyPoint.wz == 0) {
                        //var cartographic1 = $this._cesium.Cartographic.fromCartesian($this.positions[0]);
                        //var lon1 = $this._cesium.Math.toDegrees(cartographic1.longitude + $this.radius);
                        //var lat1 = $this._cesium.Math.toDegrees(cartographic1.latitude);
                        $this.gonCircleArr[1].position = { x: $this.positions[0].x + $this.topRadius, y: $this.positions[0].y, z: $this.positions[0].z };
                        $this.gonPointStretchingArr[1].position = { x: $this.positions[0].x + $this.topRadius, y: $this.positions[0].y, z: $this.positions[0].z + $this.length };
                    } else {
                        var cartographic1 = $this._cesium.Cartographic.fromCartesian($this.positions[0]);
                        var lon1 = $this._cesium.Math.toDegrees(cartographic1.longitude);
                        var lat1 = $this._cesium.Math.toDegrees(cartographic1.latitude);
                        var cartographic2 = $this._cesium.Cartographic.fromCartesian($this.positions[$this.modifyPoint.wz]);
                        var lon2 = $this._cesium.Math.toDegrees(cartographic2.longitude);
                        var lat2 = $this._cesium.Math.toDegrees(cartographic2.latitude);
                        $this.topRadius = Cdcl(lat1, lon1, lat2, lon2);
                        $this.bottomRadius = Cdcl(lat1, lon1, lat2, lon2);
                    }
                }

            }
            $this._core.CreateTooltip(tooltip, evt.endPosition, true);
        }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
        this.modifyHandler.setInputAction(function (evt) {
            if (!$this.modifyPoint) return;
            $this.modifyPoint = null;
            $this.forbidDrawWorld(false);
            tooltip = "拖动修改位置";
        }, Cesium.ScreenSpaceEventType.LEFT_UP);
    };
    Cone.prototype.forbidDrawWorld = function (isForbid) {
        this._viewer.scene.screenSpaceCameraController.enableRotate = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableTilt = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableTranslate = !isForbid;
        this._viewer.scene.screenSpaceCameraController.enableInputs = !isForbid;
    };
    Cone.prototype.getCatesian3FromPX = function (px, viewer, entitys) {
        var pick = viewer.scene.pick(px);
        var cartesian;
        var drillPick = viewer.scene.drillPick(px);
        var truePick = null;
        if (entitys) {
            for (var i = 0; i < drillPick.length; i++) {
                if (drillPick[i].id._id != entitys[0].id && drillPick[i].id._id != entitys[1].id) {
                    truePick = drillPick[i].id;
                    break;
                }
            }
        } else {
            truePick = pick;
        }
        if (viewer.scene.pickPositionSupported && Cesium.defined(truePick)) {
            cartesian = viewer.scene.pickPosition(px);
        } else {
            var ray = viewer.camera.getPickRay(px);
            if (!ray) return;
            cartesian = viewer.scene.globe.pick(ray, viewer.scene);
        }
        return cartesian;
    };
    //创建对象
    Cone.prototype.createCylinder = function (obj) {
        var $this = this;
        if (obj.length) {
            $this.length = obj.length;
        }
        return this._viewer.entities.add({
            position: new $this._cesium.CallbackProperty(function () {
                //圆柱半径
                return $this.positions[0];
            }, false),
            cylinder: {
                topRadius: new $this._cesium.CallbackProperty(function () {
                    //半径 两点间距离
                    return $this.topRadius;
                }, false),
                bottomRadius: new $this._cesium.CallbackProperty(function () {
                    return $this.bottomRadius;
                }, false),
                length: new $this._cesium.CallbackProperty(function () {
                    return $this.length;
                }, false),
                material: obj.material || Cesium.Color.WHITE
            }

        });
    };
    //动态绘制圆柱点
    Cone.prototype.createPoint = function (position, show) {
        if (!position) return;
        return this._viewer.entities.add({
            position: position,
            point: {
                pixelSize: 10,
                color: this._cesium.Color.ROYALBLUE,
                outlineWidth: 2,
                outlineColor: this._cesium.Color.WHITE,
                heightReference: this._cesium.HeightReference.CLAMP_TO_GROUND,
                disableDepthTestDistance: Number.POSITIVE_INFINITY
            },
            show: show
        });
    };
    Cone.prototype.createPointStretching = function (position, show) {
        if (!position) return;
        var cartographic = Cesium.Cartographic.fromCartesian(position);
        var lon = Cesium.Math.toDegrees(cartographic.longitude);
        var lat = Cesium.Math.toDegrees(cartographic.latitude);
        var height = cartographic.height + this.length;
        position = Cesium.Cartesian3.fromDegrees(lon, lat, height);
        return this._viewer.entities.add({
            position: position,
            point: {
                pixelSize: 10,
                color: Cesium.Color.fromAlpha(Cesium.Color.FUCHSIA, 0.5),
                outlineWidth: 2,
                outlineColor: Cesium.Color.fromAlpha(Cesium.Color.WHITE, 0.5),
                heightReference: Cesium.HeightReference.NONE,
                disableDepthTestDistance: Number.POSITIVE_INFINITY
            },
            show: show
        });
    },
        /**
         * cylinder导出工程数据
         */
        Cone.prototype.export = function () {
            var show = this.item.show == undefined ? undefined : this.item.show;
            var length = this.item.cylinder.length == undefined ? undefined : this.item.cylinder.length.getValue();
            var topRadius = this.item.cylinder.topRadius == undefined ? undefined : this.item.cylinder.topRadius.getValue();
            var bottomRadius = this.item.cylinder.bottomRadius == undefined ? undefined : this.item.cylinder.bottomRadius.getValue();
            var fill = this.item.cylinder.fill == undefined ? undefined : this.item.cylinder.fill.getValue();
            var material = this.item.cylinder.material;
            if (material != undefined) {
                material = {
                    color: material.color == undefined ? undefined : 'rgba(' + material.color._value.red + ',' + material.color._value.green + ',' + material.color._value.blue + ',' + material.color._value.alpha + ')',
                    image: material.image == undefined ? undefined : material.image._value,
                    diffusemap: material.diffusemap == undefined ? undefined : material.diffusemap._value,
                    alphamap: material.alphamap == undefined ? undefined : material.alphamap._value
                };
            }
            var outline = this.item.cylinder.outline == undefined ? undefined : this.item.cylinder.outline._value;
            var outlineColor = this.item.cylinder.outlineColor == undefined ? undefined : 'rgba(' + this.item.cylinder.outlineColor._value.red + ',' + this.item.cylinder.outlineColor._value.green + ',' + this.item.cylinder.outlineColor._value.blue + ',' + this.item.cylinder.outlineColor._value.alpha + ')';
            var outlineWidth = this.item.cylinder.outlineWidth == undefined ? undefined : this.item.cylinder.outlineWidth._value;
            var numberOfVerticalLines = this.item.cylinder.numberOfVerticalLines == undefined ? undefined : this.item.cylinder.numberOfVerticalLines._value;
            var slices = this.item.cylinder.slices == undefined ? undefined : this.item.cylinder.slices._value;
            var distanceDisplayCondition = this.item.cylinder.distanceDisplayCondition;
            var near = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.near;
            var far = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.far;

            var catographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
            var longitude = this._cesium.Math.toDegrees(catographic.longitude);
            var latitude = this._cesium.Math.toDegrees(catographic.latitude);
            var height = this._cesium.Math.toDegrees(catographic.height);
            return {
                type: 'cylinder',
                position: {
                    x: longitude,
                    y: latitude,
                    z: height
                },
                treeobj: { id: this.treeobj.id, name: this.treeobj.name, pId: this.treeobj.pId, type: this.treeobj.type },
                style: {
                    show: show,
                    length: length,
                    topRadius: topRadius,
                    bottomRadius: bottomRadius,
                    fill: fill,
                    material: material,
                    outline: outline,
                    outlineColor: outlineColor,
                    outlineWidth: outlineWidth,
                    numberOfVerticalLines: numberOfVerticalLines,
                    slices: slices,
                    near: near,
                    far: far
                }
            };
        };
    //工程树添加
    Cone.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    Cone.prototype.setVisibility = function (b) {
        this.item.show = b;
        this._scan && (this._scan.show = b);
        if (this.wall) {
            this.wall.forEach(item => {
                item.show = b;
            });
        }
    };
    /**
     * 获取体积
     * @param {Object} [cylinder] cylinder对象
     * @returns {m3} 返回体积。
     */
    Cone.prototype.getVolume = function () {
        try {
            var tj = 0.0;
            //底面半径
            var ckg = this.item._cylinder.bottomRadius;
            //顶面半径
            var dckg = this.item._cylinder.topRadius;
            //高度
            var length = this.item._cylinder.length;
            //判断是圆锥还是圆柱
            if (ckg == 0) {
                tj = (3.14159 * ckg * ckg * length) / 3;
            } else {
                tj = 3.14159 * ckg * ckg * length;
            }
        } catch (ex) {
            console.log(ex);
        }
        return tj;
    };
    /**
     * 向三维场景中添加锥。
     * @param {object} [method] 回调函数
     *
     */
    Cone.prototype.executeCone = function (method) {
        //创建圆锥和可以创建在高程上
        //var polylines = {};
        var _this = this;
        _this.shape = {
            tempPoints: [],
            button: 0,
            position: {}
        };

        var handler = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var positions = [];
        var tempPoints = [];
        //鼠标左键单击画点
        handler.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.position, _this._viewer.scene.globe.ellipsoid);
            var cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
            var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
            var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
            tempPoints.push({ lon: longitudeString, lat: latitudeString });
            var ploylinejl = { polyline: {}, positions: [], distance: [] };
            if (_this.shape.button == 0) {
                positions.push(cartesian.clone());
                positions.push(cartesian);
                _this.shape.position = cartesian;
                _this.cylinder = _this._viewer.entities.add({
                    name: "",
                    //position: _this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[1]),
                    position: _this._cesium.Cartesian3.fromDegrees(tempPoints[0].lon, tempPoints[0].lat),
                    cylinder: {
                        length: 100,
                        show: true,
                        fill: true,
                        topRadius: 0.0,
                        bottomRadius: 100,
                        material: _this._cesium.Color.RED
                    }
                });
                _this.item = _this.cylinder;
            } else if (_this.shape.button == 1) {
                var distance = Cdcl(tempPoints[0].lat, tempPoints[0].lon, tempPoints[1].lat, tempPoints[1].lon);
                _this.item.cylinder.bottomRadius = distance;
            } else if (_this.shape.button == 2) {
                handler.destroy();
                var GroupID = 0;
                if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                    GroupID = tree.selectedItem.id;
                var id = _this._core.getuid();
                var obj = {
                    id: id,
                    name: '新建圆锥' + id,
                    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                    type: 'cylinder',
                    item: _this
                };
                this.setTreeobj(obj);
                tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
                if (typeof method == 'function') {
                    method(ploylinejl);
                }
            }
            _this.shape.button = _this.shape.button + 1;
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        handler.setInputAction(function (movement) {
            if (_this.shape.button == 2) {
                var ray = _this._viewer.camera.getPickRay(movement.endPosition);
                var se = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
                _this.item.cylinder.length = se.z;
            }

        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return this;
    };
    /**
     * 向三维场景中添加圆柱。
     * @param {object} [method] 回调函数
     *
     */
    Cone.prototype.executeCylinder = function (method) {
        //创建圆柱和可以创建在高程上
        //var polylines = {};
        var _this = this;
        _this.shape = {
            tempPoints: [],
            button: 0,
            position: {}
        };

        var handler = new this._cesium.ScreenSpaceEventHandler(_this._viewer.scene.canvas);
        var positions = [];
        var tempPoints = [];
        //鼠标左键单击画点
        handler.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.position, _this._viewer.scene.globe.ellipsoid);
            var cartographic = _this._cesium.Cartographic.fromCartesian(cartesian);
            var longitudeString = _this._cesium.Math.toDegrees(cartographic.longitude);
            var latitudeString = _this._cesium.Math.toDegrees(cartographic.latitude);
            tempPoints.push({ lon: longitudeString, lat: latitudeString });
            var ploylinejl = { polyline: {}, positions: [], distance: [] };
            if (_this.shape.button == 0) {
                positions.push(cartesian.clone());
                positions.push(cartesian);
                _this.shape.position = cartesian;
                _this.cylinder = _this._viewer.entities.add({
                    name: "",
                    //position: _this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[1]),
                    position: _this._cesium.Cartesian3.fromDegrees(tempPoints[0].lon, tempPoints[0].lat),
                    cylinder: {
                        length: 100,
                        topRadius: 0.0,
                        bottomRadius: 100,
                        material: _this._cesium.Color.RED
                    }
                });
                _this.item = _this.cylinder;
            } else if (_this.shape.button == 1) {
                var distance = Cdcl(tempPoints[0].lat, tempPoints[0].lon, tempPoints[1].lat, tempPoints[1].lon);
                _this.item.cylinder.bottomRadius = distance;
                _this.item.cylinder.topRadius = distance;
            } else if (_this.shape.button == 2) {
                handler.destroy();
                var GroupID = 0;
                if (!_this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
                    GroupID = tree.selectedItem.id;
                var id = _this._core.getuid();
                var obj = {
                    id: id,
                    name: '新建圆柱' + id,
                    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                    type: 'cylinder',
                    item: _this
                };
                _this.setTreeobj(obj);
                tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
                if (typeof method == 'function') {
                    method(ploylinejl);
                }
            }
            _this.shape.button = _this.shape.button + 1;
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        //鼠标移动
        handler.setInputAction(function (movement) {
            if (_this.shape.button == 2) {
                var ray = _this._viewer.camera.getPickRay(movement.endPosition);
                var se = _this._viewer.scene.globe.pick(ray, _this._viewer.scene);
                _this.item.cylinder.length = se.z;
            }

        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return this;
    };
    /**
     * 设置CylinderGraphics的圆柱顶部的半径
     * @param {Object} [CylinderGraphics] CylinderGraphics对象
     * @param {String} [length] 长度。
     * @returns {Object} 返回一个CylinderGraphics对象。
     */
    Cone.prototype.setTopRadius = function (length) {
        try {
            this.item._cylinder.topRadius = length;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置圆柱的高度
     * @param {Object} [polygon] polygon对象
     * @param {double} [height] 高度
     * @returns {Object} 返回一个polygon对象。
     */
    Cone.prototype.setHeight = function (height) {
        try {
            var fr = this._cesium.Cartesian3.fromDegrees(-94.74211811500844, 37.34584317651723, height);
            this.item._position._value.z = fr.z;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    //删除矩形对象
    Cone.prototype.deleteObject = function () {
        let _viewer = this._viewer;
        _viewer.entities.remove(this.item);
        if (this.wall) {
            this.wall.forEach(item => {
                _viewer.entities.remove(item);
            });
            this.wall = [];
        }
        // this = null;
    };
    /**
     * 设置圆柱或圆锥的高度类型
     * @param {Object} [cylinder] cylinder对象
     * @param {int} [type] 1：该位置被夹在地形上。2：这个职位是绝对的。3：位置高度是地形上方的高度。
     * @returns {Object} 返回一个对象。
     */
    Cone.prototype.setHeightType = function (type) {
        try {
            if (type == 1) {
                this.item._cylinder.heightReference = this._cesium.HeightReference.CLAMP_TO_GROUND;
            } else if (type == 2) {
                this.item._cylinder.heightReference = this._cesium.HeightReference.NONE;
            } else if (type == 3) {
                this.item._cylinder.heightReference = this._cesium.HeightReference.RELATIVE_TO_GROUND;
            }
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置面的贴图
     * @param {Object} [polygon] polygon对象
     * @param {url} 图片路径。
     * @returns {Object} 返回一个polygon对象。
     */
    Cone.prototype.setCylinderImage = function (url) {
        try {
            this.item._cylinder.material = new this._cesium.ImageMaterialProperty({
                image: url  //可以为url、canvas、video      
            });
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置球的贴图一个Cartesian2属性，指定图像在每个方向上重复的次数。
     * @param {Object} [Ellipsoid] Ellipsoid对象
     * @param {Object} x和y上的比例。
     * @returns {Object} 返回一个Ellipsoid对象。
     */
    Cone.prototype.setCylinderRepeat = function (x, y) {
        try {
            //new Cesium.CallbackProperty
            this.item._cylinder.material.repeat = new this._cesium.Cartesian2(x, y);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 修改圆柱的可视距离
     * @param {Object} [polygon] polygon对象
     * @param {String} [min, max] 设置线段的可视距离
     * @returns {Object} 返回一个polyline对象。
     */
    Cone.prototype.setDistanceDisplayCondition = function (min, max) {
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        try {
            this.item._cylinder.distanceDisplayCondition = distance;
            //this.item._cylinder.show = true;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置CylinderGraphics圆柱体底部的半径
     * @param {Object} [CylinderGraphics] CylinderGraphics对象
     * @param {String} [length] 长度。
     * @returns {Object} 返回一个CylinderGraphics对象。
     */
    Cone.prototype.setBottomRadius = function (length) {
        try {
            this.item._cylinder.bottomRadius = length;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置CylinderGraphics是否显示。
     * @param {Object} [CylinderGraphics] CylinderGraphics对象
     * @param {define} [show] 是否显示。
     * @returns {Object} 返回一个CylinderGraphics对象。
     */
    Cone.prototype.setShow = function (show) {
        try {
            this.item._cylinder.show = show;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置CylinderGraphics的用于填充圆柱体的材料。
     * @param {Object} [CylinderGraphics] CylinderGraphics对象
     * @param {MaterialProperty} [Material ] 材料例如：Color.WHITE。
     * @returns {Object} 返回一个CylinderGraphics对象。
     */
    Cone.prototype.setMaterial = function (Material) {
        try {
            this.item._cylinder.material = Material;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置CylinderGraphics的用于填充圆柱体的颜色。
     * @param {Object} [CylinderGraphics] CylinderGraphics对象
     * @param {htmlColor} htmlColor颜色。
     * @returns {Object} 返回一个CylinderGraphics对象。
     */
    Cone.prototype.setMaterial = function (htmlColor) {
        try {
            this.item._cylinder.material.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置CylinderGraphics的用于填充圆柱体的材料透明度。
     * @param {Float} [a] 透明度 0-1
     * @returns {Object} 返回一个CylinderGraphics对象。
     */
    Cone.prototype.setMaterialAlpha = function (a) {
        try {
            this.item._cylinder.material.color._value.alpha = a;
            this.item._cylinder.show = true;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };

    Cone.prototype.setItem = function (item) {
        this.item = item;
    };

    /**
     * 仿照te修改
     *
     * 这个方法用于创建圆锥
     * @param {Object} [Position] Position表示地面对象的位置和方向。对象{
        Altitude:高度。
        AltitudeType:枚举确定高度如何解译。
        Cartesian:一个布尔值，决定是否基于直角坐标系计算。
        Distance:从摄像机到位置的距离。
        Pitch:相机或对象的倾斜角度。
        Roll:对象的滚动角。
        X:X坐标。
        Y:Y坐标。
        Yaw:该相机或对象的方向角。
    }
     * @param {number} [Radius] 圆锥体的半径。
     * @param {number} [ObjectHeight] 圆锥体的高度。
     * @param {String} [LineColor] 组成圆锥体的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 圆锥的填充色。颜色值由RGB定义。
     * @param {number} [NumOfSegments] 组成圆锥体的部分数目。部分数据越多，圆锥体越圆滑。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中圆锥的名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Cone.prototype.CreateCone = function (Position, Radius, ObjectHeight, LineColor, FillColor, NumOfSegments, GroupID, Description) {
        this._postion = Position;
        var defaultOption = {
            topRadius: 0.0,
            bottomRadius: this._cesium.defaultValue(Radius, 20000.0),
            length: this._cesium.defaultValue(ObjectHeight, 40000.0),
            slices: this._cesium.defaultValue(NumOfSegments, 128),
            material: this._cesium.Color.RED,
            outline: false,
            outlineColor: undefined,
        };

        if (LineColor && LineColor !== '') {
            defaultOption.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(LineColor);
            defaultOption.outline = true;
        }
        if (FillColor && FillColor !== '') {
            defaultOption.material = new Color(this._viewer, this._cesium).colorFromHtmlColor(FillColor);
        }

        var orientation;
        if (Position.Yaw || Position.Pitch || Position.Roll) {
            orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
                new this._cesium.HeadingPitchRoll(
                    this._cesium.Math.toRadians(Position.Yaw),
                    this._cesium.Math.toRadians(Position.Pitch),
                    this._cesium.Math.toRadians(Position.Roll)
                )
            );
        }

        this.item = this._viewer.entities.add({
            name: Description,
            position: this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
            cylinder: defaultOption,
            orientation: orientation
        });

        var obj = {
            id: this.item.id,
            name: Description,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'cylinder',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 仿照te修改
     *
     * 这个方法用于创建圆柱
     * @param {Object} [Position] Position表示地面对象的位置和方向。对象{
        Altitude:高度。
        AltitudeType:枚举确定高度如何解译。
        Cartesian:一个布尔值，决定是否基于直角坐标系计算。
        Distance:从摄像机到位置的距离。
        Pitch:相机或对象的倾斜角度。
        Roll:对象的滚动角。
        X:X坐标。
        Y:Y坐标。
        Yaw:该相机或对象的方向角。
    }
     * @param {number} [Radius] 圆柱体的半径。
     * @param {number} [ObjectHeight] 圆柱体的高度。
     * @param {String} [LineColor] 组成圆柱体的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 圆柱的填充色。颜色值由RGB定义。
     * @param {number} [NumOfSegments] 组成圆柱体的部分数目。部分数据越多，圆柱体越圆滑。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中圆柱名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Cone.prototype.CreateCylinder = function (Position, Radius, ObjectHeight, LineColor, FillColor, NumOfSegments, GroupID, Description) {
        this._postion = Position;
        var defaultOption = {
            topRadius: this._cesium.defaultValue(Radius, 20000.0),
            bottomRadius: this._cesium.defaultValue(Radius, 20000.0),
            length: this._cesium.defaultValue(ObjectHeight, 40000.0),
            slices: this._cesium.defaultValue(NumOfSegments, 128),
            material: this._cesium.Color.RED,
            outline: false,
            outlineColor: undefined,
        };

        if (LineColor && LineColor !== '') {
            defaultOption.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(LineColor);
            defaultOption.outline = true;
        }
        if (FillColor && FillColor !== '') {
            defaultOption.material = new Color(this._viewer, this._cesium).colorFromHtmlColor(FillColor);
        }

        var orientation;
        if (Position.Yaw || Position.Pitch || Position.Roll) {
            orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
                new this._cesium.HeadingPitchRoll(
                    this._cesium.Math.toRadians(Position.Yaw),
                    this._cesium.Math.toRadians(Position.Pitch),
                    this._cesium.Math.toRadians(Position.Roll)
                )
            );
        }

        this.item = this._viewer.entities.add({
            name: Description,
            position: this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
            cylinder: defaultOption,
            orientation: orientation
        });

        var obj = {
            id: this.item.id,
            name: Description,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'cylinder',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    Object.defineProperties(Cone.prototype, {
        Position: {
            Altitude: {
                get: function () {
                    return this._postion.Altitude
                },
                set: function (Altitude) {
                    try {
                        // 赋值
                        this._postion.Altitude = Altitude;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            AltitudeType: {
                get: function () {
                    return this._postion.AltitudeType
                },
                set: function (AltitudeType) {
                    try {
                        this._postion.AltitudeType = AltitudeType;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Cartesian: {
                get: function () {
                    return this._postion.Cartesian
                },
                set: function (Cartesian) {
                    try {
                        this._postion.Cartesian = Cartesian;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Distance: {
                get: function () {
                    return this._postion.Distance
                },
                set: function (Distance) {
                    try {
                        this._postion.Distance = Distance;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Pitch: {
                get: function () {
                    return this._postion.Pitch
                },
                set: function (Pitch) {
                    try {
                        this._postion.Pitch = Pitch;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Roll: {
                get: function () {
                    return this._postion.Roll
                },
                set: function (Roll) {
                    try {
                        this._postion.Roll = Roll;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            X: {
                get: function () {
                    return this._postion.X
                },
                set: function (X) {
                    try {
                        // 赋值
                        this._postion.X = X;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Y: {
                get: function () {
                    return this._postion.Y
                },
                set: function (Y) {
                    try {
                        // 赋值
                        this._postion.Y = Y;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Yaw: {
                get: function () {
                    return this._postion.Yaw
                },
                set: function (Yaw) {
                    try {
                        this._postion.Yaw = Yaw;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            }
        }
    });

    /**
     *
     * 激活标准菜单命令
     *
     * @alias execute
     * @constructor
     *
     */
    function execute(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._Cdcl = new Cdcl();
        this._core = new Core();
        this._polyline = undefined; // new Polyline(viewer, cesium);
        this._polygon = undefined;
        this._box = new Box(viewer, cesium);
        this._ellipsoid = new Ellipsoid(viewer, cesium);
        this._rectangle = new Rectangle$1(viewer, cesium);
        this._circle = new Circle(viewer, cesium);
        this._point = new Point(viewer, cesium);
        this._label = new Label(viewer, cesium);
        this._dynamicObject = new dynamicObject(viewer, cesium);
        this._elevationContour = new ElevationContour(viewer, cesium);
        this._scopefieldvision = new Scopefieldvision(viewer, cesium);
        this._cone = new Cone(viewer, cesium);
    }

    /**
     * 这个方法用于激活标准菜单命令，完整的功能调用。
     *@param {int} [commandid] 菜单命令id,其中(0,.)为创建模块、(1..)为分析模块、(2..)为时间模块。
     *@param {int} [parameters] 菜单命令id。
     *@param {Object} [parameter] 参数。
     *@param {function} [method] 回调。
     *
     */
    execute.prototype.execute = function (commandid, parameters, parameter, method) {
        var viewer = this._viewer;
        var cesium = this._cesium;
        this._polyline = new Polyline(viewer, cesium);
        this._polygon = new Polygon(viewer, cesium);
        this._core;
        if (commandid == 0 && parameters == 0) {
            return this._polyline.executePolyline(parameter, method);
        } else if (commandid == 4 && parameters == 1) {
            //创建等高线及坡度
            // return this._elevationContour.executeMaterial(method);
            return this._elevationContour.executeContourMaterial(method);
        } else if (commandid == 0 && parameters == 1) {
            //创建面
            return this._polygon.executePolygon(parameter, method);
            //return this._polygon.executePolygonvideo(method, parameter);
        } else if (commandid == 0 && parameters == 11) {
            //面贴视频
            return this._polygon.executePolygonvideo(method, parameter);
        } else if (commandid == 1 && parameters == 1) {
            //画正方体
            return this._box.executeBox(method);
        } else if (commandid == 1 && parameters == 2) {
            //圆锥
            return this._cone.executeCone(method);
        } else if (commandid == 1 && parameters == 3) {
            //圆柱
            return this._cone.executeCylinder(method);
        } else if (commandid == 1 && parameters == 4) {
            //球
            return this._ellipsoid.executeEllipsoid(method);
        } else if (commandid == 1 && parameters == 5) {
            //创建矩形
            return this._rectangle.createRectangle(parameter, method);
        } else if (commandid == 1 && parameters == 6) {
            //创建圆
            return this._circle.executeClircle(method);
        } else if (commandid == 1 && parameters == 7) {
            //创建扇形
            return this._polygon.executeSector(method, parameter);
        } else if (commandid == 1 && parameters == 8) {
            //创建矩形地形开挖
            //return this._rectangle.executeExcavation(method);
            //return this._rectangle.executeExcavation(method);
            return this._box.executeExcavation(parameter, method);
        } else if (commandid == 1 && parameters == 9) {
            //创建矩形地形开挖
            return this._box.executeExcavation(parameter, method);
        } else if (commandid == 1 && parameters == 10) {
            //画圆完善
            return this._circle.executeClirclews(method);
        } else if (commandid == 1 && parameters == 11) {
            //海拔高度。
            return this._point.executePoint(method, parameter);
            //return this._box.executeExcavation(parameter, method);
            // return this._point.executePointktd(method);
        } else if (commandid == 1 && parameters == 12) {
            //创建地形拉伸
            return this._rectangle.createRectangledxkz(method);
        } else if (commandid == 0 && parameters == 2) {
            //水平距离测量(包含地形)
            //return this._polyline.executePolyline1(method);
            return this._polyline.executeHorizontals(method, parameter);
        } else if (commandid == 0 && parameters == 3) {
            //空间面积测量
            return this._polygon.executePolygoncl(method, parameter);
        } else if (commandid == 0 && parameters == 4) {
            //水平距离测量(不包含地形)
            return this._polyline.executeHorizontal(method, parameter);
        } else if (commandid == 0 && parameters == 10) {
            //空间距离测量
            return this._polyline.executePolyline1(method, parameter);
        } else if (commandid == 0 && parameters == 5) {
            //高度测量
            return this._polyline.executeHeightTe(method, parameter);
        } else if (commandid == 0 && parameters == 6) {
            //角度测量
            return this._polyline.executeAnge(method, parameter);
        } else if (commandid == 0 && parameters == 9) {
            //三点角度测量
            return this._polyline.executeAngeSd(method, parameter);
        } else if (commandid == 0 && parameters == 7) ; else if (commandid == 0 && parameters == 8) {
            //贴地面积测量(三维表面面积测量。)
            return this._polygon.executePolygontdmj(method, parameter);
        } else if (commandid == 0 && parameters == 12) {
            //角度测量
            return this._polyline.executeAngle(method, parameter);
        } else if (commandid == 0 && parameters == 13) {
            // 创建点位
            this._point.executePointp(method, parameter);
        } else if (commandid == 2 && parameters == 0) {
            //剖面分析
            return this._polyline.executeProfile(parameter, method);
        } else if (commandid == 2 && parameters == 1) {
            //淹没分析
            return this._polygon.executePolygonym(method);
        } else if (commandid == 2 && parameters == 2) {
            let _Polygon = new Polygon(viewer, cesium);
            //淹没分析手动添加
            return _Polygon.executePolygonymsd(parameter, method);
        } else if (commandid == 2 && parameters == 3) {
            //浏览方式
            return this._dynamicObject.executeFlycesium(method);
        } else if (commandid == 2 && parameters == 4) {
            //水面效果
            return this._polygon.executePolygonymsdtt(parameter, method);
        } else if (commandid == 2 && parameters == 5) {
            //浏览边界
            return this._rectangle.createRectanglelbj(parameter, method);
        } else if (commandid == 2 && parameters == 6) {
            //剖面分析pro
            return this._polyline.executeProfilePro(parameter, method);
        } else if (commandid == 3 && parameters == 0) {
            //设置当前时间
            if (parameter != "" && parameter != null) {
                var date1 = new Date(parameter);
                var julian_time = cesium.JulianDate.fromDate(date1);
                viewer.clock.currentTime = julian_time.clone();
            }

        } else if (commandid == 3 && parameters == 1) {
            //倍率加
            this._viewer.animation.viewModel.faster();
        } else if (commandid == 3 && parameters == 2) {
            // 倍率减
            this._viewer.animation.viewModel.slower();
        } else if (commandid == 3 && parameters == 3) {
            // 往前播
            this._viewer.animation.viewModel.playForwardViewModel.command();
        } else if (commandid == 3 && parameters == 4) {
            // 往后播
            this._viewer.animation.viewModel.playReverseViewModel.command();
        } else if (commandid == 3 && parameters == 5) {
            // 暂停
            this._viewer.animation.viewModel.pauseViewModel.command();
        } else if (commandid == 3 && parameters == 6) {
            //坐标转化
            var cartographicdr = cesium.Cartographic.fromCartesian(parameter);
            var longitudeStringdr = cesium.Math.toDegrees(cartographicdr.longitude);
            var latitudeStringdr = cesium.Math.toDegrees(cartographicdr.latitude);
            var heightStringdr = cartographicdr.height;
            var positionsop = {
                lon: longitudeStringdr,
                lat: latitudeStringdr,
                hei: heightStringdr
            };
            return positionsop;
        } else if (commandid == 3 && parameters == 7) {
            // 视野范围设置
            this._scopefieldvision.executeScopefieldvision();
        }
        //} else if (commandid == 3 && parameters == 8) {
        //    // 禁止地形穿透
        //    var _this = this;
        //    _this._viewer.clock.onTick.addEventListener(function () {
        //        if (_this._viewer.camera.pitch > 0) {
        //            _this._viewer.scene.screenSpaceCameraController.enableTilt = false;
        //        }
        //    });
        //    var mousePosition, startMousePosition;
        //    var handler = new Cesium.ScreenSpaceEventHandler(_this._viewer.canvas);
        //    handler.setInputAction(function (movement) {
        //        mousePosition = startMousePosition = _this._cesium.Cartesian3.clone(movement.position);
        //        handler.setInputAction(function (movement) {
        //            mousePosition = movement.endPosition;
        //            var y = mousePosition.y - startMousePosition.y;
        //            if (y > 0) {
        //                _this._viewer.scene.screenSpaceCameraController.enableTilt = true;
        //            }
        //        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //    }, _this._cesium.ScreenSpaceEventType.MIDDLE_DOWN);
        //}
    };

    function Command(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._execute = new execute(this._viewer, this._cesium);

    }Command.prototype.execute = function (commandid, parameters, parameter, method) {
        return this._execute.execute(commandid, parameters, parameter, method);
    };

    /**
     * 事件类型.
     *
     * @enum {String}
     */
    var EventType = {
      /**
       * 左键点击.
       *
       * @type {String}
       * @constant
       */
      L_Click: 'OnLButtonClk',

      /**
       * 左键双击.
       *
       * @type {String}
       * @constant
       */
      L_DBL_Click: 'OnLButtonDblClk',

      /**
      * 左键按下.
      *
      * @type {String}
      * @constant
      */
      L_Down: 'OnLButtonDown',

      /**
       * 左键抬起.
       *
       * @type {String}
       * @constant
       */
      L_Up: 'OnLButtonUp',

      /**
      * 中键点击.
      *
      * @type {String}
      * @constant
      */
      M_Click: 'OnMButtonClk',

      /**
      * 中键按下.
      *
      * @type {String}
      * @constant
      */
      M_Down: 'OnMButtonDown',

      /**
       * 中键抬起.
       *
       * @type {String}
       * @constant
       */
      M_Up: 'OnMButtonUp',

      /**
      * 右键点击.
      *
      * @type {String}
      * @constant
      */
      R_Click: 'OnRButtonClk',

      /**
      * 右键按下.
      *
      * @type {String}
      * @constant
      */
      R_Down: 'OnRButtonDown',

      /**
       * 右键抬起.
       *
       * @type {String}
       * @constant
       */
      R_Up: 'OnRButtonUp',

      /**
      * 鼠标移动.
      *
      * @type {String}
      * @constant
      */
      Move: 'OnFrame',

      /**
       * 中键滚动.
       *
       * @type {String}
       * @constant
       */
      Wheel: 'OnMouseWheel',
    };
    var EventType$1 = Object.freeze(EventType);

    /**
     * 三维笛卡尔坐标转WGS84坐标
     *
     * @function
     *
     * @param {Cartesian3} position 要克隆的对象。
     * @returns {Object} WGS84坐标。
     * 
     * @example
     * degrees = SmartEarth.Cartesian3_to_WGS84(position);
     */
    function Cartesian3_to_WGS84(position) {
        var cartographic = Cesium.Cartographic.fromCartesian(position);
        var lat = Cesium.Math.toDegrees(cartographic.latitude);
        var lon = Cesium.Math.toDegrees(cartographic.longitude);
        var height = cartographic.height;
        return { lat, lon, height };
    }

    /**
     * CesiumHeatmapGL扩展
     *
     * @alias CesiumHeatmapGL
     * @constructor
     *
     * @param {Viewer} Viewer 地图视图。
     * @param {Object} [option] 参数。
     * @param {Boolean} [option.flyTo=true] 加载数据后定位。
     * @param {Number} [option.radius=50] 半径。
     * @param {Number} [option.alpha=1] 矩形面透明度。
     * @param {Number} [option.height] 矩形面高度，未设置高度则贴地。
     * @param {Boolean} [option.dynamic=false] 动态半径，半径随高度变化而变化。
     * @param {Number} [option.minRadius=1] 最小半径，dynamic为true生效。
     * @param {Number} [option.maxRadius=50] 最大半径，dynamic为true生效。
     * 
     * @example
     * HeatmapGLTool = SmartEarth.CesiumHeatmapGL(Viewer);
     */
    function CesiumHeatmapGL(Viewer, option = {}) {
        this._viewer = Viewer;
        this.radius = this.defaultValue(option.radius, 50);
        this.alpha = this.defaultValue(option.alpha, 1);
        this.rectangleHeight = option.height;

        this.minRadius = this.defaultValue(option.minRadius, 1);
        this.maxRadius = this.defaultValue(option.maxRadius, 50);

        this.flyTo = this.defaultValue(option.flyTo, true);

        this.datas = [];

        if (option.dynamic) {
            this.dynamicAdjust(true);
        }
    }

    CesiumHeatmapGL.prototype.defaultValue = function (a, b) {
        return Cesium.defaultValue(a, b)
    };

    /**
     * 创建热力图图层
     * 
     * @param {Object[]} [data] 热力值数据。
     * 
     * @example
     * HeatmapGLTool.create([{x:118,y:32,value,50},{x:119,y:31,value,50}]);
     */
    CesiumHeatmapGL.prototype.create = function (data) {
        this.setData(data);
        this.flyTo && this.flyToBounding();
    };

    /**
     * 从热图实例中删除所有先前存在的点并重新初始化。
     * 
     * @param {Object[]} [data] 热力值数据。
     * 
     * @example
     * HeatmapGLTool.setData([{x:118,y:32,value,50},{x:119,y:31,value,50}]);
     */
    CesiumHeatmapGL.prototype.setData = function (data) {
        let lonmin = 1000;
        let lonmax = -1000;
        let latmin = 1000;
        let latmax = -1000;
        let max = -Infinity;
        let min = Infinity;
        data.forEach(feature => {
            let lon = feature.x;
            let lat = feature.y;
            lonmin = Math.min(lon, lonmin);
            latmin = Math.min(lat, latmin);
            lonmax = Math.max(lon, lonmax);
            latmax = Math.max(lat, latmax);

            max = Math.max(feature.value, max);
            min = Math.min(feature.value, min);
        });
        let xrange = lonmax - lonmin;
        let yrange = latmax - latmin;
        let extent = { xMin: lonmin - xrange / 10, yMin: latmin - yrange / 10, xMax: lonmax + xrange / 10, yMax: latmax + yrange / 10 };
        let heatmapcanvas;
        if (!this._heatmap) {
            heatmapcanvas = document.createElement('canvas');
            document.body.appendChild(heatmapcanvas);
            heatmapcanvas.width = 1000;
            heatmapcanvas.height = parseInt(1000 / (extent.xMax - extent.xMin) * (extent.yMax - extent.yMin));
            try {
                this._heatmap = createWebGLHeatmap({ canvas: heatmapcanvas, intensityToAlpha: true });
            }
            catch (error) {
                console.error(error);
            }
        } else {
            heatmapcanvas = this._heatmap.canvas;
            this._heatmap.clear();
        }

        this.datas = [];
        let _ = max - min;
        data.forEach(feature => {
            var x = (feature.x - extent.xMin) / (extent.xMax - extent.xMin) * heatmapcanvas.clientWidth;
            var y = (-(feature.y - extent.yMin) / (extent.yMax - extent.yMin) + 1) * heatmapcanvas.clientHeight;
            this.datas.push({ x: x, y: y, size: this.radius, intensity: (feature.value - min) / _ });
        });
        this._heatmap.addPoints(this.datas);
        this._heatmap.adjustSize();
        this._heatmap.update();
        this._heatmap.display();
        this.drawHeatmapRect(heatmapcanvas, extent);

        this.rectangle = Cesium.Rectangle.fromDegrees(extent.xMin, extent.yMin, extent.xMax, extent.yMax);
        let BoundingSphere = Cesium.BoundingSphere.fromRectangle3D(this.rectangle);
        this.boundingRadius = BoundingSphere.radius;
    };

    /**
     * 定位数据范围
     * 
     */
    CesiumHeatmapGL.prototype.flyToBounding = function () {
        this._viewer.camera.flyTo({
            destination: this.rectangle
        });
    };

    CesiumHeatmapGL.prototype.drawHeatmapRect = function (canvas, extent) {
        this._worldRectangle && this._viewer.scene.primitives.remove(this._worldRectangle);
        var image = this.convertCanvasToImage(canvas);
        let Primitive = this.rectangleHeight === undefined ? Cesium.GroundPrimitive : Cesium.Primitive;
        this._worldRectangle = this._viewer.scene.primitives.add(new Primitive({
            geometryInstances: new Cesium.GeometryInstance({
                geometry: new Cesium.RectangleGeometry({
                    rectangle: Cesium.Rectangle.fromDegrees(extent.xMin, extent.yMin, extent.xMax, extent.yMax),
                    vertexFormat: Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT,
                    height: this.rectangleHeight
                })
            }),
            appearance: new Cesium.EllipsoidSurfaceAppearance({
                aboveGround: false,
                material: new Cesium.Material({
                    fabric: {
                        type: 'Image',
                        uniforms: {
                            image: image.src
                        }
                    }
                })
            })
        }));
        this.setAlpha(0);
        setTimeout(() => {
            this.setAlpha(this.alpha);
        }, 100);
    };

    /**
     * 销毁
     * 
     */
    CesiumHeatmapGL.prototype.destroy = function () {
        this.dynamicAdjust(false);
        this._viewer.scene.primitives.remove(this._worldRectangle);
        this._heatmap.clear();
        this._heatmap.canvas.remove();
    };

    /**
     * 动态变化
     * 
     * @param {Boolean} [adjust] 设置热力图是否使用动态半径。
     */
    CesiumHeatmapGL.prototype.dynamicAdjust = function (adjust) {
        if (adjust) {
            this._viewer.clock.onTick.addEventListener(this.dynamicAdjustEvent, this);
        } else {
            this._viewer.clock.onTick.removeEventListener(this.dynamicAdjustEvent, this);
        }
    };

    CesiumHeatmapGL.prototype.dynamicAdjustEvent = function () {
        if (this._heatmap && this._viewer) {
            let cameraP = this._viewer.camera.positionCartographic;
            let cameraHeight = cameraP.height;
            let globeHeight = this._viewer.scene.globe.getHeight(cameraP);
            let _height = cameraHeight - globeHeight;
            let radius = _height / this.boundingRadius * this.maxRadius;
            radius = radius.toFixed(1);
            radius > this.maxRadius && (radius = this.maxRadius);
            radius < this.minRadius && (radius = this.minRadius);
            if (radius !== this.radius && radius <= this.maxRadius && radius >= this.minRadius) {
                this.changeRadius(radius);
            }
        }
    };

    /**
     * 更新热力图
     * 
     */
    CesiumHeatmapGL.prototype.updateHeatmap = function () {
        this._heatmap.adjustSize();
        this._heatmap.update();
        this._heatmap.display();

        var image = this.convertCanvasToImage(this._heatmap.canvas);
        this._worldRectangle.appearance.material.uniforms.image = image.src;
    };

    CesiumHeatmapGL.prototype.multiply = function (value) {
        this._heatmap.multiply(value);
        this.updateHeatmap();
    };

    /**
     * 设置半径
     * 
     * @param {Number} [radius] 设置热力图半径。
     */
    CesiumHeatmapGL.prototype.changeRadius = function (radius) {
        this.radius = radius;
        this.datas.forEach(item => {
            item.size = radius;
        });
        this._heatmap.clear();
        this._heatmap.addPoints(this.datas);
        this.updateHeatmap();
    };

    CesiumHeatmapGL.prototype.clamp = function (min, max) {
        this._heatmap.clamp(min, max);
        this.updateHeatmap();
    };

    CesiumHeatmapGL.prototype.blur = function () {
        this._heatmap.blur();
        this.updateHeatmap();
    };

    /**
     * 显示隐藏热力图
     * 
     * @param {Boolean} [show] 是否显示。
     */
    CesiumHeatmapGL.prototype.show = function (show) {
        this._worldRectangle && (this._worldRectangle.show = show);
    };

    /**
     * 设置矩形面透明度
     * 
     * @param {Number} [value] 透明度。
     */
    CesiumHeatmapGL.prototype.setAlpha = function (value) {
        this._worldRectangle && (this._worldRectangle.appearance.material.uniforms.color.alpha = value);
    };

    CesiumHeatmapGL.prototype.convertCanvasToImage = function (canvas) {
        var image = new Image();
        image.src = canvas.toDataURL("image/png");
        return image;
    };

    /**
     * Heatmap-cesium扩展
     *
     * @alias CesiumHeatmap
     * @constructor
     *
     * @param {Viewer} Viewer 地图视图。
     * @param {Object} [option] 参数。
     * @param {Boolean} [option.flyTo=true] 加载数据后定位。
     * @param {String} [option.type="2D"] 热力图类型【2D | 3D】。
     * @param {Number} [option.radius=50] 半径。
     * @param {Number} [option.alpha=1] 矩形面透明度。
     * @param {Number} [option.height] 矩形面高度，未设置高度则贴地。
     * @param {Number} [option.TIN_X=200] 横向三角网个数，type为3D时生效。
         * @param {Number} [option.TIN_Y=200] 纵向三角网个数，type为3D时生效。
         * @param {Number} [option.showTIN=false] 是否显示三角网，type为3D时生效。
         * @param {Number} [option.colorScale=1] 色值转换高度的比例，type为3D时生效。
         * @param {Number} [option.minHeight=100] 3D热力图底部高度，type为3D时生效。

         * @param {Boolean} [option.dynamic=false] 动态半径，半径随高度变化而变化，点数多时不建议使用，type为3D时无效。
         * @param {Number} [option.minRadius=1] 最小半径，dynamic为true生效。
         * @param {Number} [option.maxRadius=50] 最大半径，dynamic为true生效。
         * @param {Number} [option.minOpacity=0.1] 最小透明度。
         * @param {Number} [option.maxOpacity=0.8] 最大透明度。
         * @param {Number} [option.blur=0.85] 模糊系数，模糊系数越高，渐变就越平滑
         * @param {Object} [option.gradient={'.3': 'blue','.5': 'green','.7': 'yellow','.95': 'red'}] 渐变色。
         * @param {Boolean} [option.tooltip=false] 是否显示tooltip。
         * 
         * @example
         * HeatmapTool = SmartEarth.CesiumHeatmap(Viewer);
         */
    function CesiumHeatmap(Viewer, option = {}) {
        this._viewer = Viewer;
        this.radius = this.defaultValue(option.radius, 50);
        this.minRadius = this.defaultValue(option.minRadius, 1);
        this.maxRadius = this.defaultValue(option.maxRadius, 50);

        this.blur = this.defaultValue(option.blur, 0.85);
        this.alpha = this.defaultValue(option.alpha, 1);
        // 矩形面高度
        this.rectangleHeight = option.height;
        // 是否三维热力图
        this.is3D = option.type && option.type.indexOf('3D') > -1;
        if (this.is3D) {
            this._3DOption = {
                width: option.TIN_X || 200,
                height: option.TIN_Y || 200,
                grid: this.defaultValue(option.showTIN, false),
                scale: this.defaultValue(option.colorScale, 1),
                z: this.defaultValue(option.minHeight, 100),
            };
        }

        this.minOpacity = this.defaultValue(option.minOpacity, .1);
        this.maxOpacity = this.defaultValue(option.maxOpacity, .8);

        // 渐变
        this.gradient = this.defaultValue(option.gradient, {
            '.3': 'blue',
            '.5': 'green',
            '.7': 'yellow',
            '.95': 'red'
        });

        this.flyTo = this.defaultValue(option.flyTo, true);
        if (option.dynamic && !this.is3D) {
            // 动态变化
            this.dynamicAdjust(true);
        }

        this._core = new Core();
        this.tooltip = this._core.CreateTooltip();
        if (option.tooltip) {
            this.showTooltip(true);
        }
    }

    CesiumHeatmap.prototype.defaultValue = function (a, b) {
        return Cesium.defaultValue(a, b)
    };

    /**
     * 创建热力图图层
     * 
     * @param {Object[]} [data] 热力值数据。
     * 
     * @example
     * HeatmapTool.create([{x:118,y:32,value,50},{x:119,y:31,value,50}]);
     */
    CesiumHeatmap.prototype.create = function (data) {
        this.setData(data);
        this.flyTo && this.flyToBounding();
    };

    /**
     * 从热图实例中删除所有先前存在的点并重新初始化。
     * 
     * @param {Object[]} [data] 热力值数据。
     * 
     * @example
     * HeatmapTool.setData([{x:118,y:32,value,50},{x:119,y:31,value,50}]);
     */
    CesiumHeatmap.prototype.setData = function (data) {
        let lonmin = 1000;
        let lonmax = -1000;
        let latmin = 1000;
        let latmax = -1000;
        let max = -Infinity;
        let min = Infinity;
        data.forEach(function (feature) {
            let lon = feature.x;
            let lat = feature.y;
            lonmin = Math.min(lon, lonmin);
            latmin = Math.min(lat, latmin);
            lonmax = Math.max(lon, lonmax);
            latmax = Math.max(lat, latmax);

            max = Math.max(feature.value, max);
            min = Math.min(feature.value, min);
        });
        let xrange = lonmax - lonmin;
        let yrange = latmax - latmin;
        let extent = { xMin: lonmin - xrange / 10, yMin: latmin - yrange / 10, xMax: lonmax + xrange / 10, yMax: latmax + yrange / 10 };

        let width = 1000;
        let height = parseInt(1000 / (extent.xMax - extent.xMin) * (extent.yMax - extent.yMin));
        if (!this.heatmapInstance) {
            let heatmapContainer = document.createElement('div');
            heatmapContainer.setAttribute('style', 'width:' + width + 'px;height:' + height + 'px;display:none;');
            document.body.appendChild(heatmapContainer);

            this.heatmapInstance = h337.create({
                container: heatmapContainer,
                // 最大透明度
                maxOpacity: this.maxOpacity,
                // 最小透明度
                minOpacity: this.minOpacity,
                // 模糊系数，模糊系数越高，渐变就越平滑
                blur: this.blur,
                // 默认半径
                radius: this.radius,
                // 渐变
                gradient: this.gradient
            });
        } else {
            this.heatmapInstance._renderer.canvas.setAttribute('style', 'width:' + width + 'px;height:' + height + 'px;');
        }

        var points = [];
        data.forEach(function (feature) {
            var x = (feature.x - extent.xMin) / (extent.xMax - extent.xMin) * width;
            var y = (-(feature.y - extent.yMin) / (extent.yMax - extent.yMin) + 1) * height;
            var point = {
                x: Math.round(x),
                y: Math.round(y),
                value: feature.value,
            };
            points.push(point);
        });
        this.datas = {
            max: max,
            min: min,
            data: points
        };
        this.heatmapInstance.setData(this.datas);
        this.heatmapcanvas = this.heatmapInstance._renderer.canvas;
        this.drawHeatmapRect(this.heatmapcanvas, extent);

        this.rectangle = Cesium.Rectangle.fromDegrees(extent.xMin, extent.yMin, extent.xMax, extent.yMax);
        let BoundingSphere = Cesium.BoundingSphere.fromRectangle3D(this.rectangle);
        this.boundingRadius = BoundingSphere.radius;
        this.extent = extent;
    };

    /**
     * 定位数据范围
     * 
     */
    CesiumHeatmap.prototype.flyToBounding = function () {
        this._viewer.camera.flyTo({
            destination: this.rectangle
        });
    };

    /**
     * 销毁
     * 
     */
    CesiumHeatmap.prototype.destroy = function () {
        this.dynamicAdjust(false);
        this._viewer.scene.primitives.remove(this._worldRectangle);
        this.heatmapcanvas.remove();
        this.showTooltip(false);
    };

    /**
     * 动态变化
     * 
     * @param {Boolean} [adjust] 设置热力图是否使用动态半径。
     */
    CesiumHeatmap.prototype.dynamicAdjust = function (adjust) {
        if (adjust) {
            this._viewer.clock.onTick.addEventListener(this.dynamicAdjustEvent, this);
        } else {
            this._viewer.clock.onTick.removeEventListener(this.dynamicAdjustEvent, this);
        }
    };

    CesiumHeatmap.prototype.dynamicAdjustEvent = function () {
        if (this.heatmapInstance && this._viewer) {
            let cameraP = this._viewer.camera.positionCartographic;
            let cameraHeight = cameraP.height;
            let globeHeight = this._viewer.scene.globe.getHeight(cameraP);
            let _height = cameraHeight - globeHeight;
            let radius = _height / this.boundingRadius * this.maxRadius;
            radius = radius.toFixed(1);
            radius > this.maxRadius && (radius = this.maxRadius);
            radius < this.minRadius && (radius = this.minRadius);
            if (radius !== this.radius && radius <= this.maxRadius && radius >= this.minRadius) {
                this.changeRadius(radius);
            }
        }
    };

    /**
     * 设置半径
     * 
     * @param {Number} [radius] 设置热力图半径。
     */
    CesiumHeatmap.prototype.changeRadius = async function (radius) {
        this.radius = radius;
        for (let key in this.heatmapInstance._store._radi) {
            for (let key2 in this.heatmapInstance._store._radi[key]) {
                this.heatmapInstance._store._radi[key][key2] = radius;
            }
        }
        this.heatmapInstance._coordinator.emit("renderall", this.heatmapInstance._store._getInternalData());
        this.updateHeatmap();
    };

    CesiumHeatmap.prototype.drawHeatmapRect = function (canvas, extent) {
        this._worldRectangle && this._viewer.scene.primitives.remove(this._worldRectangle);
        var image = this.convertCanvasToImage(canvas);


        if (this.is3D) {
            Object.assign(this._3DOption, extent);
            this.create3DHeatmap(image);
        } else {
            let Primitive = this.rectangleHeight === undefined ? Cesium.GroundPrimitive : Cesium.Primitive;
            this._worldRectangle = this._viewer.scene.primitives.add(new Primitive({
                geometryInstances: new Cesium.GeometryInstance({
                    geometry: new Cesium.RectangleGeometry({
                        rectangle: Cesium.Rectangle.fromDegrees(extent.xMin, extent.yMin, extent.xMax, extent.yMax),
                        vertexFormat: Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT,
                        height: this.rectangleHeight
                    })
                }),
                appearance: new Cesium.EllipsoidSurfaceAppearance({
                    aboveGround: true,
                    material: new Cesium.Material({
                        fabric: {
                            type: 'Image',
                            uniforms: {
                                image: image.src
                            }
                        }
                    })
                })
            }));
            // 避免全白颜色过渡
            this.setAlpha(0);
            setTimeout(() => {
                this.setAlpha(this.alpha);
            }, 100);
        }
    };

    // 创建三维热力图
    CesiumHeatmap.prototype.create3DHeatmap = function (image) {
        let cvs = document.createElement("canvas");
        let option = this._3DOption;
        let width = option.width + 1;
        let height = option.height + 1;
        cvs.width = width;
        cvs.height = height;
        let ctx = cvs.getContext("2d");
        let imgData = [];
        let imgDataIndex = 0;
        image.onload = () => {
            ctx.drawImage(image, 0, 0, width, height);
            let c = ctx.getImageData(0, 0, width, height);
            // 循环遍历其中每一个元素，
            // 将每个彩色像素的红、绿、蓝彩色成分求平均值，得到彩色值的灰度值
            for (let i = 0; i < c.height; i++) {
                for (let j = 0; j < c.width; j++) {
                    let x = (i * 4) * c.width + (j * 4);
                    imgData[imgDataIndex++] = c.data[x + 3];
                }
            }
            // 把灰度数据再放回到画布的绘图环境
            ctx.putImageData(c, 0, 0, 0, 0, c.width, c.height);
            option.imgData = imgData;
            let instance = new Cesium.GeometryInstance({
                geometry: this.create3DGeometry(option)
            });

            let rect = new Cesium.Primitive({
                geometryInstances: instance,
                appearance: new Cesium.EllipsoidSurfaceAppearance({
                    material: new Cesium.Material({
                        fabric: {
                            type: 'Image',
                            uniforms: {
                                image: image.src
                            }
                        }
                    })
                }),
                asynchronous: false
            });
            this._worldRectangle = this._viewer.scene.primitives.add(rect);
            // 避免全白颜色过渡
            this.setAlpha(0);
            setTimeout(() => {
                this.setAlpha(this.alpha);
            }, 100);
        };
    };

    // 创建3d热力图图形
    CesiumHeatmap.prototype.create3DGeometry = function (option) {
        let rect = this.construct3DRectangle(option);
        let geometry = new Cesium.Geometry({
            attributes: {
                position: new Cesium.GeometryAttribute({
                    componentDatatype: Cesium.ComponentDatatype.DOUBLE,
                    componentsPerAttribute: 3,
                    values: rect.positions,
                }),
                st: new Cesium.GeometryAttribute({
                    componentDatatype: Cesium.ComponentDatatype.FLOAT,
                    componentsPerAttribute: 2,
                    values: rect.st,
                }),
            },
            //索引
            indices: rect.indexs,
            //绘制类型
            primitiveType: option.grid ? Cesium.PrimitiveType.LINES : Cesium.PrimitiveType.TRIANGLES,
            boundingSphere: Cesium.BoundingSphere.fromVertices(rect.positions),
        });
        return geometry;
    };

    // 构造3d热力图矩形数据
    CesiumHeatmap.prototype.construct3DRectangle = function (options) {
        var imgData = options.imgData;
        var dx = options.xMax - options.xMin;
        var dy = options.yMax - options.yMin;
        var width = options.width;
        var height = options.height;
        var gx = dx / width;
        var gy = dy / height;

        var wgwidth = width + 1;
        var wgheight = height + 1;

        var positions = new Float64Array(wgwidth * wgheight * 3);
        var positionIndex = 0;
        var st = new Float32Array(wgwidth * wgheight * 2);
        var stIndex = 0;
        var indexs = new Uint16Array(width * height * 2 * 3);
        var indexsIndex = 0;
        //
        for (var i = 0; i < wgheight; i++) {
            for (var j = 0; j < wgwidth; j++) {
                var degx = options.xMin + gx * j;
                var degy = options.yMin + gy * i;
                var point = Cesium.Cartesian3.fromDegrees(
                    degx,
                    degy,
                    imgData[(height - i) * wgwidth + j] * options.scale + options.z
                );

                positions[positionIndex++] = point.x;
                positions[positionIndex++] = point.y;
                positions[positionIndex++] = point.z;

                st[stIndex++] = (gx * j) / dx;
                st[stIndex++] = (gy * i) / dy;

                if (i != 0 && j != 0) {
                    indexs[indexsIndex++] = (i - 1) * wgwidth + (j - 1);
                    indexs[indexsIndex++] = (i - 1) * wgwidth + j;
                    indexs[indexsIndex++] = i * wgwidth + j - 1;

                    indexs[indexsIndex++] = (i - 1) * wgwidth + j;
                    indexs[indexsIndex++] = i * wgwidth + j;
                    indexs[indexsIndex++] = i * wgwidth + j - 1;
                }
            }
        }
        return {
            positions,
            st,
            indexs,
        };
    };

    // 获取3d热力图shader
    CesiumHeatmap.prototype.get3DShader = function () {
        return "uniform sampler2D image;\n\
            czm_material czm_getMaterial(czm_materialInput materialInput)\n\
            {\n\
                vec2 repeat = vec2(1.0,1.0);\n\
                czm_material material = czm_getDefaultMaterial(materialInput);\n\
                vec4 j_color = texture2D(image, fract(repeat * materialInput.st)).rgba; \n\
                material.diffuse = j_color.rgb; \n\
                material.alpha = j_color.a;\n\
                return material;\n\
            }\n\
        "
    };
    /**
     * 显示tooltip
     * 
     * @param {Boolean} [show] 是否显示tooltip。
     */
    CesiumHeatmap.prototype.showTooltip = function (show) {
        if (show) {
            this.tooltipHandler = new Cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
            this.tooltipHandler.setInputAction(event => {
                let position = this._viewer.scene.pickPosition(event.endPosition);
                if (this.heatmapInstance && this.extent && position) {
                    let degrees = this._core.toDegrees(position);
                    let x = (degrees.lon - this.extent.xMin) / (this.extent.xMax - this.extent.xMin) * this.heatmapcanvas.width;
                    let y = (-(degrees.lat - this.extent.yMin) / (this.extent.yMax - this.extent.yMin) + 1) * this.heatmapcanvas.height;
                    if (x <= this.heatmapcanvas.width && x >= 0 & y <= this.heatmapcanvas.height && y >= 0) {
                        let value = this.heatmapInstance.getValueAt({
                            x: Math.round(x),
                            y: Math.round(y)
                        });
                        this.tooltip.showAt(event.endPosition, value);
                    } else {
                        this.tooltip.show(false);
                    }
                } else {
                    this.tooltip.show(false);
                }
            }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
        } else {
            this.tooltip.show(false);
            this.tooltipHandler && this.tooltipHandler.destroy();
            this.tooltipHandler = undefined;
        }
    };

    /**
     * 更新热力图
     * 
     */
    CesiumHeatmap.prototype.updateHeatmap = function () {
        this.heatmapcanvas = this.heatmapInstance._renderer.canvas;
        var image = this.convertCanvasToImage(this.heatmapcanvas);
        this._worldRectangle.appearance.material.uniforms.image = image.src;
    };

    /**
     * 显示隐藏热力图
     * 
     * @param {Boolean} [show] 是否显示。
     */
    CesiumHeatmap.prototype.show = function (show) {
        this._worldRectangle && (this._worldRectangle.show = show);
    };

    /**
     * 设置矩形面透明度
     * 
     * @param {Number} [value] 透明度。
     */
    CesiumHeatmap.prototype.setAlpha = function (value) {
        this._worldRectangle && (this._worldRectangle.appearance.material.uniforms.color.alpha = value);
    };

    CesiumHeatmap.prototype.config = function (options) {
        this.heatmapInstance.configure(options);
        this.updateHeatmap();
    };

    CesiumHeatmap.prototype.convertCanvasToImage = function (canvas) {
        var image = new Image();
        image.src = canvas.toDataURL("image/png");
        return image;
    };

    /**
     * 克隆对象，返回包含相同属性的新对象。
     *
     * @function
     *
     * @param {Object} object 要克隆的对象。
     * @param {Boolean} [deep=false] 如果为true，则所有属性都将以递归方式进行深度克隆。
     * @returns {Object} 克隆对象。
     */
    function clone(object, deep) {
      if (object === null || typeof object !== "object") {
        return object;
      }

      deep = defaultValue(deep, false);

      var result = new object.constructor();
      for (var propertyName in object) {
        if (object.hasOwnProperty(propertyName)) {
          var value = object[propertyName];
          if (deep) {
            value = clone(value, deep);
          }
          result[propertyName] = value;
        }
      }

      return result;
    }

    /**
     *
     * 等高线和坡度图工具
     *
     * @alias ElevationTool
     * @constructor
     *
     * @param {SGWorld} sgworld sgworld对象
     * @param {Object} [option] 参数
     * @param {Number} [option.width=2] 等高线宽度
     * @param {Number} [option.spacing=150] 等高线间距
     * @param {String} [option.startColor="#0055ff"] 起始颜色
     * @param {String} [option.endColor="#ff0000"] 终止颜色
     * @param {String} [option.contourColor="#ff0000"] 等高线颜色
     * @param {Boolean} [option.changeSlopeColor=false] 是否改变默认坡度渲染颜色
     * 
     * @example
     * elevationTool = new SmartEarth.ElevationTool(sgworld)
     * elevationTool.type = 'elevation';
     * elevationTool.render();
     */
    function ElevationTool(sgworld, option = {}) {
        this.sgworld = sgworld;
        this.contourUniforms = undefined;
        this.shadingUniforms = undefined;
        this.min = {
            'elevation': 10,
            'slope': 0
        };
        this.max = {
            'elevation': 2000,
            'slope': 70
        };
        this.width = option.width || 2;
        this.spacing = option.spacing || 150;
        this.tf = false;
        this.contourColor = option.contourColor || "#ff0000";
        this.type = 'none';
        this.Contour = undefined;
        this.startColor = option.startColor || '#0055ff';
        this.endColor = option.endColor || '#ff0000';
        this.colorArr = this.sgworld.Core.gradientColor(this.startColor, this.endColor, 7);
        this.changeSlopeColor = option.changeSlopeColor !== undefined ? option.changeSlopeColor : false;
    }

    /**
     * 刷新渲染
     */
    ElevationTool.prototype.render = function () {
        if (this.type === 'slope') {
            Cesium.ExpandBySmartEarth.displaySlopeMap = true;
            this.changeSlopeColor && this.setShopeColor();
        } else {
            Cesium.ExpandBySmartEarth.displaySlopeMap = false;
        }
        this.Contour = this.sgworld.Analysis.createElevationContour(this.tf, this.type === 'slope' ? 'none' : this.type, {
            colorArr: this.colorArr,
            min: this.min[this.type],
            max: this.max[this.type],
            width: this.width,
            spacing: this.spacing,
            lineColor: this.contourColor
        });
        this.shadingUniforms = this.Contour.item.shadingUniforms;
        this.contourUniforms = this.Contour.item.contourUniforms;
    };

    /**
     * 设置等高线颜色
     * 
     * @param {String} color 颜色
     */
    ElevationTool.prototype.setContourColor = function (color) {
        this.contourColor = color;
        this.Contour && this.Contour.setMaterialColor(this.contourColor);
    };

    ElevationTool.prototype.setShopeColor = function () {
        let arr = [];
        let value = [0, 6, 17, 31, 45, 70, 90];
        this.colorArr.forEach((color, index) => {
            arr.unshift({
                val: 100 * Math.cos(Cesium.Math.toRadians(value[index])),
                color: color
            });
        });
        Cesium.ExpandBySmartEarth.SlopeMapPallete = arr;
        Cesium.ExpandBySmartEarth.isSlopeDirty = !0;
    };

    /**
     * 设置等高线宽度
     * 
     * @param {Number} num 宽度
     */
    ElevationTool.prototype.setWidth = function (num) {
        this.width = num;
        this.Contour && this.Contour.setWidth(this.width);
    };

    /**
     * 设置等高线间距
     * 
     * @param {Number} num 间距
     */
    ElevationTool.prototype.setSpacing = function (num) {
        this.spacing = num;
        this.Contour && this.Contour.setSpacing(this.spacing);
    };

    /**
     * 设置起始颜色
     * 
     * @param {String} color 颜色
     */
    ElevationTool.prototype.setStartColor = function (color) {
        this.startColor = color;
        this.colorArr = this.sgworld.Core.gradientColor(this.startColor, this.endColor, 7);
        this.render();
    };

    /**
     * 设置终止颜色
     * 
     * @param {String} color 颜色
     */
    ElevationTool.prototype.setEndColor = function (color) {
        this.endColor = color;
        this.colorArr = this.sgworld.Core.gradientColor(this.startColor, this.endColor, 7);
        this.render();
    };

    /**
     * 设置最小值
     * 
     * @param {Number} num 最小值
     */
    ElevationTool.prototype.setMin = function (num) {
        this.min[this.type] = num;
        if (this.type === 'elevation') {
            this.shadingUniforms.minimumHeight = this.min[this.type];
        } else {
            this.render();
        }
    };

    /**
     * 设置最大值
     * 
     * @param {Number} num 最大值
     */
    ElevationTool.prototype.setMax = function (num) {
        this.max[this.type] = num;
        if (this.type === 'elevation') {
            this.shadingUniforms.maximumHeight = this.max[this.type];
        } else {
            this.render();
        }
    };

    /**
     * 重置
     * 
     */
    ElevationTool.prototype.reset = function () {
        this.contourColor = "#ff0000";
        this.startColor = '#0055ff';
        this.endColor = '#ff0000';
        this.colorArr = this.sgworld.Core.gradientColor(this.startColor, this.endColor, 7);
        this.render();
    };

    /**
     * 军标绘制扩展工具
     *
     */
    var JBAlgorithm = {
        version: "1.0.0"
    };
    var doubleArrowDefualParam = {
        type: "doublearrow",
        headHeightFactor: .25,
        headWidthFactor: .3,
        neckHeightFactor: .85,
        fixPointCount: 4,
        neckWidthFactor: .15
    };
    var tailedAttackArrowDefualParam = {
        headHeightFactor: .18,
        headWidthFactor: .3,
        neckHeightFactor: .85,
        neckWidthFactor: .15,
        tailWidthFactor: .1,
        headTailFactor: .8,
        swallowTailFactor: 1
    };
    var fineArrowDefualParam = {
        tailWidthFactor: 0.15,
        neckWidthFactor: 0.20,
        headWidthFactor: 0.25,
        headAngle: Math.PI / 8.5,
        neckAngle: Math.PI / 13
    };
    JBAlgorithm.algorithm = {};
    JBAlgorithm.algorithm.doubleArrow = function (inputPoint) {
        this.connPoint = null;
        this.tempPoint4 = null;
        this.points = inputPoint;
        var result = {
            controlPoint: null,
            polygonalPoint: null
        };
        //获取已经点击的坐标数
        var t = inputPoint.length;
        if (!(2 > t)) {
            if (2 == t) return inputPoint;
            var o = this.points[0],    //第一个点
                e = this.points[1],        //第二个点
                r = this.points[2],        //第三个点
                t = inputPoint.length; //获取已经点击的坐标数
            //下面的是移动点位后的坐标
            3 == t ? this.tempPoint4 = JBAlgorithm.algorithm.getTempPoint4(o, e, r) : this.tempPoint4 = this.points[3],
                3 == t || 4 == t ? this.connPoint = P.PlotUtils.mid(o, e) : this.connPoint = this.points[4];
            var n, g;
            P.PlotUtils.isClockWise(o, e, r) ? (n = JBAlgorithm.algorithm.getArrowPoints(o, this.connPoint, this.tempPoint4, !1), g = JBAlgorithm.algorithm.getArrowPoints(this.connPoint, e, r, !0)) : (n = JBAlgorithm.algorithm.getArrowPoints(e, this.connPoint, r, !1), g = JBAlgorithm.algorithm.getArrowPoints(this.connPoint, o, this.tempPoint4, !0));
            var i = n.length,
                s = (i - 5) / 2,
                a = n.slice(0, s),
                l = n.slice(s, s + 5),
                u = n.slice(s + 5, i),
                c = g.slice(0, s),
                p = g.slice(s, s + 5),
                h = g.slice(s + 5, i);
            c = P.PlotUtils.getBezierPoints(c);
            var d = P.PlotUtils.getBezierPoints(h.concat(a.slice(1)));
            u = P.PlotUtils.getBezierPoints(u);
            var f = c.concat(p, d, l, u);
            var newArray = JBAlgorithm.algorithm.array2Dto1D(f);
            result.controlPoint = [o, e, r, this.tempPoint4, this.connPoint];
            result.polygonalPoint = Cesium.Cartesian3.fromDegreesArray(newArray);
        }
        return result;
    };
    JBAlgorithm.algorithm.threeArrow = function (inputPoint) {
        this.connPoint = null;
        this.tempPoint4 = null;
        this.tempPoint5 = null;
        this.points = inputPoint;
        var result = {
            controlPoint: null,
            polygonalPoint: null
        };
        //获取已经点击的坐标数
        var t = inputPoint.length;
        if (t >= 2) {
            if (t == 2) {
                return inputPoint;
            }
            var o = this.points[0],    //第一个点
                e = this.points[1],        //第二个点
                r = this.points[2],        //第三个点
                t = inputPoint.length; //获取已经点击的坐标数
            //下面的是移动点位后的坐标
            if (t == 3) {
                this.tempPoint4 = JBAlgorithm.algorithm.getTempPoint4(o, e, r);
                this.tempPoint5 = P.PlotUtils.mid(r, this.tempPoint4);
            } else {
                this.tempPoint4 = this.points[3];
                this.tempPoint5 = this.points[4];
            }
            if (t < 6) {
                this.connPoint = P.PlotUtils.mid(o, e);
            } else {
                this.connPoint = this.points[5];
            }
            var n, g;
            if (P.PlotUtils.isClockWise(o, e, r)) {
                n = JBAlgorithm.algorithm.getArrowPoints(o, this.connPoint, this.tempPoint4, !1);
                g = JBAlgorithm.algorithm.getArrowPoints(this.connPoint, e, r, !0);
            } else {
                n = JBAlgorithm.algorithm.getArrowPoints(e, this.connPoint, r, !1);
                g = JBAlgorithm.algorithm.getArrowPoints(this.connPoint, o, this.tempPoint4, !0);
            }
            var i = n.length,
                s = (i - 5) / 2,
                a = n.slice(0, s),
                l = n.slice(s, s + 5),
                u = n.slice(s + 5, i),
                c = g.slice(0, s),
                p = g.slice(s, s + 5),
                h = g.slice(s + 5, i);
            c = P.PlotUtils.getBezierPoints(c);
            var d = P.PlotUtils.getBezierPoints(h.concat(a.slice(1)));
            u = P.PlotUtils.getBezierPoints(u);
            var f = c.concat(p, d, l, u);
            var newArray = JBAlgorithm.algorithm.array2Dto1D(f);
            result.controlPoint = [o, e, r, this.tempPoint4, this.tempPoint5, this.connPoint];
            result.polygonalPoint = Cesium.Cartesian3.fromDegreesArray(newArray);
        }
        return result;
    };
    JBAlgorithm.algorithm.array2Dto1D = function (array) {
        var newArray = [];
        array.forEach(function (elt) {
            newArray.push(elt[0]);
            newArray.push(elt[1]);
        });
        return newArray;
    };
    JBAlgorithm.algorithm.getArrowPoints = function (t, o, e, r) {
        this.type = doubleArrowDefualParam.type,
            this.headHeightFactor = doubleArrowDefualParam.headHeightFactor,
            this.headWidthFactor = doubleArrowDefualParam.headWidthFactor,
            this.neckHeightFactor = doubleArrowDefualParam.neckHeightFactor,
            this.neckWidthFactor = doubleArrowDefualParam.neckWidthFactor;
        var n = P.PlotUtils.mid(t, o),
            g = P.PlotUtils.distance(n, e),
            i = P.PlotUtils.getThirdPoint(e, n, 0, .3 * g, !0),
            s = P.PlotUtils.getThirdPoint(e, n, 0, .5 * g, !0);
        i = P.PlotUtils.getThirdPoint(n, i, P.Constants.HALF_PI, g / 5, r),
            s = P.PlotUtils.getThirdPoint(n, s, P.Constants.HALF_PI, g / 4, r);
        var a = [n, i, s, e],
            l = JBAlgorithm.algorithm.getArrowHeadPoints(a, this.headHeightFactor, this.headWidthFactor, this.neckHeightFactor, this.neckWidthFactor),
            u = l[0],
            c = l[4],
            p = P.PlotUtils.distance(t, o) / P.PlotUtils.getBaseLength(a) / 2,
            h = JBAlgorithm.algorithm.getArrowBodyPoints(a, u, c, p),
            d = h.length,
            f = h.slice(0, d / 2),
            E = h.slice(d / 2, d);
        return f.push(u),
            E.push(c),
            f = f.reverse(),
            f.push(o),
            E = E.reverse(),
            E.push(t),
            f.reverse().concat(l, E)
    };
    JBAlgorithm.algorithm.getArrowHeadPoints = function (t, o, e) {
        this.type = doubleArrowDefualParam.type,
            this.headHeightFactor = doubleArrowDefualParam.headHeightFactor,
            this.headWidthFactor = doubleArrowDefualParam.headWidthFactor,
            this.neckHeightFactor = doubleArrowDefualParam.neckHeightFactor,
            this.neckWidthFactor = doubleArrowDefualParam.neckWidthFactor;
        var r = P.PlotUtils.getBaseLength(t),
            n = r * this.headHeightFactor,
            g = t[t.length - 1],
            i = (P.PlotUtils.distance(o, e), n * this.headWidthFactor),
            s = n * this.neckWidthFactor,
            a = n * this.neckHeightFactor,
            l = P.PlotUtils.getThirdPoint(t[t.length - 2], g, 0, n, !0),
            u = P.PlotUtils.getThirdPoint(t[t.length - 2], g, 0, a, !0),
            c = P.PlotUtils.getThirdPoint(g, l, P.Constants.HALF_PI, i, !1),
            p = P.PlotUtils.getThirdPoint(g, l, P.Constants.HALF_PI, i, !0),
            h = P.PlotUtils.getThirdPoint(g, u, P.Constants.HALF_PI, s, !1),
            d = P.PlotUtils.getThirdPoint(g, u, P.Constants.HALF_PI, s, !0);
        return [h, c, g, p, d];
    };
    JBAlgorithm.algorithm.getArrowBodyPoints = function (t, o, e, r) {
        for (var n = P.PlotUtils.wholeDistance(t), g = P.PlotUtils.getBaseLength(t), i = g * r, s = P.PlotUtils.distance(o, e), a = (i - s) / 2, l = 0, u = [], c = [], p = 1; p < t.length - 1; p++) {
            var h = P.PlotUtils.getAngleOfThreePoints(t[p - 1], t[p], t[p + 1]) / 2;
            l += P.PlotUtils.distance(t[p - 1], t[p]);
            var d = (i / 2 - l / n * a) / Math.sin(h),
                f = P.PlotUtils.getThirdPoint(t[p - 1], t[p], Math.PI - h, d, !0),
                E = P.PlotUtils.getThirdPoint(t[p - 1], t[p], h, d, !1);
            u.push(f),
                c.push(E);
        }
        return u.concat(c)
    };
    JBAlgorithm.algorithm.getTempPoint4 = function (t, o, e) {
        var r, n, g, i, s = P.PlotUtils.mid(t, o),
            a = P.PlotUtils.distance(s, e),
            l = P.PlotUtils.getAngleOfThreePoints(t, s, e);
        return l < P.Constants.HALF_PI ? (n = a * Math.sin(l), g = a * Math.cos(l), i = P.PlotUtils.getThirdPoint(t, s, P.Constants.HALF_PI, n, !1), r = P.PlotUtils.getThirdPoint(s, i, P.Constants.HALF_PI, g, !0)) : l >= P.Constants.HALF_PI && l < Math.PI ? (n = a * Math.sin(Math.PI - l), g = a * Math.cos(Math.PI - l), i = P.PlotUtils.getThirdPoint(t, s, P.Constants.HALF_PI, n, !1), r = P.PlotUtils.getThirdPoint(s, i, P.Constants.HALF_PI, g, !1)) : l >= Math.PI && l < 1.5 * Math.PI ? (n = a * Math.sin(l - Math.PI), g = a * Math.cos(l - Math.PI), i = P.PlotUtils.getThirdPoint(t, s, P.Constants.HALF_PI, n, !0), r = P.PlotUtils.getThirdPoint(s, i, P.Constants.HALF_PI, g, !0)) : (n = a * Math.sin(2 * Math.PI - l), g = a * Math.cos(2 * Math.PI - l), i = P.PlotUtils.getThirdPoint(t, s, P.Constants.HALF_PI, n, !0), r = P.PlotUtils.getThirdPoint(s, i, P.Constants.HALF_PI, g, !1)),
            r
    };
    JBAlgorithm.algorithm.tailedAttackArrow = function (inputPoint) {
        inputPoint = JBAlgorithm.algorithm.dereplication(inputPoint);
        this.tailWidthFactor = tailedAttackArrowDefualParam.tailWidthFactor;
        this.swallowTailFactor = tailedAttackArrowDefualParam.swallowTailFactor;
        this.swallowTailPnt = tailedAttackArrowDefualParam.swallowTailPnt;
        //控制点
        var result = {
            controlPoint: null,
            polygonalPoint: null
        };
        result.controlPoint = inputPoint;
        var t = inputPoint.length;
        if (!(2 > t)) {
            if (2 == inputPoint.length) {
                result.polygonalPoint = inputPoint;
                return result;
            }
            var o = inputPoint,
                e = o[0],
                r = o[1];
            P.PlotUtils.isClockWise(o[0], o[1], o[2]) && (e = o[1], r = o[0]);
            var n = P.PlotUtils.mid(e, r),
                g = [n].concat(o.slice(2)),
                i = JBAlgorithm.algorithm.getAttackArrowHeadPoints(g, e, r, tailedAttackArrowDefualParam),
                s = i[0],
                a = i[4],
                l = P.PlotUtils.distance(e, r),
                u = P.PlotUtils.getBaseLength(g),
                c = u * this.tailWidthFactor * this.swallowTailFactor;
            this.swallowTailPnt = P.PlotUtils.getThirdPoint(g[1], g[0], 0, c, !0);
            var p = l / u,
                h = JBAlgorithm.algorithm.getAttackArrowBodyPoints(g, s, a, p),
                t = h.length,
                d = [e].concat(h.slice(0, t / 2));
            d.push(s);
            var f = [r].concat(h.slice(t / 2, t));
            var newArray = [];
            f.push(a),
                d = P.PlotUtils.getQBSplinePoints(d),
                f = P.PlotUtils.getQBSplinePoints(f),
                newArray = JBAlgorithm.algorithm.array2Dto1D(d.concat(i, f.reverse(), [this.swallowTailPnt, d[0]]));
            result.polygonalPoint = Cesium.Cartesian3.fromDegreesArray(newArray);
        }
        return result;
    };
    JBAlgorithm.algorithm.getAttackArrowHeadPoints = function (t, o, e, defaultParam) {
        this.headHeightFactor = defaultParam.headHeightFactor;
        this.headTailFactor = defaultParam.headTailFactor;
        this.headWidthFactor = defaultParam.headWidthFactor;
        this.neckWidthFactor = defaultParam.neckWidthFactor;
        this.neckHeightFactor = defaultParam.neckHeightFactor;
        var r = P.PlotUtils.getBaseLength(t),
            n = r * this.headHeightFactor,
            g = t[t.length - 1];
        r = P.PlotUtils.distance(g, t[t.length - 2]);
        var i = P.PlotUtils.distance(o, e);
        n > i * this.headTailFactor && (n = i * this.headTailFactor);
        var s = n * this.headWidthFactor,
            a = n * this.neckWidthFactor;
        n = n > r ? r : n;
        var l = n * this.neckHeightFactor,
            u = P.PlotUtils.getThirdPoint(t[t.length - 2], g, 0, n, !0),
            c = P.PlotUtils.getThirdPoint(t[t.length - 2], g, 0, l, !0),
            p = P.PlotUtils.getThirdPoint(g, u, P.Constants.HALF_PI, s, !1),
            h = P.PlotUtils.getThirdPoint(g, u, P.Constants.HALF_PI, s, !0),
            d = P.PlotUtils.getThirdPoint(g, c, P.Constants.HALF_PI, a, !1),
            f = P.PlotUtils.getThirdPoint(g, c, P.Constants.HALF_PI, a, !0);
        return [d, p, g, h, f]
    };
    JBAlgorithm.algorithm.getAttackArrowBodyPoints = function (t, o, e, r) {
        for (var n = P.PlotUtils.wholeDistance(t), g = P.PlotUtils.getBaseLength(t), i = g * r, s = P.PlotUtils.distance(o, e), a = (i - s) / 2, l = 0, u = [], c = [], p = 1; p < t.length - 1; p++) {
            var h = P.PlotUtils.getAngleOfThreePoints(t[p - 1], t[p], t[p + 1]) / 2;
            l += P.PlotUtils.distance(t[p - 1], t[p]);
            var d = (i / 2 - l / n * a) / Math.sin(h),
                f = P.PlotUtils.getThirdPoint(t[p - 1], t[p], Math.PI - h, d, !0),
                E = P.PlotUtils.getThirdPoint(t[p - 1], t[p], h, d, !1);
            u.push(f),
                c.push(E);
        }
        return u.concat(c)
    };
    JBAlgorithm.algorithm.dereplication = function (array) {
        var last = array[array.length - 1];
        var change = false;
        var newArray = [];
        newArray = array.filter(function (i) {
            if (i[0] != last[0] && i[1] != last[1]) {
                return i;
            }
            change = true;
        });
        if (change) newArray.push(last);
        return newArray;
    };
    JBAlgorithm.algorithm.fineArrow = function (tailPoint, headerPoint) {
        if ((tailPoint.length < 2) || (headerPoint.length < 2)) return;
        //画箭头的函数
        var tailWidthFactor = fineArrowDefualParam.tailWidthFactor;
        var neckWidthFactor = fineArrowDefualParam.neckWidthFactor;
        var headWidthFactor = fineArrowDefualParam.headWidthFactor;
        var headAngle = fineArrowDefualParam.headAngle;
        var neckAngle = fineArrowDefualParam.neckAngle;
        var o = [];
        o[0] = tailPoint;
        o[1] = headerPoint;
        e = o[0],
            r = o[1],
            n = P.PlotUtils.getBaseLength(o),
            g = n * tailWidthFactor,
            //尾部宽度因子
            i = n * neckWidthFactor,
            //脖子宽度银子
            s = n * headWidthFactor,
            //头部宽度因子
            a = P.PlotUtils.getThirdPoint(r, e, P.Constants.HALF_PI, g, !0),
            l = P.PlotUtils.getThirdPoint(r, e, P.Constants.HALF_PI, g, !1),
            u = P.PlotUtils.getThirdPoint(e, r, headAngle, s, !1),
            c = P.PlotUtils.getThirdPoint(e, r, headAngle, s, !0),
            p = P.PlotUtils.getThirdPoint(e, r, neckAngle, i, !1),
            h = P.PlotUtils.getThirdPoint(e, r, neckAngle, i, !0),
            d = [];
        d.push(a[0], a[1], p[0], p[1], u[0], u[1], r[0], r[1], c[0], c[1], h[0], h[1], l[0], l[1], e[0], e[1]);
        return Cesium.Cartesian3.fromDegreesArray(d);
    };

    var P = { version: "1.0.0" };
    P.PlotUtils = {}, P.PlotUtils.distance = function (t, o) {
        return Math.sqrt(Math.pow(t[0] - o[0], 2) + Math.pow(t[1] - o[1], 2))
    }, P.PlotUtils.wholeDistance = function (t) {
        for (var o = 0, e = 0; e < t.length - 1; e++) o += P.PlotUtils.distance(t[e], t[e + 1]);
        return o
    }, P.PlotUtils.getBaseLength = function (t) {
        return Math.pow(P.PlotUtils.wholeDistance(t), .99)
    }, P.PlotUtils.mid = function (t, o) {
        return [(t[0] + o[0]) / 2, (t[1] + o[1]) / 2]
    }, P.PlotUtils.getCircleCenterOfThreePoints = function (t, o, e) {
        var r = [(t[0] + o[0]) / 2, (t[1] + o[1]) / 2],
            n = [r[0] - t[1] + o[1], r[1] + t[0] - o[0]],
            g = [(t[0] + e[0]) / 2, (t[1] + e[1]) / 2],
            i = [g[0] - t[1] + e[1], g[1] + t[0] - e[0]];
        return P.PlotUtils.getIntersectPoint(r, n, g, i)
    }, P.PlotUtils.getIntersectPoint = function (t, o, e, r) {
        if (t[1] == o[1]) {
            var n = (r[0] - e[0]) / (r[1] - e[1]),
                g = n * (t[1] - e[1]) + e[0],
                i = t[1];
            return [g, i]
        }
        if (e[1] == r[1]) {
            var s = (o[0] - t[0]) / (o[1] - t[1]);
            return g = s * (e[1] - t[1]) + t[0], i = e[1], [g, i]
        }
        return s = (o[0] - t[0]) / (o[1] - t[1]), n = (r[0] - e[0]) / (r[1] - e[1]), i = (s * t[1] - t[0] - n * e[1] + e[0]) / (s - n), g = s * i - s * t[1] + t[0], [g, i]
    }, P.PlotUtils.getAzimuth = function (t, o) {
        var e, r = Math.asin(Math.abs(o[1] - t[1]) / P.PlotUtils.distance(t, o));
        return o[1] >= t[1] && o[0] >= t[0] ? e = r + Math.PI : o[1] >= t[1] && o[0] < t[0] ? e = P.Constants.TWO_PI - r : o[1] < t[1] && o[0] < t[0] ? e = r : o[1] < t[1] && o[0] >= t[0] && (e = Math.PI - r), e
    }, P.PlotUtils.getAngleOfThreePoints = function (t, o, e) {
        var r = P.PlotUtils.getAzimuth(o, t) - P.PlotUtils.getAzimuth(o, e);
        return 0 > r ? r + P.Constants.TWO_PI : r
    }, P.PlotUtils.isClockWise = function (t, o, e) {
        return (e[1] - t[1]) * (o[0] - t[0]) > (o[1] - t[1]) * (e[0] - t[0])
    }, P.PlotUtils.getPointOnLine = function (t, o, e) {
        var r = o[0] + t * (e[0] - o[0]),
            n = o[1] + t * (e[1] - o[1]);
        return [r, n]
    }, P.PlotUtils.getCubicValue = function (t, o, e, r, n) {
        t = Math.max(Math.min(t, 1), 0);
        var g = 1 - t,
            i = t * t,
            s = i * t,
            a = g * g,
            l = a * g,
            u = l * o[0] + 3 * a * t * e[0] + 3 * g * i * r[0] + s * n[0],
            c = l * o[1] + 3 * a * t * e[1] + 3 * g * i * r[1] + s * n[1];
        return [u, c]
    }, P.PlotUtils.getThirdPoint = function (t, o, e, r, n) {
        var g = P.PlotUtils.getAzimuth(t, o),
            i = n ? g + e : g - e,
            s = r * Math.cos(i),
            a = r * Math.sin(i);
        return [o[0] + s, o[1] + a]
    }, P.PlotUtils.getArcPoints = function (t, o, e, r) {
        var n, g, i = [],
            s = r - e;
        s = 0 > s ? s + P.Constants.TWO_PI : s;
        for (var a = 0; a <= P.Constants.FITTING_COUNT; a++) {
            var l = e + s * a / P.Constants.FITTING_COUNT;
            n = t[0] + o * Math.cos(l), g = t[1] + o * Math.sin(l), i.push([n, g]);
        }
        return i
    }, P.PlotUtils.getBisectorNormals = function (t, o, e, r) {
        var n = P.PlotUtils.getNormal(o, e, r),
            g = Math.sqrt(n[0] * n[0] + n[1] * n[1]),
            i = n[0] / g,
            s = n[1] / g,
            a = P.PlotUtils.distance(o, e),
            l = P.PlotUtils.distance(e, r);
        if (g > P.Constants.ZERO_TOLERANCE) if (P.PlotUtils.isClockWise(o, e, r)) {
            var u = t * a,
                c = e[0] - u * s,
                p = e[1] + u * i,
                h = [c, p];
            u = t * l, c = e[0] + u * s, p = e[1] - u * i;
            var d = [c, p];
        } else u = t * a, c = e[0] + u * s, p = e[1] - u * i, h = [c, p], u = t * l, c = e[0] - u * s, p = e[1] + u * i, d = [c, p];
        else c = e[0] + t * (o[0] - e[0]), p = e[1] + t * (o[1] - e[1]), h = [c, p], c = e[0] + t * (r[0] - e[0]), p = e[1] + t * (r[1] - e[1]), d = [c, p];
        return [h, d]
    }, P.PlotUtils.getNormal = function (t, o, e) {
        var r = t[0] - o[0],
            n = t[1] - o[1],
            g = Math.sqrt(r * r + n * n);
        r /= g, n /= g;
        var i = e[0] - o[0],
            s = e[1] - o[1],
            a = Math.sqrt(i * i + s * s);
        i /= a, s /= a;
        var l = r + i,
            u = n + s;
        return [l, u]
    }, P.PlotUtils.getCurvePoints = function (t, o) {
        for (var e = P.PlotUtils.getLeftMostControlPoint(o), r = [e], n = 0; n < o.length - 2; n++) {
            var g = o[n],
                i = o[n + 1],
                s = o[n + 2],
                a = P.PlotUtils.getBisectorNormals(t, g, i, s);
            r = r.concat(a);
        }
        var l = P.PlotUtils.getRightMostControlPoint(o);
        r.push(l);
        var u = [];
        for (n = 0; n < o.length - 1; n++) {
            g = o[n], i = o[n + 1], u.push(g);
            for (var t = 0; t < P.Constants.FITTING_COUNT; t++) {
                var c = P.PlotUtils.getCubicValue(t / P.Constants.FITTING_COUNT, g, r[2 * n], r[2 * n + 1], i);
                u.push(c);
            }
            u.push(i);
        }
        return u
    }, P.PlotUtils.getLeftMostControlPoint = function (o) {
        var e = o[0],
            r = o[1],
            n = o[2],
            g = P.PlotUtils.getBisectorNormals(0, e, r, n),
            i = g[0],
            s = P.PlotUtils.getNormal(e, r, n),
            a = Math.sqrt(s[0] * s[0] + s[1] * s[1]);
        if (a > P.Constants.ZERO_TOLERANCE) var l = P.PlotUtils.mid(e, r),
            u = e[0] - l[0],
            c = e[1] - l[1],
            p = P.PlotUtils.distance(e, r),
            h = 2 / p,
            d = -h * c,
            f = h * u,
            E = d * d - f * f,
            v = 2 * d * f,
            A = f * f - d * d,
            _ = i[0] - l[0],
            y = i[1] - l[1],
            m = l[0] + E * _ + v * y,
            O = l[1] + v * _ + A * y;
        else m = e[0] + t * (r[0] - e[0]), O = e[1] + t * (r[1] - e[1]);
        return [m, O]
    }, P.PlotUtils.getRightMostControlPoint = function (o) {
        var e = o.length,
            r = o[e - 3],
            n = o[e - 2],
            g = o[e - 1],
            i = P.PlotUtils.getBisectorNormals(0, r, n, g),
            s = i[1],
            a = P.PlotUtils.getNormal(r, n, g),
            l = Math.sqrt(a[0] * a[0] + a[1] * a[1]);
        if (l > P.Constants.ZERO_TOLERANCE) var u = P.PlotUtils.mid(n, g),
            c = g[0] - u[0],
            p = g[1] - u[1],
            h = P.PlotUtils.distance(n, g),
            d = 2 / h,
            f = -d * p,
            E = d * c,
            v = f * f - E * E,
            A = 2 * f * E,
            _ = E * E - f * f,
            y = s[0] - u[0],
            m = s[1] - u[1],
            O = u[0] + v * y + A * m,
            T = u[1] + A * y + _ * m;
        else O = g[0] + t * (n[0] - g[0]), T = g[1] + t * (n[1] - g[1]);
        return [O, T]
    }, P.PlotUtils.getBezierPoints = function (t) {
        if (t.length <= 2) return t;
        for (var o = [], e = t.length - 1, r = 0; 1 >= r; r += .01) {
            for (var n = 0, y = 0, g = 0; e >= g; g++) {
                var i = P.PlotUtils.getBinomialFactor(e, g),
                    s = Math.pow(r, g),
                    a = Math.pow(1 - r, e - g);
                n += i * s * a * t[g][0], y += i * s * a * t[g][1];
            }
            o.push([n, y]);
        }
        return o.push(t[e]), o
    }, P.PlotUtils.getBinomialFactor = function (t, o) {
        return P.PlotUtils.getFactorial(t) / (P.PlotUtils.getFactorial(o) * P.PlotUtils.getFactorial(t - o))
    }, P.PlotUtils.getFactorial = function (t) {
        if (1 >= t) return 1;
        if (2 == t) return 2;
        if (3 == t) return 6;
        if (4 == t) return 24;
        if (5 == t) return 120;
        for (var o = 1, e = 1; t >= e; e++) o *= e;
        return o
    }, P.PlotUtils.getQBSplinePoints = function (t) {
        if (t.length <= 2) return t;
        var o = 2,
            e = [],
            r = t.length - o - 1;
        e.push(t[0]);
        for (var n = 0; r >= n; n++) for (var g = 0; 1 >= g; g += .05) {
            for (var i = 0, y = 0, s = 0; o >= s; s++) {
                var a = P.PlotUtils.getQuadricBSplineFactor(s, g);
                i += a * t[n + s][0], y += a * t[n + s][1];
            }
            e.push([i, y]);
        }
        return e.push(t[t.length - 1]), e
    }, P.PlotUtils.getQuadricBSplineFactor = function (t, o) {
        return 0 == t ? Math.pow(o - 1, 2) / 2 : 1 == t ? (-2 * Math.pow(o, 2) + 2 * o + 1) / 2 : 2 == t ? Math.pow(o, 2) / 2 : 0
    }, P.Constants = {
        TWO_PI: 2 * Math.PI,
        HALF_PI: Math.PI / 2,
        FITTING_COUNT: 100,
        ZERO_TOLERANCE: 1e-4
    };

    /**
    * 天地图wmts影像工具
    *
    */
    function TDTWMTSImageProvider(urlformat, addone, minlevel, maxlevel, description, leveldiv, urlformat2) {
        var defaultCredit = new Cesium.Credit('WMTS');
        description = Cesium.defaultValue(description, {});
        this._7 = new Cesium.GeographicTilingScheme({
            numberOfLevelZeroTilesX: 2,
            numberOfLevelZeroTilesY: 1
        });
        this._3 = 256;
        this._4 = 256;
        this._10 = Cesium.defaultValue(description.fileExtension, 'jpg');
        this._9 = description.proxy;
        this._12 = description.tileDiscardPolicy;
        this._2 = minlevel;
        this._1 = maxlevel;
        this._8 = new Cesium.Rectangle(0 - Math.PI, 0 - Math.PI / 2, Math.PI, Math.PI / 2);
        this._5 = new Cesium.Rectangle(0 - Math.PI, 0 - Math.PI / 2, Math.PI, Math.PI / 2);
        this._6 = true;
        this.baseurl = urlformat;
        this.needaddone = addone;
        if (leveldiv) {
            this._0 = leveldiv;
            this.baseurl2 = urlformat2;
        }
        var credit = Cesium.defaultValue(description.credit, defaultCredit);
        if (typeof credit === 'string') {
            credit = new Cesium.Credit(credit);
        }
        this._11 = credit;
    }Object.defineProperties(TDTWMTSImageProvider.prototype, {
        tileWidth: {
            get: function () {
                return this._3
            }
        },
        tileHeight: {
            get: function () {
                return this._4
            }
        },
        defaultAlpha: {
            get: function () {
                return 1
            }
        },
        hasAlphaChannel: {
            get: function () {
                return true
            }
        },
        maximumLevel: {
            get: function () {
                return this._1
            }
        },
        minimumLevel: {
            get: function () {
                return this._2
            }
        },
        tilingScheme: {
            get: function () {
                return this._7
            }
        },
        extent: {
            get: function () {
                return this._8
            }
        },
        rectangle: {
            get: function () {
                return this._5
            }
        },
        ready: {
            get: function () {
                return this._6
            }
        },
        minimumTerrainLevel: {
            get: function () {
                return 0
            }
        },
        maximumTerrainLevel: {
            get: function () {
                return 17
            }
        }
    });
    TDTWMTSImageProvider.prototype.requestImage = function (x, y, level) {
        if (this.needaddone) {
            x += 1;
            y += 1;
            level += 1;
        }
        var tempurl = this.baseurl;
        if (this._0) if (level > this._0) tempurl = this.baseurl2;
        var url = tempurl.replace("{x}", x);
        url = url.replace("{l}", y % 8);
        url = url.replace("{y}", y);
        url = url.replace("{z}", level + 1);
        return Cesium.ImageryProvider.loadImage(this, url)
    };

    function GmlParser$1(e, t, n, r) {
        this._extractAttributes = e,
            this._featureName = t || "featureMember",
            this._xy = r,
            this._gmlns = n || "http://www.opengis.net/gml",
            this._regExes = {
                trimSpace: /^\s*|\s*$/g,
                removeSpace: /\s*/g,
                splitSpace: /\s+/,
                trimComma: /\s*,\s*/g
            };
    }
    Object.defineProperties(GmlParser$1.prototype, {
        featureName: {
            get: function () {
                return this._featureName
            },
            set: function (e) {
                this._featureName = e;
            }
        },
        extractAttributes: {
            get: function () {
                return this._extractAttributes
            },
            set: function (e) {
                this._extractAttributes = e;
            }
        },
        xy: {
            get: function () {
                return this._xy
            }
        }
    });
    GmlParser$1.prototype.getElementsByTagNameNS = function (e, t, n) {
        var r = [];
        if (e.getElementsByTagNameNS) r = e.getElementsByTagNameNS(t, n);
        else {
            var i = e.getElementsByTagName("*"),
                s, o;
            for (var u = 0, a = i.length; u < a; ++u) s = i[u],
                o = s.prefix ? s.prefix + ":" + n : n,
                (n == "*" || o == s.nodeName) && (t == "*" || t == s.namespaceURI) && r.push(s);
        }
        return r
    };
    GmlParser$1.prototype.read = function (e) {
        var t = this.getElementsByTagNameNS(e.documentElement, this._gmlns, this.featureName),
            n = [];
        for (var r = 0; r < t.length; r++) {
            var i = this.parseFeature(t[r]);
            i && n.push(i);
        }
        return n
    };
    GmlParser$1.prototype.parseFeature = function (e) {
        var t = ["MultiPolygon", "Polygon", "MultiLineString", "LineString", "MultiPoint", "Point", "Envelope"],
            n, r, i, s;
        for (var o = 0; o < t.length; ++o) {
            n = t[o],
                r = this.getElementsByTagNameNS(e, this._gmlns, n);
            if (r.length > 0) {
                s = this.parseGeometry[n.toLowerCase()],
                    s ? i = s.apply(this, [r[0]]) : console.log("unsupportedGeometryType:" + n);
                break
            }
        }
        var u, a = this.getElementsByTagNameNS(e, this._gmlns, "Box");
        for (o = 0; o < a.length; ++o) {
            var f = a[o],
                l = this.parseGeometry.box.apply(this, [f]),
                c = f.parentNode,
                h = c.localName || c.nodeName.split(":").pop();
            h === "boundedBy" ? u = l : i = l.toGeometry();
        }
        var p;
        this.extractAttributes && (p = this.parseAttributes(e));
        var d = {
            geometryType: n.toLowerCase(),
            positions: i,
            attributes: p
        };
        d.bounds = u;
        var v = e.firstChild,
            m;
        while (v) {
            if (v.nodeType == 1) {
                m = v.getAttribute("fid") || v.getAttribute("id");
                if (m) break
            }
            v = v.nextSibling;
        }
        return d.fid = m,
            d
    };
    GmlParser$1.prototype.parseGeometry = {
        point: function (e) {
            var t, n, r = [],
                t = this.getElementsByTagNameNS(e, this._gmlns, "pos");
            t.length > 0 && (n = t[0].firstChild.nodeValue, n = n.replace(this._regExes.trimSpace, ""), r = n.split(this._regExes.splitSpace)),
                r.length == 0 && (t = this.getElementsByTagNameNS(e, this._gmlns, "coordinates"), t.length > 0 && (n = t[0].firstChild.nodeValue, n = n.replace(this._regExes.removeSpace, ""), r = n.split(",")));
            if (r.length == 0) {
                t = this.getElementsByTagNameNS(e, this._gmlns, "coord");
                if (t.length > 0) {
                    var i = this.getElementsByTagNameNS(t[0], this._gmlns, "X"),
                        s = this.getElementsByTagNameNS(t[0], this._gmlns, "Y");
                    i.length > 0 && s.length > 0 && (r = [i[0].firstChild.nodeValue, s[0].firstChild.nodeValue]);
                }
            }
            return r.length == 2 && (r[2] = null),
                this.xy ? [parseFloat(r[0]), parseFloat(r[1]), parseFloat(r[2])] : [parseFloat(r[1]), parseFloat(r[0]), parseFloat(r[2])]
        },
        multipoint: function (e) {
            var t = this.getElementsByTagNameNS(e, this._gmlns, "Point"),
                n = [];
            if (t.length > 0) {
                var r;
                for (var i = 0; i < t.length; ++i) r = this.parseGeometry.point.apply(this, [t[i]]),
                    r && n.push(r);
            }
            return n
        },
        linestring: function (e, t) {
            var n, r, i = [],
                s = [];
            n = this.getElementsByTagNameNS(e, this._gmlns, "posList");
            if (n.length > 0) {
                r = this.getChildValue(n[0]),
                    r = r.replace(this._regExes.trimSpace, ""),
                    i = r.split(this._regExes.splitSpace);
                var o = parseInt(n[0].getAttribute("dimension")),
                    u, a, f, l;
                for (var c = 0; c < i.length / o; ++c) u = c * o,
                    a = parseFloat(i[u]),
                    f = parseFloat(i[u + 1]),
                    l = o == 2 ? null : parseFloat(i[u + 2]),
                    this.xy ? s.push(a, f, l) : s.push(f, a, l);
            }
            if (i.length == 0) {
                n = this.getElementsByTagNameNS(e, this._gmlns, "coordinates");
                if (n.length > 0) {
                    r = this.getChildValue(n[0]),
                        r = r.replace(this._regExes.trimSpace, ""),
                        r = r.replace(this._regExes.trimComma, ",");
                    var h = r.split(this._regExes.splitSpace);
                    for (var c = 0; c < h.length; ++c) i = h[c].split(","),
                        i.length == 2 && (i[2] = null),
                        this.xy ? s.push(parseFloat(i[0]), parseFloat(i[1]), parseFloat(i[2])) : s.push(parseFloat(i[1]), parseFloat(i[0]), parseFloat(i[2]));
                }
            }
            return s
        },
        multilinestring: function (e) {
            var t = this.getElementsByTagNameNS(e, this._gmlns, "LineString"),
                n = [];
            if (t.length > 0) {
                var r;
                for (var i = 0; i < t.length; ++i) r = this.parseGeometry.linestring.apply(this, [t[i]]),
                    r && n.push(r);
            }
            return n
        },
        polygon: function (e) {
            var t = this.getElementsByTagNameNS(e, this._gmlns, "LinearRing"),
                n = [];
            if (t.length > 0) {
                var r;
                for (var i = 0; i < t.length; ++i) r = this.parseGeometry.linestring.apply(this, [t[i], !0]),
                    r && n.push(r);
            }
            return n
        },
        multipolygon: function (e) {
            var t = this.getElementsByTagNameNS(e, this._gmlns, "Polygon"),
                n = [];
            if (t.length > 0) {
                var r;
                for (var i = 0; i < t.length; ++i) r = this.parseGeometry.polygon.apply(this, [t[i]]),
                    r && n.push(r);
            }
            return n
        },
        envelope: function (e) {
            var t = [],
                n, r, i = this.getElementsByTagNameNS(e, this._gmlns, "lowerCorner");
            if (i.length > 0) {
                var s = [];
                i.length > 0 && (n = i[0].firstChild.nodeValue, n = n.replace(this._regExes.trimSpace, ""), s = n.split(this._regExes.splitSpace)),
                    s.length == 2 && (s[2] = null);
                if (this.xy) var o = new OpenLayers_Geometry_Point(s[0], s[1], s[2]);
                else var o = new OpenLayers_Geometry_Point(s[1], s[0], s[2]);
            }
            var u = this.getElementsByTagNameNS(e, this._gmlns, "upperCorner");
            if (u.length > 0) {
                var s = [];
                u.length > 0 && (n = u[0].firstChild.nodeValue, n = n.replace(this._regExes.trimSpace, ""), s = n.split(this._regExes.splitSpace)),
                    s.length == 2 && (s[2] = null);
                if (this.xy) var a = new OpenLayers_Geometry_Point(s[0], s[1], s[2]);
                else var a = new OpenLayers_Geometry_Point(s[1], s[0], s[2]);
            }
            return o && a && (t.push([o.x, o.y, null]), t.push([a.x, o.y, null]), t.push([a.x, a.y, null]), t.push([o.x, a.y, null]), t.push([o.x, o.y, null]), r = new OpenLayers_Geometry_Polygon([
                [t]
            ])),
                r
        },
        box: function (e) {
            var t = this.getElementsByTagNameNS(e, this._gmlns, "coordinates"),
                n, r, i = null,
                s = null;
            t.length > 0 && (n = t[0].firstChild.nodeValue, r = n.split(" "), r.length == 2 && (i = r[0].split(","), s = r[1].split(",")));
            if (i !== null && s !== null) return [parseFloat(i[0]), parseFloat(i[1]), null, parseFloat(s[0]), parseFloat(s[1]), null]
        }
    };
    GmlParser$1.prototype.parseAttributes = function (e) {
        var t = {},
            n = e.firstChild,
            r, i, s, o, u, a, f;
        while (n) {
            if (n.nodeType == 1) {
                r = n.childNodes;
                for (i = 0; i < r.length; ++i) {
                    s = r[i];
                    if (s.nodeType == 1) {
                        o = s.childNodes;
                        if (o.length == 1) {
                            u = o[0];
                            if (u.nodeType == 3 || u.nodeType == 4) a = s.prefix ? s.nodeName.split(":")[1] : s.nodeName,
                                f = u.nodeValue.replace(this._regExes.trimSpace, ""),
                                t[a] = f;
                        } else t[s.nodeName.split(":").pop()] = null;
                    }
                }
                break
            }
            n = n.nextSibling;
        }
        return t
    };
    GmlParser$1.prototype.getChildValue = function (e, t) {
        var n = t || "";
        if (e)
            for (var r = e.firstChild; r; r = r.nextSibling) switch (r.nodeType) {
                case 3:
                case 4:
                    n += r.nodeValue;
            }
        return n
    };

    function TileManager1$1() {
        this._quadtree = undefined;
        this._loadTileEvent = new Cesium.Event;
        this._tilingScheme = new Cesium.GeographicTilingScheme();
        this._errorEvent = new Cesium.Event();
        this._levelZeroMaximumError = Cesium.QuadtreeTileProvider.computeDefaultLevelZeroMaximumGeometricError(this._tilingScheme);
        this.cartographicLimitRectangle = Cesium.Rectangle.clone(Cesium.Rectangle.MAX_VALUE);
        this._tileCache = [];
        this._primitivesWaitingToBeAddedToTheScene = [];
        this._pauseStreaming = !1;
        this._numTilesInLevel = [];
        this.STREAM_SPEED_IMIDIATE = 0;
        this.STREAM_SPEED_FAST = 1;
        this.STREAM_SPEED_NORMAL = 2;
        this.STREAM_SPEED_SLOW = 3;
        this._streamSpeed = this.STREAM_SPEED_NORMAL;
        if (!TileManager1$1.prototype.ready)
            Object.defineProperties(TileManager1$1.prototype, {
                quadtree: {
                    get: function () {
                        return this._quadtree;
                    },
                    set: function (value) {
                        this._quadtree = value;
                    }
                },
                ready: {
                    get: function () {
                        return true;
                    }
                },
                tilingScheme: {
                    get: function () {
                        return this._tilingScheme;
                    }
                },
                errorEvent: {
                    get: function () {
                        return this._errorEvent;
                    }
                },
                loadTileEvent: {
                    get: function () {
                        return this._loadTileEvent
                    }
                },
                pauseStreaming: {
                    get: function () {
                        return this._pauseStreaming
                    },
                    set: function (e) {
                        this._pauseStreaming = e;
                    }
                },
                streamSpeed: {
                    get: function () {
                        return this._streamSpeed
                    },
                    set: function (e) {
                        this._streamSpeed = e;
                    }
                },
                bestLevelAvailable: {
                    get: function () {
                        var e = 0;
                        for (var t = 0; t < 22; t++) this._numTilesInLevel[t] != undefined && this._numTilesInLevel[t] > 0 && e < t && (e = t);
                        return e
                    }
                }
            });
    }

    function a$6(viewer, e, n) {
        $.each(e._primitives, function (e, r) {
            if (r instanceof Cesium.BillboardCollection) {
                var i = r,
                    e = t$5.indexOf(i);
                return i._parentCollection._primitiveOld = n,
                    e !== -1 ? (viewer.scene.primitives.remove(t$5[e]._parentCollection), t$5[e] = i) : t$5.push(i),
                    !1
            }
        });
    }

    function f$3(viewer, e, t) {
        viewer.scene.primitives.remove(t),
            e._onDestroyTilePrimitive = function () {
                viewer.scene.primitives.remove(t),
                    this._onDestroyTilePrimitive = undefined;
            };
    }

    function l$4(viewer, e, t, n) {
        Cesium.when.all(e, function () {
            viewer.scene.primitives.remove(n);
        }),
            t._onDestroyTilePrimitive = function () {
                viewer.scene.primitives.remove(n),
                    this._onDestroyTilePrimitive = undefined;
            };
    }

    function c$4(viewer, e, t) {
        var n = $.map(e._primitives, function (e) {
            return e.readyPromise
        });
        l$4(viewer, n, e, t);
    }

    function h$4(viewer, e, t) {
        var n = $.map(e._primitives[0]._primitives, function (e) {
            return e.readyPromise
        });
        l$4(viewer, n, e, t);
    }

    function p$4(viewer, e, t) {
        viewer.scene.primitives.remove(t);
    }

    function d$4(viewer, e, t) {
        var n = [e.readyPromise];
        l$4(viewer, n, e, t);
    }
    TileManager1$1.prototype.streamSpeedFactor = function () {
        switch (this._streamSpeed) {
            case this.STREAM_SPEED_FAST:
                return 1;
            case this.STREAM_SPEED_NORMAL:
                return 3;
            case this.STREAM_SPEED_SLOW:
                return 20;
            default:
                return 3
        }
    };
    var t$5 = [];
    var n$6 = 0;
    TileManager1$1.prototype.onPreFrame = function (e, r) {
        n$6++;
        if (this._pauseStreaming) return;
        if (this._streamSpeed == this.STREAM_SPEED_IMIDIATE)
            while (this._primitivesWaitingToBeAddedToTheScene.length > 0) {
                var i = this._primitivesWaitingToBeAddedToTheScene.pop();
                e.primitives.add(i);
            } else if (this._primitivesWaitingToBeAddedToTheScene.length > 0 && n$6 % this.streamSpeedFactor() == 0) {
                var i = this._primitivesWaitingToBeAddedToTheScene.pop();
                i._instanceIds && i._instanceIds.length > 100 && this.streamSpeed === this.STREAM_SPEED_FAST && (this.streamSpeed = this.STREAM_SPEED_NORMAL),
                    e.primitives.add(i);
            }
        $.each(t$5, function (e, t) {
            t.ready && this.viewer.scene.primitives.remove(t._parentCollection._primitiveOld);
        });
    };
    TileManager1$1.prototype.updateForPick = function (e) { };
    var i$8 = 180 / Math.PI;

    TileManager1$1.prototype.placeHolder = function (e, t) {
        t = t || Cesium.Color.fromBytes(0, 255, 0, 255);
        var n = new Cesium.Primitive({
            geometryInstances: new Cesium.GeometryInstance({
                geometry: new Cesium.RectangleOutlineGeometry({
                    rectangle: e.rectangle,
                    height: this.viewer.camera.positionCartographic.height - TerraExplorer.internal.Navigate.HeightAboveGround * .99
                }),
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(t)
                }
            }),
            appearance: new Cesium.PerInstanceColorAppearance({
                flat: !0
            })
        });
        e.data.primitive.add(n);
    };

    TileManager1$1.prototype.getTile = function (e) {
        return this._tileCache[e]
    };
    TileManager1$1.prototype.getAllTiles = function () {
        var e = [];
        for (var t in this._tileCache) e.push(this._tileCache[t]);
        return e
    };
    TileManager1$1.prototype.addToScene = function (e) {
        this._primitivesWaitingToBeAddedToTheScene.push(e);
    };
    TileManager1$1.prototype.removeFromScene = function (e) {
        var t = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        t != -1 ? (this._primitivesWaitingToBeAddedToTheScene[t].destroy(), this._primitivesWaitingToBeAddedToTheScene.splice(t, 1)) : this.viewer.scene.primitives.remove(e);
    };
    TileManager1$1.prototype.replaceInScene = function (e, t) {
        var n = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        if (n != -1) this._primitivesWaitingToBeAddedToTheScene[n] = t;
        else {
            e.ID != t.ID && console.log("TileManager.replaceInScene Warning: new primitive has a different ID than old primitive"),
                e._replacmentPrimitive != undefined && this.viewer.scene.primitives.remove(e._replacmentPrimitive),
                e._replacmentPrimitive = t,
                this.viewer.scene.primitives.add(t);
            var r = t.ID.split(":")[0];
            switch (r) {
                case "billboards":
                    a$6(this.viewer, t, e);
                    break;
                case "labels":
                    f$3(this.viewer, t, e);
                    break;
                case "polygons":
                    c$4(this.viewer, t, e);
                    break;
                case "models":
                    h$4(this.viewer, t, e);
                    break;
                case "polylines":
                    d$4(this.viewer, t, e);
                    break;
                case "points":
                    p$4(this.viewer, t, e);
                    break;
                default:
                    console.log("Error updating layer"),
                        this.viewer.scene.primitives.remove(e);
            }
        }
    };
    var v$3 = {
        billboards: a$6,
        labels: f$3,
        polygons: c$4,
        models: h$4,
        polylines: d$4,
        points: p$4
    };
    TileManager1$1.prototype.replaceInSceneNew = function (e, t) {
        var n = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        if (n != -1) this._primitivesWaitingToBeAddedToTheScene[n] = t;
        else {
            e.ID !== t.ID && console.log("TileManager.replaceInScene Warning: new primitive has a different ID than old primitive"),
                this.addToScene(t);
            var i = t.ID.split(":")[0],
                s = v$3[i];
            s ? s(t, e) : (console.log("Error updating layer"), this.viewer.scene.primitives.remove(e));
        }
    };
    /***************************************************************************/
    TileManager1$1.prototype.update = function (frameState) {
        this._quadtree.beginFrame(frameState);
        this._quadtree.render(frameState);
        this._quadtree.endFrame(frameState);
    };

    var r$7 = !1;
    TileManager1$1.prototype.initialize = function (frameState) {
        r$7 || (this.viewer.scene.preRender.addEventListener(this.onPreFrame, this), r$7 = !0);
    };

    TileManager1$1.prototype.beginUpdate = function (frameState) {
        this.quadtree.beginFrame(frameState);
    };

    TileManager1$1.prototype.endUpdate = function (frameState) {
        var t = this;
        frameState.afterRender.push(function () {
            t.quadtree.endFrame(frameState);
        });
    };

    TileManager1$1.prototype.getLevelMaximumGeometricError = function (level) {
        return this._levelZeroMaximumError / (1 << level);
    };

    TileManager1$1.prototype.loadTile = function (frameState, tile) {
        var n = this;
        this._numTilesInLevel[tile._level] == undefined && (this._numTilesInLevel[tile._level] = 0);
        this._numTilesInLevel[tile._level]++;
        if (tile.state === Cesium.QuadtreeTileLoadState.START) {
            tile.data = {
                primitive: new Cesium.PrimitiveCollection,
                wfsLayerData: [],
                id: Cesium.createGuid(),
                freeResources: function () {
                    n._tileCache[tile.data.id] && n._numTilesInLevel[tile._level]--,
                        n._numTilesInLevel[tile._level] < 0 && (n._numTilesInLevel[tile._level] = 0);
                    if (Cesium.defined(this.wfsLayerData)) {
                        for (var e in this.wfsLayerData) Cesium.defined(this.wfsLayerData[e]) && this.wfsLayerData[e].freeResources();
                        this.wfsLayerData = undefined;
                    }
                    Cesium.defined(this.primitive) && (this.primitive.destroy(), this.primitive = undefined),
                        delete n._tileCache[tile.data.id];
                }
            },
                this._tileCache[tile.data.id] = tile;
            var r = 6371e3;
            Math.abs(r * (tile.rectangle.south - tile.rectangle.north));
            tile.data.boundingSphere3D = Cesium.BoundingSphere.fromRectangle3D(tile.rectangle);
            tile.data.boundingSphere2D = Cesium.BoundingSphere.fromRectangle2D(tile.rectangle, frameState.mapProjection);
            [i$8 * tile.rectangle.west, i$8 * tile.rectangle.south, i$8 * tile.rectangle.east, i$8 * tile.rectangle.north];
            this.loadTileEvent.raiseEvent(tile);
            tile.state = Cesium.QuadtreeTileLoadState.DONE;
            tile.renderable = true;
        }
        // if (tile.state === Cesium.QuadtreeTileLoadState.START) {
        //     this._loadTileEvent.raiseEvent(tile);
        //     tile.state = Cesium.QuadtreeTileLoadState.LOADING
        //     if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
        //         tile.data.geometryPrimitive.update(frameState, []);
        //         if (tile.data.geometryPrimitive._ready) {
        //             tile.state = Cesium.QuadtreeTileLoadState.DONE;
        //             tile.renderable = true;
        //         }
        //     }
        // }
    };

    TileManager1$1.prototype.computeTileVisibility = function (tile, frameState, occluders) {
        var distance = this.computeDistanceToTile(tile, frameState);
        tile._distance = distance;

        if (frameState.fog.enabled) {
            if (Cesium.Math.fog(distance, frameState.fog.density) >= 1.0) {
                // Tile is completely in fog so return that it is not visible.
                return Cesium.Visibility.NONE;
            }
        }

        var surfaceTile = tile.data;
        surfaceTile.tileBoundingRegion;

        if (surfaceTile.boundingVolumeSourceTile === undefined) {
            // We have no idea where this tile is, so let's just call it partially visible.
            return Cesium.Visibility.PARTIAL;
            //return Cesium.Visibility.NONE;
        }

        var cullingVolume = frameState.cullingVolume;
        var boundingVolume = surfaceTile.orientedBoundingBox;

        if (!boundingVolume && surfaceTile.renderedMesh) {
            boundingVolume = surfaceTile.renderedMesh.boundingSphere3D;
        }

        // Check if the tile is outside the limit area in cartographic space
        surfaceTile.clippedByBoundaries = false;

        function clipRectangleAntimeridian(tileRectangle, cartographicLimitRectangle) {
            if (cartographicLimitRectangle.west < cartographicLimitRectangle.east) {
                return cartographicLimitRectangle;
            }
            var splitRectangle = Rectangle.clone(cartographicLimitRectangle, splitCartographicLimitRectangleScratch);
            var tileCenter = Rectangle.center(tileRectangle, rectangleCenterScratch);
            if (tileCenter.longitude > 0.0) {
                splitRectangle.east = CesiumMath.PI;
            } else {
                splitRectangle.west = -CesiumMath.PI;
            }
            return splitRectangle;
        }
        var clippedCartographicLimitRectangle = clipRectangleAntimeridian(tile.rectangle, this
            .cartographicLimitRectangle);
        var rectangleIntersectionScratch = new Cesium.Rectangle();
        var areaLimitIntersection = Cesium.Rectangle.simpleIntersection(clippedCartographicLimitRectangle, tile
            .rectangle, rectangleIntersectionScratch);
        if (!areaLimitIntersection) {
            return Visibility.NONE;
        }
        if (!Cesium.Rectangle.equals(areaLimitIntersection, tile.rectangle)) {
            surfaceTile.clippedByBoundaries = true;
        }

        if (frameState.mode !== Cesium.SceneMode.SCENE3D) ;

        if (!boundingVolume) {
            return Cesium.Intersect.INTERSECTING;
        }

        var clippingPlanes = this._clippingPlanes;
        if (clippingPlanes && clippingPlanes.enabled) {
            var planeIntersection = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
            tile.isClipped = (planeIntersection !== Intersect.INSIDE);
            if (planeIntersection === Cesium.Intersect.OUTSIDE) {
                return Cesium.Visibility.NONE;
            }
        }

        var intersection = cullingVolume.computeVisibility(boundingVolume);
        if (intersection === Cesium.Intersect.OUTSIDE) {
            return Cesium.Visibility.NONE;
        }

        var ortho3D = frameState.mode === Cesium.SceneMode.SCENE3D && frameState.camera
            .frustum instanceof Cesium.OrthographicFrustum;
        if (frameState.mode === Cesium.SceneMode.SCENE3D && !ortho3D && occluders) {
            var occludeePointInScaledSpace = surfaceTile.occludeePointInScaledSpace;
            if (!occludeePointInScaledSpace) {
                return intersection;
            }

            if (occluders.ellipsoid.isScaledSpacePointVisible(occludeePointInScaledSpace)) {
                return intersection;
            }

            return Cesium.Visibility.NONE;
        }

        return intersection;
    };

    TileManager1$1.prototype.canRefine = function (tile, frameState, occluders) {
        if (tile.level < 16)
            return true;
        return false;
    };

    TileManager1$1.prototype.showTileThisFrame = function (tile, context, frameState, commandList) {
        if (tile.data.geometryPrimitive)
            tile.data.geometryPrimitive.update(context, frameState, commandList);
    };

    TileManager1$1.prototype.computeDistanceToTile = function (tile, frameState) {
        function computeOccludeePoint(tileProvider, center, rectangle, height, result) {
            var ellipsoidalOccluder = tileProvider.quadtree._occluders.ellipsoid;
            var ellipsoid = ellipsoidalOccluder.ellipsoid;
            var cornerPositionsScratch = [new Cesium.Cartesian3(), new Cesium.Cartesian3(), new Cesium.Cartesian3(),
            new Cesium.Cartesian3()
            ];
            var cornerPositions = cornerPositionsScratch;
            Cesium.Cartesian3.fromRadians(rectangle.west, rectangle.south, height, ellipsoid, cornerPositions[0]);
            Cesium.Cartesian3.fromRadians(rectangle.east, rectangle.south, height, ellipsoid, cornerPositions[1]);
            Cesium.Cartesian3.fromRadians(rectangle.west, rectangle.north, height, ellipsoid, cornerPositions[2]);
            Cesium.Cartesian3.fromRadians(rectangle.east, rectangle.north, height, ellipsoid, cornerPositions[3]);

            return ellipsoidalOccluder.computeHorizonCullingPoint(center, cornerPositions, result);
        }

        function updateTileBoundingRegion(tile, terrainProvider, frameState) {
            var surfaceTile = tile.data;
            if (surfaceTile === undefined) {
                surfaceTile = tile.data = new Cesium.GlobeSurfaceTile();
            }

            if (surfaceTile.tileBoundingRegion === undefined) {
                surfaceTile.tileBoundingRegion = new Cesium.TileBoundingRegion({
                    computeBoundingVolumes: false,
                    rectangle: tile.rectangle,
                    ellipsoid: tile.tilingScheme.ellipsoid,
                    minimumHeight: 0.0,
                    maximumHeight: 0.0
                });
            }
            return tile;
        }
        var heightSource = updateTileBoundingRegion(tile, this.terrainProvider);
        var surfaceTile = tile.data;
        var tileBoundingRegion = surfaceTile.tileBoundingRegion;

        if (heightSource === undefined) {
            // Can't find any min/max heights anywhere? Ok, let's just say the
            // tile is really far away so we'll load and render it rather than
            // refining.
            return 9999999999.0;
        } else if (surfaceTile.boundingVolumeSourceTile !== heightSource) {
            // Heights are from a new source tile, so update the bounding volume.
            surfaceTile.boundingVolumeSourceTile = heightSource;

            var rectangle = tile.rectangle;
            if (rectangle && rectangle.width < Cesium.Math.PI_OVER_TWO + Cesium.Math.EPSILON5) {
                surfaceTile.orientedBoundingBox = Cesium.OrientedBoundingBox.fromRectangle(
                    tile.rectangle,
                    tileBoundingRegion.minimumHeight,
                    tileBoundingRegion.maximumHeight,
                    tile.tilingScheme.ellipsoid,
                    surfaceTile.orientedBoundingBox);

                surfaceTile.occludeePointInScaledSpace = computeOccludeePoint(this, surfaceTile
                    .orientedBoundingBox.center, tile.rectangle, tileBoundingRegion.maximumHeight,
                    surfaceTile.occludeePointInScaledSpace);
            }
        }

        var min = tileBoundingRegion.minimumHeight;
        var max = tileBoundingRegion.maximumHeight;

        if (surfaceTile.boundingVolumeSourceTile !== tile) {
            var cameraHeight = frameState.camera.positionCartographic.height;
            var distanceToMin = Math.abs(cameraHeight - min);
            var distanceToMax = Math.abs(cameraHeight - max);
            if (distanceToMin > distanceToMax) {
                tileBoundingRegion.minimumHeight = min;
                tileBoundingRegion.maximumHeight = min;
            } else {
                tileBoundingRegion.minimumHeight = max;
                tileBoundingRegion.maximumHeight = max;
            }
        }

        var result = tileBoundingRegion.distanceToCamera(frameState);

        tileBoundingRegion.minimumHeight = min;
        tileBoundingRegion.maximumHeight = max;

        return result;
    };

    TileManager1$1.prototype.isDestroyed = function () {
        return false;
    };

    TileManager1$1.prototype.destroy = function () {
        return Cesium.destroyObject(this);
    };

    TileManager1$1.prototype.remove = function () {
        this.destroy();
    };
    TileManager1$1.prototype.getInstance = function (t) {
        if (Cesium.defined(t.TileManager) == 0) {
            var instance = new TileManager1$1;
            t.TileManager = instance;
            instance.viewer = t;
            var n = new Cesium.QuadtreePrimitive({
                tileProvider: t.TileManager,
                maximumScreenSpaceError: 2
            });
            t.scene.primitives.add(n);
        }
        return t.TileManager
    };

    function t$4(e, t) {
        for (var n = 0; n < e.length; n++)
            if (t(e[n])) return n
    }
    /**
    *
    * 程序池
    *
    * @alias WorkerPool
    * @constructor
    *
    */
    function WorkerPool(e) {
        e = e || [];
        if (!Cesium.defined(e.workerPath)) throw new Cesium.DeveloperError("workerPath is required.");
        this._workerPath = e.workerPath,
            this._poolSize = Cesium.defaultValue(e.poolSize, 16),
            this._workers = [],
            this._defered = [];
    }Object.defineProperties(WorkerPool.prototype, {
        errorEvent: {
            get: function () {
                return this.errorEvent
            }
        },
        poolSize: {
            get: function () {
                return this._poolSize
            }
        }
    }),
        WorkerPool.prototype.queueWorkItem = function (e, t) {
            var n = Cesium.when.defer(),
                r = null,
                i = 999999;
            for (var s = 0; s < this._workers.length; s++) {
                var r = this._workers[s];
                this._workers[s].jobQueueSize < i && (r = this._workers[s], i = this._workers[s].jobQueueSize);
            }
            if (i > 0 && this._workers.length < this.poolSize) {
                r = new Worker(this._workerPath);
                var o = this;
                r.addEventListener("message", function (e) {
                    o.onWorkerMessage(e);
                }, !1),
                    r.addEventListener("error", function (e) {
                        o.onWorkerError(e);
                    }, !1),
                    r.jobQueueSize = 0,
                    this._workers.push(r),
                    r.id = Cesium.createGuid();
            }
            e.workerId = r.id;
            var u = Cesium.createGuid();
            return e.deferedId = u,
                this._defered[u] = n,
                r.jobQueueSize++,
                r.postMessage(e, t),
                n
        };
    WorkerPool.prototype.trimPool = function (e) {
        var t = this;
        if (e == undefined) {
            this.timerId != null && clearTimeout(this.timerId),
                this.timerId = setTimeout(function () {
                    t.trimPool(!0);
                }, 5e3);
            return
        }
        for (var n = 0; n < this._workers.length; n++) this._workers[n].jobQueueSize == 0 && (this._workers[n].terminate(), this._workers.splice(n, 1), n--);
        this._workers.length ? this.timerId = setTimeout(function () {
            t.trimPool(!0);
        }, 5e3) : this.timerId = null;
    };
    WorkerPool.prototype.onWorkerMessage = function (e) {
        var n = e.data,
            r = t$4(this._workers, function (e) {
                return e.id === n.workerId
            });
        if (r != undefined) {
            var i = this._workers[r];
            i.jobQueueSize--,
                this.trimPool();
        }
        var s = this._defered[n.deferedId];
        delete this._defered[n.deferedId],
            s.resolve(n);
    };
    WorkerPool.prototype.onWorkerError = function (e) {
        console.log(e);
    };

    function SimpleSqlParser$1() { }
    function n$5(e) {
        return typeof e == "string" ? e.replace(/^\s+/g, "").replace(/\s+$/g, "") : e
    }
    function r$6(e, t) {
        var r = "######",
            i = !1,
            s = 0,
            o = "";
        for (var u = 0; u < t.length; u++)!i && /['"`]/.test(t[u]) ? i = t[u] : i && t[u] == i ? i = !1 : !i && t[u] == "(" ? s++ : !i && t[u] == ")" && s--,
            t[u] == e && (s > 0 || i) ? o += r : o += t[u];
        return t = o,
            t = t.split(e),
            t = t.map(function (t) {
                return n$5(t.replace(new RegExp(r, "g"), e))
            }),
            t
    }
    function i$7(e) {
        var t = "#",
            n = e.length;
        for (var r = 0; r < n; r++) t += e[r] + "#";
        return t
    }
    function s$2(e) {
        var t = "",
            n = e.length;
        for (var r = 1; r < n; r += 2) t += e[r];
        return t
    }
    function o$2(e) {
        this.source = e,
            this.cursor = 0,
            this.currentChar = "",
            this.readNextChar();
    }
    function u$2(e) {
        this.lexer = new o$2(e),
            this.currentToken = "",
            this.readNextToken();
    }
    function a$5(e, t) {
        var n = "";
        return typeof e.logic != "undefined" ? (n = e.terms.map(function (e) {
            return a$5(e, !0)
        }), n = n.join(" " + e.logic + " "), typeof t != "undefined" && (n = "(" + n + ")")) : typeof e.left != "undefined" ? (n = e.left, typeof e.operator != "undefined" && (n += " " + e.operator, typeof e.right != "undefined" && (e.operator === "IN" ? n += " (" + e.right + ")" : n += " " + e.right))) : n = e,
            n
    }
    SimpleSqlParser$1.sql2ast = function (e, t) {
        function p(e, t) {
            return t
        }
        if (typeof t == "undefined" || t === null) t = !0;
        var o = "###semi-colon###";
        e = e.replace(/[("'`].*;.*[)"'`]/g, function (e) {
            return e.replace(/;/g, o)
        });
        var a = "###EOR###";
        e = e.replace(/;/g, a),
            e = e.split(a)[0],
            e = e.replace(new RegExp(o, "g"), ";");
        var f = ["SELECT", "FROM", "DELETE FROM", "INSERT INTO", "UPDATE", "JOIN", "LEFT JOIN", "RIGHT JOIN", "INNER JOIN", "ORDER BY", "GROUP BY", "HAVING", "WHERE", "LIMIT", "VALUES", "SET"],
            l = f.map(function (e) {
                return e + " "
            });
        l = l.concat(f.map(function (e) {
            return e + "("
        })),
            l = l.concat(l.map(function (e) {
                return e.toLowerCase()
            }));
        var c = l.map(function (e) {
            return e.replace("(", "[\\(]")
        });
        e = e.replace(/\((.+?)\)|"(.+?)"|'(.+?)'|`(.+?)`/gi, function (e) {
            return e.replace(new RegExp(c.join("|"), "gi"), i$7)
        });
        var h = [];
        l.forEach(function (t) {
            var n = 0,
                r;
            do {
                r = e.indexOf(t, n);
                if (r != -1) {
                    var i = t.replace(/^((\w|\s)+?)\s?\(?$/i, p);
                    h[r] = i,
                        n = r + i.length;
                }
            } while (r != -1)
        });
        var d = 0;
        h.forEach(function (e, t) {
            d > t ? delete h[t] : (d = parseInt(t, 10) + e.length, e == "JOIN" && (h[t] = "INNER JOIN"));
        });
        var v = c.slice(0);
        v = v.map(function (e) {
            return i$7(e)
        }),
            v = v.join("|");
        var m = e.split(new RegExp(c.join("|"), "i"));
        e = e.replace(/\((.+?)\)|"(.+?)"|'(.+?)'|`(.+?)`/gi, function (e) {
            return e.replace(new RegExp(v, "gi"), s$2)
        }),
            m = m.map(function (e) {
                return e.replace(/\((.+?)\)|"(.+?)"|'(.+?)'|`(.+?)`/gi, function (e) {
                    return e.replace(new RegExp(v, "gi"), s$2)
                })
            });
        var g = [];
        g.SELECT = function (e) {
            var t = r$6(",", e);
            return t = t.filter(function (e) {
                return e !== ""
            }).map(function (e) {
                return {
                    name: e
                }
            }),
                t
        },
            g.SET = function (e) {
                var t = r$6(",", e);
                return t = t.filter(function (e) {
                    return e !== ""
                }).map(function (e) {
                    return {
                        expression: e
                    }
                }),
                    t
            },
            g.FROM = g["DELETE FROM"] = g.UPDATE = function (e) {
                var t = e.split(",");
                return t = t.map(function (e) {
                    return n$5(e)
                }),
                    t.forEach(function (e, n) {
                        e === "" && t.splice(n);
                    }),
                    t = t.map(function (e) {
                        var t = e.split(" AS "),
                            n = t[1] || "";
                        return n.indexOf('"') === 0 && n.lastIndexOf('"') == n.length - 1 && (n = n.substring(1, n.length - 1)),
                        {
                            table: t[0],
                            as: n
                        }
                    }),
                    t
            },
            g["LEFT JOIN"] = g.JOIN = g["INNER JOIN"] = g["RIGHT JOIN"] = function (e) {
                e = e.split(" ON ");
                var t = e[0].split(" AS "),
                    r = {};
                return r.table = n$5(t[0]),
                    r.as = n$5(t[1]) || "",
                    r.cond = n$5(e[1]),
                    r
            },
            g.WHERE = function (e) {
                return n$5(e)
            },
            g["ORDER BY"] = function (e) {
                e = e.split(",");
                var t = [];
                return e.forEach(function (e, r) {
                    var i = /([A-Za-z0-9_\.]+)\s*(ASC|DESC){0,1}/gi;
                    i = i.exec(e);
                    if (i !== null) {
                        var s = {};
                        s.column = n$5(i[1]),
                            s.order = n$5(i[2]),
                            i[2] === undefined && (s.order = "ASC"),
                            t.push(s);
                    }
                }),
                    t
            },
            g["GROUP BY"] = function (e) {
                e = e.split(",");
                var t = [];
                return e.forEach(function (e, r) {
                    var i = /([A-Za-z0-9_\.]+)/gi;
                    i = i.exec(e);
                    if (i !== null) {
                        var s = {};
                        s.column = n$5(i[1]),
                            t.push(s);
                    }
                }),
                    t
            },
            g.LIMIT = function (e) {
                var t = /((\d+)\s*,\s*)?(\d+)/gi;
                t = t.exec(e),
                    typeof t[2] == "undefined" && (t[2] = 0);
                var r = {};
                return r.nb = parseInt(n$5(t[3]), 10),
                    r.from = parseInt(n$5(t[2]), 10),
                    r
            },
            g["INSERT INTO"] = function (e) {
                var t = /([A-Za-z0-9_\.]+)\s*(\(([A-Za-z0-9_\., ]+)\))?/gi;
                t = t.exec(e);
                var r = {};
                return r.table = n$5(t[1]),
                    typeof t[3] != "undefined" && (r.columns = t[3].split(","), r.columns = r.columns.map(function (e) {
                        return n$5(e)
                    })),
                    r
            },
            g.VALUES = function (e) {
                e = n$5(e),
                    e[0] != "(" && (e = "(" + e);
                var t = r$6(",", e),
                    i = [];
                return t.forEach(function (e) {
                    e = e.replace(/^\(/g, "").replace(/\)$/g, ""),
                        e = r$6(",", e),
                        i.push(e);
                }),
                    i
            };
        var y = {},
            b = 0;
        return h.forEach(function (e, t) {
            e = e.toUpperCase(),
                b++;
            if (typeof g[e] != "undefined") {
                var n = g[e](m[b]);
                if (typeof y[e] != "undefined") {
                    if (typeof y[e] == "string" || typeof y[e][0] == "undefined") {
                        var r = y[e];
                        y[e] = [],
                            y[e].push(r);
                    }
                    y[e].push(n);
                } else y[e] = n;
            } else console.log("Can't analyze statement \"" + e + '"');
        }),
            typeof y["LEFT JOIN"] != "undefined" && (typeof y["JOIN"] == "undefined" && (y.JOIN = []), typeof y["LEFT JOIN"][0] != "undefined" ? y["LEFT JOIN"].forEach(function (e) {
                e.type = "left",
                    y.JOIN.push(e);
            }) : (y["LEFT JOIN"].type = "left", y.JOIN.push(y["LEFT JOIN"])), delete y["LEFT JOIN"]),
            typeof y["INNER JOIN"] != "undefined" && (typeof y["JOIN"] == "undefined" && (y.JOIN = []), typeof y["INNER JOIN"][0] != "undefined" ? y["INNER JOIN"].forEach(function (e) {
                e.type = "inner",
                    y.JOIN.push(e);
            }) : (y["INNER JOIN"].type = "inner", y.JOIN.push(y["INNER JOIN"])), delete y["INNER JOIN"]),
            typeof y["RIGHT JOIN"] != "undefined" && (typeof y["JOIN"] == "undefined" && (y.JOIN = []), typeof y["RIGHT JOIN"][0] != "undefined" ? y["RIGHT JOIN"].forEach(function (e) {
                e.type = "right",
                    y.JOIN.push(e);
            }) : (y["RIGHT JOIN"].type = "right", y.JOIN.push(y["RIGHT JOIN"])), delete y["RIGHT JOIN"]),
            t && (typeof y["WHERE"] == "string" && (y.WHERE = u$2.parse(y.WHERE)), typeof y["JOIN"] != "undefined" && y.JOIN.forEach(function (e, t) {
                y.JOIN[t].cond = u$2.parse(e.cond);
            })),
            y
    };
    o$2.prototype = {
        constructor: o$2,
        readNextChar: function () {
            typeof this.source != "string" ? this.currentChar = "" : this.currentChar = this.source[this.cursor++] || "";
        },
        readNextToken: function () {
            return /\w|[-]/.test(this.currentChar) ? this.readWord() : /["'`]/.test(this.currentChar) ? this.readString() : /[()]/.test(this.currentChar) ? this.readGroupSymbol() : /[!=<>]/.test(this.currentChar) ? this.readOperator() : this.currentChar === "" ? {
                type: "eot",
                value: ""
            } : (this.readNextChar(), {
                type: "empty",
                value: ""
            })
        },
        readWord: function () {
            var e = "",
                t = 0,
                n = !1;
            while (/./.test(this.currentChar)) {
                if (!n && /['"`]/.test(this.currentChar)) n = this.currentChar;
                else if (n && this.currentChar == n) n = !1;
                else {
                    if (!n) {
                        if (this.currentChar == ")" && t <= 0) break;
                        this.currentChar == "(" ? t++ : this.currentChar == ")" && t--;
                        if (/[!=<>]/.test(this.currentChar)) break
                    }
                    if (this.currentChar == " " && t <= 0) break
                }
                e += this.currentChar,
                    this.readNextChar();
            }
            return /^(AND|OR)$/i.test(e) ? {
                type: "logic",
                value: e
            } : /^(IN|IS|NOT|LIKE)$/i.test(e) ? {
                type: "operator",
                value: e
            } : {
                type: "word",
                value: e
            }
        },
        readString: function () {
            var e = "",
                t = this.currentChar;
            e += this.currentChar,
                this.readNextChar();
            while (this.currentChar != t && this.currentChar !== "") e += this.currentChar,
                this.readNextChar();
            return e += this.currentChar,
                this.readNextChar(),
                this.currentChar == "." ? (e += this.currentChar, this.readNextChar(), e += this.readString().value, {
                    type: "word",
                    value: e
                }) : {
                    type: "string",
                    value: e
                }
        },
        readGroupSymbol: function () {
            var e = this.currentChar;
            return this.readNextChar(),
            {
                type: "group",
                value: e
            }
        },
        readOperator: function () {
            var e = this.currentChar;
            return this.readNextChar(),
                /[=<>]/.test(this.currentChar) && (e += this.currentChar, this.readNextChar()),
            {
                type: "operator",
                value: e
            }
        }
    };
    o$2.tokenize = function (e) {
        var t = new o$2(e),
            n = [];
        do {
            var r = t.readNextToken();
            r.type != "empty" && n.push(r);
        } while (t.currentChar);
        return n
    };
    u$2.prototype = {
        constructor: u$2,
        readNextToken: function () {
            this.currentToken = this.lexer.readNextToken();
            while (this.currentToken.type == "empty") this.currentToken = this.lexer.readNextToken();
            return this.currentToken
        },
        parseExpressionsRecursively: function () {
            return this.parseLogicalExpression()
        },
        parseLogicalExpression: function () {
            var e = this.parseConditionExpression();
            while (this.currentToken.type == "logic") {
                var t = this.currentToken.value;
                this.readNextToken();
                var n = this.parseConditionExpression();
                if (typeof e.logic != "undefined" && e.logic == t && typeof e.terms != "undefined") e.terms.push(n);
                else {
                    var r = [e, n];
                    e = {
                        logic: t,
                        terms: r.slice(0)
                    };
                }
            }
            return e
        },
        parseConditionExpression: function () {
            var e = this.parseBaseExpression();
            if (this.currentToken.type == "operator") {
                var t = this.currentToken.value;
                this.readNextToken(),
                    this.currentToken.type == "operator" && (t += " " + this.currentToken.value, this.readNextToken());
                var n = this.parseBaseExpression();
                e = {
                    operator: t,
                    left: e,
                    right: n
                };
            }
            return e
        },
        parseBaseExpression: function () {
            var e = "";
            return this.currentToken.type == "word" || this.currentToken.type == "string" ? (e = this.currentToken.value, this.readNextToken()) : this.currentToken.type == "group" && (this.readNextToken(), e = this.parseExpressionsRecursively(), this.readNextToken()),
                e
        }
    };
    u$2.parse = function (e) {
        return (new u$2(e)).parseExpressionsRecursively()
    };
    SimpleSqlParser$1.ast2sql = function (e) {
        function n(e) {
            return typeof e["SELECT"] != "undefined" ? "SELECT " + e.SELECT.map(function (e) {
                return e.name
            }).join(", ") : ""
        }
        function r(e) {
            if (typeof e["FROM"] != "undefined") {
                var t = " FROM ",
                    n = e.FROM.map(function (e) {
                        var t = e.table;
                        return e.as !== "" && (t += " AS " + e.as),
                            t
                    });
                return t += n.join(", "),
                    t
            }
            return ""
        }
        function i(e) {
            if (typeof e["JOIN"] != "undefined") {
                var t = "";
                return e.JOIN.forEach(function (e) {
                    t += " " + e.type.toUpperCase() + " JOIN " + e.table,
                        e.as !== "" && (t += " AS " + e.as),
                        t += " ON " + a$5(e.cond);
                }),
                    t
            }
            return ""
        }
        function s(e) {
            return typeof e["WHERE"] != "undefined" ? " WHERE " + a$5(e.WHERE) : ""
        }
        function o(e) {
            if (typeof e["ORDER BY"] != "undefined") {
                var t = " ORDER BY ",
                    n = e["ORDER BY"].map(function (e) {
                        return e.column + " " + e.order
                    });
                return t += n.join(", "),
                    t
            }
            return ""
        }
        function u(e) {
            if (typeof e["GROUP BY"] != "undefined") {
                var t = " GROUP BY ",
                    n = e["GROUP BY"].map(function (e) {
                        return e.column
                    });
                return t += n.join(", "),
                    t
            }
            return ""
        }
        function f(e) {
            if (typeof e["LIMIT"] != "undefined" && typeof e["LIMIT"].nb != "undefined" && parseInt(e.LIMIT.nb, 10) > 0) {
                var t = " LIMIT ";
                return typeof e["LIMIT"].from != "undefined" && parseInt(e.LIMIT.from, 10) > 1 && (t += e.LIMIT.from + ","),
                    t += e.LIMIT.nb,
                    t
            }
            return ""
        }
        function l(e) {
            if (typeof e["INSERT INTO"] != "undefined") {
                var t = "INSERT INTO " + e["INSERT INTO"].table;
                return typeof e["INSERT INTO"].columns != "undefined" && (t += " (", t += e["INSERT INTO"].columns.join(", "), t += ")"),
                    t
            }
            return ""
        }
        function c(e) {
            if (typeof e["VALUES"] != "undefined") {
                var t = " VALUES ",
                    n = e.VALUES.map(function (e) {
                        return "(" + e.join(", ") + ")"
                    });
                return t += n.join(", "),
                    t
            }
            return ""
        }
        function h(e) {
            if (typeof e["DELETE FROM"] != "undefined") {
                var t = "DELETE FROM ";
                return t += e["DELETE FROM"].map(function (e) {
                    var t = e.table;
                    return e.as !== "" && (t += " AS " + e.as),
                        t
                }).join(", "),
                    t
            }
            return ""
        }
        function p(e) {
            if (typeof e["UPDATE"] != "undefined") {
                var t = "UPDATE ";
                return t += e.UPDATE.map(function (e) {
                    var t = e.table;
                    return e.as !== "" && (t += " AS " + e.as),
                        t
                }).join(", "),
                    t
            }
            return ""
        }
        function d(e) {
            return typeof e["SET"] != "undefined" ? " SET " + e.SET.map(function (e) {
                return e.expression
            }).join(", ") : ""
        }
        var t = "";
        return typeof e["SELECT"] != "undefined" && typeof e["FROM"] != "undefined" ? t = n(e) + r(e) + i(e) + s(e) + u(e) + o(e) + f(e) : typeof e["INSERT INTO"] != "undefined" ? t = l(e) + c(e) : typeof e["UPDATE"] != "undefined" ? t = p(e) + d(e) + s(e) : typeof e["DELETE FROM"] != "undefined" ? t = h(e) + s(e) : t = null,
            t
    };
    SimpleSqlParser$1.trim = n$5;
    SimpleSqlParser$1.protect = i$7;
    SimpleSqlParser$1.unprotect = s$2;
    SimpleSqlParser$1.protect_split = r$6;
    SimpleSqlParser$1.CondLexer = o$2;
    SimpleSqlParser$1.CondParser = u$2;

    function convertFontSizeToTEFontSize$1(e) {
        return e * 3 / 4
    }

    function getFontSizeInPixels$1(e) {
        var t = e * 72 / 96;
        return -1 * t
    }

    function polygonFeaturesToPositionsArray$1(e) {
        var t = [],
            n = e.length;
        for (var r = 0; r < n; r++) {
            var i = e[r],
                s = i.positions.length;
            for (var o = 0; o < s; o++) {
                var u = i.positions[o];
                for (var a = 0; a < u.length; a += 3) t.push(Cesium.Cartographic.fromDegrees(u[a + 0], u[a + 1], 0));
            }
        }
        return t
    }

    function _hashCode$1(e) {
        var t = 0,
            n, r;
        if (e.length === 0) return t;
        for (n = 0; n < e.length; n++) r = e.charCodeAt(n),
            t = (t << 5) - t + r,
            t |= 0;
        return t
    }

    function convertPolygonsRelativeHeightToAbsoluteHeightFromTerrainHeights$1(e, t, n, r) {
        var i, s = 0;
        for (var o = 0; o < e.length; o++) {
            var u = e[o];
            i = r ? onTerrainAltitudeOffset$1 : n(u),
                u.absoluteHeightPositions == undefined && (u.absoluteHeightPositions = []);
            for (var a = 0; a < u.positions.length; a++) {
                var f = u.positions[a],
                    l = u.absoluteHeightPositions[a] = [];
                for (var c = 2; c < f.length; c += 3) {
                    var h = r ? 0 : f[c];
                    t[s].height == undefined && (t[s].height = 0),
                        l[c - 2] = f[c - 2],
                        l[c - 1] = f[c - 1],
                        l[c - 0] = f[c - 0],
                        l[c] = h + t[s].height + i,
                        s++;
                }
            }
        }
    }

    function linestringFeaturesToPositionsArray$1(e) {
        var t = [];
        for (var n = 0; n < e.length; n++)
            for (var r = 0; r < e[n].positions.length; r += 3) t.push(Cesium.Cartographic.fromDegrees(e[n].positions[r + 0], e[n].positions[r + 1], 0));
        return t
    }

    function convertLinestringsRelativeHeightToAbsoluteHeightFromTerrainHeights$1(e, t, n, r) {
        var i, s = 0;
        for (var o = 0; o < e.length; o++) {
            i = r ? onTerrainAltitudeOffset$1 : n(e[o]);
            for (var u = 2; u < e[o].positions.length; u += 3) {
                t[s].height == undefined && (t[s].height = 0),
                    e[o].absoluteHeightPositions == undefined && (e[o].absoluteHeightPositions = []),
                    e[o].absoluteHeightPositions[u - 2] = e[o].positions[u - 2],
                    e[o].absoluteHeightPositions[u - 1] = e[o].positions[u - 1],
                    e[o].absoluteHeightPositions[u - 0] = e[o].positions[u - 0];
                var a = r ? 0 : e[o].positions[u];
                e[o].absoluteHeightPositions[u] = a + t[s].height + i,
                    s++;
            }
        }
    }

    function EntityCreator$1(e, viewer) {
        this._style = e || {};
        viewer.scene.onHoverShowTextArray = {};
        viewer.scene._lastObjectShowOnText = null;
        this.setEyeOffset = function (e, t) {
            t === undefined && (t = 0);
            e.eyeOffset = Cesium.DynamicEyeOffset(t);
        };
        this.viewer = viewer;
    }

    function addAltitudeOffsetToFeatureHeights$1(e, t) {
        var n = e.length;
        for (var r = 0; r < n; r++) {
            var i = t(e[r]);
            if (e[r].geometryType == "polygon" || e[r].geometryType == "multipolygon") {
                var s = e[r],
                    o = s.positions.length;
                for (var u = 0; u < o; u++) {
                    var a = s.positions[u];
                    for (var f = 2; f < a.length; f += 3) a[f] += i;
                    s.positions[u] = a;
                }
                e[r] = s;
            } else {
                var l = e[r],
                    c = l.positions.length;
                for (var u = 2; u < c; u += 3) l.positions[u] += i;
                e[r] = l;
            }
        }
        return e
    }

    function canAddFeature$1(e, t) {
        if (e.isQuery == undefined)
            if (e.originalInstanceIds == undefined) {
                if (e.parentLayer.isExistRenderedFeatureId(t)) return !1
            } else if (e.originalInstanceIds.indexOf(t) == -1) return !1;
        return !0
    }

    function getAltitudeOffsetFunc$1(e) {
        return function (t) {
            var n = Number(e.applyConditionalClassification(e._style.altitudeOffset, t.attributes));
            return isNaN(n) && (n = 0),
                n
        }
    }

    function teColorToCesiumColor$1(e) {
        if (typeof e != "string") return e;
        var t = Number(e);
        if (!isNaN(t)) {
            var n = t.toString(16);
            if (n.length < 6 && n != undefined) {
                var r = n.length;
                while (r < 6) n = "0" + n,
                    r++;
            }
            var i = "#" + n,
                s = Cesium.Color.fromCssColorString(i);
            if (s != undefined) {
                var o = s.red;
                s.red = s.blue,
                    s.blue = o;
            }
            return s
        }
        return e
    }

    function colorFromClassification$1(e) {
        if (e == undefined) return undefined;
        var t = parseInt(e);
        if (e.alpha == undefined && !isNaN(t)) {
            t < 0 && (t &= 16777215);
            var n = t.toString(16);
            if (n.length < 6 && n != undefined) {
                var r = n.length;
                while (r < 6) n = "0" + n,
                    r++;
            }
            var i = "#" + n;
            i = i.substring(0, 7);
            var s = Cesium.Color.fromCssColorString(i);
            if (s != undefined) {
                var o = s.red;
                s.red = s.blue,
                    s.blue = o;
            }
            return s
        }
        return e
    }

    function tryGetValueAsFloat$1(e) {
        return isNaN(e) ? e : parseFloat(e)
    }

    function applyClassificationFunc$1(e, t) {
        var n = [];
        $.each(e.attributeNames, function (e, r) {
            n.push(tryGetValueAsFloat$1(t[r]));
        });
        var r;
        return n.length === 1 ? r = e.func(n[0]) : e.attributeNames.length === 2 ? r = e.func(n[0], n[1]) : e.attributeNames.length === 3 ? r = e.func(n[0], n[1], n[2]) : e.attributeNames.length === 4 && (r = e.func(n[0], n[1], n[2], n[3])),
            r
    }

    function getClassificationValue$1(e, t) {
        if (e === undefined || e.condition.length === 0) return undefined;
        if (e.func === undefined) return tryGetValueAsFloat$1(e.value);
        var n = undefined,
            r = applyClassificationFunc$1(e, t);
        return r === !0 && (n = tryGetValueAsFloat$1(e.value)),
            n
    }

    function escapeRegExp$1(e) {
        return e.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1")
    }

    function replaceAll$1(e, t, n) {
        return e.replace(new RegExp(escapeRegExp$1(t), "g"), n)
    }

    var pointFeaturesToPositionsArray$1 = linestringFeaturesToPositionsArray$1,
        convertPointsRelativeHeightToAbsoluteHeightFromTerrainHeights$1 = convertLinestringsRelativeHeightToAbsoluteHeightFromTerrainHeights$1,
        onTerrainAltitudeOffset$1 = 1;
    Object.defineProperties(EntityCreator$1.prototype, {
        style: {
            get: function () {
                return this._style
            },
            set: function (e) {
                this._style = e;
            }
        }
    });
    EntityCreator$1.prototype.clonePartOfMultiFeature = function (e, t) {
        return {
            positions: e.positions[t],
            attributes: e.attributes,
            fid: e.fid,
            geometryType: e.geometryType
        }
    };
    EntityCreator$1.prototype.createPrimitiveFromWFSFeatures = function (e) {
        new Cesium.PrimitiveCollection;
        //try {
        var n = [];
        var r = [];
        var i = [];
        e.features.numPositions = 0;
        for (var s = 0; s < e.features.length; s++) {
            var o = e.features[s];
            this.sanitizePositions(o.positions);
            e.features.numPositions += o.positions.length;
            switch (o.geometryType) {
                case "polygon":
                    n.push(o);
                    break;
                case "multipolygon":
                    var u = o.positions.length;
                    for (var a = 0; a < u; a++) n.push(this.clonePartOfMultiFeature(o, a));
                    break;
                case "linestring":
                    r.push(o);
                    break;
                case "multilinestring":
                    var u = o.positions.length;
                    for (var a = 0; a < u; a++) r.push(this.clonePartOfMultiFeature(o, a));
                    break;
                case "point":
                    i.push(o);
                    break;
                case "multipoint":
                    var u = o.positions.length;
                    for (var a = 0; a < u; a++) i.push(this.clonePartOfMultiFeature(o, a));
            }
        }
        // n.length > 0 ? (e.features = n, this.createPolygonPrimitive(e)) : r.length > 0 ? (e.features = r, this.createLinestringPrimitive(e)) : i.length > 0 && (e.features = i, this.createPointPrimitive(e))
        if (n.length > 0) {
            e.features = n;
            this.createPolygonPrimitive(e);
        } else if (r.length > 0) {
            e.features = r;
            this.createLinestringPrimitive(e);
        } else if (i.length > 0) {
            e.features = i;
            this.createPointPrimitive(e);
        }
        //} catch (f) {
        //    console.log("Failed to create primitive from features: " + f)
        //}
    };
    EntityCreator$1.prototype.createPolygonPrimitive = function (e) {
        var t = this,
            r = function (e) {
                if (e.isQuery) {
                    e.onFinishedQuery(i);
                    return
                }
                var r = "",
                    i = [],
                    s = [],
                    o = [],
                    u = [],
                    a = [];
                for (var f = 0; f < e.features.length; f++) {
                    var l = e.features[f];
                    if (!canAddFeature$1(e, l.fid)) continue;
                    var c = l.absoluteHeightPositions ? l.absoluteHeightPositions : l.positions,
                        h = t.createPolygonOptions(c, l.attributes),
                        p = t.createCommonOptions(l.attributes);
                    l.absoluteHeightPositions && delete l.absoluteHeightPositions,
                        i.push(Cesium.BoundingSphere.fromPoints(h.hierarchy.positions));
                    if (e.isQuery) continue;
                    if (h.outline) {
                        var d = t.createPolygonGeometryHelper(Cesium.PolygonOutlineGeometry, l, h.hierarchy, h.outlineColor, h.perPositionHeight, h.extrudedHeight, h.height);
                        o.push(d);
                    }
                    if (h.fill) {
                        var d = t.createPolygonGeometryHelper(Cesium.PolygonGeometry, l, h.hierarchy, h.material, h.perPositionHeight, h.extrudedHeight, h.height, h.water);
                        s.push(d);
                    }
                    e.parentLayer.addRenderedFeatureId(l.fid),
                        r += l.fid + ";",
                        u.push(l.fid),
                        a.push(p.tooltip);
                }

                if (r == "") return;
                var v = new Cesium.PrimitiveCollection;
                var m = new Cesium.PerInstanceColorAppearance({
                    flat: !0,
                    translucent: h.material.alpha < 1
                });
                if (s.length > 0) {
                    if (h.water) {
                        let waterOption = {
                            color: h.water.color || "rgba(135,206,235,0.6)", //水面的颜色
                            image: h.water.image || window.SmartEarthRootUrl + configData$1.water, // 水面贴图
                            frequency: h.water.frequency || 1000, // 水波数
                            speed: h.water.speed || 10, // 流速
                            amplitude: h.water.amplitude || 10.0, // 水波幅度
                        };
                        let color = Cesium.Color.fromCssColorString(waterOption.color);
                        m = new Cesium.EllipsoidSurfaceAppearance({
                            material: new Cesium.Material({
                                fabric: {
                                    type: 'Water',
                                    uniforms: {
                                        baseWaterColor: color,
                                        blendColor: color,
                                        normalMap: waterOption.image,
                                        frequency: waterOption.frequency,
                                        animationSpeed: waterOption.speed / 1000,
                                        amplitude: waterOption.amplitude
                                    }
                                }
                            })
                        });
                    }
                    var y;
                    if (h.clampToGround || (!h.perPositionHeight && !h.extrudedHeight && !h.height)) {
                        // clampToGround为true或未设置高度、拉伸高度且不使用每一个点的高度则贴地
                        y = new Cesium.GroundPrimitive({
                            geometryInstances: s,
                            appearance: m,
                            classificationType: h.classificationType
                        });
                    } else {
                        y = new Cesium.Primitive({
                            geometryInstances: s,
                            appearance: m
                        });
                    }
                    y._parentCollection = v,
                        v.add(y);
                }
                if (o.length > 0) {
                    if (!h.clampToGround) {
                        var y = new Cesium.Primitive({
                            geometryInstances: o,
                            appearance: m
                        });
                        y._parentCollection = v,
                            v.add(y);
                    }
                }
                v.ID = "polygons:" + _hashCode$1(r),
                    v._instanceIds = u,
                    v._tooltips = a,
                    e.onFinishedCreatePrimitive(v, i);
            },
            // i = this.style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_TERRAIN_ABSOLUTE;
            i = this.style.altitudeMethod == 3;
        if (!i) {
            var s = polygonFeaturesToPositionsArray$1(e.features);
            var o = Cesium.sampleRenderedData(s, Cesium.SampleRenderedDataFlags.TERRAIN | Cesium.SampleRenderedDataFlags.FLOOR);
            Cesium.when(o, function (n) {
                // var i = t._style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_ON_TERRAIN ? !0 : !1;
                var i = t._style.altitudeMethod == 2 ? !0 : !1;
                convertPolygonsRelativeHeightToAbsoluteHeightFromTerrainHeights$1(e.features, n, getAltitudeOffsetFunc$1(t), i),
                    r(e);
            });
        } else e.features = addAltitudeOffsetToFeatureHeights$1(e.features, getAltitudeOffsetFunc$1(t)),
            r(e);
    };
    EntityCreator$1.prototype.createPolygonGeometryHelper = function (e, t, n, r, i, s, h, water) {
        var o = s != undefined ? Cesium.PerInstanceColorAppearance.VERTEX_FORMAT : Cesium.PerInstanceColorAppearance.FLAT_VERTEX_FORMAT;
        (water !== undefined || h !== undefined) && (o = Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT);
        var u = new e({
            polygonHierarchy: n,
            vertexFormat: o,
            perPositionHeight: h !== undefined ? undefined : i,
            extrudedHeight: s,
            height: h
        }),
            a = new Cesium.GeometryInstance({
                geometry: u,
                id: t,
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(r)
                }
            });
        return a
    };
    EntityCreator$1.prototype.createLinestringPrimitive = function (e) {
        var t = this;
        var r = function (e) {
            if (e.isQuery) {
                e.onFinishedQuery(i);
                return
            }
            var r = "";
            var i = [];
            var s;
            var o = [];
            var u = [];
            let collection = new Cesium.PrimitiveCollection();
            for (var f = 0; f < e.features.length; f++) {
                var l = e.features[f];
                if (!canAddFeature$1(e, l.fid)) continue;
                var c = l.absoluteHeightPositions ? l.absoluteHeightPositions : l.positions;
                var h = t.createLinestringOptions(c, l.attributes);
                var p = t.createCommonOptions(l.attributes);
                var ZH_USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS = 0;
                // TerraExplorer.USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS && s == undefined && (s = h.widthInMeters && t.style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_ON_TERRAIN ? !0 : !1);
                ZH_USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS && s == undefined && (s = h.widthInMeters && t.style.altitudeMethod == 2 ? !0 : !1);
                h.vertexFormat = s ? Cesium.PerInstanceColorAppearance.VERTEX_FORMAT : Cesium.PolylineColorAppearance.VERTEX_FORMAT;
                l.absoluteHeightPositions && delete l.absoluteHeightPositions;
                i.push(Cesium.BoundingSphere.fromPoints(h.positions));
                if (e.isQuery) continue;
                var PolylineGeometry, geometryInstance;

                // if (s) {
                //     (h.height = c.reduce(function (e, t, n, r) {
                //         return (n + 1) % 3 == 0 ? e + t / (r.length / 3) : e
                //     }, 0), h.cornerType = Cesium.CornerType.MITERED, h.granularity = Cesium.Math.RADIANS_PER_DEGREE, d = new Cesium.CorridorGeometry(h))
                // } else {
                //     d = new Cesium.PolylineGeometry(h);
                // }
                // var v = s ? TerraExplorer.USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS > 1 ? undefined : new Cesium.ZBiasGeometryInstanceAttribute(.1) : Cesium.ZBiasGeometryInstanceAttribute.defaultBias();
                // var v = s ? ZH_USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS > 1 ? undefined : new Cesium.ZBiasGeometryInstanceAttribute(.1) : Cesium.ZBiasGeometryInstanceAttribute.defaultBias();

                if (h.clampToGround) {
                    PolylineGeometry = new Cesium.GroundPolylineGeometry({
                        positions: h.positions,
                        width: h.width,
                    });
                    geometryInstance = new Cesium.GeometryInstance({
                        id: l,
                        geometry: PolylineGeometry,
                        attributes: {
                            color: new Cesium.ColorGeometryInstanceAttribute.fromColor(h.material),
                        }
                    });
                } else {
                    PolylineGeometry = new Cesium.PolylineGeometry(h);
                    geometryInstance = new that._cesium.GeometryInstance({
                        id: l,
                        geometry: PolylineGeometry,
                        attributes: {
                            color: new Cesium.ColorGeometryInstanceAttribute.fromColor(h.material),
                        }
                    });
                }
                // a.push(geometryInstance);
                e.parentLayer.addRenderedFeatureId(l.fid);
                r += l.fid + ";";
                o.push(l.fid);
                u.push(p.tooltip);

                let primitive = null;
                //添加
                if (h.clampToGround) {
                    primitive = new Cesium.GroundPolylinePrimitive({
                        geometryInstances: geometryInstance,
                        appearance: new Cesium.MaterialAppearance({
                            material: new Cesium.Material({
                                fabric: {
                                    type: 'Color',
                                    uniforms: {
                                        color: h.material
                                    }
                                }
                            }),
                            faceForward: true,
                            flat: false
                        }),
                        classificationType: h.classificationType
                    });
                } else {
                    primitive = new Cesium.Primitive({
                        geometryInstances: geometryInstance,
                        appearance: new Cesium.PolylineMaterialAppearance({
                            material: new Cesium.Material({
                                fabric: {
                                    type: 'Color',
                                    uniforms: {
                                        color: h.material
                                    }
                                }
                            }),
                        })
                    });
                }
                collection.add(primitive);
            }

            if (r == "") return;
            // var g = s ? Cesium.PerInstanceColorAppearance : Cesium.PolylineColorAppearance;
            // var y = s ? TerraExplorer.USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS > 1 ? Cesium.GroundPrimitive : Cesium.Primitive : Cesium.Primitive;
            // var y = s ? ZH_USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS > 1 ? Cesium.GroundPrimitive : Cesium.Primitive : Cesium.Primitive;

            var b = collection;
            // var b = new y({
            //     geometryInstances: a,
            //     appearance: new g({
            //         translucent: h.material.alpha < 1,
            //         closed: !1
            //     }),
            //     asynchronous: !0
            // });
            // n;
            b.ID = "polylines:" + _hashCode$1(r);
            b._instanceIds && b._instanceIds.length === 0 && (b._instanceIds = o);
            b._tooltips = u;

            e.onFinishedCreatePrimitive(b, i);
        },
            // i = this.style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_TERRAIN_ABSOLUTE;
            i = this.style.altitudeMethod == 3;
        if (!i) {
            var s = linestringFeaturesToPositionsArray$1(e.features);
            var o = Cesium.sampleRenderedData(s, Cesium.SampleRenderedDataFlags.TERRAIN | Cesium.SampleRenderedDataFlags.FLOOR);
            Cesium.when(o, function (n) {
                // var i = t._style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_ON_TERRAIN ? !0 : !1;
                var i = t._style.altitudeMethod == 2 ? !0 : !1;
                convertLinestringsRelativeHeightToAbsoluteHeightFromTerrainHeights$1(e.features, n, getAltitudeOffsetFunc$1(t), i);
                r(e);
            });
        } else e.features = addAltitudeOffsetToFeatureHeights$1(e.features, getAltitudeOffsetFunc$1(t)),
            r(e);
    };
    EntityCreator$1.prototype.createPointPrimitive = function (e) {
        var t = this;
        var n = function (e) {
            if (e.isQuery) {
                e.onFinishedQuery(i);
                return
            }
            var n = "";
            var r = [];
            var i = [];
            var s = [];
            var o;
            var u = new Cesium.LabelCollection({ scene: t.viewer.scene });
            var a = new Cesium.PointPrimitiveCollection({ scene: t.viewer.scene });
            var f = new Cesium.BillboardCollection({ scene: t.viewer.scene });
            var l = new Cesium.PrimitiveCollection;
            var c = new Cesium.PolylineCollection;
            for (var h = 0; h < e.features.length; h++) {
                var p = e.features[h];
                if (!canAddFeature$1(e, p.fid)) continue;
                var d = p.absoluteHeightPositions ? p.absoluteHeightPositions : p.positions;
                var v = t.createPointOptions(d, p.attributes);
                var m = t.createCommonOptions(p.attributes);
                p.clampToGround = v.clampToGround;
                v.sgsPointPosition && (p.sgsPointPosition = v.sgsPointPosition, delete v.sgsPointPosition);
                p.absoluteHeightPositions && delete p.absoluteHeightPositions;
                i.push(Cesium.BoundingSphere.fromPoints([v.position]));
                if (e.isQuery) continue;
                if (v.label) {
                    v.label.position = v.position;
                    v.label.id = p;
                    t.setEyeOffset(v.label);
                    // v.label.imageFile != undefined && (v.label.image = t.applyConditionalClassification(v.label.imageFile, p.attributes), v.label.label = v.label, f.add(v.label), t.setEyeOffset(v.label, -5));
                    // v.label.imageFile != undefined && v.label.showText != undefined && v.label.showText && (t.viewer.scene.onHoverShowTextArray[v.label.id] = !0);
                    if (v.label.imageFile != undefined) {
                        v.label.image = t.applyConditionalClassification(v.label.imageFile, p.attributes);
                        v.label.label = v.label;
                        f.add(v.label);
                        t.setEyeOffset(v.label, -5);
                    }
                    if (v.label.imageFile != undefined && v.label.showText != undefined && v.label.showText) {
                        t.viewer.scene.onHoverShowTextArray[v.label.id] = !0;
                    }
                    if (v.label.isBold != undefined && v.label.isBold) {
                        //v.label.image != undefined && delete v.label.image;
                        //var g = $.extend({}, v.label);
                        //g.outlineColor = v.label.fillColor;
                        //g.style = Cesium.LabelStyle.FILL_AND_OUTLINE;
                        //t.setEyeOffset(g, -5);
                        //g.outlineWidth = 1;
                        u.add(g);
                    } else if (v.label.isUnderline != undefined && v.label.isUnderline) {
                        var y = "_";
                        var b = v.label.text.match(/[iljf1]/g) != null ? v.label.text.match(/[iljf1]/g) : [];
                        var w = v.label.text.length;
                        var E = Array(Math.ceil(w - b.length * .5)).join(y);
                        o = $.extend({}, v.label);
                        v.label.image != undefined && delete v.label.image;
                        o.position = v.label.position;
                        o.id = v.label.id;
                        o.text = E;
                        o.alignment = v.label.alignment != undefined ? v.label.alignment : undefined;
                        o.underline = !0;
                        o.textRelativeToImage = v.label.textRelativeToImage != undefined ? v.label.textRelativeToImage : undefined;
                        v.label.font.indexOf("pt") > -1 ? Number(v.label.font.split("pt")[0]) * 4 / 3 : v.label.font.indexOf("px") > -1 ? Number(v.label.font.split("px")[0]) : 5;
                        o.pixelOffset = new Cesium.Cartesian2(0, -45),
                            u.add(o);
                    } else u.add(v.label);
                }
                v.billboard && (v.billboard.position = v.position, v.billboard.id = p, t.setEyeOffset(v.billboard), f.add(v.billboard));
                if (v.model) {
                    v.model.url = v.model.uri;
                    v.model.id = p;
                    l.add(Cesium.Model.fromGltf(v.model));
                }
                v.point && (v.point.position = v.position, v.point.id = p, t.setEyeOffset(v.point), a.add(v.point));
                if (v.lineToGround != 0) {
                    var T = Cesium.Cartographic.fromCartesian(v.position);
                    var N = Cesium.Cartesian3.fromRadians(T.longitude, T.latitude, 0);
                    if (v.lineToGround == 2) {
                        var C = v.lineToGroundLength / Cesium.Cartesian3.distance(v.position, N);
                        Cesium.Cartesian3.lerp(v.position, N, C, N);
                    }
                    c.add({
                        show: !0,
                        width: 1,
                        positions: [v.position, N],
                        material: Cesium.Material.fromType("Color", {
                            color: v.lineToGroundColor
                        })
                    });
                }
                e.parentLayer.addRenderedFeatureId(p.fid);
                n += p.fid + ";";
                r.push(p.fid);
                s.push(m.tooltip);
            }

            if (n == "") return;
            var k, L = new Cesium.PrimitiveCollection;
            // u.length > 0 && ($.each(u._labels, function (e, t) {
            //     t._type = "Label"
            // }), u._billboardCollection._parentCollection = L, L.add(u), k = "labels");

            // f.length > 0 && ($.each(f._billboards, function (e, t) {
            //     t._type = "Billboard"
            // }), f._parentCollection = L, L.add(f), k = "billboards");

            // l.length > 0 && ($.each(l._primitives, function (e, t) {
            //     t._type = "Model",
            //         t._parentCollection = L
            // }), L.add(l), k = "models");

            // a.length > 0 && ($.each(a._pointPrimitives, function (e, t) {
            //     t._type = "Point"
            // }), a._parentCollection = L, L.add(a), k = "points");

            // c.length > 0 && ($.each(c._polylines, function (e, t) {
            //     t._type = "L2G"
            // }), c._parentCollection = L, L.add(c), k = "L2G");

            if (u.length > 0) {
                $.each(u._labels, function (e, t) {
                    t._type = "Label";
                });
                u._billboardCollection._parentCollection = L;
                L.add(u);
                k = "labels";
            }

            if (f.length > 0) {
                $.each(f._billboards, function (e, t) {
                    t._type = "Billboard";
                });
                f._parentCollection = L;
                L.add(f);
                k = "billboards";
            }

            if (l.length > 0) {
                $.each(l._primitives, function (e, t) {
                    t._type = "Model";
                    t._parentCollection = L;
                });
                L.add(l);
                k = "models";
            }

            if (a.length > 0) {
                $.each(a._pointPrimitives, function (e, t) {
                    t._type = "Point";
                });
                a._parentCollection = L;
                L.add(a);
                k = "points";
            }

            if (c.length > 0) {
                $.each(c._polylines, function (e, t) {
                    t._type = "L2G";
                });
                c._parentCollection = L;
                L.add(c);
                k = "L2G";
            }


            L.ID = k + ":" + _hashCode$1(n);
            L._instanceIds = r;
            L._tooltips = s;
            e.onFinishedCreatePrimitive(L, i);
        };
        // r = this.style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_TERRAIN_ABSOLUTE;
        var r = this.style.altitudeMethod == 3;
        if (!r) {
            var i = pointFeaturesToPositionsArray$1(e.features);
            var s = Cesium.sampleRenderedData(i);
            Cesium.when(s, function (r) {
                // var i = t._style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_ON_TERRAIN ? !0 : !1;
                var i = t._style.altitudeMethod == 2 ? !0 : !1;
                convertPointsRelativeHeightToAbsoluteHeightFromTerrainHeights$1(e.features, r, getAltitudeOffsetFunc$1(t), i);
                n(e);
            }).otherwise(function (o) {
            });
        } else {
            e.features = addAltitudeOffsetToFeatureHeights$1(e.features, getAltitudeOffsetFunc$1(t));
            n(e);
        }
    };
    EntityCreator$1.prototype.createCommonOptions = function (e) {
        var t = {};
        return t.tooltip = this.applyConditionalClassification(this.style.tooltip, e),
            t
    };
    EntityCreator$1.prototype.createPolygonOptions = function (e, t) {
        var n = this.getPolygonStyle(this.style);
        n.polygon.hierarchy = {
            positions: Cesium.Cartesian3.fromDegreesArrayHeights(e[0]),
            holes: []
        };
        for (var r = 1; r < e.length; r++) n.polygon.hierarchy.holes.push({
            positions: Cesium.Cartesian3.fromDegreesArrayHeights(e[r])
        });
        var i = this.applyConditionalClassification(n.polygon.material, t);
        n.polygon.material = teColorToCesiumColor$1(i);
        if (n.polygon.fill != undefined && n.polygon.fromKml != undefined) {
            var s = this.applyConditionalClassification(n.polygon.fill, t);
            s > 1 && (s /= 100),
                n.polygon.material = new Cesium.Color(n.polygon.material.red, n.polygon.material.green, n.polygon.material.blue, s);
        }
        //薛鹏修改
        if (n.polygon.extrudedHeight && n.polygon.extrudedHeight && n.polygon.extrudedHeight.indexOf && n.polygon.extrudedHeight.indexOf("[") > -1 && n.polygon.extrudedHeight.defaultValue.indexOf("]") > -1) {
            var i = t[n.polygon.extrudedHeight.defaultValue.substring(1, n.polygon.extrudedHeight.defaultValue.length - 1)];
            var i = parseInt(i);
            i !== undefined && (n.polygon.extrudedHeight = i * 3);
        }
        if (t.FSCALE) {
            var f = this.getLevelDistance(t.FSCALE);
            n.polygon.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(1, f);
        }
        return i = this.applyConditionalClassification(n.polygon.outlineColor, t),
            n.polygon.outlineColor = teColorToCesiumColor$1(i),
            n.polygon
    };
    EntityCreator$1.prototype.translateLineWidth = function (e, t) {
        var n = this.applyConditionalClassification(e.polyline.width, t);
        return n > 0 ? TerraExplorer.USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS ? n > 1 && (e.polyline.widthInMeters = !0, n *= .8, e.polyline.backgroundOpacity > 0 && (n *= .8)) : n = n > 1 ? 2 : 1 : n < 0 ? n = Math.min(5, Math.abs(n)) : n == 0 && (n = 1),
            n
    };
    EntityCreator$1.prototype.createLinestringOptions = function (e, t) {
        var n = this.getLinestringStyle(this.style);
        n.id = t;
        n.polyline.positions = Cesium.Cartesian3.fromDegreesArrayHeights(e);
        var r = this.applyConditionalClassification(n.polyline.material, t);
        n.polyline.material = teColorToCesiumColor$1(r);
        if (n.polyline.lineOpacity != undefined) {
            var i = this.applyConditionalClassification(n.polyline.lineOpacity, t);
            i > 1 && (i /= 100),
                n.polyline.material = new Cesium.Color(n.polyline.material.red, n.polyline.material.green, n.polyline.material.blue, i);
        }
        if (n.polyline.far) {
            n.polyline.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(n.polyline.near !== undefined ? n.polyline.near : 0, n.polyline.far);
        }
        if (t.FSCALE) {
            var f = this.getLevelDistance(t.FSCALE);
            n.polyline.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(1, f);
        }
        //return n.polyline.width = this.translateLineWidth(n, t),
        //    n.polyline
        return n.polyline.width = this.applyConditionalClassification(n.polyline.width, t),
            n.polyline
    };
    EntityCreator$1.prototype.applyConditionalClassification = function (e, t) {
        if (e == undefined) return undefined;
        if (e.defaultValue == undefined) return e;
        var n = tryGetValueAsFloat$1(e.defaultValue);
        if (e.classificationArray === undefined) {
            if (!isNaN(n))
                return n;
            if (n instanceof Cesium.Color)
                return n
        }
        if (e.attributeName !== undefined) {
            var r = "[" + e.attributeName + "]";
            if (n === r)
                n = t[e.attributeName];
            else if (e.multipleAttributeReplacementNeeded) {
                for (name in t)
                    n = replaceAll$1(n, "[" + name + "]", t[name]);
            } else {
                n = replaceAll$1(n, r, t[e.attributeName]);
            }
            return n
        }
        if (e.classification !== undefined) return n = applyClassificationFunc$1(e.classification, t),
            n;
        var i = e.classificationArray;
        return i !== undefined ? ($(Object.keys(i)).each(function (e, r) {
            var s = getClassificationValue$1(i[r], t);
            s && (n = s);
        }), n) : n
    };
    EntityCreator$1.prototype.createLineToGroundOptions = function (e, t) {
        var n = this.applyConditionalClassification(e.lineToGround, t);
        if (n != undefined && Number(n) != 0) {
            e.lineToGround = n;
            var r = this.applyConditionalClassification(e.lineToGroundColor, t);
            r = colorFromClassification$1(r),
                e.lineToGroundColor = r;
            var i = this.applyConditionalClassification(e.lineToGroundLength, t);
            e.lineToGroundLength = Number(i);
        } else e.lineToGround = 0,
            e.lineToGroundColor = 0,
            e.lineToGroundLength = 0;
    };
    EntityCreator$1.prototype.createPointOptions = function (e, t) {
        var n = this.getPointStyle(this.style);
        //张丹钊修改
        if (n.pointHeight) {
            n.position = Cesium.Cartesian3.fromDegrees(e[0], e[1], n.pointHeight);
            e[2] = n.pointHeight;
        } else {
            n.position = Cesium.Cartesian3.fromDegrees(e[0], e[1], e[2]);
        }
        n.sgsPointPosition = e;
        n.id = t;
        if (n.label) {
            var r = n.label.text;
            // if (r !== undefined && r.indexOf("[") > -1 && r.indexOf("]") > -1) {
            if (r !== undefined && r.defaultValue.indexOf("[") > -1 && r.defaultValue.indexOf("]") > -1) {
                var i = t[r.defaultValue.substring(1, r.defaultValue.length - 1)];
                i !== undefined && (n.label.text = i);
            }
            if (this.applyConditionalClassification(n.label.text, t))
                n.label.text = this.applyConditionalClassification(n.label.text, t).toString();
            else
                n.label.text = this.applyConditionalClassification(n.label.text, t);

            //function s(e) {
            //    return e.split("").reverse().join("")
            //}

            //function o(e) {
            //    if (!e) return e;
            //    var t = "A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿Ⰰ-﬜﷾-﹯﻽-￿",
            //        n = "֑-߿יִ-﷽ﹰ-ﻼ",
            //        r = new RegExp("^[^" + t + "]*[" + n + "]");
            //    return r.test(e[0])
            //}
            //n.label.text = o(n.label.text) ? s(n.label.text) : n.label.text;
            //薛鹏修改
            n.label.text = this.o(n.label.text) ? this.s(n.label.text) : n.label.text;
            if (n.label.text.indexOf("[") > -1 && n.label.text.indexOf("]") > -1) {
                n.label.text = '';
            }
            if (n.label.family != undefined) {
                var u = this.applyConditionalClassification(n.label.family, t),
                    a = this.applyConditionalClassification(n.label.font, t);
                a >= 0 ? n.label.font = convertFontSizeToTEFontSize$1(a).toString() + "pt " + u : n.label.font = convertFontSizeToTEFontSize$1(getFontSizeInPixels$1(a)).toString() + "pt " + u;
            }
            n.label.fillColor = colorFromClassification$1(this.applyConditionalClassification(n.label.fillColor, t)),
                n.label.backgroundColor = colorFromClassification$1(this.applyConditionalClassification(n.label.backgroundColor, t)),
                n.label.backgroundColor == undefined && (n.label.backgroundColor = new Cesium.Color(.165, .165, .165, 0)),
                n.label.showBackground = !0;
            if (n.label.showText != undefined) {
                var f = this.applyConditionalClassification(n.label.showText, t);
                f && Number(f) === 1 && (n.label.onHoverShowText = !0);
                if (f && viewer.scene.canvas.onHoverShowText == undefined) {
                    var l = viewer.scene,
                        c = new Cesium.ScreenSpaceEventHandler(l.canvas);
                    c.setInputAction(function (e) {
                        var t = {};
                            l.screenToWorld(e.endPosition, t);
                        Cesium.defined(t.pickPrimitive) && t.pickPrimitive.constructor.name == "Billboard" && t.pickPrimitive.label != undefined ? l.onHoverShowTextArray[t.pickPrimitive.label.id] != undefined && (l._lastObjectShowOnText != null && l._lastObjectShowOnText.id != t.pickPrimitive.label.id && l._lastObjectShowOnText.show != undefined && (l._lastObjectShowOnText.show = !1), viewer.scene._lastObjectShowOnText = l.onHoverShowTextArray[t.pickPrimitive.label.id], l._lastObjectShowOnText.show != undefined && (viewer.scene._lastObjectShowOnText.show = !0)) : l._lastObjectShowOnText != null && l._lastObjectShowOnText.show != undefined && (l._lastObjectShowOnText.show = !1);
                    }, Cesium.ScreenSpaceEventType.MOUSE_MOVE),
                        viewer.scene.canvas.onHoverShowText = !0;
                }
            }
            n.label.textRelativeToImage != undefined && n.label.textAlignment != undefined && (n.label.textRelativeToImage = this.applyConditionalClassification(n.label.textRelativeToImage, t), n.label.alignment = this.applyConditionalClassification(n.label.textAlignment, t)),
                n.label.underline != undefined && (n.label.isUnderline = this.applyConditionalClassification(n.label.underline, t));
            // n.label.bold != undefined && (n.label.isBold = this.applyConditionalClassification(n.label.bold, t));
            if (n.label.bold != undefined) {
                var h = this.applyConditionalClassification(n.label.bold, t);
                h == 1 && (n.label.font = "bold " + n.label.font);
            }
            if (n.label.italic != undefined) {
                var h = this.applyConditionalClassification(n.label.italic, t);
                h == 1 && (n.label.font = "italic " + n.label.font);
            }

            n.label.backgroundOpacity != undefined && (n.label.backgroundColor.alpha = this.applyConditionalClassification(n.label.backgroundOpacity, t));
            //薛鹏修改
            //var p = parseFloat(n.label.scale.defaultValue);
            //n.label.scale = clamp(this.applyConditionalClassification(n.label.scale, t) / p, .7, 1.3),
            //    n.label.scale = this.applyConditionalClassification(n.label.scale, t);
            if (n.label.minViewingHeight != undefined) {
                var d = this.applyConditionalClassification(n.label.minViewingHeight, t),
                    v = this.applyConditionalClassification(n.label.scaleMPP, t) * 650;
                n.label.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(d, v);
            }
            if (t.FSCALE) {
                var f = this.getLevelDistance(t.FSCALE);
                n.label.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(1, f);
            }
            !n.label.disableDepthTestDistance && (n.label.disableDepthTestDistance = 1000);
            n.clampToGround && (n.label.heightReference = 1);
            // isNaN(n.label.scale) && (n.label.scale = 1.5);
            //张丹钊修改（影响远近可视）
            // if (n.label.limitGrowth != undefined && n.label.scaleMPP != undefined) {
            //     var m = this.applyConditionalClassification(n.label.limitGrowth, t),
            //         g = this.applyConditionalClassification(n.label.scaleMPP, t) * 1e3;
            //     m ? n.label.scaleByDistance = new Cesium.NearFarScalar(g, 1, g * 10, 0) : n.label.scaleByDistance = new Cesium.NearFarScalar(15, 50, g * 10, .1)
            // }
        }
        if (n.billboard) {
            n.billboard.sizeInMeters = !1;
            if (n.billboard.imageColor != undefined) {
                var y = this.applyConditionalClassification(n.billboard.imageColor, t);
                y = colorFromClassification$1(y),
                    n.billboard.color = y;
            }
            n.billboard.imageOpacity != undefined && n.billboard.color.alpha != undefined && (n.billboard.color.alpha = Number(this.applyConditionalClassification(n.billboard.imageOpacity, t))),
                n.billboard.image = this.applyConditionalClassification(n.billboard.image, t);
            //张丹钊修改（影响远近可视）
            // if (n.billboard.limitGrowth != undefined && n.billboard.scaleTE != undefined) {
            //     var m = this.applyConditionalClassification(n.billboard.limitGrowth, t);
            //     m.defaultValue == undefined && !isNaN(Number(m)) && (m = Number(m));
            //     var g = this.applyConditionalClassification(n.billboard.scaleTE, t) * 1e3;
            //     m ? n.billboard.scaleByDistance = new Cesium.NearFarScalar(g, 1, g * 10, 0) : (n.billboard.sizeInMeters = !0, n.billboard.scaleByDistance = new Cesium.NearFarScalar(g, g / 1e3, g * 10, g / 1e3))
            // }
            if (n.billboard.minViewingHeight != undefined) {
                var d = this.applyConditionalClassification(n.billboard.minViewingHeight, t),
                    v = this.applyConditionalClassification(n.billboard.scaleMPP, t) * 650;
                n.billboard.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(d, v);
            }
            if (t.FSCALE) {
                var f = this.getLevelDistance(t.FSCALE);
                n.billboard.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(1, f);
            }
            if (n.billboard.link) {
                n.id && typeof n.id === 'object' && (n.id.link = this.applyConditionalClassification(n.billboard.link, t));
            }
            !n.billboard.disableDepthTestDistance && (n.billboard.disableDepthTestDistance = 1000);
            n.clampToGround && (n.billboard.heightReference = 1);
        }
        if (n.model) {
            var b = function (e) {
                var t = Number(e);
                if (!Cesium.defined(t) || isNaN(t)) t = 0;
                return t
            };
            n.model.uri = this.applyClassification(n.model.uri, t),
                n.model.scale = b(this.applyClassification(n.model.scale, t));
            var w = b(this.applyClassification(n.model.heading, t)),
                E = b(this.applyClassification(n.model.pitch, t)),
                S = b(this.applyClassification(n.model.roll, t)),
                x = new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(w), Cesium.Math.toRadians(E), Cesium.Math.toRadians(S));
            n.model.modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(n.position, x);
        }
        return this.createLineToGroundOptions(n, t),
            n
    },
        //薛鹏修改
        EntityCreator$1.prototype.s = function (e) {
            return e.split("").reverse().join("");
        },
        //张丹钊添加
        EntityCreator$1.prototype.getLevelDistance = function (level) {
            var distance = 20000000;
            switch (parseInt(level)) {
                case 2: distance = 10123000; break;
                case 3: distance = 7123000; break;
                case 4: distance = 6321000; break;
                case 5: distance = 5522000; break;
                case 6: distance = 3436000; break;
                case 7: distance = 539000; break;
                case 8: distance = 305000; break;
                case 9: distance = 180000; break;
                case 10: distance = 133000; break;
                case 11: distance = 100000; break;
                case 12: distance = 76500; break;
                case 13: distance = 58200; break;
                case 14: distance = 23500; break;
                case 15: distance = 9600; break;
                case 16: distance = 4000; break;
                case 17: distance = 2000; break;
                case 18: distance = 1700; break;
                case 19: distance = 1500; break;
                case 20: distance = 1000; break;
                case 21: distance = 500; break;
                case 22: distance = 200; break;
                case 23: distance = 100; break;
            }
            return distance;
        };
    EntityCreator$1.prototype.o = function (e) {
        if (!e) return e;
        var t = "A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿Ⰰ-﬜﷾-﹯﻽-￿",
            n = "֑-߿יִ-﷽ﹰ-ﻼ",
            r = new RegExp("^[^" + t + "]*[" + n + "]");
        return r.test(e[0]);
    };
    EntityCreator$1.prototype.applyClassification = function (text, attributes) {
        if ($.type(text) !== "string") return text;
        if (/(\[([^\]]+)\])/g.exec(text) != null)
            for (var attr in attributes) text = replaceAll$1(text, "[" + attr + "]", attributes[attr]);
        text == "undefined" && (text = "");
        var myRegexp = /(\<([^\>]+)\>)/g,
            match = myRegexp.exec(text);
        while (match != null) {
            try {
                var expression = match[match.length - 1],
                    value = (0, eval)(expression);
                text = text.replace(match[0], value);
            } catch (e) {
            }
            match = myRegexp.exec(text);
        }
        return text
    };
    EntityCreator$1.prototype.getPolygonStyle = function (e) {
        var t = $.extend(!0, {}, PredefinedFeatureStyles$1.DEFAULT_POLYGON_STYLE, e);
        return t
    };
    EntityCreator$1.prototype.getLinestringStyle = function (e) {
        var t = $.extend(!0, {}, PredefinedFeatureStyles$1.DEFAULT_POLYLINE_STYLE, e);
        return t
    };
    EntityCreator$1.prototype.getPointStyle = function (e) {
        if (e.label != undefined) {
            var t = $.extend(!0, {}, PredefinedFeatureStyles$1.DEFAULT_LABEL_STYLE, e);
            return t
        }
        if (e.billboard != undefined) {
            var n = $.extend(!0, {}, PredefinedFeatureStyles$1.DEFAULT_BILLBOARD_STYLE, e);
            return n
        }
        if (e.model != undefined) {
            var r = $.extend(!0, {}, PredefinedFeatureStyles$1.DEFAULT_MODEL_STYLE, e);
            return r
        }
        if (e.point != undefined) {
            var i = $.extend(!0, {}, PredefinedFeatureStyles$1.DEFAULT_POINT_STYLE, e);
            return i
        }
        return PredefinedFeatureStyles$1.DEFAULT_POINT_STYLE
    };
    EntityCreator$1.prototype.sanitizePositions = function (e) {
        for (var t = 0; t < e.length; t++) e[t] instanceof Array ? this.sanitizePositions(e[t]) : isNaN(e[t]) && (e[t] = 0);
    };
    var PredefinedFeatureStyles$1 = {};
    Object.defineProperties(PredefinedFeatureStyles$1, {
        DEFAULT_POLYGON_STYLE: {
            get: function () {
                return {
                    polygon: {
                        perPositionHeight: !0,
                        fill: 0,
                        material: Cesium.Color.GREEN,
                        outline: true,
                        outlineColor: Cesium.Color.WHITE,
                        outlineWidth: 1
                    }
                }
            }
        },
        DEFAULT_POLYLINE_STYLE: {
            get: function () {
                return {
                    polyline: {
                        material: Cesium.Color.WHITE,
                        width: 1
                    }
                }
            }
        },
        DEFAULT_POINT_STYLE: {
            get: function () {
                return {
                    point: {
                        color: Cesium.Color.RED,
                        pixelSize: 5,
                        outlineColor: Cesium.Color.WHITE,
                        outlineWidth: 2
                    }
                }
            }
        },
        DEFAULT_LABEL_STYLE: {
            get: function () {
                return {
                    label: {
                        text: "Text",
                        font: "18px arial",
                        style: Cesium.LabelStyle.FILL,
                        fillColor: Cesium.Color.WHITE,
                        outlineColor: Cesium.Color.BLACK,
                        outlineWidth: 5,
                        scale: 1,
                        horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        eyeOffset: Cesium.Cartesian3.ZERO,
                        pixelOffset: new Cesium.Cartesian2(0, -50)
                    }
                }
            }
        },
        DEFAULT_BILLBOARD_STYLE: {
            get: function () {
                return {
                    billboard: {
                        image: "./img/query.png",
                        scale: 1,
                        horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM
                    }
                }
            }
        },
        DEFAULT_MODEL_STYLE: {
            get: function () {
                return {
                    model: {
                        uri: "./img/CesiumTexturedBoxTest.bgltf",
                        scale: 1e3
                    }
                }
            }
        }
    });

    /**
     *
     * @param {Object} e viewer
     * @param {String} t url "http://192.168.1.40:8090/geoserver/swagger/wms?"
     * @param {String} n name "swagger:point"
     * @param {Object} r level 2
     * @param {Object} i style-billboard "{"billboard":{"color":{"red":1,"green":1,"blue":1,"alpha":1},"image":{"defaultValue":"http://localhost/SG/resources/397940/defaultIcon.gif"},"imageColor":{"defaultValue":{"red":1,"green":1,"blue":1,"alpha":1}},"imageOpacity":{"defaultValue":"1"},"scaleTE":{"defaultValue":"15000"},"limitGrowth":{"defaultValue":"1"},"minViewingHeightObj":{"defaultValue":"0"}},"lineToGround":{"defaultValue":"0"},"lineToGroundLength":{"defaultValue":"0"},"lineToGroundColor":{"defaultValue":{"red":1,"green":1,"blue":1,"alpha":1}},"altitudeMethod":0,"altitudeOffset":{"defaultValue":"0"}}"
     *                   style-polygon   "{"polygon":{"outlineColor":{"defaultValue":{"red":1,"green":1,"blue":1,"alpha":1}},"outlineWidth":1,"fill":{"defaultValue":"0"},"outline":{"defaultValue":"1"},"material":{"defaultValue":{"red":0.39215686274509803,"green":0.39215686274509803,"blue":0.39215686274509803,"alpha":1}},"fromKml":true},"altitudeMethod":2,"altitudeOffset":{"defaultValue":"0"}}"
     * @param {String} s displayName "swagger:point"
     * @param {Object} o subdomains undefined
     * @param {Object} u latlon undefined
     * @param {Object} a myLayer undefined
     */
    var TileManager$4;
    function WfsLayer$1(e, t, n, r, i, s, o, u, a) {
        var _that = this;
        this._viewer = e;
        this._Viewer = e;
        _that.G = 65535;
        TileManager$4 = new TileManager1$1();
        workerPool$1 = new WorkerPool({
            //workerPath: "./wfs/featurefetcherworker.js"
            workerPath: lj$3()
        });

        if (!Cesium.sampleRenderedData) {
            if (Cesium.Resource) {
                Cesium.loadText = Cesium.Resource.fetchText;
                Cesium.loadJson = Cesium.Resource.fetchJson;
                Cesium.loadBlob = Cesium.Resource.fetchBlob;
                Cesium.loadArrayBuffer = Cesium.Resource.fetchArrayBuffer;
                Cesium.loadImage = Cesium.Resource.fetchImage;
            }

            function K(e, t) {
                function r() {
                    e.ready ? Cesium.when(J(e, t), function (e) {
                        n.resolve(e);
                    }) : setTimeout(r, 10);
                }

                Cesium.Check.typeOf.object("terrainProvider", e),
                    Cesium.Check.defined("positions", t);
                var n = Cesium.when.defer();
                return r(),
                    n.promise
            }

            function V(e, t) {
                for (var n = 0; n < e.children.length; n++) {
                    var r = e.children[n].state >= Cesium.QuadtreeTileLoadState.DONE && (e.children[n].data.terrainData._mesh != undefined || e.children[n].data.terrainData._buffer != undefined);
                    if (r && e.children[n].x == t.x && e.children[n].y == t.y) return e.children[n]
                }
                return undefined
            }

            function $$$(e, t) {
                var n = e.tilingScheme,
                    r = n.positionToTileXY(t, 0),
                    i = _that._Viewer.scene.globe._surface.tileProvider.quadtree._levelZeroTiles,
                    s = i[0].x == r.x && i[0].y == r.y ? i[0] : i[1];
                for (var o = 1; o < 22; o++) {
                    r = n.positionToTileXY(t, o);
                    var u = V(s, r);
                    if (u == undefined) break;
                    s = u;
                }
                return s
            }

            function Z(e, t) {
                Cesium.Check.defined("positions", e);
                var n = Cesium.when.defer();
                return Cesium.when(Y(e), function (e) {
                    n.resolve(e);
                }),
                    n.promise
            }

            function Y(t, n) {
                $.grep(_that._Viewer.scene.primitives._primitives, function (e) {
                    return e instanceof Cesium.Cesium3DTileset
                });
                    var i;
                for (i = 0; i < t.length; ++i) {
                    var s = t[i],
                        o = s instanceof Cesium.Cartographic,
                        u = o ? s : Cesium.Cartographic.fromCartesian(s);
                    u.height = _that.G;
                    // r.forEach(function (e) {
                    //     if (e.ready && e.show) {
                    //         var t = Q(e, u, n);
                    //         t !== undefined && (n ? t.content && t.content._model && t.content._model.floor && (u.height = t.content._model.floor.getHeight(u.longitude, u.latitude), _that.G = t.content._model.floor.nullValue) : u.height = t._boundingVolume.maximumHeight)
                    //     }
                    // });
                    if (!o) {
                        var a = Cesium.Cartesian3.fromRadiansArrayHeights([u.longitude, u.latitude, u.height])[0];
                        s.z = a.z;
                    }
                }
                return t
            }

            function J(e, t) {
                var n;
                for (n = 0; n < t.length; ++n) {
                    var r = t[n],
                        i = $$$(e, r);
                    r.height = i.data.terrainData.interpolateHeight(i.rectangle, r.longitude, r.latitude);
                }
                return t
            }
            function j(e) {
                this.value = new Float32Array([e]);
            }

            j.fromZBias = function (e) {
                if (!Cesium.defined(e)) throw new DeveloperError("zbias is required.");
                return new j(e)
            };
            j.toValue = function (e, t) {
                if (!Cesium.defined(e)) throw new DeveloperError("zbias is required.");
                return Cesium.defined(t) ? color.toBytes(t) : new Float32Array(e)
            };
            j.equals = function (e, t) {
                return e === t || Cesium.defined(e) && Cesium.defined(t) && e.value[0] === t.value[0]
            };
            j.defaultBias = function () {
                // var e = TerraExplorer.zbiaz == undefined ? 15e-6 : TerraExplorer.zbiaz;
                var e = 15e-6 ;
                return j.fromZBias(e)
            };
            Cesium.ZBiasGeometryInstanceAttribute = j;
            Cesium.ZBiasGeometryInstanceAttribute = j;
            Cesium.SampleRenderedDataFlags = {
                TERRAIN: 2,
                MESH: 4,
                FLOOR: 8
            };
            Cesium.DynamicEyeOffset = function (e) {
                return e === undefined && (e = 0),
                    new Cesium.Cartesian3(.001234321, 0, e)
            };

            Cesium.sampleRenderedData = function (e, t) {
                var et = {
                    TERRAIN: 2,
                    MESH: 4,
                    FLOOR: 8
                };
                t == undefined && (t = et.TERRAIN | et.MESH);
                var n = Cesium.when.defer(),
                    r = [];
                t > et.TERRAIN ? e.forEach(function (e) {
                    r.push(Cesium.Cartographic.fromRadians(e.longitude, e.latitude, e.height));
                }) : r = e;
                var i = [];
                t & et.TERRAIN && i.push(K(_that._Viewer.terrainProvider, e));
                var s = (t & et.FLOOR) > 0;
                return t & (et.MESH | et.FLOOR) && i.push(Z(r)),
                    Cesium.when.all(i).then(function (t) {
                        if (i.length > 1)
                            for (var r = 0; r < e.length; r++) {
                                var o = t[0][r],
                                    u = t[1][r];
                                if (u.height == _that.G) continue;
                                if (o.height < u.height || s) o.height = u.height;
                            }
                        n.resolve(t[0]);
                    }),
                    n.promise
            };
            Cesium.sampleRenderedMesh = function (e, t) {
                Cesium.Check.defined("positions", e);
                var n = Cesium.when.defer();
                return Cesium.when(Y(e), function (e) {
                    n.resolve(e);
                }),
                    n.promise
            };
            Cesium.sampleRenderedTerrain = function (e, t) {
                function r() {
                    e.ready ? Cesium.when(J(e, t), function (e) {
                        n.resolve(e);
                    }) : setTimeout(r, 10);
                }

                Cesium.Check.typeOf.object("terrainProvider", e),
                    Cesium.Check.defined("positions", t);
                var n = Cesium.when.defer();
                return r(),
                    n.promise
            };
            Cesium.QuadtreePrimitive.prototype.getRenderedBestLevelInfo = function () {
                var e = this.getRenderedLevelInfo(),
                    t = 0;
                for (var n in e) t < Number(n) && (t = Number(n));
                return {
                    bestLevel: t,
                    count: e[t]
                }
            };
            Cesium.QuadtreePrimitive.prototype.getRenderedLevelInfo = function () {
                var e = [];
                return this._tilesToRender.forEach(function (t) {
                    e[t.level] == undefined && (e[t.level] = 0),
                        e[t.level]++;
                }),
                    e
            };
        }
        i = i || {};
        this._level = r || { min: 0, max: 22 };
        if (typeof this._level === 'number') {
            this._level = { min: r, max: 22 };
        }
        this._url = t;
        this._layerName = n;
        this._guid = Cesium.createGuid();

        this._gmlParser = new GmlParser$1(!0, null, null, !0);
        this._tileManager = TileManager$4.getInstance(e);
        this._tileManager._loadTileEvent.addEventListener(WfsLayer$1.prototype.loadTile, this);
        this._useWorkers = !0;
        this._layerDisplayName = s;
        this._showAttributesAsMessage = i.showAttributesAsMessage;
        delete i.showAttributesAsMessage;
        this._entityCreator = new EntityCreator$1(i, e);
        this._visible = !0;
        this._featuresMap = {};
        this._boundingBox = undefined;
        this._geometryFieldName = undefined;
        this._operations = {};
        this._subdomains = o;
        this.latLon = u;
        this._addedFeatures = [];
        this.simpleSqlParser = SimpleSqlParser$1;
        this.myLayer = a;
        this._statistics = {
            numberOfAddedFeatures: 0,
            numberOfDeletedFeatures: 0,
            numberOfAddePositions: 0,
            numberOfDeletedPositions: 0,
            getNumberOfCurrentlyRenderedFeatures: function () {
                return this.numberOfAddedFeatures - this.numberOfDeletedFeatures
            },
            getNumberOfCurrentlyRenderedPositions: function () {
                return this.numberOfAddePositions - this.numberOfDeletedPositions
            }
        };
        initLayerCapabilities$1(this);
        initFeatureType$1(this);
    }

    function ReplaceTagWithOriginalDomain$1(e, t) {
        var n;
        return e.indexOf("{s}") != -1 ? n = t != undefined && t.length > 0 ? e.replace("{s}", t[0]) : console.error("Error - sTag with no subdomains.") : n = e,
            n
    }

    function getXmlTag$1(t, n, r) {
        var i = $(t).find(n);
        return i.length == 0 && r.toLowerCase() === "wfs" && (i = $(t).find("wfs\\:" + n + "," + n)),
            i.length > 0 ? i : $([])
    }

    function parseBBox$1(e, t) {
        getXmlTag$1(t, "FeatureType", "wfs").each(function (t, n) {
            if (getXmlTag$1(n, "Name", "wfs").text() == e._layerName) {
                var r = getXmlTag$1(n, "LatLongBoundingBox", "wfs");
                return r.length !== 1 ? !1 : (e._boundingBox = Cesium.Rectangle.fromDegrees(parseFloat(r[0].attributes.minx.value), parseFloat(r[0].attributes.miny.value), parseFloat(r[0].attributes.maxx.value), parseFloat(r[0].attributes.maxy.value)), !1)
            }
            return !0
        });
    }

    function queryStringExist$1(t) {
        return t.indexOf("?") > -1 ? "&" : "?"
    }

    function initLayerCapabilities$1(e) {
        var t = e.cleanUrl(e._url).replace("{s}", e.sTag(e._layerName.length, e._layerName.length, e._level));
        t += queryStringExist$1(t),
            t += "SERVICE=WFS&VERSION=1.0.0&REQUEST=GetCapabilities&outputFormat=GML2&typeName=" + e._layerName;
        //var n = TerraExplorer.internal.Settings.connectionUrl,
        var r = Cesium.TrustedServers.contains(ReplaceTagWithOriginalDomain$1(e._url, e._subdomains));
        $.ajax({
            dataType: "xml",
            xhrFields: {
                withCredentials: r
            },
            url: encodeURI(t),
            success: function (t) {
                parseBBox$1(e, t),
                    initAllowedOperations$1(e, t);
            }
        });
    }

    function initAllowedOperations$1(e, t) {
        $(t).find("FeatureType").each(function (t, n) {
            if ($(n).children("Name").text() == e._layerName) {
                var r = $(n).children("Operations");
                return r.length == 0 ? !1 : (r.children().each(function () {
                    e._operations[this.tagName.toLowerCase()] = {};
                }), !1)
            }
            return !0
        });
    }

    function initFeatureType$1(e) {
        e.featureColumnNames = null;
        var t = e.cleanUrl(e._url).replace("{s}", e.sTag(e._layerName.length, e._layerName.length, e._level));
        t += queryStringExist$1(t),
            t += "SERVICE=WFS&VERSION=1.0.0&REQUEST=DescribeFeatureType&typeName=" + e._layerName;
        //var n = TerraExplorer.internal.Settings.connectionUrl,
        var r = Cesium.TrustedServers.contains(ReplaceTagWithOriginalDomain$1(e._url, e._subdomains));
        $.ajax({
            dataType: "xml",
            xhrFields: {
                withCredentials: r
            },
            url: encodeURI(t),
            success: function (t) {
                parseDescribeFeatureResponse$1(e, t);
            }
        });
    }

    function getWfsNamespace$1(xmlText, testElementName) {
        let eval2 = eval;
        if (xmlText == null) return null;
        try {
            var match = (new XMLSerializer).serializeToString(xmlText).match(eval2("/[<]([a-z]+):" + testElementName + "[>]/i"));
            return match != null ? match[1] : null
        } catch (ex) {
            return !1
        }
    }

    function isElementNameExists$1(xmlText, testElementName) {
        if (xmlText == null) return !1;
        try {
            let eval2 = eval;
            var match = (new XMLSerializer).serializeToString(xmlText.context != null ? xmlText.context : xmlText).match(eval2("/[<](([a-z]+):)?" + testElementName + "[^>]*[>]/i"));
            return match != null
        } catch (ex) {
            return !1
        }
    }

    function parseDescribeFeatureResponse$1(e, t) {
        var n = $(t).find("[type^='gml:']");
        e._geometryFieldName = $(n).attr("name"),
            e.geometryResponseData = t,
            e.wfsNamespace = getWfsNamespace$1(e.geometryResponseData, "sequence"),
            e.wfsNamespace == null && (e.wfsNamespace = "xsd"),
            e.sgSchemaExists = $(e.geometryResponseData).find(e.wfsNamespace + "\\:schema").attr("xmlns:sfs"),
            e.sgSchemaExists || (e.sgSchemaExists = $(e.geometryResponseData).find("schema").attr("xmlns:sfs"));
        var r = $(e.geometryResponseData).find(e.wfsNamespace + "\\:sequence " + e.wfsNamespace + "\\:element");
        r.length == 0 && (r = $(e.geometryResponseData).find("sequence").find("element")),
            e.geomFields = [],
            r.each(function () {
                var t = $(this),
                    n = t.attr("name"),
                    r = t.attr("type");
                if (r == null) r = "string";
                else {
                    var i = r.match(/.*[:](\w+)/);
                    i && (r = i[1]);
                }
                e.geomFields.push({
                    name: n,
                    type: r
                });
            });
    }

    function sqlParserToWfs$1(e, t) {
        if (e.operator) {
            var n = "";
            switch (e.operator.toLowerCase()) {
                case "=":
                    n = "PropertyIsEqualTo";
                    break;
                case "<>":
                    n = "PropertyIsNotEqualTo";
                    break;
                case ">":
                    n = "PropertyIsGreaterThan";
                    break;
                case ">=":
                    n = "PropertyIsGreaterThanOrEqualTo";
                    break;
                case "<":
                    n = "PropertyIsLessThan";
                    break;
                case "<=":
                    n = "PropertyIsLessThanOrEqualTo";
                    break;
                case "like":
                    n = "PropertyIsLike";
            }
            var r = t.indexOf(e.right) != -1 ? e.right : e.left,
                i = "<ogc:" + n + (e.operator.toLowerCase() == "like" ? ' wildCard="*" singleChar="*" escape="*"' : "") + ">";
            i += "<ogc:PropertyName>" + r + "</ogc:PropertyName>";
            var s = t.indexOf(e.right) != -1 ? e.left : e.right;
            s = s.replace(/^'|'$$/g, "");
            var o = s.match(/^[%]|[%]$$/) == null;
            return e.operator.toLowerCase() == "like" && o && (s = "%" + s + "%"),
                i += "<ogc:Literal>" + s + "</ogc:Literal>",
                i += "</ogc:" + n + ">",
                i
        }
        var u = e.logic.toLowerCase() == "and" ? "And" : "Or",
            i = "<ogc:" + u + ">";
        return e.terms.length == 2 ? i += sqlParserToWfs$1(e.terms[0], t) : i += sqlParserToWfs$1({
            logic: u,
            terms: e.terms.slice(0, e.terms.length - 1)
        }, t),
            i += sqlParserToWfs$1(e.terms[e.terms.length - 1], t),
            i += "</ogc:" + u + ">",
            i
    }

    function parseFeaturesResult$1(e) {
        var t = [],
            n = $(e).find("gml\\:featureMember");
        return n.length == 0 && (n = $(e).find("featureMember")),
            n.each(function () {
                var e = {},
                    n = $(this).children().first();
                e.layerId = n[0].nodeName,
                    e.originFid = n.attr("fid"),
                    e.fid = n.attr("fid"),
                    e.fid == null && (e.fid = -1);
                var r = e.fid.match(/[.]?(\d+)$$/);
                r && (e.fid = r[1]),
                    e.node = n[0],
                    n.children().each(function () {
                        e[this.nodeName] = this.innerHTML,
                            e[this.nodeName] == null && (e[this.nodeName] = $(this).text());
                    }),
                    t.push(e);
            }),
            t
    }

    function internalBlockRequestPrimitiveFromPrimitive$1(e) {
        return e == undefined ? undefined : e.parentLayer ? e : e._parentCollection ? e._parentCollection : e.primitive && e.primitive._parentCollection ? e.primitive._parentCollection : undefined
    }

    Object.defineProperties(WfsLayer$1.prototype, {
        LayerDisplayName: {
            get: function () {
                return this._layerDisplayName
            }
        },
        displayName: {
            get: function () {
                return this.LayerDisplayName
            }
        },
        guid: {
            get: function () {
                return this._guid
            }
        },
        Style: {
            get: function () {
                return this._entityCreator.style
            }
        },
        show: {
            get: function () {
                return this._visible
            },
            set: function (e) {
                this.setVisibility(e);
            }
        },
        BoundingBox: {
            get: function () {
                return this._boundingBox
            }
        },
        Statistics: {
            get: function () {
                return this._statistics
            }
        }
    });
    var DEGREES_PER_RADIAN$1 = 180 / Math.PI,
        REQUEST_MAX_FEATURES$1 = 1e3;
    WfsLayer$1.prototype.getRequestMaxFeatures = function () {
        return REQUEST_MAX_FEATURES$1
    };
    WfsLayer$1.prototype.isAttributeField = function (e, t) {
        return !t || !e || e.toLowerCase() == "" || e.toLowerCase() == "fid" ? !1 : t.toLowerCase() == "string" || t.toLowerCase() == "integer" || t.toLowerCase() == "double" ? !0 : !1
    };
    WfsLayer$1.prototype.updateFeatures = function (e, t) {
        if (e.length <= 0) {
            t();
            return
        }
        var n = this,
            r = [];
        $(this.geomFields).each(function () {
            n.isAttributeField(this.name, this.type) && r.push(this.name);
        });
        var i = "<wfs:Transaction version='1.0.0' service='WFS' username='' password='' xmlns:sfs='http://www.skylineglobe.com/sfs-schema' xmlns:ogc='http://www.opengis.net/ogc' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:wfs='http://www.opengis.net/wfs' xmlns:gml='http://www.opengis.net/gml'> {wfs_updates}</wfs:Transaction>",
            s = "";
        $(e).each(function () {
            var e = this,
                t = '<wfs:Update typeName="{lyaer_id}">'.replace("{lyaer_id}", this.layerId);
            $(r).each(function () {
                t += "<wfs:Property><wfs:Name>" + this + "</wfs:Name><wfs:Value>" + e[this] + "</wfs:Value></wfs:Property>";
            }),
                t += '<ogc:Filter><ogc:FeatureId fid="' + e.originFid + '"/></ogc:Filter>',
                t += "</wfs:Update>",
                s += t;
        }),
            i = i.replace("{wfs_updates}", s);
        var o = "Failed to save changes to server",
            u = ReplaceTagWithOriginalDomain$1(this.cleanUrl(this._url), this._subdomains),
            a = Cesium.TrustedServers.contains(u);
        $.ajax({
            dataType: "xml",
            type: "POST",
            data: i,
            xhrFields: {
                withCredentials: a
            },
            url: encodeURI(u),
            success: function (e) {
                var n = (new XMLSerializer).serializeToString(e.documentElement).toLowerCase();
                if (n.match(/success\s*\//) == null) {
                    t(o);
                    return
                }
                t();
            },
            error: function (e, n, r) {
                t(o);
            },
            timeout: 1e4
        });
    };
    WfsLayer$1.prototype.getFeatures = function (e, t, n) {
        var r = this,
            i = [];
        $(this.geomFields).each(function () {
            r.isAttributeField(this.name, this.type) && i.push(this.name);
        });
        var s = "<wfs:GetFeature version='1.0.0' service='WFS' username='' password='' maxFeatures='{REQUEST_MAX_FEATURES}'  xmlns:sfs='http://www.skylineglobe.com/sfs-schema' xmlns:ogc='http://www.opengis.net/ogc' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:wfs='http://www.opengis.net/wfs' xmlns:gml='http://www.opengis.net/gml'> <wfs:Query typeName='{layer_name}'> {wfs_filter}</wfs:Query> </wfs:GetFeature>";
        s = s.replace("{layer_name}", this._layerName),
            s = s.replace("{REQUEST_MAX_FEATURES}", REQUEST_MAX_FEATURES$1);
        var o = "";
        if (e.replace(/[ ]/g, "") != "") {
            o = "<ogc:Filter  xmlns:sfs='http://www.skylineglobe.com/sfs-schema' xmlns:ogc='http://www.opengis.net/ogc' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:wfs='http://www.opengis.net/wfs' xmlns:gml='http://www.opengis.net/gml'>";
            var u = r.simpleSqlParser.sql2ast("SELECT * FROM x WHERE " + e);
            o += sqlParserToWfs$1(u.WHERE, i),
                o += "</ogc:Filter>";
        }
        s = s.replace("{wfs_filter}", o);
        var a = ReplaceTagWithOriginalDomain$1(this.cleanUrl(this._url), this._subdomains),
            f = Cesium.TrustedServers.contains(a);
        t.xhr = $.ajax({
            url: encodeURI(a),
            type: "POST",
            data: s,
            dataType: "xml",
            xhrFields: {
                withCredentials: f
            },
            success: function (e) {
                var t = isElementNameExists$1($(e), "FeatureCollection");
                if (!t) {
                    n(null, TELang.i18n("layer_error_reading_features"));
                    return
                }
                var r = parseFeaturesResult$1(e);
                n(r);
            },
            error: function (e, t, r) {
                n(null, e.statusText);
            },
            timeout: 1e4
        });
    };
    WfsLayer$1.prototype.getFeatureColumnNames = function () {
        if (this.featureColumnNames) return this.featureColumnNames;
        var e = $(this.geometryResponseData).find(this.wfsNamespace + "\\:sequence " + this.wfsNamespace + "\\:element");
        e.length == 0 && (e = $(this.geometryResponseData).find("sequence").find("element"));
        var t = [];
        return e.each(function () {
            var e = $(this);
            e.attr("name").toLowerCase() != "geom" && t.push(e.attr("name").toLowerCase());
        }),
            this.featureColumnNames = t,
            this.featureColumnNames
    };
    WfsLayer$1.prototype.refresh = function (e) {
        var t = this._tileManager.getAllTiles(),
            n = t.length;
        for (var r = 0; r < n; r++) t[r].data.wfsLayerData[this._guid] && t[r].data.wfsLayerData[this._guid].freeResources(),
            this.loadTile(t[r]);
        e && initFeatureType$1(this);
    };
    WfsLayer$1.prototype.setVisibility = function (e) {
        if (this._visible != e) {
            this._visible = e;
            if (e == 0) {
                var t = this._tileManager.getAllTiles(),
                    n = t.length;
                for (var r = 0; r < n; r++) t[r].data.wfsLayerData[this._guid] && t[r].data.wfsLayerData[this._guid].primitive && (t[r].data.wfsLayerData[this._guid].primitive.show = !1);
            } else {
                var t = this._tileManager.getAllTiles(),
                    n = t.length;
                for (var r = 0; r < n; r++) t[r].data.wfsLayerData[this._guid] && (t[r].data.wfsLayerData[this._guid].primitive ? t[r].data.wfsLayerData[this._guid].primitive.show = !0 : this.loadTile(t[r]));
            }
        }
    };
    WfsLayer$1.prototype.loadTile = function (e) {
        var t = this;
        e.data.wfsLayerData[this._guid] = {
            id: e.data.id,
            primitive: undefined,
            freeResources: function () {
                Cesium.defined(this.xhr) && (this.xhr.abort(), this.xhr = undefined),
                    Cesium.defined(this.features) && (t.removeFeaturesFromLayer(this.features), this.features = undefined),
                    Cesium.defined(this.primitive) && (t._tileManager.removeFromScene(this.primitive), this.primitive = undefined);
            }
        };
        //this.beginLoadWFSData(e);
        if (this.show && e.level >= this._level.min && e.level <= this._level.max) {
            this.statc = 0;
            this._guide = this._guid;
            this.beginLoadWFSData(e);
            // } else if (e.level > this._level.max + 1) {
            //     this.statc = 1;
            //     var t = this._tileManager.getAllTiles(),
            //         n = t.length;
            //     if (n > 0) {
            //         for (var r = 0; r < n; r++) t[r].data.wfsLayerData[this._guid] && t[r].data.wfsLayerData[this._guid].freeResources();
            //     }
        }


        //e.level === this._level && this.show && this.beginLoadWFSData(e);
    };
    WfsLayer$1.prototype.isDestroyed = function () {
        return !1
    };
    WfsLayer$1.prototype.destroy = function () {
        var t = this._tileManager.getAllTiles(),
            n = t.length;
        if (n > 0) {
            for (var r = 0; r < n; r++) t[r].data.wfsLayerData[this._guid] && t[r].data.wfsLayerData[this._guid].freeResources();
        }
        return this._tileManager._loadTileEvent.removeEventListener(WfsLayer$1.prototype.loadTile, this),
            Cesium.destroyObject(this)
    };
    WfsLayer$1.prototype.sTag = function (e, t, n) {
        if (this._subdomains == undefined) return "";
        var r = (e + t + n) % this._subdomains.length;
        return this._subdomains[r]
    };
    WfsLayer$1.prototype.cleanUrl = function (e) {
        return e.indexOf("?") != -1 ? e.split("?")[0] : e
    };
    //WfsLayer.prototype.lj = function () {
    //    var scriptObjs = document.scripts;
    //    var url = "./wfs/featurefetcherworker.js";
    //    for (var i = 0; i < scriptObjs.length; i++) {
    //        var jssz = scriptObjs[i].src.split("/");
    //        var dx = jssz[jssz.length - 1];
    //        if (dx == "SmartEarth.js") {
    //            url = scriptObjs[i].outerHTML.split("\"")[1].replace("SmartEarth.js", 'Workers/featurefetcherworker.js');
    //        }
    //    }
    //    return url;
    //}
    function lj$3() {
        var scriptObjs = document.scripts;
        var url = "./wfs/featurefetcherworker.js";
        for (var i = 0; i < scriptObjs.length; i++) {
            var jssz = scriptObjs[i].src.split("/");
            var dx = jssz[jssz.length - 1];
            if (dx == "SmartEarth.js") {
                url = scriptObjs[i].outerHTML.split("\"")[1].replace("SmartEarth.js", 'Workers/featurefetcherworker.js');
            } else if (dx == "SmartEarth.min.js") {
                url = scriptObjs[i].outerHTML.split("\"")[1].replace("SmartEarth.min.js", 'Workers/featurefetcherworker.js');
            }
        }
        return url;
    }

    WfsLayer$1.prototype.beginLoadWFSData = function (e) {
        if (this.latLon != undefined && !this.latLon) return;
        this.BoundingBox != undefined && (this.BoundingBox.width == 0 || this.BoundingBox.height == 0) && (this.BoundingBox.east += 1, this.BoundingBox.north += 1, this.BoundingBox.beenModified = !0);
        if (this.BoundingBox !== undefined && Cesium.Rectangle.intersection(this.BoundingBox, e.rectangle) === undefined) return;
        var t = [DEGREES_PER_RADIAN$1 * e.rectangle.west, DEGREES_PER_RADIAN$1 * e.rectangle.south, DEGREES_PER_RADIAN$1 * e.rectangle.east, DEGREES_PER_RADIAN$1 * e.rectangle.north];
        var n = this;
        var r = this.cleanUrl(this._url).replace("{s}", this.sTag(e.x, e.y, e.level));
        r += queryStringExist$1(r);
        r += "SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&outputFormat=GML2&typeName=" + this._layerName + "&srsName=EPSG:4326" + "&BBOX=" + t.join(",");
        //r += "SERVICE=WFS&VERSION=1.1.0&REQUEST=GetFeature&outputFormat=GML3&typeName=" + this._layerName + "&srsName=EPSG:4326" + "&BBOX=" + t.join(",");
        //r += "SERVICE=WFS&VERSION=2.0.0&REQUEST=getFeature&typeName=" + this._layerName;
        //var i = TerraExplorer.internal.Settings.connectionUrl,
        var s = Cesium.TrustedServers.contains(ReplaceTagWithOriginalDomain$1(this._url, this._subdomains));
        e.data.wfsLayerData[this._guid].xhr = $.ajax({
            dataType: this._useWorkers ? "text" : "xml",
            url: encodeURI(r),
            cache: !0,
            xhrFields: {
                withCredentials: s
            },
            success: function (t) {
                n.processWFSData(e, t);
            },
            error: function (e, t, n) {
                n !== "abort" && console.log("Failed to retrieve data from " + r + " :" + n);
            },
            complete: function () {
                e.data.wfsLayerData[n._guid].xhr = undefined;
            }
        });
    };
    var workerPool$1;
    WfsLayer$1.prototype.processWFSData = function (e, t) {
        e.data.wfsLayerData[this._guid].xhr = undefined;
        if (this._useWorkers) {
            var n = this;
            workerPool$1.queueWorkItem({
                id: e.data.id,
                text: t,
                geometryFieldName: this._geometryFieldName
            }).then(function (e) {
                n.addFeaturesToTile(e);
            });
        } else {
            var r = this._gmlParser.read(t);
            this.addFeaturesToTile({
                id: e.data.id,
                features: r
            });
        }

    };
    WfsLayer$1.prototype.boundingSphereFromGML = function (e, t) {
        var n = viewer.scene.globe._surface.getRenderedBestLevelInfo().bestLevel,
            r = this;
        workerPool$1.queueWorkItem({
            id: "0",
            text: e,
            geometryFieldName: this._geometryFieldName
        }).then(function (e) {
            var i = {
                parentLayer: r,
                features: e.features,
                sampleTerrainLevel: n + 1,
                isQuery: !0,
                onFinishedQuery: function (e) {
                    var n;
                    e.length > 0 && (n = Cesium.BoundingSphere.fromBoundingSpheres(e)),
                        t(n);
                }
            };
            r._entityCreator.createPrimitiveFromWFSFeatures(i);
        });
    };
    WfsLayer$1.prototype.boundingSphereFromFeature = function (e) {
        var t, n = viewer.scene.globe._surface.getRenderedBestLevelInfo().bestLevel,
            r = {
                parentLayer: this,
                features: [e],
                sampleTerrainLevel: n + 1,
                isQuery: !0,
                onFinishedQuery: function (e) {
                    e.length > 0 && (t = Cesium.BoundingSphere.fromBoundingSpheres(e));
                }
            };
        return this._entityCreator.createPrimitiveFromWFSFeatures(r),
            t
    };
    WfsLayer$1.prototype.addRenderedFeatureId = function (e) {
        this._addedFeatures[e] == undefined && (this._addedFeatures[e] = 0),
            this._addedFeatures[e]++;
    };
    WfsLayer$1.prototype.removeRenderedFeatureId = function (e) {
        this._addedFeatures[e] != undefined && this._addedFeatures[e]--,
            this._addedFeatures[e] == 0 && (this._addedFeatures[e] = undefined);
    };
    WfsLayer$1.prototype.isExistRenderedFeatureId = function (e) {
        return this._addedFeatures[e] != undefined
    };
    WfsLayer$1.prototype.addFeaturesToTile = function (e, t) {
        var n = this._tileManager.getTile(e.id);
        if (n === undefined) return;
        // var r = this._viewer.scene.globe._surface.getRenderedBestLevelInfo().bestLevel;
        var i = t ? n.data.wfsLayerData[this._guid].primitive._instanceIds : undefined;
        var s = this;
        var o = {
            parentLayer: this,
            originalInstanceIds: i,
            features: e.features,
            // sampleTerrainLevel: r + 1,
            onFinishedCreatePrimitive: function (r) {
                if (e.features == undefined || n.data.wfsLayerData == undefined) return;
                n.data.wfsLayerData[s._guid].features = e.features,
                    t || s.addFeaturesToLayer(n.data.wfsLayerData[s._guid].features);
                if (r.length === undefined || r.length > 0) {
                    var i = n.data.wfsLayerData[s._guid].primitive;
                    r.show = s.show;
                    n.data.wfsLayerData[s._guid].primitive = r;
                    r.parentLayer = s;
                    r.parentTileId = e.id;
                    r._guid = Cesium.createGuid();
                    if (t) {
                        s._tileManager.replaceInScene(i, r);
                    } else {
                        s._tileManager.addToScene(r);
                    }
                }
            }
        };
        this._entityCreator.createPrimitiveFromWFSFeatures(o);
    };
    WfsLayer$1.prototype.addFeaturesToLayer = function (e) {
        this._statistics.numberOfAddedFeatures += e.length,
            this._statistics.numberOfAddePositions += Cesium.defaultValue(e.numPositions, 0);
        var t = e.length;
        for (var n = 0; n < t; n++) Object.prototype.hasOwnProperty.call(this._featuresMap, e[n].fid) === !1 ? this._featuresMap[e[n].fid] = {
            refCount: 1,
            feature: e[n]
        } : this._featuresMap[e[n].fid].refCount++;
    };
    WfsLayer$1.prototype.removeFeaturesFromLayer = function (e) {
        this._statistics.numberOfDeletedFeatures += e.length,
            this._statistics.numberOfDeletedPositions += Cesium.defaultValue(e.numPositions, 0);
        var t = e.length;
        for (var n = 0; n < t; n++) {
            if (Object.prototype.hasOwnProperty.call(this._featuresMap, e[n].fid) === !1) continue;
            this._featuresMap[e[n].fid].refCount--,
                this._featuresMap[e[n].fid].refCount === 0 && delete this._featuresMap[e[n].fid],
                this.removeRenderedFeatureId(e[n].fid);
        }
    };
    WfsLayer$1.prototype.getFeature = function (e) {
        return Object.prototype.hasOwnProperty.call(this._featuresMap, e) === !1 ? null : this._featuresMap[e]
    };
    WfsLayer$1.prototype.updateTile = function (e) {
        var t = this._tileManager.getTile(e);
        if (t === undefined) return;
        t.data.wfsLayerData[this._guid].features == undefined ? this.loadTile(t) : this.addFeaturesToTile(t.data.wfsLayerData[this._guid], !0);
    };
    WfsLayer$1.blockRequestPrimitiveFromPrimitive = function (e) {
        if (e == undefined) return undefined;
        var t = internalBlockRequestPrimitiveFromPrimitive$1(e);
        return t != undefined ? t : (e._labelCollection && e._labelCollection._billboardCollection ? t = internalBlockRequestPrimitiveFromPrimitive$1(e._labelCollection._billboardCollection) : e._billboardCollection && (t = internalBlockRequestPrimitiveFromPrimitive$1(e._billboardCollection)), t)
    };
    WfsLayer$1.prototype.resetAttributesTable = function () {
        this.lastEditedCell = null,
            this.attrTblDialogMemo = null;
    };

    /**
     *
     * WFS工具
     *
     * @alias WFSTool
     * @constructor
     *
     * @param {Viewer} Viewer 地图视图
     * 
     * @example
     * var sgwfs = new SmartEarth.WFSTool(Viewer);
     * sgwfs.CreateWfs('point',{
     *      urls:'http://183.162.245.49:82/SG/Streamer.ashx',
     *      layer:'shenghuiming.399152',
     *      text: '[name]',
     *      color: '#de3',
     *      disableDepthTestDistance:Infinity
     *  })
     */
    function WFSTool(Viewer) {
        this.Viewer = Viewer;
        this._core = new Core();
        this.colorTool = this._core.gradientColor();
    }

    /**
     * 
     * @param {String} type 类型【point|polyline|polygon】
     * @param {Object} [option] 参数
     * @param {String} [option.name] 名称
     * @param {String} [option.urls] wfs服务地址
     * @param {String} [option.layer] 图层名
     * @param {String} [option.sgStyleJSON] TE导出的样式文件，可选
     * @param {String} [option.color] 点线面填充颜色
     * @param {String} [option.outlineColor=#ffffff] 点和面边框颜色
     * @param {Number} [option.alpha=1] 点线面透明度
     * @param {Boolean} [option.clampToGround] 点线面是否贴地
     * @param {String} [option.text] 点参数，文本内容，未设置则不显示文本
     * @param {String} [option.font="Arial"] 点参数，字体
     * @param {Number} [option.scale=2] 点参数，文本比例大小
     * @param {String} [option.bgColor] 点参数，文本背景颜色
     * @param {Number} [option.outlineWidth=2] 点参数，文本边框宽度
     * @param {Boolean} [option.italic=false] 点参数，文本是否斜体
     * @param {Boolean} [option.bold=false] 点参数，文本是否加粗
     * @param {Number} [option.offsetX=0] 点参数，文本水平偏移量，常用于文本和图标同时显示
     * @param {Number} [option.offsetY=0] 点参数，文本垂直偏移量，常用于文本和图标同时显示
     * @param {Number} [option.disableDepthTestDistance=0] 点参数，禁用深度检测距离，设为Infinity则忽略遮挡
     * @param {String} [option.image] 点参数，图片路径，未设置则不显示图标
     * @param {Number} [option.imageScale=1] 点参数，图标比例大小
     * @param {String} [option.link] 点参数，图标链接地址
     * @param {Number} [option.width=4] 线参数，线宽
     * @param {Number} [option.extrudedHeight] 面参数，拉伸高度
     * @param {Boolean} [option.outline] 面参数，是否显示边框
     * @param {Boolean} [option.water=false] 面参数，是否显示为水面
     * @param {Boolean} [option.checked=true] 是否显示
     * @param {Number} [option.minimumLevel=0] 最小可视层级
     * @param {Number} [option.maximumLevel=22] 最大可视层级
     * @returns {WfsLayer} WfsLayer
     */
    WFSTool.prototype.CreateWfs = function (type, option) {
        let de = {};
        let color, outlineColor;
        if (type === "point") {
            if (!option.sgStyleJSON) {
                color = this.colorTool.colorRgb(
                    this._core.defaultValue(option.color, "#ffffff")
                );
                var bgColor = this.colorTool.colorRgb(
                    this._core.defaultValue(option.bgColor, "#010101")
                );
                de = {
                    lineToGround: {
                        defaultValue: "0",
                    },
                    lineToGroundLength: {
                        defaultValue: "0",
                    },
                    lineToGroundColor: {
                        defaultValue: {
                            red: 1,
                            green: 1,
                            blue: 1,
                            alpha: 1,
                        },
                    },
                    altitudeMethod: 0,
                    altitudeOffset: {
                        defaultValue: "0",
                    },
                    clampToGround: this._core.defaultValue(option.clampToGround, false),
                    //"pointHeight": 100
                };
                if (option.text) {
                    option.offsetX && (option.offsetX = parseInt(option.offsetX));
                    option.offsetY && (option.offsetY = parseInt(option.offsetY));
                    de.label = {
                        text: {
                            defaultValue: option.text,
                        },
                        scaleMPP: {
                            defaultValue: "15000",
                        },
                        fillColor: {
                            defaultValue: {
                                red: color[0] / 255,
                                green: color[1] / 255,
                                blue: color[2] / 255,
                                alpha: this._core.defaultValue(option.alpha, 1),
                            },
                        },
                        scaleByDistance: {
                            near: 150,
                            nearValue: 1,
                            far: 800000,
                            farValue: 0.5,
                        },
                        minViewingHeight: {
                            defaultValue: "0",
                        },
                        font: {
                            defaultValue: "12",
                        },
                        family: {
                            defaultValue: this._core.defaultValue(option.font, "Arial"),
                        },
                        backgroundColor: {
                            defaultValue: {
                                red: bgColor[0] / 255,
                                green: bgColor[1] / 255,
                                blue: bgColor[2] / 255,
                                alpha: this._core.defaultValue(option.alpha, 1),
                            },
                        },
                        scale: this._core.defaultValue(option.scale, 2),
                        backgroundOpacity: {
                            defaultValue: option.bgColor ? "0.5" : "0",
                        },
                        italic: {
                            defaultValue: option.italic ? "1" : "0",
                        },
                        bold: {
                            defaultValue: option.bold ? "1" : "0",
                        },
                        limitGrowth: {
                            defaultValue: "1",
                        },
                        textRelativeToImage: {
                            defaultValue: "0",
                        },
                        showText: {
                            defaultValue: "0",
                        },
                        textAlignment: {
                            defaultValue: "17",
                        },
                        pixelOffset: new Cesium.Cartesian2(
                            this._core.defaultValue(option.offsetX, 0),
                            this._core.defaultValue(option.offsetY, option.image ? -10 : 0)
                        ),
                        outlineColor: Cesium.Color.fromCssColorString(
                            this._core.defaultValue(option.outlineColor, "#ffffff")
                        ),
                        outlineWidth: this._core.defaultValue(option.outlineWidth, 2),
                        horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        disableDepthTestDistance: option.disableDepthTestDistance === "Infinity" ? Number.POSITIVE_INFINITY : option.disableDepthTestDistance
                    };
                }

                if (option.outlineColor) {
                    de.label &&
                        (de.label.style = Cesium.LabelStyle.FILL_AND_OUTLINE);
                }
                if (option.image) {
                    de.billboard = {
                        image: option.image,
                        scale: this._core.defaultValue(option.imageScale, 1),
                        disableDepthTestDistance: option.disableDepthTestDistance,
                        horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        link: option.link,
                    };
                }
            } else {
                de = this.getSGStyle(
                    "point",
                    option.sgStyleJSON,
                    option.name
                );
            }
        } else if (type === "polyline") {
            if (!option.sgStyleJSON) {
                color = this.colorTool.colorRgb(
                    this._core.defaultValue(option.color, "#ffff00")
                );
                de = {
                    polyline: {
                        material: {
                            red: color[0] / 255,
                            green: color[1] / 255,
                            blue: color[2] / 255,
                            alpha: this._core.defaultValue(option.alpha, 1),
                        },
                        lineOpacity: this._core.defaultValue(option.alpha, 1),
                        width: this._core.defaultValue(option.width, 4),
                        clampToGround: this._core.defaultValue(option.clampToGround, true),
                    },
                };
            } else {
                de = this.getSGStyle(
                    "polyline",
                    option.sgStyleJSON,
                    option.name
                );
            }
        } else if (type === "polygon") {
            if (!option.sgStyleJSON) {
                color = this.colorTool.colorRgb(
                    this._core.defaultValue(option.color, "#6bbeef")
                );
                outlineColor = this.colorTool.colorRgb(
                    this._core.defaultValue(option.outlineColor, "#ffffff")
                );
                de = {
                    polygon: {
                        outlineColor: {
                            defaultValue: {
                                red: outlineColor[0] / 255,
                                green: outlineColor[1] / 255,
                                blue: outlineColor[2] / 255,
                                alpha: this._core.defaultValue(option.alpha, 1),
                            },
                        },
                        outlineWidth: 1,
                        fill: {
                            defaultValue: this._core.defaultValue(option.alpha, 1),
                        },
                        extrudedHeight: option.extrudedHeight,
                        clampToGround: option.clampToGround,
                        water: option.water,
                        outline: this._core.defaultValue(option.outline, true),
                        material: {
                            defaultValue: {
                                red: color[0] / 255,
                                green: color[1] / 255,
                                blue: color[2] / 255,
                                alpha: this._core.defaultValue(option.alpha, 1),
                            },
                        },
                        fromKml: true,
                    },
                    altitudeMethod: 2,
                    altitudeOffset: {
                        defaultValue: "0",
                    },
                };
            } else {
                de = this.getSGStyle(
                    "polygon",
                    option.sgStyleJSON,
                    option.name
                );
            }
        }
        if (!de && option.sgStyleJSON) {
            console.log(option.name + "获取样式失败！");
            return;
        }
        if (de.position_x) {
            option.lon = de.position_x;
            option.lat = de.position_y;
            option.height = de.position_z;
        }
        return new WfsLayer$1(
            this.Viewer,
            this._core.defaultValue(option.urls, de.urls),
            this._core.defaultValue(option.layer, de.layer),
            {
                min: this._core.defaultValue(option.minimumLevel, de.minimumLevel || 0),
                max: this._core.defaultValue(option.maximumLevel, de.maximumLevel || 22),
            },
            de,
            this._core.defaultValue(option.layer, de.layer),
            option.pID || '0',
            option.checked,
            undefined
        );
    };

    //转换sg颜色
    WFSTool.prototype.getSGColor = function (color) {
        let _color = parseInt(color).toString(16);
        if (_color.length === 2) {
            _color = "0000" + _color;
        } else if (_color.length === 4) {
            _color = "00" + _color;
        }
        _color = "#" + _color.slice(4) + _color.slice(2, 4) + _color.slice(0, 2);
        return _color;
    };

    //获取sg样式配置
    WFSTool.prototype.getSGStyle = function (type, json, name) {
        let de;

        //获取数据
        $.ajax({
            url: json,
            async: false,
            contentType: 'application/json',
            success: _data => {
                if (_data && typeof _data === "string") {
                    _data = JSON.parse(_data);
                }
                let style = _data.filter((item) => {
                    return item.LayerName === name;
                });
                if (type === "point") {
                    let data = style[0];
                    style = data.Point;
                    style.Line_Color = this.getSGColor(style.Line_Color);
                    style.Image_Color = this.getSGColor(style.Image_Color);
                    style.Text_Color = this.getSGColor(style.Text_Color);
                    style.Background_Color = this.getSGColor(style.Background_Color);

                    let color = this.colorTool.colorRgb(
                        this._core.defaultValue(style.Text_Color, "#ffffff")
                    );
                    let bgColor = this.colorTool.colorRgb(
                        this._core.defaultValue(style.Background_Color, "#010101")
                    );
                    de = {
                        label: {
                            text: {
                                defaultValue: this._core.defaultValue(
                                    style.Text.match(/<Value>(\S*)<\/Value>/)[1],
                                    style.Text.match(/<DefaultValue>(\S*)<\/DefaultValue>/)[1]
                                ),
                            },
                            scaleMPP: { defaultValue: style.Scale },
                            fillColor: {
                                defaultValue: {
                                    red: color[0] / 255,
                                    green: color[1] / 255,
                                    blue: color[2] / 255,
                                    alpha: 1,
                                },
                            },
                            scaleByDistance: {
                                near: 0,
                                nearValue: 1,
                                far: 800000000,
                                farValue: 1,
                            },
                            minViewingHeight: { defaultValue: "0" },
                            font: { defaultValue: style.Text_Size },
                            family: { defaultValue: this._core.defaultValue(style.Font, "Arial") },
                            backgroundColor: {
                                defaultValue: {
                                    red: bgColor[0] / 255,
                                    green: bgColor[1] / 255,
                                    blue: bgColor[2] / 255,
                                    alpha: 1,
                                },
                            },
                            scale: this._core.defaultValue(style.TextScale, 1.5),
                            backgroundOpacity: { defaultValue: style.Background_Opacity },
                            italic: { defaultValue: style.Italic },
                            bold: { defaultValue: style.Bold },
                            limitGrowth: { defaultValue: "1" },
                            textRelativeToImage: { defaultValue: "0" },
                            showText: { defaultValue: "0" },
                            textAlignment: { defaultValue: "17" },
                            pixelOffset: new Cesium.Cartesian2(
                                this._core.defaultValue(style.offsetX, 0),
                                this._core.defaultValue(style.offsetY, style.Image_file ? -10 : 0)
                            ),
                            outlineColor: Cesium.Color.fromCssColorString(
                                this._core.defaultValue(style.Line_Color, "#ffffff")
                            ),
                            outlineWidth: this._core.defaultValue(style.outlineWidth, 2),
                            horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
                            verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        },
                        lineToGround: { defaultValue: style.Line_to_Ground },
                        lineToGroundLength: { defaultValue: style.Line_Length },
                        lineToGroundColor: {
                            defaultValue: { red: 1, green: 1, blue: 1, alpha: 1 },
                        },
                        altitudeMethod: 0,
                        altitudeOffset: { defaultValue: "0" },
                        clampToGround: this._core.defaultValue(style.clampToGround, true),
                        pointHeight: this._core.defaultValue(style.pointHeight, undefined),
                        minimumLevel: this._core.defaultValue(style.level_min, 0),
                        maximumLevel: this._core.defaultValue(style.level_max, 22),
                        position_x: data.position_x,
                        position_y: data.position_y,
                        position_z: data.position_z == 0 ? 10000 : data.position_z,
                        urls: data.Server,
                        layer: data.ServerName,
                    };
                    if (style.Line_Color) {
                        de.label && (de.label.style = Cesium.LabelStyle.FILL_AND_OUTLINE);
                    }
                    if (style.Image_file) {
                        de.billboard = {
                            image: style.Image_file,
                            scale: this._core.defaultValue(style.ImageScale, 1),
                            scaleMPP: { defaultValue: style.Scale },
                            scaleByDistance: {
                                near: 0,
                                nearValue: 1,
                                far: 800000000,
                                farValue: 1,
                            },
                            minViewingHeight: { defaultValue: "0" },
                            verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        };
                    }
                } else if (type === "polyline") {
                    let data = style[0];
                    style = data.Line;
                    style.Line_Color = this.getSGColor(style.Line_Color);
                    if (style.Line_Width) {
                        if (style.Line_Width.length === 2) {
                            style.Line_Width /= 10;
                        } else if (style.Line_Width.length === 3) {
                            style.Line_Width /= 100;
                        }
                    }
                    let color = this.colorTool.colorRgb(
                        this._core.defaultValue(style.Line_Color, "#ff0000")
                    );
                    de = {
                        polyline: {
                            material: {
                                red: color[0] / 255,
                                green: color[1] / 255,
                                blue: color[2] / 255,
                                alpha: 1,
                            },
                            lineOpacity: parseInt(this._core.defaultValue(style.Line_Opacity, 1)),
                            width: parseInt(this._core.defaultValue(style.Line_Width, 4)),
                            near: style.Near,
                            far: style.Far,
                            clampToGround: this._core.defaultValue(style.clampToGround, true),
                        },
                        minimumLevel: this._core.defaultValue(style.level_min, 0),
                        maximumLevel: this._core.defaultValue(style.level_max, 22),
                        position_x: data.position_x,
                        position_y: data.position_y,
                        position_z: data.position_z == 0 ? 10000 : data.position_z,
                        urls: data.Server,
                        layer: data.ServerName,
                    };
                } else if (type === "polygon") {
                    let data = style[0];
                    style = data.data;

                    style.fill = Cesium.Color.fromCssColorString(style.fill);
                    style.outlineColor = Cesium.Color.fromCssColorString(
                        style.outlineColor
                    );
                    de = {
                        polygon: {
                            outlineColor: {
                                defaultValue: style.outlineColor,
                            },
                            outlineWidth: style.outlineWidth,
                            fill: { defaultValue: style.fill.alpha },
                            extrudedHeight: style.extrudedHeight || 0,
                            height: style.height,
                            outline: style.outline,
                            material: {
                                defaultValue: style.fill,
                            },
                            clampToGround: !style.extrudedHeight ? true : false,
                            fromKml: true,
                        },
                        altitudeMethod: 2,
                        altitudeOffset: { defaultValue: "0" },
                        minimumLevel: this._core.defaultValue(style.level_min, 0),
                        maximumLevel: this._core.defaultValue(style.level_max, 22),
                        position_x: data.position_x,
                        position_y: data.position_y,
                        position_z: data.position_z == 0 ? 10000 : data.position_z,
                        urls: data.Server,
                        layer: data.ServerName,
                    };
                }
            },
            error: () => {
                console.log("获取样式配置失败！");
            }
        });
        return de;
    };

    /**
     * WGS84坐标转三维笛卡尔坐标
     *
     * @function
     *
     * @param {Object} [degrees] WGS84坐标。
     * @param {Number} [degrees.lon] 经度。
     * @param {Number} [degrees.lat] 纬度。
     * @param {Number} [degrees.height] 高度。
     * @returns {Cartesian3} 三维笛卡尔坐标。
     * 
     * @example
     * position = SmartEarth.WGS84_to_Cartesian3(degrees);
     */
    function WGS84_to_Cartesian3(degrees) {
        return Cesium.Cartesian3.fromDegrees(degrees.lon, degrees.lat, degrees.height);
    }

    /**
     *
     * 百度地图
     *
     * @alias BaiduImageryProvider
     * @constructor
     *
     */
    function BaiduImageryProvider(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    var _createClass = function () {
        function defineProperties(target, props) {
            for (var i = 0; i < props.length; i++) {
                var descriptor = props[i];
                descriptor.enumerable = descriptor.enumerable || false;
                descriptor.configurable = true;
                if ("value" in descriptor) descriptor.writable = true;
                Object.defineProperty(target, descriptor.key, descriptor);
            }
        }

        return function (Constructor, protoProps, staticProps) {
            if (protoProps) defineProperties(Constructor.prototype, protoProps);
            if (staticProps) defineProperties(Constructor, staticProps);
            return Constructor;
        };
    }();

    function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
            throw new TypeError("Cannot call a class as a function");
        }
    }

    var TEMP_MAP_URL = 'http://api{s}.map.bdimg.com/customimage/tile?&x={x}&y={y}&z={z}&scale=1&customid={style}';

    BaiduImageryProvider.prototype.BaiduImageryProvider = function () {

        function BaiduImageryProvider() {
            var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

            _classCallCheck(this, BaiduImageryProvider);

            this._url = TEMP_MAP_URL;
            this._tileWidth = 256;
            this._tileHeight = 256;
            this._maximumLevel = 18;
            this._tilingScheme = new Cesium.WebMercatorTilingScheme({
                rectangleSouthwestInMeters: new Cesium.Cartesian2(-33554054, -33746824),
                rectangleNortheastInMeters: new Cesium.Cartesian2(33554054, 33746824)
            });
            this._rectangle = this._tilingScheme.rectangle;
            this._credit = undefined;
            this._style = options.style || 'normal';
        }

        _createClass(BaiduImageryProvider, [{
            key: 'getTileCredits',
            value: function getTileCredits(x, y, level) {
            }
        }, {
            key: 'requestImage',
            value: function requestImage(x, y, level) {
                if (!this.ready) {
                    throw new Cesium.DeveloperError('requestImage must not be called before the imagery provider is ready.');
                }
                var xTiles = this._tilingScheme.getNumberOfXTilesAtLevel(level);
                var yTiles = this._tilingScheme.getNumberOfYTilesAtLevel(level);
                var url = this._url.replace('{x}', x - xTiles / 2).replace('{y}', yTiles / 2 - y - 1).replace('{z}', level).replace('{s}', 1).replace('{style}', this._style);
                return Cesium.ImageryProvider.loadImage(this, url);
            }
        }, {
            key: 'url',
            get: function get() {
                return this._url;
            }
        }, {
            key: 'token',
            get: function get() {
                return this._token;
            }
        }, {
            key: 'tileWidth',
            get: function get() {
                if (!this.ready) {
                    throw new Cesium.DeveloperError('tileWidth must not be called before the imagery provider is ready.');
                }
                return this._tileWidth;
            }
        }, {
            key: 'tileHeight',
            get: function get() {
                if (!this.ready) {
                    throw new Cesium.DeveloperError('tileHeight must not be called before the imagery provider is ready.');
                }
                return this._tileHeight;
            }
        }, {
            key: 'maximumLevel',
            get: function get() {
                if (!this.ready) {
                    throw new Cesium.DeveloperError('maximumLevel must not be called before the imagery provider is ready.');
                }
                return this._maximumLevel;
            }
        }, {
            key: 'minimumLevel',
            get: function get() {
                if (!this.ready) {
                    throw new Cesium.DeveloperError('minimumLevel must not be called before the imagery provider is ready.');
                }
                return 0;
            }
        }, {
            key: 'tilingScheme',
            get: function get() {
                if (!this.ready) {
                    throw new Cesium.DeveloperError('tilingScheme must not be called before the imagery provider is ready.');
                }
                return this._tilingScheme;
            }
        }, {
            key: 'rectangle',
            get: function get() {
                if (!this.ready) {
                    throw new Cesium.DeveloperError('rectangle must not be called before the imagery provider is ready.');
                }
                return this._rectangle;
            }
        }, {
            key: 'ready',
            get: function get() {
                return !!this._url;
            }
        }, {
            key: 'credit',
            get: function get() {
                return this._credit;
            }
        }]);

        return BaiduImageryProvider;
    }();

    /**
     *
     * 创建图片标签。
     *
     * @alias createBillboard
     * @constructor
     *
     */
    function Billboard(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 这个方法用于创建图片标签
     * @param {Array} [objs] 一个经纬度数组 例如：[{image:"tup.img",log:-114.0,lat: 40.0, height:300000.0}]。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Billboard.prototype.createBillboardbatch = function (objs) {
        var defaultOption = {
            show: true,
            position: this._cesium.Cartesian3.ZERO,
            pixelOffset: this._cesium.Cartesian2.ZERO,
            eyeOffset: this._cesium.Cartesian3.ZERO,
            heightReference: this._cesium.HeightReference.NONE,
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER,
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,
            scale: 1.0,
            image: "",
            imageSubRegion: undefined,
            color: this._cesium.Color.WHITE,
            id: undefined,
            rotation: 0.0,
            alignedAxis: this._cesium.Cartesian3.ZERO,
            width: undefined,
            height: undefined,
            scaleByDistance: undefined,
            translucencyByDistance: undefined,
            pixelOffsetScaleByDistance: undefined,
            sizeInMeters: false,
            distanceDisplayCondition: undefined
        };
        for (var i = 0; i < objs.length; i++) {
            var obj = objs[i];
            defaultOption.image = obj.image;
            this._viewer.entities.add({
                name: "",
                //中心的位置（长、宽、高）
                position: this._cesium.Cartesian3.fromDegrees(obj.log, obj.lat, obj.height),
                billboard: defaultOption
            });
        }
        return this;
    };
    /**
     * box导出工程数据
     */
    Billboard.prototype.export = function () {
        var show = this.item.show == undefined ? undefined : this.item.show._value;
        var dimensions = this.item.box.dimensions == undefined ? undefined : this.item.box.dimensions.getValue();
        var fill = this.item.box.fill == undefined ? undefined : this.item.box.fill._value;
        var material = this.item.box.material;
        if (material != undefined) {
            material = {
                color: material.color._value == undefined ? undefined : 'rgba(' + material.color._value.red + ',' + material.color._value.green + ',' + material.color._value.blue + ',' + material.color._value.alpha + ')',
                image: material.image == undefined ? undefined : material.image._value,
                diffusemap: material.diffusemap == undefined ? undefined : material.diffusemap._value,
                alphamap: material.alphamap == undefined ? undefined : material.alphamap._value
            };
        }
        var outline = this.item.box.outline == undefined ? undefined : this.item.box.outline._value;
        var outlineColor = this.item.box.outlineColor == undefined ? undefined : 'rgba(' + this.item.box.outlineColor._value.red + ',' + this.item.box.outlineColor._value.green + ',' + this.item.box.outlineColor._value.blue + ',' + this.item.box.outlineColor._value.alpha + ')';
        var outlineWidth = this.item.box.outlineWidth == undefined ? undefined : this.item.box.outlineWidth._value;
        var distanceDisplayCondition = this.item.box.distanceDisplayCondition;
        var near = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.near;
        var far = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.far;

        var catographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
        var longitude = this._cesium.Math.toDegrees(catographic.longitude);
        var latitude = this._cesium.Math.toDegrees(catographic.latitude);
        var height = this._cesium.Math.toDegrees(catographic.height);
        return {
            type: 'box',
            position: {
                x: longitude,
                y: latitude,
                z: height
            },
            treeobj: { id: this.treeobj.id, name: this.treeobj.name, pId: this.treeobj.pId, type: this.treeobj.type },
            style: {
                show: show,
                dimensions: dimensions,
                fill: fill,
                material: material,
                outline: outline,
                outlineColor: outlineColor,
                outlineWidth: outlineWidth,
                near: near,
                far: far
            }
        };
    };
    //工程树添加
    Billboard.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    Billboard.prototype.setVisibility = function (b) {
        this.item.show = b;
    };
    /**
     * 设置box的显示或隐藏
     * @param {Object} [Box] Box对象
     * @param {define} [show] 是否显示。
     * @returns {Object} 返回一个Box对象。
     */
    Billboard.prototype.setShow = function (show) {
        try {
            this.item._box.show = show;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    //删除矩形对象
    Billboard.prototype.deleteObject = function () {
        this._viewer.entities.remove(this.item);
        // this = null;
    };
    Object.defineProperties(Billboard.prototype, {
        /**
         * 透明度
         */
        ColorAlpha: {
            get: function () {
                return this.item._box.color._value.alpha;
            }
        },
        /**
         * 显示比例
         */
        Scale: {
            get: function () {
                return this.item._box.scale;
            }
        },
        /**
         * 旋转角度
         */
        Rotation: {
            get: function () {
                return this.item._box.rotation;
            }
        },
        /**
         * 宽度
         */
        Width: {
            get: function () {
                return this.item._box.width;
            }
        },
        /**
         * 高度
         */
        Height: {
            get: function () {
                return this.item._box.heightReference;
            }
        },
        /**
         * 颜色
         */
        Color: {
            get: function () {
                return this._color.toHtmlColor('rgb(' + this.item._box.backgroundColor._value.red * 255 + ',' + this.item._box.backgroundColor._value.green * 255 + ',' + this.item._box.backgroundColor._value.blue * 255 + ',' + this.item._box.backgroundColor._value.alpha * 255 + ')')
            }
        }
    });

    /**
     *
     * 仿照te修改
     *
     * 这个方法用于创建长方体
     * @param {Object} [Position] Position表示地面对象的位置和方向。对象{
        Altitude:高度。
        AltitudeType:枚举确定高度如何解译。
        Cartesian:一个布尔值，决定是否基于直角坐标系计算。
        Distance:从摄像机到位置的距离。
        Pitch:相机或对象的倾斜角度。
        Roll:对象的滚动角。
        X:X坐标。
        Y:Y坐标。
        Yaw:该相机或对象的方向角。
    }
     * @param {number} [ObjectWidth] 长方体的宽度（单位：米）。
     * @param {number} [ObjectDepth] 长方体的深度（单位：米）。
     * @param {number} [ObjectHeight] 长方体的高度（单位：米）。
     * @param {String} [LineColor] 组成长方体的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 长方体的填充色。颜色值由RGB定义。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中长方体的名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Billboard.prototype.CreateBox = function (Position, ObjectWidth, ObjectDepth, ObjectHeight, LineColor, FillColor, GroupID, Description) {
        this._postion = Position;

        var defaultOption = {
            dimensions: new this._cesium.Cartesian3(ObjectHeight, ObjectWidth, ObjectDepth),
            material: this._cesium.Color.YELLOW,
            outline: true,
            outlineColor: this._cesium.Color.RED,
        };

        if (LineColor && LineColor !== '') {
            defaultOption.outlineColor = new Color(this._viewer, this._cesium).colorFromHtmlColor(LineColor);
        }
        if (FillColor && FillColor !== '') {
            defaultOption.material = new Color(this._viewer, this._cesium).colorFromHtmlColor(FillColor);
        }

        var orientation;
        if (Position.Yaw || Position.Pitch || Position.Roll) {
            orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
                new this._cesium.HeadingPitchRoll(
                    this._cesium.Math.toRadians(Position.Yaw),
                    this._cesium.Math.toRadians(Position.Pitch),
                    this._cesium.Math.toRadians(Position.Roll)
                )
            );
        }
        this.item = this._viewer.entities.add({
            name: Description,
            //中心的位置
            position: this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
            box: defaultOption,
            orientation: orientation
        });
        var obj = {
            id: this.item.id,
            name: Description,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'box',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    Object.defineProperties(Billboard.prototype, {
        Position: {
            Altitude: {
                get: function () {
                    return this._postion.Altitude
                },
                set: function (Altitude) {
                    try {
                        // 赋值
                        this._postion.Altitude = Altitude;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            AltitudeType: {
                get: function () {
                    return this._postion.AltitudeType
                },
                set: function (AltitudeType) {
                    try {
                        this._postion.AltitudeType = AltitudeType;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Cartesian: {
                get: function () {
                    return this._postion.Cartesian
                },
                set: function (Cartesian) {
                    try {
                        this._postion.Cartesian = Cartesian;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Distance: {
                get: function () {
                    return this._postion.Distance
                },
                set: function (Distance) {
                    try {
                        this._postion.Distance = Distance;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Pitch: {
                get: function () {
                    return this._postion.Pitch
                },
                set: function (Pitch) {
                    try {
                        this._postion.Pitch = Pitch;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Roll: {
                get: function () {
                    return this._postion.Roll
                },
                set: function (Roll) {
                    try {
                        this._postion.Roll = Roll;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            X: {
                get: function () {
                    return this._postion.X
                },
                set: function (X) {
                    try {
                        // 赋值
                        this._postion.X = X;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Y: {
                get: function () {
                    return this._postion.Y
                },
                set: function (Y) {
                    try {
                        // 赋值
                        this._postion.Y = Y;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Yaw: {
                get: function () {
                    return this._postion.Yaw
                },
                set: function (Yaw) {
                    try {
                        this._postion.Yaw = Yaw;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            }
        }
    });

    /**
     *
     * 创建长方体Geojson要素图层。
     *
     * @alias BoxGeoJsonFeatureLayer
     * @constructor
     *
     */
    function BoxGeoJsonFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
    }
    BoxGeoJsonFeatureLayer.prototype.createBoxGeojsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var defaultOptions = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            granularity: CesiumMath.RADIANS_PER_DEGREE, //
            perPositionHeight: false, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.charAt(0) == "[" && option.material.charAt(option.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        var that = this;
        dataSource.then(function (dataSource) {
            var entities = dataSource.entities.values;
            var geometries = [];
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                options.polygonHierarchy = new that._cesium.PolygonHierarchy(entity.polyline.positions._value, []);
                var geometry = new that._cesium.GeometryInstance({
                    id: entity, //拾取属性修改
                    geometry: new that._cesium.PolygonGeometry(options),
                    attributes: {
                        color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material)
                    }
                });
                geometries.push(geometry);
            }
            var ps = that._viewer.scene.primitives.add(new that._cesium.Primitive({
                geometryInstances: geometries,
                appearance: new that._cesium.PerInstanceColorAppearance({
                    translucent: false
                }),
                shadows: that._cesium.ShadowMode.ENABLED
            }));
            ps.show = options.show;
            that.item = ps;
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this._tree.insertGroupId({
            id: options.id,
            name: name,
            checked: options.show,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineLayer',
            item: this
        }, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    /**
     *
     * 走廊
     *
     * @alias Corridor
     * @constructor
     *
     */
    function Corridor(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 创建走廊
     * 
     * @param {string} [name] 名称
     * @param {object} [options] 名称
     */
    Corridor.prototype.createCorridor = function (name, Geometry, options, GroupID) {
        var defaultOptions = {
            show: true,
            material: this._cesium.Color.RED.withAlpha(0.5),
            width: 1000
        };
        if (this._core.isnull(options)) {
            console.log('options is required');
            return;
        }
        options = this._core.extend(defaultOptions, options, true);
        var pArray = [];
        if (!Geometry[0].x && !Geometry[0].y) {
            if (Geometry[0].length === 2) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1]));
                }
            } else if (Geometry[0].length === 3) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1], Geometry[i][2]));
                }
            }
        } else {
            if (Geometry[0].z !== undefined) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y, Geometry[i].z));
                }
            } else {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y));
                }
            }
        }
        options.positions = pArray;
        var Corridor = this._viewer.entities.add({
            name: name,
            id: this._core.getuid(),
            corridor: options,
        });
        this.item = Corridor;
        this._tree.insertGroupId({
            id: Corridor.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'corridor',
            item: this
        }, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
        * 获取corridor样式
        */
    Corridor.prototype.getstyles = function () {
        var styles = {};
        styles.show = this.item.ellipse.show ? this.item.ellipse.show._value : true;
        styles.positions = this.item.ellipse.positions ? this.item.ellipse.positions.getValue().toString() : undefined;
        styles.width = this.item.ellipse.width && this.item.ellipse.width._value ? this.item.ellipse.width.toString() : undefined;
        styles.height = this.item.ellipse.height && this.item.ellipse.height._value ? this.item.ellipse.height.toString() : undefined;
        styles.heightReference = this.item.ellipse.heightReference && this.item.ellipse.heightReference._value ? this.item.ellipse.heightReference._value : undefined;
        styles.extrudedHeight = this.item.ellipse.extrudedHeight && this.item.ellipse.extrudedHeight.getValue() ? this.item.ellipse.extrudedHeight.getValue() : undefined;
        styles.extrudedHeightReference = this.item.ellipse.extrudedHeightReference && this.item.ellipse.extrudedHeightReference._value ? this.item.ellipse.extrudedHeightReference._value : undefined;
        styles.cornerType = this.item.ellipse.cornerType ? this.item.ellipse.cornerType._value : undefined;
        styles.material = {};
        tyles.material.color = this.item.ellipse.material && this.item.ellipse.material.color && this.item.ellipse.material.color._value ? this.item.ellipse.material.color.toString() : undefined;
        styles.material.image = this.item.ellipse.material && this.item.ellipse.material.image && this.item.ellipse.material.image._value ? this.item.ellipse.material.image._value : undefined;
        styles.material.repeat = this.item.ellipse.material && this.item.ellipse.material.repeat && this.item.ellipse.material.repeat._value ? this.item.ellipse.material.repeat._value : undefined;
        styles.fill = this.item.ellipse.fill ? this.item.ellipse.fill._value : undefined;
        styles.outline = this.item.ellipse.outline ? this.item.ellipse.outline._value : undefined;
        styles.outlineWidth = this.item.ellipse.outlineWidth && this.item.ellipse.outlineWidth._value ? this.item.ellipse.outlineWidth._value : undefined;
        styles.outlineColor = this.item.ellipse.outlineColor && this.item.ellipse.outlineColor._value ? 'rgba' + this.item.ellipse.outlineColor.toString() + '' : undefined;
        styles.near = this.item.ellipse.distanceDisplayCondition ? this.item.ellipse.distanceDisplayCondition._value.near : undefined;
        styles.far = this.item.ellipse.distanceDisplayCondition ? this.item.ellipse.distanceDisplayCondition._value.far : undefined;
        styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
     * 设置wall的可见性
     */
    Corridor.prototype.setVisibility = function (b) {
        this.item.show = b;
    };
    /**
     * 获取wall的可见性
     */
    Corridor.prototype.getVisibility = function () {
        return this.item.show;
    };
    /**
     * 删除元素
     */
    Corridor.prototype.deleteObject = function () {
        this._viewer.entities.remove(this.item);
    };


    Corridor.prototype.setItem = function (item) {
        this.item = item;
    };
    //工程树添加
    Corridor.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    function GmlParser(e, t, n, r) {
        this._extractAttributes = e,
            this._featureName = t || "featureMember",
            this._xy = r,
            this._gmlns = n || "http://www.opengis.net/gml",
            this._regExes = {
                trimSpace: /^\s*|\s*$/g,
                removeSpace: /\s*/g,
                splitSpace: /\s+/,
                trimComma: /\s*,\s*/g
            };
    }
    Object.defineProperties(GmlParser.prototype, {
        featureName: {
            get: function () {
                return this._featureName
            },
            set: function (e) {
                this._featureName = e;
            }
        },
        extractAttributes: {
            get: function () {
                return this._extractAttributes
            },
            set: function (e) {
                this._extractAttributes = e;
            }
        },
        xy: {
            get: function () {
                return this._xy
            }
        }
    });
    GmlParser.prototype.getElementsByTagNameNS = function (e, t, n) {
        var r = [];
        if (e.getElementsByTagNameNS) r = e.getElementsByTagNameNS(t, n);
        else {
            var i = e.getElementsByTagName("*"),
                s, o;
            for (var u = 0, a = i.length; u < a; ++u) s = i[u],
                o = s.prefix ? s.prefix + ":" + n : n,
                (n == "*" || o == s.nodeName) && (t == "*" || t == s.namespaceURI) && r.push(s);
        }
        return r
    };
    GmlParser.prototype.read = function (e) {
        var t = this.getElementsByTagNameNS(e.documentElement, this._gmlns, this.featureName),
            n = [];
        for (var r = 0; r < t.length; r++) {
            var i = this.parseFeature(t[r]);
            i && n.push(i);
        }
        return n
    };
    GmlParser.prototype.parseFeature = function (e) {
        var t = ["MultiPolygon", "Polygon", "MultiLineString", "LineString", "MultiPoint", "Point", "Envelope"],
            n, r, i, s;
        for (var o = 0; o < t.length; ++o) {
            n = t[o],
                r = this.getElementsByTagNameNS(e, this._gmlns, n);
            if (r.length > 0) {
                s = this.parseGeometry[n.toLowerCase()],
                    s ? i = s.apply(this, [r[0]]) : console.log("unsupportedGeometryType:" + n);
                break
            }
        }
        var u, a = this.getElementsByTagNameNS(e, this._gmlns, "Box");
        for (o = 0; o < a.length; ++o) {
            var f = a[o],
                l = this.parseGeometry.box.apply(this, [f]),
                c = f.parentNode,
                h = c.localName || c.nodeName.split(":").pop();
            h === "boundedBy" ? u = l : i = l.toGeometry();
        }
        var p;
        this.extractAttributes && (p = this.parseAttributes(e));
        var d = {
            geometryType: n.toLowerCase(),
            positions: i,
            attributes: p
        };
        d.bounds = u;
        var v = e.firstChild,
            m;
        while (v) {
            if (v.nodeType == 1) {
                m = v.getAttribute("fid") || v.getAttribute("id");
                if (m) break
            }
            v = v.nextSibling;
        }
        return d.fid = m,
            d
    };
    GmlParser.prototype.parseGeometry = {
        point: function (e) {
            var t, n, r = [],
                t = this.getElementsByTagNameNS(e, this._gmlns, "pos");
            t.length > 0 && (n = t[0].firstChild.nodeValue, n = n.replace(this._regExes.trimSpace, ""), r = n.split(this._regExes.splitSpace)),
                r.length == 0 && (t = this.getElementsByTagNameNS(e, this._gmlns, "coordinates"), t.length > 0 && (n = t[0].firstChild.nodeValue, n = n.replace(this._regExes.removeSpace, ""), r = n.split(",")));
            if (r.length == 0) {
                t = this.getElementsByTagNameNS(e, this._gmlns, "coord");
                if (t.length > 0) {
                    var i = this.getElementsByTagNameNS(t[0], this._gmlns, "X"),
                        s = this.getElementsByTagNameNS(t[0], this._gmlns, "Y");
                    i.length > 0 && s.length > 0 && (r = [i[0].firstChild.nodeValue, s[0].firstChild.nodeValue]);
                }
            }
            return r.length == 2 && (r[2] = null),
                this.xy ? [parseFloat(r[0]), parseFloat(r[1]), parseFloat(r[2])] : [parseFloat(r[1]), parseFloat(r[0]), parseFloat(r[2])]
        },
        multipoint: function (e) {
            var t = this.getElementsByTagNameNS(e, this._gmlns, "Point"),
                n = [];
            if (t.length > 0) {
                var r;
                for (var i = 0; i < t.length; ++i) r = this.parseGeometry.point.apply(this, [t[i]]),
                    r && n.push(r);
            }
            return n
        },
        linestring: function (e, t) {
            var n, r, i = [],
                s = [];
            n = this.getElementsByTagNameNS(e, this._gmlns, "posList");
            if (n.length > 0) {
                r = this.getChildValue(n[0]),
                    r = r.replace(this._regExes.trimSpace, ""),
                    i = r.split(this._regExes.splitSpace);
                var o = parseInt(n[0].getAttribute("dimension")),
                    u, a, f, l;
                for (var c = 0; c < i.length / o; ++c) u = c * o,
                    a = parseFloat(i[u]),
                    f = parseFloat(i[u + 1]),
                    l = o == 2 ? null : parseFloat(i[u + 2]),
                    this.xy ? s.push(a, f, l) : s.push(f, a, l);
            }
            if (i.length == 0) {
                n = this.getElementsByTagNameNS(e, this._gmlns, "coordinates");
                if (n.length > 0) {
                    r = this.getChildValue(n[0]),
                        r = r.replace(this._regExes.trimSpace, ""),
                        r = r.replace(this._regExes.trimComma, ",");
                    var h = r.split(this._regExes.splitSpace);
                    for (var c = 0; c < h.length; ++c) i = h[c].split(","),
                        i.length == 2 && (i[2] = null),
                        this.xy ? s.push(parseFloat(i[0]), parseFloat(i[1]), parseFloat(i[2])) : s.push(parseFloat(i[1]), parseFloat(i[0]), parseFloat(i[2]));
                }
            }
            return s
        },
        multilinestring: function (e) {
            var t = this.getElementsByTagNameNS(e, this._gmlns, "LineString"),
                n = [];
            if (t.length > 0) {
                var r;
                for (var i = 0; i < t.length; ++i) r = this.parseGeometry.linestring.apply(this, [t[i]]),
                    r && n.push(r);
            }
            return n
        },
        polygon: function (e) {
            var t = this.getElementsByTagNameNS(e, this._gmlns, "LinearRing"),
                n = [];
            if (t.length > 0) {
                var r;
                for (var i = 0; i < t.length; ++i) r = this.parseGeometry.linestring.apply(this, [t[i], !0]),
                    r && n.push(r);
            }
            return n
        },
        multipolygon: function (e) {
            var t = this.getElementsByTagNameNS(e, this._gmlns, "Polygon"),
                n = [];
            if (t.length > 0) {
                var r;
                for (var i = 0; i < t.length; ++i) r = this.parseGeometry.polygon.apply(this, [t[i]]),
                    r && n.push(r);
            }
            return n
        },
        envelope: function (e) {
            var t = [],
                n, r, i = this.getElementsByTagNameNS(e, this._gmlns, "lowerCorner");
            if (i.length > 0) {
                var s = [];
                i.length > 0 && (n = i[0].firstChild.nodeValue, n = n.replace(this._regExes.trimSpace, ""), s = n.split(this._regExes.splitSpace)),
                    s.length == 2 && (s[2] = null);
                if (this.xy) var o = new OpenLayers_Geometry_Point(s[0], s[1], s[2]);
                else var o = new OpenLayers_Geometry_Point(s[1], s[0], s[2]);
            }
            var u = this.getElementsByTagNameNS(e, this._gmlns, "upperCorner");
            if (u.length > 0) {
                var s = [];
                u.length > 0 && (n = u[0].firstChild.nodeValue, n = n.replace(this._regExes.trimSpace, ""), s = n.split(this._regExes.splitSpace)),
                    s.length == 2 && (s[2] = null);
                if (this.xy) var a = new OpenLayers_Geometry_Point(s[0], s[1], s[2]);
                else var a = new OpenLayers_Geometry_Point(s[1], s[0], s[2]);
            }
            return o && a && (t.push([o.x, o.y, null]), t.push([a.x, o.y, null]), t.push([a.x, a.y, null]), t.push([o.x, a.y, null]), t.push([o.x, o.y, null]), r = new OpenLayers_Geometry_Polygon([
                [t]
            ])),
                r
        },
        box: function (e) {
            var t = this.getElementsByTagNameNS(e, this._gmlns, "coordinates"),
                n, r, i = null,
                s = null;
            t.length > 0 && (n = t[0].firstChild.nodeValue, r = n.split(" "), r.length == 2 && (i = r[0].split(","), s = r[1].split(",")));
            if (i !== null && s !== null) return [parseFloat(i[0]), parseFloat(i[1]), null, parseFloat(s[0]), parseFloat(s[1]), null]
        }
    };
    GmlParser.prototype.parseAttributes = function (e) {
        var t = {},
            n = e.firstChild,
            r, i, s, o, u, a, f;
        while (n) {
            if (n.nodeType == 1) {
                r = n.childNodes;
                for (i = 0; i < r.length; ++i) {
                    s = r[i];
                    if (s.nodeType == 1) {
                        o = s.childNodes;
                        if (o.length == 1) {
                            u = o[0];
                            if (u.nodeType == 3 || u.nodeType == 4) a = s.prefix ? s.nodeName.split(":")[1] : s.nodeName,
                                f = u.nodeValue.replace(this._regExes.trimSpace, ""),
                                t[a] = f;
                        } else t[s.nodeName.split(":").pop()] = null;
                    }
                }
                break
            }
            n = n.nextSibling;
        }
        return t
    };
    GmlParser.prototype.getChildValue = function (e, t) {
        var n = t || "";
        if (e)
            for (var r = e.firstChild; r; r = r.nextSibling) switch (r.nodeType) {
                case 3:
                case 4:
                    n += r.nodeValue;
            }
        return n
    };

    function TileManager1() {
        this._quadtree = undefined;
        this._loadTileEvent = new Cesium.Event;
        this._tilingScheme = new Cesium.GeographicTilingScheme();
        this._errorEvent = new Cesium.Event();
        this._levelZeroMaximumError = Cesium.QuadtreeTileProvider.computeDefaultLevelZeroMaximumGeometricError(this._tilingScheme);
        this.cartographicLimitRectangle = Cesium.Rectangle.clone(Cesium.Rectangle.MAX_VALUE);
        this._tileCache = [];
        this._primitivesWaitingToBeAddedToTheScene = [];
        this._pauseStreaming = !1;
        this._numTilesInLevel = [];
        this.STREAM_SPEED_IMIDIATE = 0;
        this.STREAM_SPEED_FAST = 1;
        this.STREAM_SPEED_NORMAL = 2;
        this.STREAM_SPEED_SLOW = 3;
        this._streamSpeed = this.STREAM_SPEED_NORMAL;
        if (!TileManager1.prototype.ready)
            Object.defineProperties(TileManager1.prototype, {
                quadtree: {
                    get: function () {
                        return this._quadtree;
                    },
                    set: function (value) {
                        this._quadtree = value;
                    }
                },
                ready: {
                    get: function () {
                        return true;
                    }
                },
                tilingScheme: {
                    get: function () {
                        return this._tilingScheme;
                    }
                },
                errorEvent: {
                    get: function () {
                        return this._errorEvent;
                    }
                },
                loadTileEvent: {
                    get: function () {
                        return this._loadTileEvent
                    }
                },
                pauseStreaming: {
                    get: function () {
                        return this._pauseStreaming
                    },
                    set: function (e) {
                        this._pauseStreaming = e;
                    }
                },
                streamSpeed: {
                    get: function () {
                        return this._streamSpeed
                    },
                    set: function (e) {
                        this._streamSpeed = e;
                    }
                },
                bestLevelAvailable: {
                    get: function () {
                        var e = 0;
                        for (var t = 0; t < 22; t++) this._numTilesInLevel[t] != undefined && this._numTilesInLevel[t] > 0 && e < t && (e = t);
                        return e
                    }
                }
            });
    }

    function a$4(viewer, e, n) {
        $.each(e._primitives, function (e, r) {
            if (r instanceof Cesium.BillboardCollection) {
                var i = r,
                    e = t$3.indexOf(i);
                return i._parentCollection._primitiveOld = n,
                    e !== -1 ? (viewer.scene.primitives.remove(t$3[e]._parentCollection), t$3[e] = i) : t$3.push(i),
                    !1
            }
        });
    }

    function f$2(viewer, e, t) {
        viewer.scene.primitives.remove(t),
            e._onDestroyTilePrimitive = function () {
                viewer.scene.primitives.remove(t),
                    this._onDestroyTilePrimitive = undefined;
            };
    }

    function l$3(viewer, e, t, n) {
        Cesium.when.all(e, function () {
            viewer.scene.primitives.remove(n);
        }),
            t._onDestroyTilePrimitive = function () {
                viewer.scene.primitives.remove(n),
                    this._onDestroyTilePrimitive = undefined;
            };
    }

    function c$3(viewer, e, t) {
        var n = $.map(e._primitives, function (e) {
            return e.readyPromise
        });
        l$3(viewer, n, e, t);
    }

    function h$3(viewer, e, t) {
        var n = $.map(e._primitives[0]._primitives, function (e) {
            return e.readyPromise
        });
        l$3(viewer, n, e, t);
    }

    function p$3(viewer, e, t) {
        viewer.scene.primitives.remove(t);
    }

    function d$3(viewer, e, t) {
        var n = [e.readyPromise];
        l$3(viewer, n, e, t);
    }
    TileManager1.prototype.streamSpeedFactor = function () {
        switch (this._streamSpeed) {
            case this.STREAM_SPEED_FAST:
                return 1;
            case this.STREAM_SPEED_NORMAL:
                return 3;
            case this.STREAM_SPEED_SLOW:
                return 20;
            default:
                return 3
        }
    };
    var t$3 = [];
    var n$4 = 0;
    TileManager1.prototype.onPreFrame = function (e, r) {
        n$4++;
        if (this._pauseStreaming) return;
        if (this._streamSpeed == this.STREAM_SPEED_IMIDIATE)
            while (this._primitivesWaitingToBeAddedToTheScene.length > 0) {
                var i = this._primitivesWaitingToBeAddedToTheScene.pop();
                e.primitives.add(i);
            } else if (this._primitivesWaitingToBeAddedToTheScene.length > 0 && n$4 % this.streamSpeedFactor() == 0) {
                var i = this._primitivesWaitingToBeAddedToTheScene.pop();
                i._instanceIds && i._instanceIds.length > 100 && this.streamSpeed === this.STREAM_SPEED_FAST && (this.streamSpeed = this.STREAM_SPEED_NORMAL),
                    e.primitives.add(i);
            }
        $.each(t$3, function (e, t) {
            t.ready && this.viewer.scene.primitives.remove(t._parentCollection._primitiveOld);
        });
    };
    TileManager1.prototype.updateForPick = function (e) { };
    var i$6 = 180 / Math.PI;

    TileManager1.prototype.placeHolder = function (e, t) {
        t = t || Cesium.Color.fromBytes(0, 255, 0, 255);
        var n = new Cesium.Primitive({
            geometryInstances: new Cesium.GeometryInstance({
                geometry: new Cesium.RectangleOutlineGeometry({
                    rectangle: e.rectangle,
                    height: this.viewer.camera.positionCartographic.height - TerraExplorer.internal.Navigate.HeightAboveGround * .99
                }),
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(t)
                }
            }),
            appearance: new Cesium.PerInstanceColorAppearance({
                flat: !0
            })
        });
        e.data.primitive.add(n);
    };

    TileManager1.prototype.getTile = function (e) {
        return this._tileCache[e]
    };
    TileManager1.prototype.getAllTiles = function () {
        var e = [];
        for (var t in this._tileCache) e.push(this._tileCache[t]);
        return e
    };
    TileManager1.prototype.addToScene = function (e) {
        this._primitivesWaitingToBeAddedToTheScene.push(e);
    };
    TileManager1.prototype.removeFromScene = function (e) {
        var t = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        t != -1 ? (this._primitivesWaitingToBeAddedToTheScene[t].destroy(), this._primitivesWaitingToBeAddedToTheScene.splice(t, 1)) : this.viewer.scene.primitives.remove(e);
    };
    TileManager1.prototype.replaceInScene = function (e, t) {
        var n = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        if (n != -1) this._primitivesWaitingToBeAddedToTheScene[n] = t;
        else {
            e.ID != t.ID && console.log("TileManager.replaceInScene Warning: new primitive has a different ID than old primitive"),
                e._replacmentPrimitive != undefined && this.viewer.scene.primitives.remove(e._replacmentPrimitive),
                e._replacmentPrimitive = t,
                this.viewer.scene.primitives.add(t);
            var r = t.ID.split(":")[0];
            switch (r) {
                case "billboards":
                    a$4(this.viewer, t, e);
                    break;
                case "labels":
                    f$2(this.viewer, t, e);
                    break;
                case "polygons":
                    c$3(this.viewer, t, e);
                    break;
                case "models":
                    h$3(this.viewer, t, e);
                    break;
                case "polylines":
                    d$3(this.viewer, t, e);
                    break;
                case "points":
                    p$3(this.viewer, t, e);
                    break;
                default:
                    console.log("Error updating layer"),
                        this.viewer.scene.primitives.remove(e);
            }
        }
    };
    var v$2 = {
        billboards: a$4,
        labels: f$2,
        polygons: c$3,
        models: h$3,
        polylines: d$3,
        points: p$3
    };
    TileManager1.prototype.replaceInSceneNew = function (e, t) {
        var n = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        if (n != -1) this._primitivesWaitingToBeAddedToTheScene[n] = t;
        else {
            e.ID !== t.ID && console.log("TileManager.replaceInScene Warning: new primitive has a different ID than old primitive"),
                this.addToScene(t);
            var i = t.ID.split(":")[0],
                s = v$2[i];
            s ? s(t, e) : (console.log("Error updating layer"), this.viewer.scene.primitives.remove(e));
        }
    };
    /***************************************************************************/
    TileManager1.prototype.update = function (frameState) {
        this._quadtree.beginFrame(frameState);
        this._quadtree.render(frameState);
        this._quadtree.endFrame(frameState);
    };

    var r$5 = !1;
    TileManager1.prototype.initialize = function (frameState) {
        r$5 || (this.viewer.scene.preRender.addEventListener(this.onPreFrame, this), r$5 = !0);
    };

    TileManager1.prototype.beginUpdate = function (frameState) {
        this.quadtree.beginFrame(frameState);
    };

    TileManager1.prototype.endUpdate = function (frameState) {
        var t = this;
        frameState.afterRender.push(function () {
            t.quadtree.endFrame(frameState);
        });
    };

    TileManager1.prototype.getLevelMaximumGeometricError = function (level) {
        return this._levelZeroMaximumError / (1 << level);
    };

    TileManager1.prototype.loadTile = function (frameState, tile) {
        var n = this;
        this._numTilesInLevel[tile._level] == undefined && (this._numTilesInLevel[tile._level] = 0);
        this._numTilesInLevel[tile._level]++;
        if (tile.state === Cesium.QuadtreeTileLoadState.START) {
            tile.data = {
                primitive: new Cesium.PrimitiveCollection,
                wfsLayerData: [],
                id: Cesium.createGuid(),
                freeResources: function () {
                    n._tileCache[tile.data.id] && n._numTilesInLevel[tile._level]--,
                        n._numTilesInLevel[tile._level] < 0 && (n._numTilesInLevel[tile._level] = 0);
                    if (Cesium.defined(this.wfsLayerData)) {
                        for (var e in this.wfsLayerData) Cesium.defined(this.wfsLayerData[e]) && this.wfsLayerData[e].freeResources();
                        this.wfsLayerData = undefined;
                    }
                    Cesium.defined(this.primitive) && (this.primitive.destroy(), this.primitive = undefined),
                        delete n._tileCache[tile.data.id];
                }
            },
                this._tileCache[tile.data.id] = tile;
            var r = 6371e3;
            Math.abs(r * (tile.rectangle.south - tile.rectangle.north));
            tile.data.boundingSphere3D = Cesium.BoundingSphere.fromRectangle3D(tile.rectangle);
            tile.data.boundingSphere2D = Cesium.BoundingSphere.fromRectangle2D(tile.rectangle, frameState.mapProjection);
            [i$6 * tile.rectangle.west, i$6 * tile.rectangle.south, i$6 * tile.rectangle.east, i$6 * tile.rectangle.north];
            this.loadTileEvent.raiseEvent(tile);
            tile.state = Cesium.QuadtreeTileLoadState.DONE;
            tile.renderable = true;
        }
        // if (tile.state === Cesium.QuadtreeTileLoadState.START) {
        //     this._loadTileEvent.raiseEvent(tile);
        //     tile.state = Cesium.QuadtreeTileLoadState.LOADING
        //     if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
        //         tile.data.geometryPrimitive.update(frameState, []);
        //         if (tile.data.geometryPrimitive._ready) {
        //             tile.state = Cesium.QuadtreeTileLoadState.DONE;
        //             tile.renderable = true;
        //         }
        //     }
        // }
    };

    TileManager1.prototype.computeTileVisibility = function (tile, frameState, occluders) {
        var distance = this.computeDistanceToTile(tile, frameState);
        tile._distance = distance;

        if (frameState.fog.enabled) {
            if (Cesium.Math.fog(distance, frameState.fog.density) >= 1.0) {
                // Tile is completely in fog so return that it is not visible.
                return Cesium.Visibility.NONE;
            }
        }

        var surfaceTile = tile.data;
        surfaceTile.tileBoundingRegion;

        if (surfaceTile.boundingVolumeSourceTile === undefined) {
            // We have no idea where this tile is, so let's just call it partially visible.
            return Cesium.Visibility.PARTIAL;
            //return Cesium.Visibility.NONE;
        }

        var cullingVolume = frameState.cullingVolume;
        var boundingVolume = surfaceTile.orientedBoundingBox;

        if (!boundingVolume && surfaceTile.renderedMesh) {
            boundingVolume = surfaceTile.renderedMesh.boundingSphere3D;
        }

        // Check if the tile is outside the limit area in cartographic space
        surfaceTile.clippedByBoundaries = false;

        function clipRectangleAntimeridian(tileRectangle, cartographicLimitRectangle) {
            if (cartographicLimitRectangle.west < cartographicLimitRectangle.east) {
                return cartographicLimitRectangle;
            }
            var splitRectangle = Rectangle.clone(cartographicLimitRectangle, splitCartographicLimitRectangleScratch);
            var tileCenter = Rectangle.center(tileRectangle, rectangleCenterScratch);
            if (tileCenter.longitude > 0.0) {
                splitRectangle.east = CesiumMath.PI;
            } else {
                splitRectangle.west = -CesiumMath.PI;
            }
            return splitRectangle;
        }
        var clippedCartographicLimitRectangle = clipRectangleAntimeridian(tile.rectangle, this
            .cartographicLimitRectangle);
        var rectangleIntersectionScratch = new Cesium.Rectangle();
        var areaLimitIntersection = Cesium.Rectangle.simpleIntersection(clippedCartographicLimitRectangle, tile
            .rectangle, rectangleIntersectionScratch);
        if (!areaLimitIntersection) {
            return Visibility.NONE;
        }
        if (!Cesium.Rectangle.equals(areaLimitIntersection, tile.rectangle)) {
            surfaceTile.clippedByBoundaries = true;
        }

        if (frameState.mode !== Cesium.SceneMode.SCENE3D) ;

        if (!boundingVolume) {
            return Cesium.Intersect.INTERSECTING;
        }

        var clippingPlanes = this._clippingPlanes;
        if (clippingPlanes && clippingPlanes.enabled) {
            var planeIntersection = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
            tile.isClipped = (planeIntersection !== Intersect.INSIDE);
            if (planeIntersection === Cesium.Intersect.OUTSIDE) {
                return Cesium.Visibility.NONE;
            }
        }

        var intersection = cullingVolume.computeVisibility(boundingVolume);
        if (intersection === Cesium.Intersect.OUTSIDE) {
            return Cesium.Visibility.NONE;
        }

        var ortho3D = frameState.mode === Cesium.SceneMode.SCENE3D && frameState.camera
            .frustum instanceof Cesium.OrthographicFrustum;
        if (frameState.mode === Cesium.SceneMode.SCENE3D && !ortho3D && occluders) {
            var occludeePointInScaledSpace = surfaceTile.occludeePointInScaledSpace;
            if (!occludeePointInScaledSpace) {
                return intersection;
            }

            if (occluders.ellipsoid.isScaledSpacePointVisible(occludeePointInScaledSpace)) {
                return intersection;
            }

            return Cesium.Visibility.NONE;
        }

        return intersection;
    };

    TileManager1.prototype.canRefine = function (tile, frameState, occluders) {
        if (tile.level < 16)
            return true;
        return false;
    };

    TileManager1.prototype.showTileThisFrame = function (tile, context, frameState, commandList) {
        if (tile.data.geometryPrimitive)
            tile.data.geometryPrimitive.update(context, frameState, commandList);
    };

    TileManager1.prototype.computeDistanceToTile = function (tile, frameState) {
        function computeOccludeePoint(tileProvider, center, rectangle, height, result) {
            var ellipsoidalOccluder = tileProvider.quadtree._occluders.ellipsoid;
            var ellipsoid = ellipsoidalOccluder.ellipsoid;
            var cornerPositionsScratch = [new Cesium.Cartesian3(), new Cesium.Cartesian3(), new Cesium.Cartesian3(),
            new Cesium.Cartesian3()
            ];
            var cornerPositions = cornerPositionsScratch;
            Cesium.Cartesian3.fromRadians(rectangle.west, rectangle.south, height, ellipsoid, cornerPositions[0]);
            Cesium.Cartesian3.fromRadians(rectangle.east, rectangle.south, height, ellipsoid, cornerPositions[1]);
            Cesium.Cartesian3.fromRadians(rectangle.west, rectangle.north, height, ellipsoid, cornerPositions[2]);
            Cesium.Cartesian3.fromRadians(rectangle.east, rectangle.north, height, ellipsoid, cornerPositions[3]);

            return ellipsoidalOccluder.computeHorizonCullingPoint(center, cornerPositions, result);
        }

        function updateTileBoundingRegion(tile, terrainProvider, frameState) {
            var surfaceTile = tile.data;
            if (surfaceTile === undefined) {
                surfaceTile = tile.data = new Cesium.GlobeSurfaceTile();
            }

            if (surfaceTile.tileBoundingRegion === undefined) {
                surfaceTile.tileBoundingRegion = new Cesium.TileBoundingRegion({
                    computeBoundingVolumes: false,
                    rectangle: tile.rectangle,
                    ellipsoid: tile.tilingScheme.ellipsoid,
                    minimumHeight: 0.0,
                    maximumHeight: 0.0
                });
            }
            return tile;
        }
        var heightSource = updateTileBoundingRegion(tile, this.terrainProvider);
        var surfaceTile = tile.data;
        var tileBoundingRegion = surfaceTile.tileBoundingRegion;

        if (heightSource === undefined) {
            // Can't find any min/max heights anywhere? Ok, let's just say the
            // tile is really far away so we'll load and render it rather than
            // refining.
            return 9999999999.0;
        } else if (surfaceTile.boundingVolumeSourceTile !== heightSource) {
            // Heights are from a new source tile, so update the bounding volume.
            surfaceTile.boundingVolumeSourceTile = heightSource;

            var rectangle = tile.rectangle;
            if (rectangle && rectangle.width < Cesium.Math.PI_OVER_TWO + Cesium.Math.EPSILON5) {
                surfaceTile.orientedBoundingBox = Cesium.OrientedBoundingBox.fromRectangle(
                    tile.rectangle,
                    tileBoundingRegion.minimumHeight,
                    tileBoundingRegion.maximumHeight,
                    tile.tilingScheme.ellipsoid,
                    surfaceTile.orientedBoundingBox);

                surfaceTile.occludeePointInScaledSpace = computeOccludeePoint(this, surfaceTile
                    .orientedBoundingBox.center, tile.rectangle, tileBoundingRegion.maximumHeight,
                    surfaceTile.occludeePointInScaledSpace);
            }
        }

        var min = tileBoundingRegion.minimumHeight;
        var max = tileBoundingRegion.maximumHeight;

        if (surfaceTile.boundingVolumeSourceTile !== tile) {
            var cameraHeight = frameState.camera.positionCartographic.height;
            var distanceToMin = Math.abs(cameraHeight - min);
            var distanceToMax = Math.abs(cameraHeight - max);
            if (distanceToMin > distanceToMax) {
                tileBoundingRegion.minimumHeight = min;
                tileBoundingRegion.maximumHeight = min;
            } else {
                tileBoundingRegion.minimumHeight = max;
                tileBoundingRegion.maximumHeight = max;
            }
        }

        var result = tileBoundingRegion.distanceToCamera(frameState);

        tileBoundingRegion.minimumHeight = min;
        tileBoundingRegion.maximumHeight = max;

        return result;
    };

    TileManager1.prototype.isDestroyed = function () {
        return false;
    };

    TileManager1.prototype.destroy = function () {
        return Cesium.destroyObject(this);
    };

    TileManager1.prototype.remove = function () {
        this.destroy();
    };
    TileManager1.prototype.getInstance = function (t) {
        if (Cesium.defined(t.TileManager) == 0) {
            var instance = new TileManager1;
            t.TileManager = instance;
            instance.viewer = t;
            var n = new Cesium.QuadtreePrimitive({
                tileProvider: t.TileManager,
                maximumScreenSpaceError: 2
            });
            t.scene.primitives.add(n);
        }
        return t.TileManager
    };

    function SimpleSqlParser() { }
    function n$3(e) {
        return typeof e == "string" ? e.replace(/^\s+/g, "").replace(/\s+$/g, "") : e
    }
    function r$4(e, t) {
        var r = "######",
            i = !1,
            s = 0,
            o = "";
        for (var u = 0; u < t.length; u++)!i && /['"`]/.test(t[u]) ? i = t[u] : i && t[u] == i ? i = !1 : !i && t[u] == "(" ? s++ : !i && t[u] == ")" && s--,
            t[u] == e && (s > 0 || i) ? o += r : o += t[u];
        return t = o,
            t = t.split(e),
            t = t.map(function (t) {
                return n$3(t.replace(new RegExp(r, "g"), e))
            }),
            t
    }
    function i$5(e) {
        var t = "#",
            n = e.length;
        for (var r = 0; r < n; r++) t += e[r] + "#";
        return t
    }
    function s$1(e) {
        var t = "",
            n = e.length;
        for (var r = 1; r < n; r += 2) t += e[r];
        return t
    }
    function o$1(e) {
        this.source = e,
            this.cursor = 0,
            this.currentChar = "",
            this.readNextChar();
    }
    function u$1(e) {
        this.lexer = new o$1(e),
            this.currentToken = "",
            this.readNextToken();
    }
    function a$3(e, t) {
        var n = "";
        return typeof e.logic != "undefined" ? (n = e.terms.map(function (e) {
            return a$3(e, !0)
        }), n = n.join(" " + e.logic + " "), typeof t != "undefined" && (n = "(" + n + ")")) : typeof e.left != "undefined" ? (n = e.left, typeof e.operator != "undefined" && (n += " " + e.operator, typeof e.right != "undefined" && (e.operator === "IN" ? n += " (" + e.right + ")" : n += " " + e.right))) : n = e,
            n
    }
    SimpleSqlParser.sql2ast = function (e, t) {
        function p(e, t) {
            return t
        }
        if (typeof t == "undefined" || t === null) t = !0;
        var o = "###semi-colon###";
        e = e.replace(/[("'`].*;.*[)"'`]/g, function (e) {
            return e.replace(/;/g, o)
        });
        var a = "###EOR###";
        e = e.replace(/;/g, a),
            e = e.split(a)[0],
            e = e.replace(new RegExp(o, "g"), ";");
        var f = ["SELECT", "FROM", "DELETE FROM", "INSERT INTO", "UPDATE", "JOIN", "LEFT JOIN", "RIGHT JOIN", "INNER JOIN", "ORDER BY", "GROUP BY", "HAVING", "WHERE", "LIMIT", "VALUES", "SET"],
            l = f.map(function (e) {
                return e + " "
            });
        l = l.concat(f.map(function (e) {
            return e + "("
        })),
            l = l.concat(l.map(function (e) {
                return e.toLowerCase()
            }));
        var c = l.map(function (e) {
            return e.replace("(", "[\\(]")
        });
        e = e.replace(/\((.+?)\)|"(.+?)"|'(.+?)'|`(.+?)`/gi, function (e) {
            return e.replace(new RegExp(c.join("|"), "gi"), i$5)
        });
        var h = [];
        l.forEach(function (t) {
            var n = 0,
                r;
            do {
                r = e.indexOf(t, n);
                if (r != -1) {
                    var i = t.replace(/^((\w|\s)+?)\s?\(?$/i, p);
                    h[r] = i,
                        n = r + i.length;
                }
            } while (r != -1)
        });
        var d = 0;
        h.forEach(function (e, t) {
            d > t ? delete h[t] : (d = parseInt(t, 10) + e.length, e == "JOIN" && (h[t] = "INNER JOIN"));
        });
        var v = c.slice(0);
        v = v.map(function (e) {
            return i$5(e)
        }),
            v = v.join("|");
        var m = e.split(new RegExp(c.join("|"), "i"));
        e = e.replace(/\((.+?)\)|"(.+?)"|'(.+?)'|`(.+?)`/gi, function (e) {
            return e.replace(new RegExp(v, "gi"), s$1)
        }),
            m = m.map(function (e) {
                return e.replace(/\((.+?)\)|"(.+?)"|'(.+?)'|`(.+?)`/gi, function (e) {
                    return e.replace(new RegExp(v, "gi"), s$1)
                })
            });
        var g = [];
        g.SELECT = function (e) {
            var t = r$4(",", e);
            return t = t.filter(function (e) {
                return e !== ""
            }).map(function (e) {
                return {
                    name: e
                }
            }),
                t
        },
            g.SET = function (e) {
                var t = r$4(",", e);
                return t = t.filter(function (e) {
                    return e !== ""
                }).map(function (e) {
                    return {
                        expression: e
                    }
                }),
                    t
            },
            g.FROM = g["DELETE FROM"] = g.UPDATE = function (e) {
                var t = e.split(",");
                return t = t.map(function (e) {
                    return n$3(e)
                }),
                    t.forEach(function (e, n) {
                        e === "" && t.splice(n);
                    }),
                    t = t.map(function (e) {
                        var t = e.split(" AS "),
                            n = t[1] || "";
                        return n.indexOf('"') === 0 && n.lastIndexOf('"') == n.length - 1 && (n = n.substring(1, n.length - 1)),
                        {
                            table: t[0],
                            as: n
                        }
                    }),
                    t
            },
            g["LEFT JOIN"] = g.JOIN = g["INNER JOIN"] = g["RIGHT JOIN"] = function (e) {
                e = e.split(" ON ");
                var t = e[0].split(" AS "),
                    r = {};
                return r.table = n$3(t[0]),
                    r.as = n$3(t[1]) || "",
                    r.cond = n$3(e[1]),
                    r
            },
            g.WHERE = function (e) {
                return n$3(e)
            },
            g["ORDER BY"] = function (e) {
                e = e.split(",");
                var t = [];
                return e.forEach(function (e, r) {
                    var i = /([A-Za-z0-9_\.]+)\s*(ASC|DESC){0,1}/gi;
                    i = i.exec(e);
                    if (i !== null) {
                        var s = {};
                        s.column = n$3(i[1]),
                            s.order = n$3(i[2]),
                            i[2] === undefined && (s.order = "ASC"),
                            t.push(s);
                    }
                }),
                    t
            },
            g["GROUP BY"] = function (e) {
                e = e.split(",");
                var t = [];
                return e.forEach(function (e, r) {
                    var i = /([A-Za-z0-9_\.]+)/gi;
                    i = i.exec(e);
                    if (i !== null) {
                        var s = {};
                        s.column = n$3(i[1]),
                            t.push(s);
                    }
                }),
                    t
            },
            g.LIMIT = function (e) {
                var t = /((\d+)\s*,\s*)?(\d+)/gi;
                t = t.exec(e),
                    typeof t[2] == "undefined" && (t[2] = 0);
                var r = {};
                return r.nb = parseInt(n$3(t[3]), 10),
                    r.from = parseInt(n$3(t[2]), 10),
                    r
            },
            g["INSERT INTO"] = function (e) {
                var t = /([A-Za-z0-9_\.]+)\s*(\(([A-Za-z0-9_\., ]+)\))?/gi;
                t = t.exec(e);
                var r = {};
                return r.table = n$3(t[1]),
                    typeof t[3] != "undefined" && (r.columns = t[3].split(","), r.columns = r.columns.map(function (e) {
                        return n$3(e)
                    })),
                    r
            },
            g.VALUES = function (e) {
                e = n$3(e),
                    e[0] != "(" && (e = "(" + e);
                var t = r$4(",", e),
                    i = [];
                return t.forEach(function (e) {
                    e = e.replace(/^\(/g, "").replace(/\)$/g, ""),
                        e = r$4(",", e),
                        i.push(e);
                }),
                    i
            };
        var y = {},
            b = 0;
        return h.forEach(function (e, t) {
            e = e.toUpperCase(),
                b++;
            if (typeof g[e] != "undefined") {
                var n = g[e](m[b]);
                if (typeof y[e] != "undefined") {
                    if (typeof y[e] == "string" || typeof y[e][0] == "undefined") {
                        var r = y[e];
                        y[e] = [],
                            y[e].push(r);
                    }
                    y[e].push(n);
                } else y[e] = n;
            } else console.log("Can't analyze statement \"" + e + '"');
        }),
            typeof y["LEFT JOIN"] != "undefined" && (typeof y["JOIN"] == "undefined" && (y.JOIN = []), typeof y["LEFT JOIN"][0] != "undefined" ? y["LEFT JOIN"].forEach(function (e) {
                e.type = "left",
                    y.JOIN.push(e);
            }) : (y["LEFT JOIN"].type = "left", y.JOIN.push(y["LEFT JOIN"])), delete y["LEFT JOIN"]),
            typeof y["INNER JOIN"] != "undefined" && (typeof y["JOIN"] == "undefined" && (y.JOIN = []), typeof y["INNER JOIN"][0] != "undefined" ? y["INNER JOIN"].forEach(function (e) {
                e.type = "inner",
                    y.JOIN.push(e);
            }) : (y["INNER JOIN"].type = "inner", y.JOIN.push(y["INNER JOIN"])), delete y["INNER JOIN"]),
            typeof y["RIGHT JOIN"] != "undefined" && (typeof y["JOIN"] == "undefined" && (y.JOIN = []), typeof y["RIGHT JOIN"][0] != "undefined" ? y["RIGHT JOIN"].forEach(function (e) {
                e.type = "right",
                    y.JOIN.push(e);
            }) : (y["RIGHT JOIN"].type = "right", y.JOIN.push(y["RIGHT JOIN"])), delete y["RIGHT JOIN"]),
            t && (typeof y["WHERE"] == "string" && (y.WHERE = u$1.parse(y.WHERE)), typeof y["JOIN"] != "undefined" && y.JOIN.forEach(function (e, t) {
                y.JOIN[t].cond = u$1.parse(e.cond);
            })),
            y
    };
    o$1.prototype = {
        constructor: o$1,
        readNextChar: function () {
            typeof this.source != "string" ? this.currentChar = "" : this.currentChar = this.source[this.cursor++] || "";
        },
        readNextToken: function () {
            return /\w|[-]/.test(this.currentChar) ? this.readWord() : /["'`]/.test(this.currentChar) ? this.readString() : /[()]/.test(this.currentChar) ? this.readGroupSymbol() : /[!=<>]/.test(this.currentChar) ? this.readOperator() : this.currentChar === "" ? {
                type: "eot",
                value: ""
            } : (this.readNextChar(), {
                type: "empty",
                value: ""
            })
        },
        readWord: function () {
            var e = "",
                t = 0,
                n = !1;
            while (/./.test(this.currentChar)) {
                if (!n && /['"`]/.test(this.currentChar)) n = this.currentChar;
                else if (n && this.currentChar == n) n = !1;
                else {
                    if (!n) {
                        if (this.currentChar == ")" && t <= 0) break;
                        this.currentChar == "(" ? t++ : this.currentChar == ")" && t--;
                        if (/[!=<>]/.test(this.currentChar)) break
                    }
                    if (this.currentChar == " " && t <= 0) break
                }
                e += this.currentChar,
                    this.readNextChar();
            }
            return /^(AND|OR)$/i.test(e) ? {
                type: "logic",
                value: e
            } : /^(IN|IS|NOT|LIKE)$/i.test(e) ? {
                type: "operator",
                value: e
            } : {
                type: "word",
                value: e
            }
        },
        readString: function () {
            var e = "",
                t = this.currentChar;
            e += this.currentChar,
                this.readNextChar();
            while (this.currentChar != t && this.currentChar !== "") e += this.currentChar,
                this.readNextChar();
            return e += this.currentChar,
                this.readNextChar(),
                this.currentChar == "." ? (e += this.currentChar, this.readNextChar(), e += this.readString().value, {
                    type: "word",
                    value: e
                }) : {
                    type: "string",
                    value: e
                }
        },
        readGroupSymbol: function () {
            var e = this.currentChar;
            return this.readNextChar(),
            {
                type: "group",
                value: e
            }
        },
        readOperator: function () {
            var e = this.currentChar;
            return this.readNextChar(),
                /[=<>]/.test(this.currentChar) && (e += this.currentChar, this.readNextChar()),
            {
                type: "operator",
                value: e
            }
        }
    };
    o$1.tokenize = function (e) {
        var t = new o$1(e),
            n = [];
        do {
            var r = t.readNextToken();
            r.type != "empty" && n.push(r);
        } while (t.currentChar);
        return n
    };
    u$1.prototype = {
        constructor: u$1,
        readNextToken: function () {
            this.currentToken = this.lexer.readNextToken();
            while (this.currentToken.type == "empty") this.currentToken = this.lexer.readNextToken();
            return this.currentToken
        },
        parseExpressionsRecursively: function () {
            return this.parseLogicalExpression()
        },
        parseLogicalExpression: function () {
            var e = this.parseConditionExpression();
            while (this.currentToken.type == "logic") {
                var t = this.currentToken.value;
                this.readNextToken();
                var n = this.parseConditionExpression();
                if (typeof e.logic != "undefined" && e.logic == t && typeof e.terms != "undefined") e.terms.push(n);
                else {
                    var r = [e, n];
                    e = {
                        logic: t,
                        terms: r.slice(0)
                    };
                }
            }
            return e
        },
        parseConditionExpression: function () {
            var e = this.parseBaseExpression();
            if (this.currentToken.type == "operator") {
                var t = this.currentToken.value;
                this.readNextToken(),
                    this.currentToken.type == "operator" && (t += " " + this.currentToken.value, this.readNextToken());
                var n = this.parseBaseExpression();
                e = {
                    operator: t,
                    left: e,
                    right: n
                };
            }
            return e
        },
        parseBaseExpression: function () {
            var e = "";
            return this.currentToken.type == "word" || this.currentToken.type == "string" ? (e = this.currentToken.value, this.readNextToken()) : this.currentToken.type == "group" && (this.readNextToken(), e = this.parseExpressionsRecursively(), this.readNextToken()),
                e
        }
    };
    u$1.parse = function (e) {
        return (new u$1(e)).parseExpressionsRecursively()
    };
    SimpleSqlParser.ast2sql = function (e) {
        function n(e) {
            return typeof e["SELECT"] != "undefined" ? "SELECT " + e.SELECT.map(function (e) {
                return e.name
            }).join(", ") : ""
        }
        function r(e) {
            if (typeof e["FROM"] != "undefined") {
                var t = " FROM ",
                    n = e.FROM.map(function (e) {
                        var t = e.table;
                        return e.as !== "" && (t += " AS " + e.as),
                            t
                    });
                return t += n.join(", "),
                    t
            }
            return ""
        }
        function i(e) {
            if (typeof e["JOIN"] != "undefined") {
                var t = "";
                return e.JOIN.forEach(function (e) {
                    t += " " + e.type.toUpperCase() + " JOIN " + e.table,
                        e.as !== "" && (t += " AS " + e.as),
                        t += " ON " + a$3(e.cond);
                }),
                    t
            }
            return ""
        }
        function s(e) {
            return typeof e["WHERE"] != "undefined" ? " WHERE " + a$3(e.WHERE) : ""
        }
        function o(e) {
            if (typeof e["ORDER BY"] != "undefined") {
                var t = " ORDER BY ",
                    n = e["ORDER BY"].map(function (e) {
                        return e.column + " " + e.order
                    });
                return t += n.join(", "),
                    t
            }
            return ""
        }
        function u(e) {
            if (typeof e["GROUP BY"] != "undefined") {
                var t = " GROUP BY ",
                    n = e["GROUP BY"].map(function (e) {
                        return e.column
                    });
                return t += n.join(", "),
                    t
            }
            return ""
        }
        function f(e) {
            if (typeof e["LIMIT"] != "undefined" && typeof e["LIMIT"].nb != "undefined" && parseInt(e.LIMIT.nb, 10) > 0) {
                var t = " LIMIT ";
                return typeof e["LIMIT"].from != "undefined" && parseInt(e.LIMIT.from, 10) > 1 && (t += e.LIMIT.from + ","),
                    t += e.LIMIT.nb,
                    t
            }
            return ""
        }
        function l(e) {
            if (typeof e["INSERT INTO"] != "undefined") {
                var t = "INSERT INTO " + e["INSERT INTO"].table;
                return typeof e["INSERT INTO"].columns != "undefined" && (t += " (", t += e["INSERT INTO"].columns.join(", "), t += ")"),
                    t
            }
            return ""
        }
        function c(e) {
            if (typeof e["VALUES"] != "undefined") {
                var t = " VALUES ",
                    n = e.VALUES.map(function (e) {
                        return "(" + e.join(", ") + ")"
                    });
                return t += n.join(", "),
                    t
            }
            return ""
        }
        function h(e) {
            if (typeof e["DELETE FROM"] != "undefined") {
                var t = "DELETE FROM ";
                return t += e["DELETE FROM"].map(function (e) {
                    var t = e.table;
                    return e.as !== "" && (t += " AS " + e.as),
                        t
                }).join(", "),
                    t
            }
            return ""
        }
        function p(e) {
            if (typeof e["UPDATE"] != "undefined") {
                var t = "UPDATE ";
                return t += e.UPDATE.map(function (e) {
                    var t = e.table;
                    return e.as !== "" && (t += " AS " + e.as),
                        t
                }).join(", "),
                    t
            }
            return ""
        }
        function d(e) {
            return typeof e["SET"] != "undefined" ? " SET " + e.SET.map(function (e) {
                return e.expression
            }).join(", ") : ""
        }
        var t = "";
        return typeof e["SELECT"] != "undefined" && typeof e["FROM"] != "undefined" ? t = n(e) + r(e) + i(e) + s(e) + u(e) + o(e) + f(e) : typeof e["INSERT INTO"] != "undefined" ? t = l(e) + c(e) : typeof e["UPDATE"] != "undefined" ? t = p(e) + d(e) + s(e) : typeof e["DELETE FROM"] != "undefined" ? t = h(e) + s(e) : t = null,
            t
    };
    SimpleSqlParser.trim = n$3;
    SimpleSqlParser.protect = i$5;
    SimpleSqlParser.unprotect = s$1;
    SimpleSqlParser.protect_split = r$4;
    SimpleSqlParser.CondLexer = o$1;
    SimpleSqlParser.CondParser = u$1;

    function convertFontSizeToTEFontSize(e) {
        return e * 3 / 4
    }

    function getFontSizeInPixels(e) {
        var t = e * 72 / 96;
        return -1 * t
    }

    function polygonFeaturesToPositionsArray(e) {
        var t = [],
            n = e.length;
        for (var r = 0; r < n; r++) {
            var i = e[r],
                s = i.positions.length;
            for (var o = 0; o < s; o++) {
                var u = i.positions[o];
                for (var a = 0; a < u.length; a += 3) t.push(Cesium.Cartographic.fromDegrees(u[a + 0], u[a + 1], 0));
            }
        }
        return t
    }

    function _hashCode(e) {
        var t = 0,
            n, r;
        if (e.length === 0) return t;
        for (n = 0; n < e.length; n++) r = e.charCodeAt(n),
            t = (t << 5) - t + r,
            t |= 0;
        return t
    }

    function convertPolygonsRelativeHeightToAbsoluteHeightFromTerrainHeights(e, t, n, r) {
        var i, s = 0;
        for (var o = 0; o < e.length; o++) {
            var u = e[o];
            i = r ? onTerrainAltitudeOffset : n(u),
                u.absoluteHeightPositions == undefined && (u.absoluteHeightPositions = []);
            for (var a = 0; a < u.positions.length; a++) {
                var f = u.positions[a],
                    l = u.absoluteHeightPositions[a] = [];
                for (var c = 2; c < f.length; c += 3) {
                    var h = r ? 0 : f[c];
                    t[s].height == undefined && (t[s].height = 0),
                        l[c - 2] = f[c - 2],
                        l[c - 1] = f[c - 1],
                        l[c - 0] = f[c - 0],
                        l[c] = h + t[s].height + i,
                        s++;
                }
            }
        }
    }

    function linestringFeaturesToPositionsArray(e) {
        var t = [];
        for (var n = 0; n < e.length; n++)
            for (var r = 0; r < e[n].positions.length; r += 3) t.push(Cesium.Cartographic.fromDegrees(e[n].positions[r + 0], e[n].positions[r + 1], 0));
        return t
    }

    function convertLinestringsRelativeHeightToAbsoluteHeightFromTerrainHeights(e, t, n, r) {
        var i, s = 0;
        for (var o = 0; o < e.length; o++) {
            i = r ? onTerrainAltitudeOffset : n(e[o]);
            for (var u = 2; u < e[o].positions.length; u += 3) {
                t[s].height == undefined && (t[s].height = 0),
                    e[o].absoluteHeightPositions == undefined && (e[o].absoluteHeightPositions = []),
                    e[o].absoluteHeightPositions[u - 2] = e[o].positions[u - 2],
                    e[o].absoluteHeightPositions[u - 1] = e[o].positions[u - 1],
                    e[o].absoluteHeightPositions[u - 0] = e[o].positions[u - 0];
                var a = r ? 0 : e[o].positions[u];
                e[o].absoluteHeightPositions[u] = a + t[s].height + i,
                    s++;
            }
        }
    }

    function EntityCreator(e, viewer) {
        this._style = e || {};
        viewer.scene.onHoverShowTextArray = {};
        viewer.scene._lastObjectShowOnText = null;
        this.setEyeOffset = function (e, t) {
            t === undefined && (t = 0);
            e.eyeOffset = Cesium.DynamicEyeOffset(t);
        };
        this.viewer = viewer;
    }

    function addAltitudeOffsetToFeatureHeights(e, t) {
        var n = e.length;
        for (var r = 0; r < n; r++) {
            var i = t(e[r]);
            if (e[r].geometryType == "polygon" || e[r].geometryType == "multipolygon") {
                var s = e[r],
                    o = s.positions.length;
                for (var u = 0; u < o; u++) {
                    var a = s.positions[u];
                    for (var f = 2; f < a.length; f += 3) a[f] += i;
                    s.positions[u] = a;
                }
                e[r] = s;
            } else {
                var l = e[r],
                    c = l.positions.length;
                for (var u = 2; u < c; u += 3) l.positions[u] += i;
                e[r] = l;
            }
        }
        return e
    }

    function canAddFeature(e, t) {
        if (e.isQuery == undefined)
            if (e.originalInstanceIds == undefined) {
                if (e.parentLayer.isExistRenderedFeatureId(t)) return !1
            } else if (e.originalInstanceIds.indexOf(t) == -1) return !1;
        return !0
    }

    function getAltitudeOffsetFunc(e) {
        return function (t) {
            var n = Number(e.applyConditionalClassification(e._style.altitudeOffset, t.attributes));
            return isNaN(n) && (n = 0),
                n
        }
    }

    function teColorToCesiumColor(e) {
        if (typeof e != "string") return e;
        var t = Number(e);
        if (!isNaN(t)) {
            var n = t.toString(16);
            if (n.length < 6 && n != undefined) {
                var r = n.length;
                while (r < 6) n = "0" + n,
                    r++;
            }
            var i = "#" + n,
                s = Cesium.Color.fromCssColorString(i);
            if (s != undefined) {
                var o = s.red;
                s.red = s.blue,
                    s.blue = o;
            }
            return s
        }
        return e
    }

    function colorFromClassification(e) {
        if (e == undefined) return undefined;
        var t = parseInt(e);
        if (e.alpha == undefined && !isNaN(t)) {
            t < 0 && (t &= 16777215);
            var n = t.toString(16);
            if (n.length < 6 && n != undefined) {
                var r = n.length;
                while (r < 6) n = "0" + n,
                    r++;
            }
            var i = "#" + n;
            i = i.substring(0, 7);
            var s = Cesium.Color.fromCssColorString(i);
            if (s != undefined) {
                var o = s.red;
                s.red = s.blue,
                    s.blue = o;
            }
            return s
        }
        return e
    }

    function tryGetValueAsFloat(e) {
        return isNaN(e) ? e : parseFloat(e)
    }

    function applyClassificationFunc(e, t) {
        var n = [];
        $.each(e.attributeNames, function (e, r) {
            n.push(tryGetValueAsFloat(t[r]));
        });
        var r;
        return n.length === 1 ? r = e.func(n[0]) : e.attributeNames.length === 2 ? r = e.func(n[0], n[1]) : e.attributeNames.length === 3 ? r = e.func(n[0], n[1], n[2]) : e.attributeNames.length === 4 && (r = e.func(n[0], n[1], n[2], n[3])),
            r
    }

    function getClassificationValue(e, t) {
        if (e === undefined || e.condition.length === 0) return undefined;
        if (e.func === undefined) return tryGetValueAsFloat(e.value);
        var n = undefined,
            r = applyClassificationFunc(e, t);
        return r === !0 && (n = tryGetValueAsFloat(e.value)),
            n
    }

    function escapeRegExp(e) {
        return e.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1")
    }

    function replaceAll(e, t, n) {
        return e.replace(new RegExp(escapeRegExp(t), "g"), n)
    }

    var pointFeaturesToPositionsArray = linestringFeaturesToPositionsArray,
        convertPointsRelativeHeightToAbsoluteHeightFromTerrainHeights = convertLinestringsRelativeHeightToAbsoluteHeightFromTerrainHeights,
        onTerrainAltitudeOffset = 1;
    Object.defineProperties(EntityCreator.prototype, {
        style: {
            get: function () {
                return this._style
            },
            set: function (e) {
                this._style = e;
            }
        }
    });
    EntityCreator.prototype.clonePartOfMultiFeature = function (e, t) {
        return {
            positions: e.positions[t],
            attributes: e.attributes,
            fid: e.fid,
            geometryType: e.geometryType
        }
    };
    EntityCreator.prototype.createPrimitiveFromWFSFeatures = function (e) {
        new Cesium.PrimitiveCollection;
        //try {
        var n = [];
        var r = [];
        var i = [];
        e.features.numPositions = 0;
        for (var s = 0; s < e.features.length; s++) {
            var o = e.features[s];
            this.sanitizePositions(o.positions);
            e.features.numPositions += o.positions.length;
            switch (o.geometryType) {
                case "polygon":
                    n.push(o);
                    break;
                case "multipolygon":
                    var u = o.positions.length;
                    for (var a = 0; a < u; a++) n.push(this.clonePartOfMultiFeature(o, a));
                    break;
                case "linestring":
                    r.push(o);
                    break;
                case "multilinestring":
                    var u = o.positions.length;
                    for (var a = 0; a < u; a++) r.push(this.clonePartOfMultiFeature(o, a));
                    break;
                case "point":
                    i.push(o);
                    break;
                case "multipoint":
                    var u = o.positions.length;
                    for (var a = 0; a < u; a++) i.push(this.clonePartOfMultiFeature(o, a));
            }
        }
        // n.length > 0 ? (e.features = n, this.createPolygonPrimitive(e)) : r.length > 0 ? (e.features = r, this.createLinestringPrimitive(e)) : i.length > 0 && (e.features = i, this.createPointPrimitive(e))
        if (n.length > 0) {
            e.features = n;
            this.createPolygonPrimitive(e);
        } else if (r.length > 0) {
            e.features = r;
            this.createLinestringPrimitive(e);
        } else if (i.length > 0) {
            e.features = i;
            this.createPointPrimitive(e);
        }
        //} catch (f) {
        //    console.log("Failed to create primitive from features: " + f)
        //}
    };
    EntityCreator.prototype.createPolygonPrimitive = function (e) {
        var t = this,
            r = function (e) {
                if (e.isQuery) {
                    e.onFinishedQuery(i);
                    return
                }
                var r = "",
                    i = [],
                    s = [],
                    o = [],
                    u = [],
                    a = [];
                for (var f = 0; f < e.features.length; f++) {
                    var l = e.features[f];
                    if (!canAddFeature(e, l.fid)) continue;
                    var c = l.absoluteHeightPositions ? l.absoluteHeightPositions : l.positions,
                        h = t.createPolygonOptions(c, l.attributes),
                        p = t.createCommonOptions(l.attributes);
                    l.absoluteHeightPositions && delete l.absoluteHeightPositions,
                        i.push(Cesium.BoundingSphere.fromPoints(h.hierarchy.positions));
                    if (e.isQuery) continue;
                    if (h.outline) {
                        var d = t.createPolygonGeometryHelper(Cesium.PolygonOutlineGeometry, l, h.hierarchy, h.outlineColor, h.perPositionHeight, h.extrudedHeight, h.height);
                        o.push(d);
                    }
                    if (h.fill) {
                        var d = t.createPolygonGeometryHelper(Cesium.PolygonGeometry, l, h.hierarchy, h.material, h.perPositionHeight, h.extrudedHeight, h.height, h.water);
                        s.push(d);
                    }
                    e.parentLayer.addRenderedFeatureId(l.fid),
                        r += l.fid + ";",
                        u.push(l.fid),
                        a.push(p.tooltip);
                }

                if (r == "") return;
                var v = new Cesium.PrimitiveCollection;
                var m = new Cesium.PerInstanceColorAppearance({
                    flat: !0,
                    translucent: h.material.alpha < 1
                });
                if (s.length > 0) {
                    if (h.water) {
                        let waterOption = {
                            color: h.water.color || "rgba(135,206,235,0.6)", //水面的颜色
                            image: h.water.image || window.SmartEarthRootUrl + configData$1.water, // 水面贴图
                            frequency: h.water.frequency || 1000, // 水波数
                            speed: h.water.speed || 10, // 流速
                            amplitude: h.water.amplitude || 10.0, // 水波幅度
                        };
                        let color = Cesium.Color.fromCssColorString(waterOption.color);
                        m = new Cesium.EllipsoidSurfaceAppearance({
                            material: new Cesium.Material({
                                fabric: {
                                    type: 'Water',
                                    uniforms: {
                                        baseWaterColor: color,
                                        blendColor: color,
                                        normalMap: waterOption.image,
                                        frequency: waterOption.frequency,
                                        animationSpeed: waterOption.speed / 1000,
                                        amplitude: waterOption.amplitude
                                    }
                                }
                            })
                        });
                    }
                    var y;
                    if (h.clampToGround || (!h.perPositionHeight && !h.extrudedHeight && !h.height)) {
                        // clampToGround为true或未设置高度、拉伸高度且不使用每一个点的高度则贴地
                        y = new Cesium.GroundPrimitive({
                            geometryInstances: s,
                            appearance: m,
                            classificationType: h.classificationType
                        });
                    } else {
                        y = new Cesium.Primitive({
                            geometryInstances: s,
                            appearance: m
                        });
                    }
                    y._parentCollection = v,
                        v.add(y);
                }
                if (o.length > 0) {
                    if (!h.clampToGround) {
                        var y = new Cesium.Primitive({
                            geometryInstances: o,
                            appearance: m
                        });
                        y._parentCollection = v,
                            v.add(y);
                    }
                }
                v.ID = "polygons:" + _hashCode(r),
                    v._instanceIds = u,
                    v._tooltips = a,
                    e.onFinishedCreatePrimitive(v, i);
            },
            // i = this.style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_TERRAIN_ABSOLUTE;
            i = this.style.altitudeMethod == 3;
        if (!i) {
            var s = polygonFeaturesToPositionsArray(e.features);
            var o = Cesium.sampleRenderedData(s, Cesium.SampleRenderedDataFlags.TERRAIN | Cesium.SampleRenderedDataFlags.FLOOR);
            Cesium.when(o, function (n) {
                // var i = t._style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_ON_TERRAIN ? !0 : !1;
                var i = t._style.altitudeMethod == 2 ? !0 : !1;
                convertPolygonsRelativeHeightToAbsoluteHeightFromTerrainHeights(e.features, n, getAltitudeOffsetFunc(t), i),
                    r(e);
            });
        } else e.features = addAltitudeOffsetToFeatureHeights(e.features, getAltitudeOffsetFunc(t)),
            r(e);
    };
    EntityCreator.prototype.createPolygonGeometryHelper = function (e, t, n, r, i, s, h, water) {
        var o = s != undefined ? Cesium.PerInstanceColorAppearance.VERTEX_FORMAT : Cesium.PerInstanceColorAppearance.FLAT_VERTEX_FORMAT;
        (water !== undefined || h !== undefined) && (o = Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT);
        var u = new e({
            polygonHierarchy: n,
            vertexFormat: o,
            perPositionHeight: h !== undefined ? undefined : i,
            extrudedHeight: s,
            height: h
        }),
            a = new Cesium.GeometryInstance({
                geometry: u,
                id: t,
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(r)
                }
            });
        return a
    };
    EntityCreator.prototype.createLinestringPrimitive = function (e) {
        var t = this;
        var r = function (e) {
            if (e.isQuery) {
                e.onFinishedQuery(i);
                return
            }
            var r = "";
            var i = [];
            var s;
            var o = [];
            var u = [];
            let collection = new Cesium.PrimitiveCollection();
            for (var f = 0; f < e.features.length; f++) {
                var l = e.features[f];
                if (!canAddFeature(e, l.fid)) continue;
                var c = l.absoluteHeightPositions ? l.absoluteHeightPositions : l.positions;
                var h = t.createLinestringOptions(c, l.attributes);
                var p = t.createCommonOptions(l.attributes);
                var ZH_USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS = 0;
                // TerraExplorer.USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS && s == undefined && (s = h.widthInMeters && t.style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_ON_TERRAIN ? !0 : !1);
                ZH_USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS && s == undefined && (s = h.widthInMeters && t.style.altitudeMethod == 2 ? !0 : !1);
                h.vertexFormat = s ? Cesium.PerInstanceColorAppearance.VERTEX_FORMAT : Cesium.PolylineColorAppearance.VERTEX_FORMAT;
                l.absoluteHeightPositions && delete l.absoluteHeightPositions;
                i.push(Cesium.BoundingSphere.fromPoints(h.positions));
                if (e.isQuery) continue;
                var PolylineGeometry, geometryInstance;

                // if (s) {
                //     (h.height = c.reduce(function (e, t, n, r) {
                //         return (n + 1) % 3 == 0 ? e + t / (r.length / 3) : e
                //     }, 0), h.cornerType = Cesium.CornerType.MITERED, h.granularity = Cesium.Math.RADIANS_PER_DEGREE, d = new Cesium.CorridorGeometry(h))
                // } else {
                //     d = new Cesium.PolylineGeometry(h);
                // }
                // var v = s ? TerraExplorer.USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS > 1 ? undefined : new Cesium.ZBiasGeometryInstanceAttribute(.1) : Cesium.ZBiasGeometryInstanceAttribute.defaultBias();
                // var v = s ? ZH_USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS > 1 ? undefined : new Cesium.ZBiasGeometryInstanceAttribute(.1) : Cesium.ZBiasGeometryInstanceAttribute.defaultBias();

                if (h.clampToGround) {
                    PolylineGeometry = new Cesium.GroundPolylineGeometry({
                        positions: h.positions,
                        width: h.width,
                    });
                    geometryInstance = new Cesium.GeometryInstance({
                        id: l,
                        geometry: PolylineGeometry,
                        attributes: {
                            color: new Cesium.ColorGeometryInstanceAttribute.fromColor(h.material),
                        }
                    });
                } else {
                    PolylineGeometry = new Cesium.PolylineGeometry(h);
                    geometryInstance = new that._cesium.GeometryInstance({
                        id: l,
                        geometry: PolylineGeometry,
                        attributes: {
                            color: new Cesium.ColorGeometryInstanceAttribute.fromColor(h.material),
                        }
                    });
                }
                // a.push(geometryInstance);
                e.parentLayer.addRenderedFeatureId(l.fid);
                r += l.fid + ";";
                o.push(l.fid);
                u.push(p.tooltip);

                let primitive = null;
                //添加
                if (h.clampToGround) {
                    primitive = new Cesium.GroundPolylinePrimitive({
                        geometryInstances: geometryInstance,
                        appearance: new Cesium.MaterialAppearance({
                            material: new Cesium.Material({
                                fabric: {
                                    type: 'Color',
                                    uniforms: {
                                        color: h.material
                                    }
                                }
                            }),
                            faceForward: true,
                            flat: false
                        }),
                        classificationType: h.classificationType
                    });
                } else {
                    primitive = new Cesium.Primitive({
                        geometryInstances: geometryInstance,
                        appearance: new Cesium.PolylineMaterialAppearance({
                            material: new Cesium.Material({
                                fabric: {
                                    type: 'Color',
                                    uniforms: {
                                        color: h.material
                                    }
                                }
                            }),
                        })
                    });
                }
                collection.add(primitive);
            }

            if (r == "") return;
            // var g = s ? Cesium.PerInstanceColorAppearance : Cesium.PolylineColorAppearance;
            // var y = s ? TerraExplorer.USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS > 1 ? Cesium.GroundPrimitive : Cesium.Primitive : Cesium.Primitive;
            // var y = s ? ZH_USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS > 1 ? Cesium.GroundPrimitive : Cesium.Primitive : Cesium.Primitive;

            var b = collection;
            // var b = new y({
            //     geometryInstances: a,
            //     appearance: new g({
            //         translucent: h.material.alpha < 1,
            //         closed: !1
            //     }),
            //     asynchronous: !0
            // });
            // n;
            b.ID = "polylines:" + _hashCode(r);
            b._instanceIds && b._instanceIds.length === 0 && (b._instanceIds = o);
            b._tooltips = u;

            e.onFinishedCreatePrimitive(b, i);
        },
            // i = this.style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_TERRAIN_ABSOLUTE;
            i = this.style.altitudeMethod == 3;
        if (!i) {
            var s = linestringFeaturesToPositionsArray(e.features);
            var o = Cesium.sampleRenderedData(s, Cesium.SampleRenderedDataFlags.TERRAIN | Cesium.SampleRenderedDataFlags.FLOOR);
            Cesium.when(o, function (n) {
                // var i = t._style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_ON_TERRAIN ? !0 : !1;
                var i = t._style.altitudeMethod == 2 ? !0 : !1;
                convertLinestringsRelativeHeightToAbsoluteHeightFromTerrainHeights(e.features, n, getAltitudeOffsetFunc(t), i);
                r(e);
            });
        } else e.features = addAltitudeOffsetToFeatureHeights(e.features, getAltitudeOffsetFunc(t)),
            r(e);
    };
    EntityCreator.prototype.createPointPrimitive = function (e) {
        var t = this;
        var n = function (e) {
            if (e.isQuery) {
                e.onFinishedQuery(i);
                return
            }
            var n = "";
            var r = [];
            var i = [];
            var s = [];
            var o;
            var u = new Cesium.LabelCollection({ scene: t.viewer.scene });
            var a = new Cesium.PointPrimitiveCollection({ scene: t.viewer.scene });
            var f = new Cesium.BillboardCollection({ scene: t.viewer.scene });
            var l = new Cesium.PrimitiveCollection;
            var c = new Cesium.PolylineCollection;
            for (var h = 0; h < e.features.length; h++) {
                var p = e.features[h];
                if (!canAddFeature(e, p.fid)) continue;
                var d = p.absoluteHeightPositions ? p.absoluteHeightPositions : p.positions;
                var v = t.createPointOptions(d, p.attributes);
                var m = t.createCommonOptions(p.attributes);
                p.clampToGround = v.clampToGround;
                v.sgsPointPosition && (p.sgsPointPosition = v.sgsPointPosition, delete v.sgsPointPosition);
                p.absoluteHeightPositions && delete p.absoluteHeightPositions;
                i.push(Cesium.BoundingSphere.fromPoints([v.position]));
                if (e.isQuery) continue;
                if (v.label) {
                    v.label.position = v.position;
                    v.label.id = p;
                    t.setEyeOffset(v.label);
                    // v.label.imageFile != undefined && (v.label.image = t.applyConditionalClassification(v.label.imageFile, p.attributes), v.label.label = v.label, f.add(v.label), t.setEyeOffset(v.label, -5));
                    // v.label.imageFile != undefined && v.label.showText != undefined && v.label.showText && (t.viewer.scene.onHoverShowTextArray[v.label.id] = !0);
                    if (v.label.imageFile != undefined) {
                        v.label.image = t.applyConditionalClassification(v.label.imageFile, p.attributes);
                        v.label.label = v.label;
                        f.add(v.label);
                        t.setEyeOffset(v.label, -5);
                    }
                    if (v.label.imageFile != undefined && v.label.showText != undefined && v.label.showText) {
                        t.viewer.scene.onHoverShowTextArray[v.label.id] = !0;
                    }
                    if (v.label.isBold != undefined && v.label.isBold) {
                        //v.label.image != undefined && delete v.label.image;
                        //var g = $.extend({}, v.label);
                        //g.outlineColor = v.label.fillColor;
                        //g.style = Cesium.LabelStyle.FILL_AND_OUTLINE;
                        //t.setEyeOffset(g, -5);
                        //g.outlineWidth = 1;
                        u.add(g);
                    } else if (v.label.isUnderline != undefined && v.label.isUnderline) {
                        var y = "_";
                        var b = v.label.text.match(/[iljf1]/g) != null ? v.label.text.match(/[iljf1]/g) : [];
                        var w = v.label.text.length;
                        var E = Array(Math.ceil(w - b.length * .5)).join(y);
                        o = $.extend({}, v.label);
                        v.label.image != undefined && delete v.label.image;
                        o.position = v.label.position;
                        o.id = v.label.id;
                        o.text = E;
                        o.alignment = v.label.alignment != undefined ? v.label.alignment : undefined;
                        o.underline = !0;
                        o.textRelativeToImage = v.label.textRelativeToImage != undefined ? v.label.textRelativeToImage : undefined;
                        v.label.font.indexOf("pt") > -1 ? Number(v.label.font.split("pt")[0]) * 4 / 3 : v.label.font.indexOf("px") > -1 ? Number(v.label.font.split("px")[0]) : 5;
                        o.pixelOffset = new Cesium.Cartesian2(0, -45),
                            u.add(o);
                    } else u.add(v.label);
                }
                v.billboard && (v.billboard.position = v.position, v.billboard.id = p, t.setEyeOffset(v.billboard), f.add(v.billboard));
                if (v.model) {
                    v.model.url = v.model.uri;
                    v.model.id = p;
                    l.add(Cesium.Model.fromGltf(v.model));
                }
                v.point && (v.point.position = v.position, v.point.id = p, t.setEyeOffset(v.point), a.add(v.point));
                if (v.lineToGround != 0) {
                    var T = Cesium.Cartographic.fromCartesian(v.position);
                    var N = Cesium.Cartesian3.fromRadians(T.longitude, T.latitude, 0);
                    if (v.lineToGround == 2) {
                        var C = v.lineToGroundLength / Cesium.Cartesian3.distance(v.position, N);
                        Cesium.Cartesian3.lerp(v.position, N, C, N);
                    }
                    c.add({
                        show: !0,
                        width: 1,
                        positions: [v.position, N],
                        material: Cesium.Material.fromType("Color", {
                            color: v.lineToGroundColor
                        })
                    });
                }
                e.parentLayer.addRenderedFeatureId(p.fid);
                n += p.fid + ";";
                r.push(p.fid);
                s.push(m.tooltip);
            }

            if (n == "") return;
            var k, L = new Cesium.PrimitiveCollection;
            // u.length > 0 && ($.each(u._labels, function (e, t) {
            //     t._type = "Label"
            // }), u._billboardCollection._parentCollection = L, L.add(u), k = "labels");

            // f.length > 0 && ($.each(f._billboards, function (e, t) {
            //     t._type = "Billboard"
            // }), f._parentCollection = L, L.add(f), k = "billboards");

            // l.length > 0 && ($.each(l._primitives, function (e, t) {
            //     t._type = "Model",
            //         t._parentCollection = L
            // }), L.add(l), k = "models");

            // a.length > 0 && ($.each(a._pointPrimitives, function (e, t) {
            //     t._type = "Point"
            // }), a._parentCollection = L, L.add(a), k = "points");

            // c.length > 0 && ($.each(c._polylines, function (e, t) {
            //     t._type = "L2G"
            // }), c._parentCollection = L, L.add(c), k = "L2G");

            if (u.length > 0) {
                $.each(u._labels, function (e, t) {
                    t._type = "Label";
                });
                u._billboardCollection._parentCollection = L;
                L.add(u);
                k = "labels";
            }

            if (f.length > 0) {
                $.each(f._billboards, function (e, t) {
                    t._type = "Billboard";
                });
                f._parentCollection = L;
                L.add(f);
                k = "billboards";
            }

            if (l.length > 0) {
                $.each(l._primitives, function (e, t) {
                    t._type = "Model";
                    t._parentCollection = L;
                });
                L.add(l);
                k = "models";
            }

            if (a.length > 0) {
                $.each(a._pointPrimitives, function (e, t) {
                    t._type = "Point";
                });
                a._parentCollection = L;
                L.add(a);
                k = "points";
            }

            if (c.length > 0) {
                $.each(c._polylines, function (e, t) {
                    t._type = "L2G";
                });
                c._parentCollection = L;
                L.add(c);
                k = "L2G";
            }


            L.ID = k + ":" + _hashCode(n);
            L._instanceIds = r;
            L._tooltips = s;
            e.onFinishedCreatePrimitive(L, i);
        };
        // r = this.style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_TERRAIN_ABSOLUTE;
        var r = this.style.altitudeMethod == 3;
        if (!r) {
            var i = pointFeaturesToPositionsArray(e.features);
            var s = Cesium.sampleRenderedData(i);
            Cesium.when(s, function (r) {
                // var i = t._style.altitudeMethod == TerraExplorer.internal.TEPosition.ATC_ON_TERRAIN ? !0 : !1;
                var i = t._style.altitudeMethod == 2 ? !0 : !1;
                convertPointsRelativeHeightToAbsoluteHeightFromTerrainHeights(e.features, r, getAltitudeOffsetFunc(t), i);
                n(e);
            }).otherwise(function (o) {
            });
        } else {
            e.features = addAltitudeOffsetToFeatureHeights(e.features, getAltitudeOffsetFunc(t));
            n(e);
        }
    };
    EntityCreator.prototype.createCommonOptions = function (e) {
        var t = {};
        return t.tooltip = this.applyConditionalClassification(this.style.tooltip, e),
            t
    };
    EntityCreator.prototype.createPolygonOptions = function (e, t) {
        var n = this.getPolygonStyle(this.style);
        n.polygon.hierarchy = {
            positions: Cesium.Cartesian3.fromDegreesArrayHeights(e[0]),
            holes: []
        };
        for (var r = 1; r < e.length; r++) n.polygon.hierarchy.holes.push({
            positions: Cesium.Cartesian3.fromDegreesArrayHeights(e[r])
        });
        var i = this.applyConditionalClassification(n.polygon.material, t);
        n.polygon.material = teColorToCesiumColor(i);
        if (n.polygon.fill != undefined && n.polygon.fromKml != undefined) {
            var s = this.applyConditionalClassification(n.polygon.fill, t);
            s > 1 && (s /= 100),
                n.polygon.material = new Cesium.Color(n.polygon.material.red, n.polygon.material.green, n.polygon.material.blue, s);
        }
        //薛鹏修改
        if (n.polygon.extrudedHeight && n.polygon.extrudedHeight && n.polygon.extrudedHeight.indexOf && n.polygon.extrudedHeight.indexOf("[") > -1 && n.polygon.extrudedHeight.defaultValue.indexOf("]") > -1) {
            var i = t[n.polygon.extrudedHeight.defaultValue.substring(1, n.polygon.extrudedHeight.defaultValue.length - 1)];
            var i = parseInt(i);
            i !== undefined && (n.polygon.extrudedHeight = i * 3);
        }
        if (t.FSCALE) {
            var f = this.getLevelDistance(t.FSCALE);
            n.polygon.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(1, f);
        }
        return i = this.applyConditionalClassification(n.polygon.outlineColor, t),
            n.polygon.outlineColor = teColorToCesiumColor(i),
            n.polygon
    };
    EntityCreator.prototype.translateLineWidth = function (e, t) {
        var n = this.applyConditionalClassification(e.polyline.width, t);
        return n > 0 ? TerraExplorer.USE_CORRIDOR_FOR_LINE_WIDTH_IN_METERS ? n > 1 && (e.polyline.widthInMeters = !0, n *= .8, e.polyline.backgroundOpacity > 0 && (n *= .8)) : n = n > 1 ? 2 : 1 : n < 0 ? n = Math.min(5, Math.abs(n)) : n == 0 && (n = 1),
            n
    };
    EntityCreator.prototype.createLinestringOptions = function (e, t) {
        var n = this.getLinestringStyle(this.style);
        n.id = t;
        n.polyline.positions = Cesium.Cartesian3.fromDegreesArrayHeights(e);
        var r = this.applyConditionalClassification(n.polyline.material, t);
        n.polyline.material = teColorToCesiumColor(r);
        if (n.polyline.lineOpacity != undefined) {
            var i = this.applyConditionalClassification(n.polyline.lineOpacity, t);
            i > 1 && (i /= 100),
                n.polyline.material = new Cesium.Color(n.polyline.material.red, n.polyline.material.green, n.polyline.material.blue, i);
        }
        if (n.polyline.far) {
            n.polyline.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(n.polyline.near !== undefined ? n.polyline.near : 0, n.polyline.far);
        }
        if (t.FSCALE) {
            var f = this.getLevelDistance(t.FSCALE);
            n.polyline.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(1, f);
        }
        //return n.polyline.width = this.translateLineWidth(n, t),
        //    n.polyline
        return n.polyline.width = this.applyConditionalClassification(n.polyline.width, t),
            n.polyline
    };
    EntityCreator.prototype.applyConditionalClassification = function (e, t) {
        if (e == undefined) return undefined;
        if (e.defaultValue == undefined) return e;
        var n = tryGetValueAsFloat(e.defaultValue);
        if (e.classificationArray === undefined) {
            if (!isNaN(n))
                return n;
            if (n instanceof Cesium.Color)
                return n
        }
        if (e.attributeName !== undefined) {
            var r = "[" + e.attributeName + "]";
            if (n === r)
                n = t[e.attributeName];
            else if (e.multipleAttributeReplacementNeeded) {
                for (name in t)
                    n = replaceAll(n, "[" + name + "]", t[name]);
            } else {
                n = replaceAll(n, r, t[e.attributeName]);
            }
            return n
        }
        if (e.classification !== undefined) return n = applyClassificationFunc(e.classification, t),
            n;
        var i = e.classificationArray;
        return i !== undefined ? ($(Object.keys(i)).each(function (e, r) {
            var s = getClassificationValue(i[r], t);
            s && (n = s);
        }), n) : n
    };
    EntityCreator.prototype.createLineToGroundOptions = function (e, t) {
        var n = this.applyConditionalClassification(e.lineToGround, t);
        if (n != undefined && Number(n) != 0) {
            e.lineToGround = n;
            var r = this.applyConditionalClassification(e.lineToGroundColor, t);
            r = colorFromClassification(r),
                e.lineToGroundColor = r;
            var i = this.applyConditionalClassification(e.lineToGroundLength, t);
            e.lineToGroundLength = Number(i);
        } else e.lineToGround = 0,
            e.lineToGroundColor = 0,
            e.lineToGroundLength = 0;
    };
    EntityCreator.prototype.createPointOptions = function (e, t) {
        var n = this.getPointStyle(this.style);
        //张丹钊修改
        if (n.pointHeight) {
            n.position = Cesium.Cartesian3.fromDegrees(e[0], e[1], n.pointHeight);
            e[2] = n.pointHeight;
        } else {
            n.position = Cesium.Cartesian3.fromDegrees(e[0], e[1], e[2]);
        }
        n.sgsPointPosition = e;
        n.id = t;
        if (n.label) {
            var r = n.label.text;
            // if (r !== undefined && r.indexOf("[") > -1 && r.indexOf("]") > -1) {
            if (r !== undefined && r.defaultValue.indexOf("[") > -1 && r.defaultValue.indexOf("]") > -1) {
                var i = t[r.defaultValue.substring(1, r.defaultValue.length - 1)];
                i !== undefined && (n.label.text = i);
            }
            if (this.applyConditionalClassification(n.label.text, t))
                n.label.text = this.applyConditionalClassification(n.label.text, t).toString();
            else
                n.label.text = this.applyConditionalClassification(n.label.text, t);

            //function s(e) {
            //    return e.split("").reverse().join("")
            //}

            //function o(e) {
            //    if (!e) return e;
            //    var t = "A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿Ⰰ-﬜﷾-﹯﻽-￿",
            //        n = "֑-߿יִ-﷽ﹰ-ﻼ",
            //        r = new RegExp("^[^" + t + "]*[" + n + "]");
            //    return r.test(e[0])
            //}
            //n.label.text = o(n.label.text) ? s(n.label.text) : n.label.text;
            //薛鹏修改
            n.label.text = this.o(n.label.text) ? this.s(n.label.text) : n.label.text;
            if (n.label.text.indexOf("[") > -1 && n.label.text.indexOf("]") > -1) {
                n.label.text = '';
            }
            if (n.label.family != undefined) {
                var u = this.applyConditionalClassification(n.label.family, t),
                    a = this.applyConditionalClassification(n.label.font, t);
                a >= 0 ? n.label.font = convertFontSizeToTEFontSize(a).toString() + "pt " + u : n.label.font = convertFontSizeToTEFontSize(getFontSizeInPixels(a)).toString() + "pt " + u;
            }
            n.label.fillColor = colorFromClassification(this.applyConditionalClassification(n.label.fillColor, t)),
                n.label.backgroundColor = colorFromClassification(this.applyConditionalClassification(n.label.backgroundColor, t)),
                n.label.backgroundColor == undefined && (n.label.backgroundColor = new Cesium.Color(.165, .165, .165, 0)),
                n.label.showBackground = !0;
            if (n.label.showText != undefined) {
                var f = this.applyConditionalClassification(n.label.showText, t);
                f && Number(f) === 1 && (n.label.onHoverShowText = !0);
                if (f && viewer.scene.canvas.onHoverShowText == undefined) {
                    var l = viewer.scene,
                        c = new Cesium.ScreenSpaceEventHandler(l.canvas);
                    c.setInputAction(function (e) {
                        var t = {};
                            l.screenToWorld(e.endPosition, t);
                        Cesium.defined(t.pickPrimitive) && t.pickPrimitive.constructor.name == "Billboard" && t.pickPrimitive.label != undefined ? l.onHoverShowTextArray[t.pickPrimitive.label.id] != undefined && (l._lastObjectShowOnText != null && l._lastObjectShowOnText.id != t.pickPrimitive.label.id && l._lastObjectShowOnText.show != undefined && (l._lastObjectShowOnText.show = !1), viewer.scene._lastObjectShowOnText = l.onHoverShowTextArray[t.pickPrimitive.label.id], l._lastObjectShowOnText.show != undefined && (viewer.scene._lastObjectShowOnText.show = !0)) : l._lastObjectShowOnText != null && l._lastObjectShowOnText.show != undefined && (l._lastObjectShowOnText.show = !1);
                    }, Cesium.ScreenSpaceEventType.MOUSE_MOVE),
                        viewer.scene.canvas.onHoverShowText = !0;
                }
            }
            n.label.textRelativeToImage != undefined && n.label.textAlignment != undefined && (n.label.textRelativeToImage = this.applyConditionalClassification(n.label.textRelativeToImage, t), n.label.alignment = this.applyConditionalClassification(n.label.textAlignment, t)),
                n.label.underline != undefined && (n.label.isUnderline = this.applyConditionalClassification(n.label.underline, t));
            // n.label.bold != undefined && (n.label.isBold = this.applyConditionalClassification(n.label.bold, t));
            if (n.label.bold != undefined) {
                var h = this.applyConditionalClassification(n.label.bold, t);
                h == 1 && (n.label.font = "bold " + n.label.font);
            }
            if (n.label.italic != undefined) {
                var h = this.applyConditionalClassification(n.label.italic, t);
                h == 1 && (n.label.font = "italic " + n.label.font);
            }

            n.label.backgroundOpacity != undefined && (n.label.backgroundColor.alpha = this.applyConditionalClassification(n.label.backgroundOpacity, t));
            //薛鹏修改
            //var p = parseFloat(n.label.scale.defaultValue);
            //n.label.scale = clamp(this.applyConditionalClassification(n.label.scale, t) / p, .7, 1.3),
            //    n.label.scale = this.applyConditionalClassification(n.label.scale, t);
            if (n.label.minViewingHeight != undefined) {
                var d = this.applyConditionalClassification(n.label.minViewingHeight, t),
                    v = this.applyConditionalClassification(n.label.scaleMPP, t) * 650;
                n.label.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(d, v);
            }
            if (t.FSCALE) {
                var f = this.getLevelDistance(t.FSCALE);
                n.label.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(1, f);
            }
            !n.label.disableDepthTestDistance && (n.label.disableDepthTestDistance = 1000);
            n.clampToGround && (n.label.heightReference = 1);
            // isNaN(n.label.scale) && (n.label.scale = 1.5);
            //张丹钊修改（影响远近可视）
            // if (n.label.limitGrowth != undefined && n.label.scaleMPP != undefined) {
            //     var m = this.applyConditionalClassification(n.label.limitGrowth, t),
            //         g = this.applyConditionalClassification(n.label.scaleMPP, t) * 1e3;
            //     m ? n.label.scaleByDistance = new Cesium.NearFarScalar(g, 1, g * 10, 0) : n.label.scaleByDistance = new Cesium.NearFarScalar(15, 50, g * 10, .1)
            // }
        }
        if (n.billboard) {
            n.billboard.sizeInMeters = !1;
            if (n.billboard.imageColor != undefined) {
                var y = this.applyConditionalClassification(n.billboard.imageColor, t);
                y = colorFromClassification(y),
                    n.billboard.color = y;
            }
            n.billboard.imageOpacity != undefined && n.billboard.color.alpha != undefined && (n.billboard.color.alpha = Number(this.applyConditionalClassification(n.billboard.imageOpacity, t))),
                n.billboard.image = this.applyConditionalClassification(n.billboard.image, t);
            //张丹钊修改（影响远近可视）
            // if (n.billboard.limitGrowth != undefined && n.billboard.scaleTE != undefined) {
            //     var m = this.applyConditionalClassification(n.billboard.limitGrowth, t);
            //     m.defaultValue == undefined && !isNaN(Number(m)) && (m = Number(m));
            //     var g = this.applyConditionalClassification(n.billboard.scaleTE, t) * 1e3;
            //     m ? n.billboard.scaleByDistance = new Cesium.NearFarScalar(g, 1, g * 10, 0) : (n.billboard.sizeInMeters = !0, n.billboard.scaleByDistance = new Cesium.NearFarScalar(g, g / 1e3, g * 10, g / 1e3))
            // }
            if (n.billboard.minViewingHeight != undefined) {
                var d = this.applyConditionalClassification(n.billboard.minViewingHeight, t),
                    v = this.applyConditionalClassification(n.billboard.scaleMPP, t) * 650;
                n.billboard.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(d, v);
            }
            if (t.FSCALE) {
                var f = this.getLevelDistance(t.FSCALE);
                n.billboard.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(1, f);
            }
            if (n.billboard.link) {
                n.id && typeof n.id === 'object' && (n.id.link = this.applyConditionalClassification(n.billboard.link, t));
            }
            !n.billboard.disableDepthTestDistance && (n.billboard.disableDepthTestDistance = 1000);
            n.clampToGround && (n.billboard.heightReference = 1);
        }
        if (n.model) {
            var b = function (e) {
                var t = Number(e);
                if (!Cesium.defined(t) || isNaN(t)) t = 0;
                return t
            };
            n.model.uri = this.applyClassification(n.model.uri, t),
                n.model.scale = b(this.applyClassification(n.model.scale, t));
            var w = b(this.applyClassification(n.model.heading, t)),
                E = b(this.applyClassification(n.model.pitch, t)),
                S = b(this.applyClassification(n.model.roll, t)),
                x = new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(w), Cesium.Math.toRadians(E), Cesium.Math.toRadians(S));
            n.model.modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(n.position, x);
        }
        return this.createLineToGroundOptions(n, t),
            n
    },
        //薛鹏修改
        EntityCreator.prototype.s = function (e) {
            return e.split("").reverse().join("");
        },
        //张丹钊添加
        EntityCreator.prototype.getLevelDistance = function (level) {
            var distance = 20000000;
            switch (parseInt(level)) {
                case 2: distance = 10123000; break;
                case 3: distance = 7123000; break;
                case 4: distance = 6321000; break;
                case 5: distance = 5522000; break;
                case 6: distance = 3436000; break;
                case 7: distance = 539000; break;
                case 8: distance = 305000; break;
                case 9: distance = 180000; break;
                case 10: distance = 133000; break;
                case 11: distance = 100000; break;
                case 12: distance = 76500; break;
                case 13: distance = 58200; break;
                case 14: distance = 23500; break;
                case 15: distance = 9600; break;
                case 16: distance = 4000; break;
                case 17: distance = 2000; break;
                case 18: distance = 1700; break;
                case 19: distance = 1500; break;
                case 20: distance = 1000; break;
                case 21: distance = 500; break;
                case 22: distance = 200; break;
                case 23: distance = 100; break;
            }
            return distance;
        };
    EntityCreator.prototype.o = function (e) {
        if (!e) return e;
        var t = "A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿Ⰰ-﬜﷾-﹯﻽-￿",
            n = "֑-߿יִ-﷽ﹰ-ﻼ",
            r = new RegExp("^[^" + t + "]*[" + n + "]");
        return r.test(e[0]);
    };
    EntityCreator.prototype.applyClassification = function (text, attributes) {
        if ($.type(text) !== "string") return text;
        if (/(\[([^\]]+)\])/g.exec(text) != null)
            for (var attr in attributes) text = replaceAll(text, "[" + attr + "]", attributes[attr]);
        text == "undefined" && (text = "");
        var myRegexp = /(\<([^\>]+)\>)/g,
            match = myRegexp.exec(text);
        while (match != null) {
            try {
                var expression = match[match.length - 1],
                    value = (0, eval)(expression);
                text = text.replace(match[0], value);
            } catch (e) {
            }
            match = myRegexp.exec(text);
        }
        return text
    };
    EntityCreator.prototype.getPolygonStyle = function (e) {
        var t = $.extend(!0, {}, PredefinedFeatureStyles.DEFAULT_POLYGON_STYLE, e);
        return t
    };
    EntityCreator.prototype.getLinestringStyle = function (e) {
        var t = $.extend(!0, {}, PredefinedFeatureStyles.DEFAULT_POLYLINE_STYLE, e);
        return t
    };
    EntityCreator.prototype.getPointStyle = function (e) {
        if (e.label != undefined) {
            var t = $.extend(!0, {}, PredefinedFeatureStyles.DEFAULT_LABEL_STYLE, e);
            return t
        }
        if (e.billboard != undefined) {
            var n = $.extend(!0, {}, PredefinedFeatureStyles.DEFAULT_BILLBOARD_STYLE, e);
            return n
        }
        if (e.model != undefined) {
            var r = $.extend(!0, {}, PredefinedFeatureStyles.DEFAULT_MODEL_STYLE, e);
            return r
        }
        if (e.point != undefined) {
            var i = $.extend(!0, {}, PredefinedFeatureStyles.DEFAULT_POINT_STYLE, e);
            return i
        }
        return PredefinedFeatureStyles.DEFAULT_POINT_STYLE
    };
    EntityCreator.prototype.sanitizePositions = function (e) {
        for (var t = 0; t < e.length; t++) e[t] instanceof Array ? this.sanitizePositions(e[t]) : isNaN(e[t]) && (e[t] = 0);
    };
    var PredefinedFeatureStyles = {};
    Object.defineProperties(PredefinedFeatureStyles, {
        DEFAULT_POLYGON_STYLE: {
            get: function () {
                return {
                    polygon: {
                        perPositionHeight: !0,
                        fill: 0,
                        material: Cesium.Color.GREEN,
                        outline: true,
                        outlineColor: Cesium.Color.WHITE,
                        outlineWidth: 1
                    }
                }
            }
        },
        DEFAULT_POLYLINE_STYLE: {
            get: function () {
                return {
                    polyline: {
                        material: Cesium.Color.WHITE,
                        width: 1
                    }
                }
            }
        },
        DEFAULT_POINT_STYLE: {
            get: function () {
                return {
                    point: {
                        color: Cesium.Color.RED,
                        pixelSize: 5,
                        outlineColor: Cesium.Color.WHITE,
                        outlineWidth: 2
                    }
                }
            }
        },
        DEFAULT_LABEL_STYLE: {
            get: function () {
                return {
                    label: {
                        text: "Text",
                        font: "18px arial",
                        style: Cesium.LabelStyle.FILL,
                        fillColor: Cesium.Color.WHITE,
                        outlineColor: Cesium.Color.BLACK,
                        outlineWidth: 5,
                        scale: 1,
                        horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                        eyeOffset: Cesium.Cartesian3.ZERO,
                        pixelOffset: new Cesium.Cartesian2(0, -50)
                    }
                }
            }
        },
        DEFAULT_BILLBOARD_STYLE: {
            get: function () {
                return {
                    billboard: {
                        image: "./img/query.png",
                        scale: 1,
                        horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM
                    }
                }
            }
        },
        DEFAULT_MODEL_STYLE: {
            get: function () {
                return {
                    model: {
                        uri: "./img/CesiumTexturedBoxTest.bgltf",
                        scale: 1e3
                    }
                }
            }
        }
    });

    /**
     *
     * @param {Object} e viewer
     * @param {String} t url "http://192.168.1.40:8090/geoserver/swagger/wms?"
     * @param {String} n name "swagger:point"
     * @param {Object} r level 2
     * @param {Object} i style-billboard "{"billboard":{"color":{"red":1,"green":1,"blue":1,"alpha":1},"image":{"defaultValue":"http://localhost/SG/resources/397940/defaultIcon.gif"},"imageColor":{"defaultValue":{"red":1,"green":1,"blue":1,"alpha":1}},"imageOpacity":{"defaultValue":"1"},"scaleTE":{"defaultValue":"15000"},"limitGrowth":{"defaultValue":"1"},"minViewingHeightObj":{"defaultValue":"0"}},"lineToGround":{"defaultValue":"0"},"lineToGroundLength":{"defaultValue":"0"},"lineToGroundColor":{"defaultValue":{"red":1,"green":1,"blue":1,"alpha":1}},"altitudeMethod":0,"altitudeOffset":{"defaultValue":"0"}}"
     *                   style-polygon   "{"polygon":{"outlineColor":{"defaultValue":{"red":1,"green":1,"blue":1,"alpha":1}},"outlineWidth":1,"fill":{"defaultValue":"0"},"outline":{"defaultValue":"1"},"material":{"defaultValue":{"red":0.39215686274509803,"green":0.39215686274509803,"blue":0.39215686274509803,"alpha":1}},"fromKml":true},"altitudeMethod":2,"altitudeOffset":{"defaultValue":"0"}}"
     * @param {String} s displayName "swagger:point"
     * @param {Object} o subdomains undefined
     * @param {Object} u latlon undefined
     * @param {Object} a myLayer undefined
     */
    var TileManager$3;
    function WfsLayer(e, t, n, r, i, s, o, u, a) {
        var _that = this;
        this._viewer = e;
        this._Viewer = e;
        _that.G = 65535;
        TileManager$3 = new TileManager1();
        workerPool = new WorkerPool({
            //workerPath: "./wfs/featurefetcherworker.js"
            workerPath: lj$2()
        });

        if (!Cesium.sampleRenderedData) {
            if (Cesium.Resource) {
                Cesium.loadText = Cesium.Resource.fetchText;
                Cesium.loadJson = Cesium.Resource.fetchJson;
                Cesium.loadBlob = Cesium.Resource.fetchBlob;
                Cesium.loadArrayBuffer = Cesium.Resource.fetchArrayBuffer;
                Cesium.loadImage = Cesium.Resource.fetchImage;
            }

            function K(e, t) {
                function r() {
                    e.ready ? Cesium.when(J(e, t), function (e) {
                        n.resolve(e);
                    }) : setTimeout(r, 10);
                }

                Cesium.Check.typeOf.object("terrainProvider", e),
                    Cesium.Check.defined("positions", t);
                var n = Cesium.when.defer();
                return r(),
                    n.promise
            }

            function V(e, t) {
                for (var n = 0; n < e.children.length; n++) {
                    var r = e.children[n].state >= Cesium.QuadtreeTileLoadState.DONE && (e.children[n].data.terrainData._mesh != undefined || e.children[n].data.terrainData._buffer != undefined);
                    if (r && e.children[n].x == t.x && e.children[n].y == t.y) return e.children[n]
                }
                return undefined
            }

            function $$$(e, t) {
                var n = e.tilingScheme,
                    r = n.positionToTileXY(t, 0),
                    i = _that._Viewer.scene.globe._surface.tileProvider.quadtree._levelZeroTiles,
                    s = i[0].x == r.x && i[0].y == r.y ? i[0] : i[1];
                for (var o = 1; o < 22; o++) {
                    r = n.positionToTileXY(t, o);
                    var u = V(s, r);
                    if (u == undefined) break;
                    s = u;
                }
                return s
            }

            function Z(e, t) {
                Cesium.Check.defined("positions", e);
                var n = Cesium.when.defer();
                return Cesium.when(Y(e), function (e) {
                    n.resolve(e);
                }),
                    n.promise
            }

            function Y(t, n) {
                $.grep(_that._Viewer.scene.primitives._primitives, function (e) {
                    return e instanceof Cesium.Cesium3DTileset
                });
                    var i;
                for (i = 0; i < t.length; ++i) {
                    var s = t[i],
                        o = s instanceof Cesium.Cartographic,
                        u = o ? s : Cesium.Cartographic.fromCartesian(s);
                    u.height = _that.G;
                    // r.forEach(function (e) {
                    //     if (e.ready && e.show) {
                    //         var t = Q(e, u, n);
                    //         t !== undefined && (n ? t.content && t.content._model && t.content._model.floor && (u.height = t.content._model.floor.getHeight(u.longitude, u.latitude), _that.G = t.content._model.floor.nullValue) : u.height = t._boundingVolume.maximumHeight)
                    //     }
                    // });
                    if (!o) {
                        var a = Cesium.Cartesian3.fromRadiansArrayHeights([u.longitude, u.latitude, u.height])[0];
                        s.z = a.z;
                    }
                }
                return t
            }

            function J(e, t) {
                var n;
                for (n = 0; n < t.length; ++n) {
                    var r = t[n],
                        i = $$$(e, r);
                    r.height = i.data.terrainData.interpolateHeight(i.rectangle, r.longitude, r.latitude);
                }
                return t
            }
            function j(e) {
                this.value = new Float32Array([e]);
            }

            j.fromZBias = function (e) {
                if (!Cesium.defined(e)) throw new DeveloperError("zbias is required.");
                return new j(e)
            };
            j.toValue = function (e, t) {
                if (!Cesium.defined(e)) throw new DeveloperError("zbias is required.");
                return Cesium.defined(t) ? color.toBytes(t) : new Float32Array(e)
            };
            j.equals = function (e, t) {
                return e === t || Cesium.defined(e) && Cesium.defined(t) && e.value[0] === t.value[0]
            };
            j.defaultBias = function () {
                // var e = TerraExplorer.zbiaz == undefined ? 15e-6 : TerraExplorer.zbiaz;
                var e = 15e-6 ;
                return j.fromZBias(e)
            };
            Cesium.ZBiasGeometryInstanceAttribute = j;
            Cesium.ZBiasGeometryInstanceAttribute = j;
            Cesium.SampleRenderedDataFlags = {
                TERRAIN: 2,
                MESH: 4,
                FLOOR: 8
            };
            Cesium.DynamicEyeOffset = function (e) {
                return e === undefined && (e = 0),
                    new Cesium.Cartesian3(.001234321, 0, e)
            };

            Cesium.sampleRenderedData = function (e, t) {
                var et = {
                    TERRAIN: 2,
                    MESH: 4,
                    FLOOR: 8
                };
                t == undefined && (t = et.TERRAIN | et.MESH);
                var n = Cesium.when.defer(),
                    r = [];
                t > et.TERRAIN ? e.forEach(function (e) {
                    r.push(Cesium.Cartographic.fromRadians(e.longitude, e.latitude, e.height));
                }) : r = e;
                var i = [];
                t & et.TERRAIN && i.push(K(_that._Viewer.terrainProvider, e));
                var s = (t & et.FLOOR) > 0;
                return t & (et.MESH | et.FLOOR) && i.push(Z(r)),
                    Cesium.when.all(i).then(function (t) {
                        if (i.length > 1)
                            for (var r = 0; r < e.length; r++) {
                                var o = t[0][r],
                                    u = t[1][r];
                                if (u.height == _that.G) continue;
                                if (o.height < u.height || s) o.height = u.height;
                            }
                        n.resolve(t[0]);
                    }),
                    n.promise
            };
            Cesium.sampleRenderedMesh = function (e, t) {
                Cesium.Check.defined("positions", e);
                var n = Cesium.when.defer();
                return Cesium.when(Y(e), function (e) {
                    n.resolve(e);
                }),
                    n.promise
            };
            Cesium.sampleRenderedTerrain = function (e, t) {
                function r() {
                    e.ready ? Cesium.when(J(e, t), function (e) {
                        n.resolve(e);
                    }) : setTimeout(r, 10);
                }

                Cesium.Check.typeOf.object("terrainProvider", e),
                    Cesium.Check.defined("positions", t);
                var n = Cesium.when.defer();
                return r(),
                    n.promise
            };
            Cesium.QuadtreePrimitive.prototype.getRenderedBestLevelInfo = function () {
                var e = this.getRenderedLevelInfo(),
                    t = 0;
                for (var n in e) t < Number(n) && (t = Number(n));
                return {
                    bestLevel: t,
                    count: e[t]
                }
            };
            Cesium.QuadtreePrimitive.prototype.getRenderedLevelInfo = function () {
                var e = [];
                return this._tilesToRender.forEach(function (t) {
                    e[t.level] == undefined && (e[t.level] = 0),
                        e[t.level]++;
                }),
                    e
            };
        }
        i = i || {};
        this._level = r || { min: 0, max: 22 };
        if (typeof this._level === 'number') {
            this._level = { min: r, max: 22 };
        }
        this._url = t;
        this._layerName = n;
        this._guid = Cesium.createGuid();

        this._gmlParser = new GmlParser(!0, null, null, !0);
        this._tileManager = TileManager$3.getInstance(e);
        this._tileManager._loadTileEvent.addEventListener(WfsLayer.prototype.loadTile, this);
        this._useWorkers = !0;
        this._layerDisplayName = s;
        this._showAttributesAsMessage = i.showAttributesAsMessage;
        delete i.showAttributesAsMessage;
        this._entityCreator = new EntityCreator(i, e);
        this._visible = !0;
        this._featuresMap = {};
        this._boundingBox = undefined;
        this._geometryFieldName = undefined;
        this._operations = {};
        this._subdomains = o;
        this.latLon = u;
        this._addedFeatures = [];
        this.simpleSqlParser = SimpleSqlParser;
        this.myLayer = a;
        this._statistics = {
            numberOfAddedFeatures: 0,
            numberOfDeletedFeatures: 0,
            numberOfAddePositions: 0,
            numberOfDeletedPositions: 0,
            getNumberOfCurrentlyRenderedFeatures: function () {
                return this.numberOfAddedFeatures - this.numberOfDeletedFeatures
            },
            getNumberOfCurrentlyRenderedPositions: function () {
                return this.numberOfAddePositions - this.numberOfDeletedPositions
            }
        };
        initLayerCapabilities(this);
        initFeatureType(this);
    }

    function ReplaceTagWithOriginalDomain(e, t) {
        var n;
        return e.indexOf("{s}") != -1 ? n = t != undefined && t.length > 0 ? e.replace("{s}", t[0]) : console.error("Error - sTag with no subdomains.") : n = e,
            n
    }

    function getXmlTag(t, n, r) {
        var i = $(t).find(n);
        return i.length == 0 && r.toLowerCase() === "wfs" && (i = $(t).find("wfs\\:" + n + "," + n)),
            i.length > 0 ? i : $([])
    }

    function parseBBox(e, t) {
        getXmlTag(t, "FeatureType", "wfs").each(function (t, n) {
            if (getXmlTag(n, "Name", "wfs").text() == e._layerName) {
                var r = getXmlTag(n, "LatLongBoundingBox", "wfs");
                return r.length !== 1 ? !1 : (e._boundingBox = Cesium.Rectangle.fromDegrees(parseFloat(r[0].attributes.minx.value), parseFloat(r[0].attributes.miny.value), parseFloat(r[0].attributes.maxx.value), parseFloat(r[0].attributes.maxy.value)), !1)
            }
            return !0
        });
    }

    function queryStringExist(t) {
        return t.indexOf("?") > -1 ? "&" : "?"
    }

    function initLayerCapabilities(e) {
        var t = e.cleanUrl(e._url).replace("{s}", e.sTag(e._layerName.length, e._layerName.length, e._level));
        t += queryStringExist(t),
            t += "SERVICE=WFS&VERSION=1.0.0&REQUEST=GetCapabilities&outputFormat=GML2&typeName=" + e._layerName;
        //var n = TerraExplorer.internal.Settings.connectionUrl,
        var r = Cesium.TrustedServers.contains(ReplaceTagWithOriginalDomain(e._url, e._subdomains));
        $.ajax({
            dataType: "xml",
            xhrFields: {
                withCredentials: r
            },
            url: encodeURI(t),
            success: function (t) {
                parseBBox(e, t),
                    initAllowedOperations(e, t);
            }
        });
    }

    function initAllowedOperations(e, t) {
        $(t).find("FeatureType").each(function (t, n) {
            if ($(n).children("Name").text() == e._layerName) {
                var r = $(n).children("Operations");
                return r.length == 0 ? !1 : (r.children().each(function () {
                    e._operations[this.tagName.toLowerCase()] = {};
                }), !1)
            }
            return !0
        });
    }

    function initFeatureType(e) {
        e.featureColumnNames = null;
        var t = e.cleanUrl(e._url).replace("{s}", e.sTag(e._layerName.length, e._layerName.length, e._level));
        t += queryStringExist(t),
            t += "SERVICE=WFS&VERSION=1.0.0&REQUEST=DescribeFeatureType&typeName=" + e._layerName;
        //var n = TerraExplorer.internal.Settings.connectionUrl,
        var r = Cesium.TrustedServers.contains(ReplaceTagWithOriginalDomain(e._url, e._subdomains));
        $.ajax({
            dataType: "xml",
            xhrFields: {
                withCredentials: r
            },
            url: encodeURI(t),
            success: function (t) {
                parseDescribeFeatureResponse(e, t);
            }
        });
    }

    function getWfsNamespace(xmlText, testElementName) {
        let eval2 = eval;
        if (xmlText == null) return null;
        try {
            var match = (new XMLSerializer).serializeToString(xmlText).match(eval2("/[<]([a-z]+):" + testElementName + "[>]/i"));
            return match != null ? match[1] : null
        } catch (ex) {
            return !1
        }
    }

    function isElementNameExists(xmlText, testElementName) {
        if (xmlText == null) return !1;
        try {
            let eval2 = eval;
            var match = (new XMLSerializer).serializeToString(xmlText.context != null ? xmlText.context : xmlText).match(eval2("/[<](([a-z]+):)?" + testElementName + "[^>]*[>]/i"));
            return match != null
        } catch (ex) {
            return !1
        }
    }

    function parseDescribeFeatureResponse(e, t) {
        var n = $(t).find("[type^='gml:']");
        e._geometryFieldName = $(n).attr("name"),
            e.geometryResponseData = t,
            e.wfsNamespace = getWfsNamespace(e.geometryResponseData, "sequence"),
            e.wfsNamespace == null && (e.wfsNamespace = "xsd"),
            e.sgSchemaExists = $(e.geometryResponseData).find(e.wfsNamespace + "\\:schema").attr("xmlns:sfs"),
            e.sgSchemaExists || (e.sgSchemaExists = $(e.geometryResponseData).find("schema").attr("xmlns:sfs"));
        var r = $(e.geometryResponseData).find(e.wfsNamespace + "\\:sequence " + e.wfsNamespace + "\\:element");
        r.length == 0 && (r = $(e.geometryResponseData).find("sequence").find("element")),
            e.geomFields = [],
            r.each(function () {
                var t = $(this),
                    n = t.attr("name"),
                    r = t.attr("type");
                if (r == null) r = "string";
                else {
                    var i = r.match(/.*[:](\w+)/);
                    i && (r = i[1]);
                }
                e.geomFields.push({
                    name: n,
                    type: r
                });
            });
    }

    function sqlParserToWfs(e, t) {
        if (e.operator) {
            var n = "";
            switch (e.operator.toLowerCase()) {
                case "=":
                    n = "PropertyIsEqualTo";
                    break;
                case "<>":
                    n = "PropertyIsNotEqualTo";
                    break;
                case ">":
                    n = "PropertyIsGreaterThan";
                    break;
                case ">=":
                    n = "PropertyIsGreaterThanOrEqualTo";
                    break;
                case "<":
                    n = "PropertyIsLessThan";
                    break;
                case "<=":
                    n = "PropertyIsLessThanOrEqualTo";
                    break;
                case "like":
                    n = "PropertyIsLike";
            }
            var r = t.indexOf(e.right) != -1 ? e.right : e.left,
                i = "<ogc:" + n + (e.operator.toLowerCase() == "like" ? ' wildCard="*" singleChar="*" escape="*"' : "") + ">";
            i += "<ogc:PropertyName>" + r + "</ogc:PropertyName>";
            var s = t.indexOf(e.right) != -1 ? e.left : e.right;
            s = s.replace(/^'|'$$/g, "");
            var o = s.match(/^[%]|[%]$$/) == null;
            return e.operator.toLowerCase() == "like" && o && (s = "%" + s + "%"),
                i += "<ogc:Literal>" + s + "</ogc:Literal>",
                i += "</ogc:" + n + ">",
                i
        }
        var u = e.logic.toLowerCase() == "and" ? "And" : "Or",
            i = "<ogc:" + u + ">";
        return e.terms.length == 2 ? i += sqlParserToWfs(e.terms[0], t) : i += sqlParserToWfs({
            logic: u,
            terms: e.terms.slice(0, e.terms.length - 1)
        }, t),
            i += sqlParserToWfs(e.terms[e.terms.length - 1], t),
            i += "</ogc:" + u + ">",
            i
    }

    function parseFeaturesResult(e) {
        var t = [],
            n = $(e).find("gml\\:featureMember");
        return n.length == 0 && (n = $(e).find("featureMember")),
            n.each(function () {
                var e = {},
                    n = $(this).children().first();
                e.layerId = n[0].nodeName,
                    e.originFid = n.attr("fid"),
                    e.fid = n.attr("fid"),
                    e.fid == null && (e.fid = -1);
                var r = e.fid.match(/[.]?(\d+)$$/);
                r && (e.fid = r[1]),
                    e.node = n[0],
                    n.children().each(function () {
                        e[this.nodeName] = this.innerHTML,
                            e[this.nodeName] == null && (e[this.nodeName] = $(this).text());
                    }),
                    t.push(e);
            }),
            t
    }

    function internalBlockRequestPrimitiveFromPrimitive(e) {
        return e == undefined ? undefined : e.parentLayer ? e : e._parentCollection ? e._parentCollection : e.primitive && e.primitive._parentCollection ? e.primitive._parentCollection : undefined
    }

    Object.defineProperties(WfsLayer.prototype, {
        LayerDisplayName: {
            get: function () {
                return this._layerDisplayName
            }
        },
        displayName: {
            get: function () {
                return this.LayerDisplayName
            }
        },
        guid: {
            get: function () {
                return this._guid
            }
        },
        Style: {
            get: function () {
                return this._entityCreator.style
            }
        },
        show: {
            get: function () {
                return this._visible
            },
            set: function (e) {
                this.setVisibility(e);
            }
        },
        BoundingBox: {
            get: function () {
                return this._boundingBox
            }
        },
        Statistics: {
            get: function () {
                return this._statistics
            }
        }
    });
    var DEGREES_PER_RADIAN = 180 / Math.PI,
        REQUEST_MAX_FEATURES = 1e3;
    WfsLayer.prototype.getRequestMaxFeatures = function () {
        return REQUEST_MAX_FEATURES
    };
    WfsLayer.prototype.isAttributeField = function (e, t) {
        return !t || !e || e.toLowerCase() == "" || e.toLowerCase() == "fid" ? !1 : t.toLowerCase() == "string" || t.toLowerCase() == "integer" || t.toLowerCase() == "double" ? !0 : !1
    };
    WfsLayer.prototype.updateFeatures = function (e, t) {
        if (e.length <= 0) {
            t();
            return
        }
        var n = this,
            r = [];
        $(this.geomFields).each(function () {
            n.isAttributeField(this.name, this.type) && r.push(this.name);
        });
        var i = "<wfs:Transaction version='1.0.0' service='WFS' username='' password='' xmlns:sfs='http://www.skylineglobe.com/sfs-schema' xmlns:ogc='http://www.opengis.net/ogc' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:wfs='http://www.opengis.net/wfs' xmlns:gml='http://www.opengis.net/gml'> {wfs_updates}</wfs:Transaction>",
            s = "";
        $(e).each(function () {
            var e = this,
                t = '<wfs:Update typeName="{lyaer_id}">'.replace("{lyaer_id}", this.layerId);
            $(r).each(function () {
                t += "<wfs:Property><wfs:Name>" + this + "</wfs:Name><wfs:Value>" + e[this] + "</wfs:Value></wfs:Property>";
            }),
                t += '<ogc:Filter><ogc:FeatureId fid="' + e.originFid + '"/></ogc:Filter>',
                t += "</wfs:Update>",
                s += t;
        }),
            i = i.replace("{wfs_updates}", s);
        var o = "Failed to save changes to server",
            u = ReplaceTagWithOriginalDomain(this.cleanUrl(this._url), this._subdomains),
            a = Cesium.TrustedServers.contains(u);
        $.ajax({
            dataType: "xml",
            type: "POST",
            data: i,
            xhrFields: {
                withCredentials: a
            },
            url: encodeURI(u),
            success: function (e) {
                var n = (new XMLSerializer).serializeToString(e.documentElement).toLowerCase();
                if (n.match(/success\s*\//) == null) {
                    t(o);
                    return
                }
                t();
            },
            error: function (e, n, r) {
                t(o);
            },
            timeout: 1e4
        });
    };
    WfsLayer.prototype.getFeatures = function (e, t, n) {
        var r = this,
            i = [];
        $(this.geomFields).each(function () {
            r.isAttributeField(this.name, this.type) && i.push(this.name);
        });
        var s = "<wfs:GetFeature version='1.0.0' service='WFS' username='' password='' maxFeatures='{REQUEST_MAX_FEATURES}'  xmlns:sfs='http://www.skylineglobe.com/sfs-schema' xmlns:ogc='http://www.opengis.net/ogc' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:wfs='http://www.opengis.net/wfs' xmlns:gml='http://www.opengis.net/gml'> <wfs:Query typeName='{layer_name}'> {wfs_filter}</wfs:Query> </wfs:GetFeature>";
        s = s.replace("{layer_name}", this._layerName),
            s = s.replace("{REQUEST_MAX_FEATURES}", REQUEST_MAX_FEATURES);
        var o = "";
        if (e.replace(/[ ]/g, "") != "") {
            o = "<ogc:Filter  xmlns:sfs='http://www.skylineglobe.com/sfs-schema' xmlns:ogc='http://www.opengis.net/ogc' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:wfs='http://www.opengis.net/wfs' xmlns:gml='http://www.opengis.net/gml'>";
            var u = r.simpleSqlParser.sql2ast("SELECT * FROM x WHERE " + e);
            o += sqlParserToWfs(u.WHERE, i),
                o += "</ogc:Filter>";
        }
        s = s.replace("{wfs_filter}", o);
        var a = ReplaceTagWithOriginalDomain(this.cleanUrl(this._url), this._subdomains),
            f = Cesium.TrustedServers.contains(a);
        t.xhr = $.ajax({
            url: encodeURI(a),
            type: "POST",
            data: s,
            dataType: "xml",
            xhrFields: {
                withCredentials: f
            },
            success: function (e) {
                var t = isElementNameExists($(e), "FeatureCollection");
                if (!t) {
                    n(null, TELang.i18n("layer_error_reading_features"));
                    return
                }
                var r = parseFeaturesResult(e);
                n(r);
            },
            error: function (e, t, r) {
                n(null, e.statusText);
            },
            timeout: 1e4
        });
    };
    WfsLayer.prototype.getFeatureColumnNames = function () {
        if (this.featureColumnNames) return this.featureColumnNames;
        var e = $(this.geometryResponseData).find(this.wfsNamespace + "\\:sequence " + this.wfsNamespace + "\\:element");
        e.length == 0 && (e = $(this.geometryResponseData).find("sequence").find("element"));
        var t = [];
        return e.each(function () {
            var e = $(this);
            e.attr("name").toLowerCase() != "geom" && t.push(e.attr("name").toLowerCase());
        }),
            this.featureColumnNames = t,
            this.featureColumnNames
    };
    WfsLayer.prototype.refresh = function (e) {
        var t = this._tileManager.getAllTiles(),
            n = t.length;
        for (var r = 0; r < n; r++) t[r].data.wfsLayerData[this._guid] && t[r].data.wfsLayerData[this._guid].freeResources(),
            this.loadTile(t[r]);
        e && initFeatureType(this);
    };
    WfsLayer.prototype.setVisibility = function (e) {
        if (this._visible != e) {
            this._visible = e;
            if (e == 0) {
                var t = this._tileManager.getAllTiles(),
                    n = t.length;
                for (var r = 0; r < n; r++) t[r].data.wfsLayerData[this._guid] && t[r].data.wfsLayerData[this._guid].primitive && (t[r].data.wfsLayerData[this._guid].primitive.show = !1);
            } else {
                var t = this._tileManager.getAllTiles(),
                    n = t.length;
                for (var r = 0; r < n; r++) t[r].data.wfsLayerData[this._guid] && (t[r].data.wfsLayerData[this._guid].primitive ? t[r].data.wfsLayerData[this._guid].primitive.show = !0 : this.loadTile(t[r]));
            }
        }
    };
    WfsLayer.prototype.loadTile = function (e) {
        var t = this;
        e.data.wfsLayerData[this._guid] = {
            id: e.data.id,
            primitive: undefined,
            freeResources: function () {
                Cesium.defined(this.xhr) && (this.xhr.abort(), this.xhr = undefined),
                    Cesium.defined(this.features) && (t.removeFeaturesFromLayer(this.features), this.features = undefined),
                    Cesium.defined(this.primitive) && (t._tileManager.removeFromScene(this.primitive), this.primitive = undefined);
            }
        };
        //this.beginLoadWFSData(e);
        if (this.show && e.level >= this._level.min && e.level <= this._level.max) {
            this.statc = 0;
            this._guide = this._guid;
            this.beginLoadWFSData(e);
            // } else if (e.level > this._level.max + 1) {
            //     this.statc = 1;
            //     var t = this._tileManager.getAllTiles(),
            //         n = t.length;
            //     if (n > 0) {
            //         for (var r = 0; r < n; r++) t[r].data.wfsLayerData[this._guid] && t[r].data.wfsLayerData[this._guid].freeResources();
            //     }
        }


        //e.level === this._level && this.show && this.beginLoadWFSData(e);
    };
    WfsLayer.prototype.isDestroyed = function () {
        return !1
    };
    WfsLayer.prototype.destroy = function () {
        var t = this._tileManager.getAllTiles(),
            n = t.length;
        if (n > 0) {
            for (var r = 0; r < n; r++) t[r].data.wfsLayerData[this._guid] && t[r].data.wfsLayerData[this._guid].freeResources();
        }
        return this._tileManager._loadTileEvent.removeEventListener(WfsLayer.prototype.loadTile, this),
            Cesium.destroyObject(this)
    };
    WfsLayer.prototype.sTag = function (e, t, n) {
        if (this._subdomains == undefined) return "";
        var r = (e + t + n) % this._subdomains.length;
        return this._subdomains[r]
    };
    WfsLayer.prototype.cleanUrl = function (e) {
        return e.indexOf("?") != -1 ? e.split("?")[0] : e
    };
    //WfsLayer.prototype.lj = function () {
    //    var scriptObjs = document.scripts;
    //    var url = "./wfs/featurefetcherworker.js";
    //    for (var i = 0; i < scriptObjs.length; i++) {
    //        var jssz = scriptObjs[i].src.split("/");
    //        var dx = jssz[jssz.length - 1];
    //        if (dx == "SmartEarth.js") {
    //            url = scriptObjs[i].outerHTML.split("\"")[1].replace("SmartEarth.js", 'Workers/featurefetcherworker.js');
    //        }
    //    }
    //    return url;
    //}
    function lj$2() {
        var scriptObjs = document.scripts;
        var url = "./wfs/featurefetcherworker.js";
        for (var i = 0; i < scriptObjs.length; i++) {
            var jssz = scriptObjs[i].src.split("/");
            var dx = jssz[jssz.length - 1];
            if (dx == "SmartEarth.js") {
                url = scriptObjs[i].outerHTML.split("\"")[1].replace("SmartEarth.js", 'Workers/featurefetcherworker.js');
            } else if (dx == "SmartEarth.min.js") {
                url = scriptObjs[i].outerHTML.split("\"")[1].replace("SmartEarth.min.js", 'Workers/featurefetcherworker.js');
            }
        }
        return url;
    }

    WfsLayer.prototype.beginLoadWFSData = function (e) {
        if (this.latLon != undefined && !this.latLon) return;
        this.BoundingBox != undefined && (this.BoundingBox.width == 0 || this.BoundingBox.height == 0) && (this.BoundingBox.east += 1, this.BoundingBox.north += 1, this.BoundingBox.beenModified = !0);
        if (this.BoundingBox !== undefined && Cesium.Rectangle.intersection(this.BoundingBox, e.rectangle) === undefined) return;
        var t = [DEGREES_PER_RADIAN * e.rectangle.west, DEGREES_PER_RADIAN * e.rectangle.south, DEGREES_PER_RADIAN * e.rectangle.east, DEGREES_PER_RADIAN * e.rectangle.north];
        var n = this;
        var r = this.cleanUrl(this._url).replace("{s}", this.sTag(e.x, e.y, e.level));
        r += queryStringExist(r);
        r += "SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&outputFormat=GML2&typeName=" + this._layerName + "&srsName=EPSG:4326" + "&BBOX=" + t.join(",");
        //r += "SERVICE=WFS&VERSION=1.1.0&REQUEST=GetFeature&outputFormat=GML3&typeName=" + this._layerName + "&srsName=EPSG:4326" + "&BBOX=" + t.join(",");
        //r += "SERVICE=WFS&VERSION=2.0.0&REQUEST=getFeature&typeName=" + this._layerName;
        //var i = TerraExplorer.internal.Settings.connectionUrl,
        var s = Cesium.TrustedServers.contains(ReplaceTagWithOriginalDomain(this._url, this._subdomains));
        e.data.wfsLayerData[this._guid].xhr = $.ajax({
            dataType: this._useWorkers ? "text" : "xml",
            url: encodeURI(r),
            cache: !0,
            xhrFields: {
                withCredentials: s
            },
            success: function (t) {
                n.processWFSData(e, t);
            },
            error: function (e, t, n) {
                n !== "abort" && console.log("Failed to retrieve data from " + r + " :" + n);
            },
            complete: function () {
                e.data.wfsLayerData[n._guid].xhr = undefined;
            }
        });
    };
    var workerPool;
    WfsLayer.prototype.processWFSData = function (e, t) {
        e.data.wfsLayerData[this._guid].xhr = undefined;
        if (this._useWorkers) {
            var n = this;
            workerPool.queueWorkItem({
                id: e.data.id,
                text: t,
                geometryFieldName: this._geometryFieldName
            }).then(function (e) {
                n.addFeaturesToTile(e);
            });
        } else {
            var r = this._gmlParser.read(t);
            this.addFeaturesToTile({
                id: e.data.id,
                features: r
            });
        }

    };
    WfsLayer.prototype.boundingSphereFromGML = function (e, t) {
        var n = viewer.scene.globe._surface.getRenderedBestLevelInfo().bestLevel,
            r = this;
        workerPool.queueWorkItem({
            id: "0",
            text: e,
            geometryFieldName: this._geometryFieldName
        }).then(function (e) {
            var i = {
                parentLayer: r,
                features: e.features,
                sampleTerrainLevel: n + 1,
                isQuery: !0,
                onFinishedQuery: function (e) {
                    var n;
                    e.length > 0 && (n = Cesium.BoundingSphere.fromBoundingSpheres(e)),
                        t(n);
                }
            };
            r._entityCreator.createPrimitiveFromWFSFeatures(i);
        });
    };
    WfsLayer.prototype.boundingSphereFromFeature = function (e) {
        var t, n = viewer.scene.globe._surface.getRenderedBestLevelInfo().bestLevel,
            r = {
                parentLayer: this,
                features: [e],
                sampleTerrainLevel: n + 1,
                isQuery: !0,
                onFinishedQuery: function (e) {
                    e.length > 0 && (t = Cesium.BoundingSphere.fromBoundingSpheres(e));
                }
            };
        return this._entityCreator.createPrimitiveFromWFSFeatures(r),
            t
    };
    WfsLayer.prototype.addRenderedFeatureId = function (e) {
        this._addedFeatures[e] == undefined && (this._addedFeatures[e] = 0),
            this._addedFeatures[e]++;
    };
    WfsLayer.prototype.removeRenderedFeatureId = function (e) {
        this._addedFeatures[e] != undefined && this._addedFeatures[e]--,
            this._addedFeatures[e] == 0 && (this._addedFeatures[e] = undefined);
    };
    WfsLayer.prototype.isExistRenderedFeatureId = function (e) {
        return this._addedFeatures[e] != undefined
    };
    WfsLayer.prototype.addFeaturesToTile = function (e, t) {
        var n = this._tileManager.getTile(e.id);
        if (n === undefined) return;
        // var r = this._viewer.scene.globe._surface.getRenderedBestLevelInfo().bestLevel;
        var i = t ? n.data.wfsLayerData[this._guid].primitive._instanceIds : undefined;
        var s = this;
        var o = {
            parentLayer: this,
            originalInstanceIds: i,
            features: e.features,
            // sampleTerrainLevel: r + 1,
            onFinishedCreatePrimitive: function (r) {
                if (e.features == undefined || n.data.wfsLayerData == undefined) return;
                n.data.wfsLayerData[s._guid].features = e.features,
                    t || s.addFeaturesToLayer(n.data.wfsLayerData[s._guid].features);
                if (r.length === undefined || r.length > 0) {
                    var i = n.data.wfsLayerData[s._guid].primitive;
                    r.show = s.show;
                    n.data.wfsLayerData[s._guid].primitive = r;
                    r.parentLayer = s;
                    r.parentTileId = e.id;
                    r._guid = Cesium.createGuid();
                    if (t) {
                        s._tileManager.replaceInScene(i, r);
                    } else {
                        s._tileManager.addToScene(r);
                    }
                }
            }
        };
        this._entityCreator.createPrimitiveFromWFSFeatures(o);
    };
    WfsLayer.prototype.addFeaturesToLayer = function (e) {
        this._statistics.numberOfAddedFeatures += e.length,
            this._statistics.numberOfAddePositions += Cesium.defaultValue(e.numPositions, 0);
        var t = e.length;
        for (var n = 0; n < t; n++) Object.prototype.hasOwnProperty.call(this._featuresMap, e[n].fid) === !1 ? this._featuresMap[e[n].fid] = {
            refCount: 1,
            feature: e[n]
        } : this._featuresMap[e[n].fid].refCount++;
    };
    WfsLayer.prototype.removeFeaturesFromLayer = function (e) {
        this._statistics.numberOfDeletedFeatures += e.length,
            this._statistics.numberOfDeletedPositions += Cesium.defaultValue(e.numPositions, 0);
        var t = e.length;
        for (var n = 0; n < t; n++) {
            if (Object.prototype.hasOwnProperty.call(this._featuresMap, e[n].fid) === !1) continue;
            this._featuresMap[e[n].fid].refCount--,
                this._featuresMap[e[n].fid].refCount === 0 && delete this._featuresMap[e[n].fid],
                this.removeRenderedFeatureId(e[n].fid);
        }
    };
    WfsLayer.prototype.getFeature = function (e) {
        return Object.prototype.hasOwnProperty.call(this._featuresMap, e) === !1 ? null : this._featuresMap[e]
    };
    WfsLayer.prototype.updateTile = function (e) {
        var t = this._tileManager.getTile(e);
        if (t === undefined) return;
        t.data.wfsLayerData[this._guid].features == undefined ? this.loadTile(t) : this.addFeaturesToTile(t.data.wfsLayerData[this._guid], !0);
    };
    WfsLayer.blockRequestPrimitiveFromPrimitive = function (e) {
        if (e == undefined) return undefined;
        var t = internalBlockRequestPrimitiveFromPrimitive(e);
        return t != undefined ? t : (e._labelCollection && e._labelCollection._billboardCollection ? t = internalBlockRequestPrimitiveFromPrimitive(e._labelCollection._billboardCollection) : e._billboardCollection && (t = internalBlockRequestPrimitiveFromPrimitive(e._billboardCollection)), t)
    };
    WfsLayer.prototype.resetAttributesTable = function () {
        this.lastEditedCell = null,
            this.attrTblDialogMemo = null;
    };

    function TileManager$2() {
        this._quadtree = undefined,
            this._tilingScheme = new Cesium.GeographicTilingScheme,
            this._errorEvent = new Cesium.Event,
            this._loadTileEvent = new Cesium.Event,
            this._levelZeroMaximumError = Cesium.TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap(this._tilingScheme.ellipsoid, 128, this._tilingScheme.getNumberOfXTilesAtLevel(0)),
            this._tileCache = [],
            this._primitivesWaitingToBeAddedToTheScene = [],
            this._pauseStreaming = !1,
            this._numTilesInLevel = [],
            this.STREAM_SPEED_IMIDIATE = 0,
            this.STREAM_SPEED_FAST = 1,
            this.STREAM_SPEED_NORMAL = 2,
            this.STREAM_SPEED_SLOW = 3,
            this._streamSpeed = this.STREAM_SPEED_NORMAL;
    }

    function a$2(e, n) {
        $.each(e._primitives, function (e, r) {
            if (r instanceof Cesium.BillboardCollection) {
                var i = r,
                    e = t$2.indexOf(i);
                return i._parentCollection._primitiveOld = n,
                    e !== -1 ? (viewer.scene.primitives.remove(t$2[e]._parentCollection), t$2[e] = i) : t$2.push(i),
                    !1
            }
        });
    }

    function f$1(e, t) {
        viewer.scene.primitives.remove(t),
            e._onDestroyTilePrimitive = function () {
                viewer.scene.primitives.remove(t),
                    this._onDestroyTilePrimitive = undefined;
            };
    }

    function l$2(e, t, n) {
        Cesium.when.all(e, function () {
            viewer.scene.primitives.remove(n);
        }),
            t._onDestroyTilePrimitive = function () {
                viewer.scene.primitives.remove(n),
                    this._onDestroyTilePrimitive = undefined;
            };
    }

    function c$2(e, t) {
        var n = $.map(e._primitives, function (e) {
            return e.readyPromise
        });
        l$2(n, e, t);
    }

    function h$2(e, t) {
        var n = $.map(e._primitives[0]._primitives, function (e) {
            return e.readyPromise
        });
        l$2(n, e, t);
    }

    function p$2(e, t) {
        viewer.scene.primitives.remove(t);
    }

    function d$2(e, t) {
        var n = [e.readyPromise];
        l$2(n, e, t);
    }
    Object.defineProperties(TileManager$2.prototype, {
        quadtree: {
            get: function () {
                return this._quadtree
            },
            set: function (e) {
                this._quadtree = e;
            }
        },
        ready: {
            get: function () {
                return !0
            }
        },
        tilingScheme: {
            get: function () {
                return this._tilingScheme
            }
        },
        errorEvent: {
            get: function () {
                return this._errorEvent
            }
        },
        loadTileEvent: {
            get: function () {
                return this._loadTileEvent
            }
        },
        pauseStreaming: {
            get: function () {
                return this._pauseStreaming
            },
            set: function (e) {
                this._pauseStreaming = e;
            }
        },
        streamSpeed: {
            get: function () {
                return this._streamSpeed
            },
            set: function (e) {
                this._streamSpeed = e;
            }
        },
        bestLevelAvailable: {
            get: function () {
                var e = 0;
                for (var t = 0; t < 22; t++) this._numTilesInLevel[t] != undefined && this._numTilesInLevel[t] > 0 && e < t && (e = t);
                return e
            }
        }
    });
    TileManager$2.prototype.streamSpeedFactor = function () {
        switch (this._streamSpeed) {
            case this.STREAM_SPEED_FAST:
                return 1;
            case this.STREAM_SPEED_NORMAL:
                return 3;
            case this.STREAM_SPEED_SLOW:
                return 20;
            default:
                return 3
        }
    };
    var t$2 = [];
    var n$2 = 0;
    TileManager$2.prototype.onPreFrame = function (e, r) {
        n$2++;
        if (this._pauseStreaming) return;
        if (this._streamSpeed == this.STREAM_SPEED_IMIDIATE)
            while (this._primitivesWaitingToBeAddedToTheScene.length > 0) {
                var i = this._primitivesWaitingToBeAddedToTheScene.pop();
                e.primitives.add(i);
            } else if (this._primitivesWaitingToBeAddedToTheScene.length > 0 && n$2 % this.streamSpeedFactor() == 0) {
                var i = this._primitivesWaitingToBeAddedToTheScene.pop();
                i._instanceIds && i._instanceIds.length > 100 && this.streamSpeed === this.STREAM_SPEED_FAST && (this.streamSpeed = this.STREAM_SPEED_NORMAL),
                    e.primitives.add(i);
            }
        $.each(t$2, function (e, t) {
            t.ready && viewer.scene.primitives.remove(t._parentCollection._primitiveOld);
        });
    };
    var r$3 = !1;
    TileManager$2.prototype.initialize = function (e) {
        r$3 || (viewer.scene.preRender.addEventListener(this.onPreFrame, this), r$3 = !0);
    };
    TileManager$2.prototype.beginUpdate = function (e) {
        this.quadtree.beginFrame(e);
    };

    TileManager$2.prototype.endUpdate = function (e) {
        var t = this;
        e.afterRender.push(function () {
            t.quadtree.endFrame(e);
        });
    };

    TileManager$2.prototype.updateForPick = function (e) { };

    TileManager$2.prototype.getLevelMaximumGeometricError = function (e) {
        return this._levelZeroMaximumError / (1 << e) * this._quadtree.maximumScreenSpaceError
    };
    var i$4 = 180 / Math.PI;

    TileManager$2.prototype.placeHolder = function (e, t) {
        t = t || Cesium.Color.fromBytes(0, 255, 0, 255);
        var n = new Cesium.Primitive({
            geometryInstances: new Cesium.GeometryInstance({
                geometry: new Cesium.RectangleOutlineGeometry({
                    rectangle: e.rectangle,
                    height: viewer.camera.positionCartographic.height - TerraExplorer.internal.Navigate.HeightAboveGround * .99
                }),
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(t)
                }
            }),
            appearance: new Cesium.PerInstanceColorAppearance({
                flat: !0
            })
        });
        e.data.primitive.add(n);
    };
    TileManager$2.prototype.loadTile = function (e, t) {
        var n = this;
        this._numTilesInLevel[t._level] == undefined && (this._numTilesInLevel[t._level] = 0),
            this._numTilesInLevel[t._level]++;
        if (t.state === Cesium.QuadtreeTileLoadState.START) {
            t.data = {
                primitive: new Cesium.PrimitiveCollection,
                wfsLayerData: [],
                id: Cesium.createGuid(),
                freeResources: function () {
                    n._tileCache[t.data.id] && n._numTilesInLevel[t._level]--,
                        n._numTilesInLevel[t._level] < 0 && (n._numTilesInLevel[t._level] = 0);
                    if (Cesium.defined(this.wfsLayerData)) {
                        for (var e in this.wfsLayerData) Cesium.defined(this.wfsLayerData[e]) && this.wfsLayerData[e].freeResources();
                        this.wfsLayerData = undefined;
                    }
                    Cesium.defined(this.primitive) && (this.primitive.destroy(), this.primitive = undefined),
                        delete n._tileCache[t.data.id];
                }
            },
                this._tileCache[t.data.id] = t;
            var r = 6371e3;
                Math.abs(r * (t.rectangle.south - t.rectangle.north));
            t.data.boundingSphere3D = Cesium.BoundingSphere.fromRectangle3D(t.rectangle),
                t.data.boundingSphere2D = Cesium.BoundingSphere.fromRectangle2D(t.rectangle, e.mapProjection);
            [i$4 * t.rectangle.west, i$4 * t.rectangle.south, i$4 * t.rectangle.east, i$4 * t.rectangle.north];
            this.loadTileEvent.raiseEvent(t),
                t.state = Cesium.QuadtreeTileLoadState.DONE,
                t.renderable = !0;
        }
    };
    TileManager$2.prototype.getTile = function (e) {
        return this._tileCache[e]
    };
    TileManager$2.prototype.getAllTiles = function () {
        var e = [];
        for (var t in this._tileCache) e.push(this._tileCache[t]);
        return e
    };
    TileManager$2.prototype.computeTileVisibility = function (e, t, n) {
        var r = this.computeDistanceToTile(e, t);
        e._distance = r;
        if (t.fog.enabled && e._level > 9 && Cesium.Math.fog(r, t.fog.density) >= 1) return Cesium.Visibility.NONE;
        var i;
        return t.mode === Cesium.SceneMode.SCENE3D ? i = e.data.boundingSphere3D : i = e.data.boundingSphere2D,
            t.cullingVolume.computeVisibility(i)
    };
    TileManager$2.prototype.showTileThisFrame = function (e, t) {
        e.data.primitive.update(t);
    };
    TileManager$2.prototype.computeDistanceToTile = function (e, t) {
        var n;
        var o = new Cesium.Cartesian3;

        t.mode === Cesium.SceneMode.SCENE3D ? n = e.data.boundingSphere3D : n = e.data.boundingSphere2D;
        var r = Cesium.Cartesian3.subtract(n.center, t.camera.positionWC, o),
            i = Cesium.Cartesian3.magnitude(r);
        return Math.max(1, i - TerraExplorer.internal.Navigate.GroundHeightAtCameraPosition)
    };
    TileManager$2.prototype.isDestroyed = function () {
        return !1
    };
    TileManager$2.prototype.destroy = function () {
        return Cesium.destroyObject(this)
    };
    TileManager$2.prototype.getInstance = function (t) {
        if (Cesium.defined(t.TileManager) == 0) {
            t.TileManager = new e;
            var n = new Cesium.QuadtreePrimitive({
                tileProvider: t.TileManager,
                maximumScreenSpaceError: 2
            });
            t.scene.primitives.add(n);
        }
        return t.TileManager
    };
    TileManager$2.prototype.addToScene = function (e) {
        this._primitivesWaitingToBeAddedToTheScene.push(e);
    };
    TileManager$2.prototype.removeFromScene = function (e) {
        var t = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        t != -1 ? (this._primitivesWaitingToBeAddedToTheScene[t].destroy(), this._primitivesWaitingToBeAddedToTheScene.splice(t, 1)) : viewer.scene.primitives.remove(e);
    };
    TileManager$2.prototype.replaceInScene = function (e, t) {
        var n = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        if (n != -1) this._primitivesWaitingToBeAddedToTheScene[n] = t;
        else {
            e.ID != t.ID && console.log("TileManager.replaceInScene Warning: new primitive has a different ID than old primitive"),
                e._replacmentPrimitive != undefined && viewer.scene.primitives.remove(e._replacmentPrimitive),
                e._replacmentPrimitive = t,
                viewer.scene.primitives.add(t);
            var r = t.ID.split(":")[0];
            switch (r) {
                case "billboards":
                    a$2(t, e);
                    break;
                case "labels":
                    f$1(t, e);
                    break;
                case "polygons":
                    c$2(t, e);
                    break;
                case "models":
                    h$2(t, e);
                    break;
                case "polylines":
                    d$2(t, e);
                    break;
                case "points":
                    p$2(t, e);
                    break;
                default:
                    console.log("Error updating layer"),
                        viewer.scene.primitives.remove(e);
            }
        }
    };
    var v$1 = {
        billboards: a$2,
        labels: f$1,
        polygons: c$2,
        models: h$2,
        polylines: d$2,
        points: p$2
    };
    TileManager$2.prototype.replaceInSceneNew = function (e, t) {
        var n = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        if (n != -1) this._primitivesWaitingToBeAddedToTheScene[n] = t;
        else {
            e.ID !== t.ID && console.log("TileManager.replaceInScene Warning: new primitive has a different ID than old primitive"),
                this.addToScene(t);
            var i = t.ID.split(":")[0],
                s = v$1[i];
            s ? s(t, e) : (console.log("Error updating layer"), viewer.scene.primitives.remove(e));
        }
    };

    /**
     *
     * 创建wfs图层
     *
     * @alias WfsFeatureLayer 
     * @constructor
     *
     */
    var TileManager$1;
    function WfsFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        TileManager$1 = new TileManager$2();
    }
    /**
     * 创建wfs图层
     * 
     * @param {Object} e viewer
     * @param {String} t url "http://192.168.1.40:8090/geoserver/swagger/wms?"
     * @param {String} n name "swagger:point"
     * @param {Float} r level 2
     * @param {Object} i style "{"billboard":{"color":{"red":1,"green":1,"blue":1,"alpha":1},"image":{"defaultValue":"http://localhost/SG/resources/397940/defaultIcon.gif"},"imageColor":{"defaultValue":{"red":1,"green":1,"blue":1,"alpha":1}},"imageOpacity":{"defaultValue":"1"},"scaleTE":{"defaultValue":"15000"},"limitGrowth":{"defaultValue":"1"},"minViewingHeightObj":{"defaultValue":"0"}},"lineToGround":{"defaultValue":"0"},"lineToGroundLength":{"defaultValue":"0"},"lineToGroundColor":{"defaultValue":{"red":1,"green":1,"blue":1,"alpha":1}},"altitudeMethod":0,"altitudeOffset":{"defaultValue":"0"}}"
     * @param {String} s displayName "swagger:point"
     * @param {Object} o subdomains undefined
     * @param {Object} u latlon undefined
     * @param {Object} a myLayer undefined
     */
    WfsFeatureLayer.prototype.CreateWfsFeatureLayer = function (e, t, n, r, i, s, o, u, a) {
        var wfs = new WfsLayer(e, t, n, r, i, s, o, u, a);
        return wfs;
    };
    WfsFeatureLayer.prototype.initTileManager = function () {
        this._viewer.scene;
        var vi = this._viewer;
        vi.scene.preRender.addEventListener(function (scene, time) {
            TileManager$1.getInstance(vi).streamSpeed = 2;
        });
    };

    /**
       *
       *   管线
       *
       * @alias PolylineVolume
       * @constructor
       *
       * @param {viewer|object} viewer 传入数据。
       *
       */
    function PolylineVolume(viewer) {
        this._viewer = viewer;
        this._cesium = Cesium;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 创建wall
     * 
     * @param {string} [name] 名称
     * @param {object} [options] 名称
     */
    PolylineVolume.prototype.createPolylineVolume = function (name, Geometry, type, options, GroupID) {
        var defaultOptions = {
            positions: [],
            shape: this.starPositions(7, 30000.0, 20000.0),
            //outline: true,
            //outlineColor: this._cesium.Color.WHITE,
            //outlineWidth: 1,
            material: this._cesium.Color.fromRandom({ alpha: 1.0 })
        };
        if (this._core.isnull(options)) {
            console.log('options is required');
            return;
        }
        options = this._core.extend(defaultOptions, options, true);
        var pArray = [];
        if (!Geometry[0].x && !Geometry[0].y) {
            if (Geometry[0].length === 2) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1]));
                }
            } else if (Geometry[0].length === 3) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1], Geometry[i][2]));
                }
            }
        } else {
            if (Geometry[0].z) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y, Geometry[i].z));
                }
            } else {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y));
                }
            }
        }
        options.positions = pArray;
        if (type === 'circle') {
            options.shape = this.computeCircle(options.radius || 10);
        } else if (type === 'star') {
            options.shape = this.starPositions(options.arms || 7, options.rOuter || 30, options.rInner || 20);
            options.cornerType = Cesium.CornerType.MITERED;
        } else if (type === 'box') {
            options.radius = options.radius || 10;
            options.shape = [
                new this._cesium.Cartesian2(-options.radius, -options.radius),
                new this._cesium.Cartesian2(options.radius, -options.radius),
                new this._cesium.Cartesian2(options.radius, options.radius),
                new this._cesium.Cartesian2(-options.radius, options.radius)
            ];
            options.cornerType = Cesium.CornerType.BEVELED;
        }
        var PolylineVolume = this._viewer.entities.add({
            id: this._core.getuid(),
            name: name,
            polylineVolume: options
        });
        this.item = PolylineVolume;
        this._tree.insertGroupId({
            id: PolylineVolume.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylinevolume',
            item: this
        }, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    /**
      * 获取polylineVolume样式
      */
    PolylineVolume.prototype.getstyles = function () {
        var styles = {};
        styles.show = this.item.polylineVolume.show ? this.item.polylineVolume.show._value : true;
        styles.positions = this.item.polylineVolume.positions.getValue().toString();
        styles.shape = this.item.polylineVolume.shape.toString();
        styles.cornerType = this.item.polylineVolume.cornerType ? this.item.polylineVolume.cornerType.toString() : null;
        styles.granularity = this.item.polylineVolume.granularity ? this.item.polylineVolume.granularity.toString() : null;
        styles.fill = this.item.polylineVolume.fill ? this.item.polylineVolume.fill._value : null;
        styles.material = this.item.polylineVolume.material ? this.item.polylineVolume.material.toString() : null;
        styles.outline = this.item.polylineVolume.outline ? this.item.polylineVolume.outline._value : null;
        styles.outlineWidth = this.item.polylineVolume.outlineWidth ? this.item.polylineVolume.outlineWidth.toString() : null;
        styles.outlineColor = this.item.polylineVolume.outlineColor && this.item.polylineVolume.outlineColor._value ? 'rgba' + this.item.polylineVolume.outlineColor.toString() + '' : null;
        styles.near = this.item.polylineVolume.distanceDisplayCondition ? this.item.polylineVolume.distanceDisplayCondition._value.near : null;
        styles.far = this.item.polylineVolume.distanceDisplayCondition ? this.item.polylineVolume.distanceDisplayCondition._value.far : null;
        // styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
     * 
     * 用于command调用创建wall
     * 
     * @param {Array} [ponsitions] [x,y,z......]这是传入的参数
     * 
     * */
    PolylineVolume.prototype.executeWall = function (name, GroupID) {
        var positions = [];
        var poly = undefined;
        var _this = this;
        var wallPoly = (function () {
            function _wall(positions) {
                this.options = {
                    id: _this._core.getuid(),
                    type: "wall",
                    wall: {
                        positions: [],
                        minimumHeights: [2000, 2000],
                        maximumHeights: [1000, 1000],
                        material: _this._cesium.Color.AQUA.withAlpha(1)
                    }
                };
                this.positions = positions;
                this._init();
            }
            _wall.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    var dp = [];
                    for (var i = 0; i < _self.positions.length; i++) {
                        if (!positions[i]) return;
                        var ellipsoid = _this._viewer.scene.globe.ellipsoid;
                        var cartesian3 = new _this._cesium.Cartesian3(positions[i].x, positions[i].y, positions[i].z);
                        var cartographic = ellipsoid.cartesianToCartographic(cartesian3);
                        var lat = _this._cesium.Math.toDegrees(cartographic.latitude);
                        var lng = _this._cesium.Math.toDegrees(cartographic.longitude);
                        cartographic.height;
                        dp.push(lng);
                        dp.push(lat);
                        //_self.options.wall.minimumHeights.push(2000);
                        //dp.push(200);
                    }
                    //return _this._cesium.Cartesian3.fromDegreesArrayHeights(dp);//_self.positions;
                    return _this._cesium.Cartesian3.fromDegreesArray(dp);//_self.positions;
                };
                var _updatemaxheight = function () {
                    var heights = [];
                    for (var i = 0; i < _self.positions.length; i++) {
                        heights.push(2000);
                    }
                    return heights;
                };
                var _updateminheight = function () {
                    var heights = [];
                    for (var i = 0; i < _self.positions.length; i++) {
                        heights.push(1000);
                    }
                    return heights;
                };
                this.options.wall.maximumHeights = new _this._cesium.CallbackProperty(_updatemaxheight, false);
                this.options.wall.minimumHeights = new _this._cesium.CallbackProperty(_updateminheight, false);
                this.options.wall.positions = new _this._cesium.CallbackProperty(_update, false);
                var wall = _this._viewer.entities.add(this.options);
                _this.item = wall;
                _this._tree.insertGroupId({
                    id: this.options.id,
                    name: name,
                    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                    type: 'wall',
                    item: _this
                }, _this._core.isnull(GroupID) ? 0 : GroupID);
            };
            return _wall;
        })();
        var handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        handler.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.position, _this._viewer.scene.globe.ellipsoid);
            if (positions.length == 0) {
                positions.push(lodash.clone(cartesian));
            }
            positions.push(lodash.clone(cartesian));
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        handler.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.endPosition, _this._viewer.scene.globe.ellipsoid);
            if (positions.length >= 1) {
                if (!_this._cesium.defined(poly)) {
                    poly = new wallPoly(positions);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        handler.setInputAction(function (movement) {
            handler.destroy();
            positions.pop();
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
    };

    PolylineVolume.prototype.starPositions = function (arms, rOuter, rInner) {
        var angle = Math.PI / arms;
        var pos = [];
        for (var i = 0; i < 2 * arms; i++) {
            var r = (i % 2) === 0 ? rOuter : rInner;
            var p = new this._cesium.Cartesian2(Math.cos(i * angle) * r, Math.sin(i * angle) * r);
            pos.push(p);
        }
        return pos;
    };
    PolylineVolume.prototype.computeCircle = function (radius) {
        var positions = [];
        for (var i = 0; i < 360; i++) {
            var radians = this._cesium.Math.toRadians(i);
            positions.push(new this._cesium.Cartesian2(radius * Math.cos(radians), radius * Math.sin(radians)));
        }
        return positions;
    };
    /**
     * 设置wall的可见性
     */
    PolylineVolume.prototype.setVisibility = function (b) {
        this.item.polylineVolume.show = b;
    };
    /**
     * 获取wall的可见性
     */
    PolylineVolume.prototype.getVisibility = function () {
        return this.item.polylineVolume.show;
    };
    /**
     * 删除元素
     */
    PolylineVolume.prototype.deleteObject = function () {
        this._viewer.entities.remove(this.item);
    };
    Object.defineProperties(PolylineVolume.prototype, {
        /**
         * 获取或设置矩形
         */
        rectangle: {
            get: function () {
                return this.item.rectangle;
            },
            set: function (rectangle) {
                this.item.rectangle = rectangle;
            }
        }
    });

    Object.defineProperties(PolylineVolume.prototype, {
        /**
         * 获取或设置线条
         */
        polyline: {
            get: function () {
                return this.item.polyline;
            },
            set: function (polyline) {
                this.item.polyline = polyline;
            }
        }
    });


    PolylineVolume.prototype.setItem = function (item) {
        this.item = item;
    };
    //工程树添加
    PolylineVolume.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    Object.defineProperties(PolylineVolume.prototype, {
        /**
         * 获取或设置面
         */
        polygon: {
            get: function () {
                return this.item.polygon;
            },
            set: function (polygon) {
                this.item.polygon = polygon;
            }
        }
    });

    Object.defineProperties(PolylineVolume.prototype, {
        /**
         * 获取或设置点
         */
        point: {
            get: function () {
                return this.item.point;
            },
            set: function (point) {
                this.item.point = point;
            }
        }
    });

    Object.defineProperties(PolylineVolume.prototype, {
        /**
         * 获取或设置标签
         */
        label: {
            get: function () {
                return this.item.label;
            },
            set: function (label) {
                this.item.label = label;
            }
        }
    });

    Object.defineProperties(PolylineVolume.prototype, {
        /**
         * 获取或设置模型
         */
        model: {
            get: function () {
                return this.item.model;
            },
            set: function (model) {
                this.item.model = model;
            }
        }
    });

    Object.defineProperties(PolylineVolume.prototype, {
        /**
         * 获取或设置墙
         */
        wall: {
            get: function () {
                return this.item.wall;
            },
            set: function (wall) {
                this.item.wall = wall;
            }
        }
    });

    Object.defineProperties(PolylineVolume.prototype, {
        /**
         * 获取墙的模板属性
         */
        wallTempOptions: {
            get: function () {
                return {
                    positions: [],//	Property		optional A Property specifying the array of Cartesian3 positions which define the top of the wall.
                    maximumHeights: [],//	Property		optional A Property specifying an array of heights to be used for the top of the wall instead of the height of each position.
                    minimumHeights: [],//	Property		optional A Property specifying an array of heights to be used for the bottom of the wall instead of the globe surface.
                    show: true,//	Property	true	optional A boolean Property specifying the visibility of the wall.
                    fill: true,//	Property	true	optional A boolean Property specifying whether the wall is filled with the provided material.
                    material: this._cesium.Color.WHITE,//	MaterialProperty	Color.WHITE	optional A Property specifying the material used to fill the wall.
                    outline: false,//	Property	false	optional A boolean Property specifying whether the wall is outlined.
                    outlineColor: this._cesium.Color.BLACK,//	Property	Color.BLACK	optional A Property specifying the Color of the outline.
                    outlineWidth: 1.0,//	Property	1.0	optional A numeric Property specifying the width of the outline.
                    granularity: this._cesium.Math.RADIANS_PER_DEGREE,//	Property	Cesium.Math.RADIANS_PER_DEGREE	optional A numeric Property specifying the angular distance between each latitude and longitude point.
                    shadows: ShadowMode.DISABLED,//	Property	ShadowMode.DISABLED	optional An enum Property specifying whether the wall casts or receives shadows from each light source.
                    distanceDisplayCondition: null
                }
            }
        }
    });

    /**
     *
     * 创建位置
     *
     * @alias Position
     * @constructor
     *
     */
    function Position(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    /**
     * 这个方法用于创建颜色
     *@param {number} [red] 红色组件。
     * @param {number} [green] 绿色组件。
     * @param {number} [blue] 蓝色组件。
     * @param {number} [alphae] alphea组件。
     * @returns {Promise.<Object>} 返回一个Cesium的颜色对象。
     */
    Position.prototype.createPosition = function (x, y, z) {
        var position = new this.Cartesian3.fromDegrees(x, y, z);
        return position;
    };

    /**
     * 这个方法用于创建Position对象
     *
     *@param {number} [X] 兴趣点的东西方向坐标。
     * @param {number} [Y] 兴趣点的南北方向坐标。
     * @param {number} [Altitude] 兴趣点的高程。
     * @param {number} [AltitudeType] 一个枚举值，定义了了高程类型。
     * @param {number} [Yaw] 视点和兴趣点的偏移角度。
     * @param {number} [Pitch] 视点和兴趣点的俯仰角度。
     * @param {number} [Roll] 视点和兴趣点的翻滚角度。
     * @param {number} [Distance] 距离点坐标（X,Y,height）的距离，点必须在视线范围内。
     * @returns {Promise.<Object>} 返回一个Position对象。
     */
    Position.prototype.CreatePosition = function (X, Y, Altitude, AltitudeType, Yaw, Pitch, Roll, Distance) {
        var position = {
            X: X,
            Y: Y,
            Altitude: Altitude,
            AltitudeType: AltitudeType,
            Yaw: Yaw,
            Pitch: Pitch,
            Roll: Roll,
            Distance: Distance
        };
        return position;
    };

    /**
     *
     * 这个方法用于创建图像标签。
     *
     * @alias ImageLabel 
     * @constructor
     *
     */
    function ImageLabel(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree;
        this._core = new Core();
        this._Color = new Color(this._viewer, this._cesium);
    }
    /**
    * 这个方法用于创建图像标签
    * @param {Array} [position] 一个经纬度数组 例如：[-114.0, 40.0, 300000.0]。
    * @param {object} [ImageLabel] 对象。对象{
       image: '../images/Cesium_Logo_overlay.png', 
            show: true, // default
            color: this._cesium.Color.IVORY,
    }
    * @param {double} [GroupID] 组的ID，高程数据图层在该组中被创建。如果GroupID设置为零，则对象在根节点下创建。你可以通过以下方法获得GroupID。
    * @param {double} [Description] 标签名字。
    * @returns {Promise.<Object>} 返回一个Cesium的对象。
    * 
    */
    ImageLabel.prototype.createImageLabel = function (position, ImageLabel, GroupID, Description) {
        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
            image: '../images/Cesium_Logo_overlay.png',
            show: true, // default
            //pixelOffset: new this._cesium.Cartesian2(0, -50),
            //eyeOffset: new this._cesium.Cartesian3(0.0, 0.0, 0.0),
            //horizontalOrigin: this._cesium.HorizontalOrigin.CENTER,
            //verticalOrigin: this._cesium.VerticalOrigin.BOTTOM,
            //scale: 2.0, 
            color: this._cesium.Color.IVORY,
            //rotation: this._cesium.Math.PI_OVER_FOUR,
            //alignedAxis: this._cesium.Cartesian3.ZERO,
            //width: 100,
            //height: 25 
        };
        var options = this._core.extend(defaultOption, ImageLabel, true);

        //填充颜色设置
        if (options.color) {
            if (!this._core.isnull(options) && !this._core.isnull(options.color)) {
                if (options.color.toString().charAt(0) == "[" && options.color.toString().charAt(options.color.length - 1) == "]") ; else {
                    if (this._core.isHtmlColor(options.color) && /^#/.test(options.color.toString())) {
                        options.color = this._Color.colorFromHtmlColor(options.color);
                    } else {
                        if (/^rgb/.test(options.color)) {
                            options.color = this._Color.rgbaStringToRgbaObj(options.color);
                        }
                        if (options.color.r > 1) {
                            options.color.r = options.color.r / 255;
                        }
                        if (options.color.g > 1) {
                            options.color.g = options.color.g / 255;
                        }
                        if (options.color.b > 1) {
                            options.color.b = options.color.b / 255;
                        }
                        if (options.color.a > 1) {
                            options.color.a = options.color.a / 255;
                        }
                        if (options.color.r)
                            options.color = this._Color.createColor(options.color.r, options.color.g, options.color.b, options.color.a);
                    }
                }
            }
        }

        if (options.near && options.far) {
            options.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(options.near, options.far);
        }

        this.item = this._viewer.entities.add({
            name: Description,
            //中心的位置（长、宽、高）
            position: this._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]),
            billboard: options
        });
        var obj = {
            id: this.item.id,
            name: Description,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'Imagelabel',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    /**
     * 获取billboard样式
     */
    ImageLabel.prototype.getstyles = function () {
        var styles = {};
        styles.show = this.item.billboard.show ? this.item.billboard.show._value : true;
        styles.image = this.item.billboard.image && this.item.billboard.image._value ? this.item.billboard.image._value : undefined;
        styles.scale = this.item.billboard.scale && this.item.billboard.scale._value ? this.item.billboard.scale._value : undefined;
        styles.pixelOffset = this.item.billboard.pixelOffset ? this.item.billboard.pixelOffset._value : undefined;
        styles.horizontalOrigin = this.item.billboard.horizontalOrigin && this.item.billboard.horizontalOrigin._value ? this.item.billboard.horizontalOrigin._value : undefined;
        styles.verticalOrigin = this.item.billboard.verticalOrigin && this.item.billboard.verticalOrigin._value ? this.item.billboard.verticalOrigin._value : undefined;
        styles.heightReference = this.item.billboard.heightReference && this.item.billboard.heightReference._value && this.item.billboard.heightReference._value ? this.item.billboard.heightReference._value : null;
        styles.color = this.item.billboard.color && this.item.billboard.color._value ? 'rgba' + this.item.billboard.color.toString() + '' : undefined;
        styles.width = this.item.billboard.width && this.item.billboard.width._value ? this.item.billboard.width._value : undefined;
        styles.height = this.item.billboard.height && this.item.billboard.height._value ? this.item.billboard.height._value : undefined;
        styles.near = this.item.billboard.distanceDisplayCondition ? this.item.billboard.distanceDisplayCondition._value.near : undefined;
        styles.far = this.item.billboard.distanceDisplayCondition ? this.item.billboard.distanceDisplayCondition._value.far : undefined;
        styles.position = this.item.position.getValue().toString();
        return styles;
    };
    /**
     * 删除label标签
     */
    ImageLabel.prototype.deleteObject = function () {
        this._viewer.entities.remove(this.item);
        // this = null;
    };
    /**
     * 修改图像标签的可视距离
     * @param {Object} [ImageLabel] ImageLabel对象
     * @param {String} [min, max] 设置线段的可视距离
     * @returns {Object} 返回一个ImageLabel对象。
     */
    ImageLabel.prototype.setDistanceDisplayCondition = function (min, max) {
        var distance = new this._cesium.DistanceDisplayCondition(min, max);
        try {
            this.item._billboard.distanceDisplayCondition = distance;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置ImageLabel的图像地址
     * @param {url} [url] 图像地址
     */
    ImageLabel.prototype.setUrl = function (url) {
        this.item._billboard.image = url;
    };

    /**
     * 设置label文本的透明度
     * @param {boolean} [b] true|false
     */
    ImageLabel.prototype.setVisibility = function (b) {
        this.item.show = b;
    };
    /**
     * 获取imagelabel的显示与隐藏
     */
    ImageLabel.prototype.getVisibility = function () {
        return this.item.show;
    };
    /**
     * 设置ImageLabel的颜色
     * @param {Object} [ImageLabel] ImageLabel对象
     * @param {String} [color] 颜色。
     * @returns {Object} 返回一个ImageLabel对象。
     */
    ImageLabel.prototype.setColor = function (htmlColor) {
        try {
            this.item._billboard.color = new Color(this._viewer, this._cesium).colorFromHtmlColor(htmlColor);
            this.item.color = this.item._billboard.color;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置ImageLabel的宽度
     * @param {Object} [ImageLabel] ImageLabel对象
     * @param {String} [width] 长度。
     * @returns {Object} 返回一个ImageLabel对象。
     */
    ImageLabel.prototype.setWidth = function (width) {
        try {
            this.item._billboard.width = width;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置ImageLabel的透明度
     * @param {Object} [ImageLabel] ImageLabel对象
     * @param {Float} [a] 透明度 0-1
     * @returns {Object} 返回一个ImageLabel对象。
     */
    ImageLabel.prototype.setColorAlpha = function (a) {
        try {
            this.item._billboard.color._value.alpha = a;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置ImageLabel的高度
     * @param {Object} [ImageLabel] ImageLabel对象
     * @param {String} [width] 长度。
     * @returns {Object} 返回一个ImageLabel对象。
     */
    ImageLabel.prototype.setHeight = function (height) {
        try {
            this.item._billboard.height = height;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置ImageLabel的高度类型
     * @param {Object} [ImageLabel] ImageLabel对象
     * @param {int} [type] 1：该位置被夹在地形上。2：这个职位是绝对的。3：位置高度是地形上方的高度。
     * @returns {Object} 返回一个对象。
     */
    ImageLabel.prototype.setHeightType = function (type) {
        try {
            if (type == 1) {
                this.item._billboard.heightReference = this._cesium.HeightReference.CLAMP_TO_GROUND;
            } else if (type == 2) {
                this.item._billboard.heightReference = this._cesium.HeightReference.NONE;
            } else if (type == 3) {
                this.item._billboard.heightReference = this._cesium.HeightReference.RELATIVE_TO_GROUND;
            }
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
     * 设置ImageLabel的旋转角
     * @param {Object} [ImageLabel] ImageLabel对象
     * @param {String} [width] 长度。
     * @returns {Object} 返回一个ImageLabel对象。
     */
    ImageLabel.prototype.setRotation = function (angle) {
        try {
            this.item._billboard.rotation = this._cesium.Math.toRadians(angle);
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    ImageLabel.prototype.setItem = function (item) {
        this.item = item;
    };
    /**
     * 设置ImageLabel的图像大小的比例。
     * @param {Object} [ImageLabel] ImageLabel对象
     * @param {String} [angle]1.0。
     * @returns {Object} 返回一个ImageLabel对象。
     */
    ImageLabel.prototype.setScale = function (angle) {
        try {
            this.item._billboard.scale = angle;
        } catch (ex) {
            console.log(ex);
        }
        return this;
    };
    /**
    * 这个方法用于创建图像标签
    * @param {Array} [position] IPosition6表示标签的位置和方向。
    * @param {String} [ImageLabel] 显示在标签中图像文件的完整路径或URL
    * @param {Object} [LabelStyle]ILabelStyle表示标签样式（例如，颜色，字体和可视距离属性）。
    * @param {Double} [GroupID] 组的ID，标签在该组中被创建。如果GroupID设置为零，则对象在根节点下创建。
    * @param {String} [Description] 显示在信息树中标签的名称。
    * @returns {Promise.<Object>} 返回一个Cesium的对象。
    * 
    */
    ImageLabel.prototype.CreateImageLabel = function (position, ImageFileName, LabelStyle, GroupID, Description) {
        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
            image: ImageLabel,
            show: true, // default
            scale: LabelStyle.Scale,
            color: LabelStyle.IconColor,
            distanceDisplayCondition: new this._cesium.DistanceDisplayCondition(LabelStyle.MinViewingHeight, LabelStyle.MaxViewingHeight)
        };
        this.item = this._viewer.entities.add({
            name: Description,
            //中心的位置（长、宽、高）
            position: this._cesium.Cartesian3.fromDegrees(positions.X, positions.X, positions.Altitude),
            billboard: defaultOption
        });
        var txname = this.item.id;
        if (Description == "") {
            txname = Description;
        }
        var obj = {
            id: this.item.id,
            name: txname,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'Imagelabel',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //return this;
        return this;
    };
    /**
     * 导出工程树数据
     * 
     */
    ImageLabel.prototype.export = function () {
        var image = this.item.billboard.image == undefined ? undefined : this.item.billboard.image._value;
        var show = this.item.billboard.show == undefined ? undefined : this.item.billboard.show._value;
        var scale = this.item.billboard.scale == undefined ? undefined : this.item.billboard.scale._value;
        var horizontalOrigin = this.item.billboard.horizontalOrigin == undefined ? undefined : this.item.billboard.horizontalOrigin._value;
        var verticalOrigin = this.item.billboard.verticalOrigin == undefined ? undefined : this.item.billboard.verticalOrigin._value;
        var rotation = this.item.billboard.rotation == undefined ? undefined : this.item.billboard.rotation._value;
        var width = this.item.billboard.width == undefined ? undefined : this.item.billboard.width._value;
        var height = this.item.billboard.height == undefined ? undefined : this.item.billboard.height._value;
        var color = this.item.billboard.color == undefined ? undefined : 'rgba(' + this.item.billboard.color._value.red + ',' + this.item.billboard.color._value.green + ',' + this.item.billboard.color._value.blue + ',' + this.item.billboard.color._value.alpha + ')';
        var heightReference = this.item.billboard.heightReference == undefined ? undefined : this.item.billboard.heightReference._value;
        var distanceDisplayCondition = this.item.billboard.distanceDisplayCondition;
        var near = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.near;
        var far = distanceDisplayCondition == undefined ? undefined : distanceDisplayCondition._value.far;
        var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
        var z = this._cesium.Math.toDegrees(Cartographic.height);
        return {
            type: 'image',
            position: {
                x: longitude,
                y: latitude,
                z: z
            },
            treeobj: { id: this.treeobj.id, name: this.treeobj.name, pId: this.treeobj.pId, type: this.treeobj.type },
            style: {
                image: image,
                show: show,
                scale: scale,
                horizontalOrigin: horizontalOrigin,
                verticalOrigin: verticalOrigin,
                rotation: rotation,
                width: width,
                height: height,
                color: color,
                heightReference: heightReference,
                near: near,
                far: far
            }
        }
    };
    //工程树添加
    ImageLabel.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    Object.defineProperties(ImageLabel.prototype, {
        position: {
            Altitude: {
                get: function () {
                    return this._postion.Altitude
                },
                set: function (Altitude) {
                    try {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        var height = this._cesium.Math.toDegrees(Cartographic.height);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, Altitude);
                        this.item.position.position = position;
                        this._postion.Altitude = Altitude;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            AltitudeType: {
                get: function () {
                    return this._postion.AltitudeType
                },
                set: function (AltitudeType) {
                    try {
                        this._postion.AltitudeType = AltitudeType;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Cartesian: {
                get: function () {
                    return this._postion.Cartesian
                },
                set: function (Cartesian) {
                    try {
                        this._postion.Cartesian = Cartesian;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Distance: {
                get: function () {
                    return this._postion.Distance
                },
                set: function (Distance) {
                    try {
                        this._postion.Distance = Distance;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Pitch: {
                get: function () {
                    return this._postion.Pitch
                },
                set: function (Pitch) {
                    try {
                        this._postion.Pitch = Pitch;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Roll: {
                get: function () {
                    return this._postion.Roll
                },
                set: function (Roll) {
                    try {
                        this._postion.Roll = Roll;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            X: {
                get: function () {
                    return this._postion.X
                },
                set: function (X) {
                    try {
                        this._postion.X = X;
                        var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        var height = this._cesium.Math.toDegrees(Cartographic.height);
                        // 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(X, latitude, height);
                        this.item.position.position = position;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Y: {
                get: function () {
                    return this._postion.Y
                },
                set: function (Y) {
                    try {
                        this._postion.Y = Y;
                        var Cartographic = this._cesium.Cartographic.fromCartesian(this.item.position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        var height = this._cesium.Math.toDegrees(Cartographic.height);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, Y, height);
                        this.item.position.position = position;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Yaw: {
                get: function () {
                    return this._postion.Yaw
                },
                set: function (Yaw) {
                    try {
                        this._postion.Yaw = Yaw;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            }
        },
        LabelStyle: {
            BackgroundColor: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            Bold: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            FontName: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            FontSize: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            FrameFileName: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            IconColor: {
                set: lodash.debounce(function (color) {
                    if (this._core.isnull(color)) return;
                    if (!this._core.isnull(color)) {
                        if (this._core.isHtmlColor(color)) {
                            color = this._Color.colorFromHtmlColor(color);
                        } else {
                            if (/^rgb/.test(color)) {
                                color = this._Color.rgbaStringToRgbaObj(color);
                            }
                            if (color.r > 1) {
                                color.r = color.r / 255;
                            }
                            if (color.g > 1) {
                                color.g = color.g / 255;
                            }
                            if (color.b > 1) {
                                color.b = color.b / 255;
                            }
                            if (color.a > 1) {
                                color.a = color.a / 255;
                            }
                            color = this._Color.createColor(color.r, color.g, color.b, color.a);
                        }
                    }
                    this.item.label.fillColor = color;
                    //this.item.fillColor = color;
                }, 500),
                get: function () {
                    var color = this.item.label.fillColor;
                    return this._Color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            },
            Italic: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            LimitScreenSize: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            LineColor: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            LineToGround: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            LockMode: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            MaxImageSize: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            MaxViewingHeight: {
                get: function () {
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        return this.item._label.distanceDisplayCondition._value.far;
                    }
                },
                set: function (far) {
                    var near = 0;
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        near = this.item._label.distanceDisplayCondition._value.near;
                    }
                    this.item._label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                }
            },
            MinViewingHeight: {
                get: function () {
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        return this.item._label.distanceDisplayCondition._value.near;
                    }
                },
                set: function (near) {
                    var far = 0;
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        far = this.item._label.distanceDisplayCondition._value.far;
                    }
                    this.item._label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                }
            },
            MultilineJustification: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            PivotAlignment: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            Scale: {
                get: function () {
                    if (this.item._label.scale != undefined) {
                        return this.item.label.scale.getValue();
                    }
                },
                set: function (fontq) {
                    this.item.label.scale.setValue(fontq);
                }
            },
            TextAlignment: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            TextColor: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            TextOnImage: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            Underline: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            }
        }
    });

    /**
     * 仿照te修改
     */
    ImageLabel.prototype.CreateImageLabel = function (Position, ImageFileName, LabelStyle, GroupID, Description) {
        this._postion = Position;

        var defaultOption = {
            id: this._core.getuid(), //获取或设置拾取标签时返回的用户定义值。
            image: ImageFileName,
            backgroundColor: LabelStyle.BackgroundColor, //获取或设置此标签的背景色。
            fillColor: LabelStyle.IconColor,
            font: LabelStyle.FontName,
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER,
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,
            outlineColor: LabelStyle.LineColor,
            show: true,
            scale: LabelStyle.Scale,
            showBackground: false,
            distanceDisplayCondition: new this._cesium.DistanceDisplayCondition(LabelStyle.MinViewingHeight, LabelStyle.MaxViewingHeight)
        };
        if (LabelStyle.Italic) {
            defaultOption.font = "italic " + defaultOption.font;
        }
        if (LabelStyle.Italic) {
            defaultOption.font = "Bold " + defaultOption.font;
        }
        var options = this._core.extend(defaultOption, LabelStyle, true);

        this.item = this._viewer.entities.add({
            name: Description,
            position: this._cesium.Cartesian3.fromDegrees(Position.X, Position.Y, Position.Altitude),
            billboard: options
        });

        var obj = {
            id: this.item.id,
            name: Description,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ImageLabel',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    Object.defineProperties(ImageLabel.prototype, {
        Position: {
            Altitude: {
                get: function () {
                    return this._postion.Altitude
                },
                set: function (Altitude) {
                    try {
                        // 赋值
                        this._postion.Altitude = Altitude;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            AltitudeType: {
                get: function () {
                    return this._postion.AltitudeType
                },
                set: function (AltitudeType) {
                    try {
                        this._postion.AltitudeType = AltitudeType;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Cartesian: {
                get: function () {
                    return this._postion.Cartesian
                },
                set: function (Cartesian) {
                    try {
                        this._postion.Cartesian = Cartesian;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Distance: {
                get: function () {
                    return this._postion.Distance
                },
                set: function (Distance) {
                    try {
                        this._postion.Distance = Distance;
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Pitch: {
                get: function () {
                    return this._postion.Pitch
                },
                set: function (Pitch) {
                    try {
                        this._postion.Pitch = Pitch;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Roll: {
                get: function () {
                    return this._postion.Roll
                },
                set: function (Roll) {
                    try {
                        this._postion.Roll = Roll;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            X: {
                get: function () {
                    return this._postion.X
                },
                set: function (X) {
                    try {
                        // 赋值
                        this._postion.X = X;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Y: {
                get: function () {
                    return this._postion.Y
                },
                set: function (Y) {
                    try {
                        // 赋值
                        this._postion.Y = Y;
                        this.item.position = this._cesium.Cartesian3.fromDegrees(this._postion.X, this._postion.Y, this._postion.Altitude);
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            },
            Yaw: {
                get: function () {
                    return this._postion.Yaw
                },
                set: function (Yaw) {
                    try {
                        this._postion.Yaw = Yaw;
                        this.item.orientation = this._cesium.Transforms.headingPitchRollQuaternion(
                            this.item.position._value,
                            new this._cesium.HeadingPitchRoll(
                                this._cesium.Math.toRadians(this._postion.Yaw),
                                this._cesium.Math.toRadians(this._postion.Pitch),
                                this._cesium.Math.toRadians(this._postion.Roll)
                            )
                        );
                    } catch (ex) {
                        console.log(ex);
                    }
                }
            }
        },
        LabelStyle: {
            BackgroundColor: {
                set: lodash.debounce(function (color) {
                    if (this._core.isnull(color)) return;
                    if (!this._core.isnull(color)) {
                        if (this._core.isHtmlColor(color)) {
                            color = this._Color.colorFromHtmlColor(color);
                        } else {
                            if (/^rgb/.test(color)) {
                                color = this._Color.rgbaStringToRgbaObj(color);
                            }
                            if (color.r > 1) {
                                color.r = color.r / 255;
                            }
                            if (color.g > 1) {
                                color.g = color.g / 255;
                            }
                            if (color.b > 1) {
                                color.b = color.b / 255;
                            }
                            if (color.a > 1) {
                                color.a = color.a / 255;
                            }
                            color = this._Color.createColor(color.r, color.g, color.b, color.a);
                        }
                    }
                    this.item.label.backgroundColor = color;
                    this.item.backgroundColor = color;
                }, 500),
                get: function () {
                    var color = this.item.label.backgroundColor;
                    return this._Color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            },
            Bold: {
                get: function () {
                    var font = this.item._label.font.getValue();
                    return font.indexOf("bold") != -1;
                },
                set: function () {
                    var font = "bold " + this.item._label.font.getValue();
                    this.item._label.font.setValue(font);
                }
            },
            FontName: {
                get: function () {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i] != "bold" && sz[i].indexOf("px") == -1 && sz[i].indexOf("PX") == -1) {
                            return sz[i];
                        }
                    }
                },
                set: function (fontq) {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    var fonts = fontq;
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i] != "bold" && sz[i].indexOf("px") == -1 && sz[i].indexOf("PX") == -1) ; else {
                            fonts = fonts + " " + sz[i];
                        }
                    }
                    this.item._label.font.setValue(fonts);
                }
            },
            FontSize: {
                get: function () {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i].indexOf("px") != -1) {
                            return sz[i];
                        }
                    }
                },
                set: function (fontq) {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    var fonts = fontq;
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i].indexOf("px") == -1) ; else {
                            fonts = fonts + " " + sz[i];
                        }
                    }
                    this.item._label.font.setValue(fonts);
                }
            },
            FrameFileName: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            IconColor: {
                set: lodash.debounce(function (color) {
                    if (this._core.isnull(color)) return;
                    if (!this._core.isnull(color)) {
                        if (this._core.isHtmlColor(color)) {
                            color = this._Color.colorFromHtmlColor(color);
                        } else {
                            if (/^rgb/.test(color)) {
                                color = this._Color.rgbaStringToRgbaObj(color);
                            }
                            if (color.r > 1) {
                                color.r = color.r / 255;
                            }
                            if (color.g > 1) {
                                color.g = color.g / 255;
                            }
                            if (color.b > 1) {
                                color.b = color.b / 255;
                            }
                            if (color.a > 1) {
                                color.a = color.a / 255;
                            }
                            color = this._Color.createColor(color.r, color.g, color.b, color.a);
                        }
                    }
                    this.item.label.fillColor = color;
                    //this.item.fillColor = color;
                }, 500),
                get: function () {
                    var color = this.item.label.fillColor;
                    return this._Color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            },
            Italic: {
                get: function () {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i].indexOf("italic") != -1) {
                            return sz[i];
                        }
                    }
                },
                set: function (fontq) {
                    var font = this.item._label.font.getValue();
                    var sz = font.split(" ");
                    var fonts = fontq;
                    for (var i = 0; i < sz.length; i++) {
                        if (sz[i].indexOf("italic") == -1) ; else {
                            fonts = fonts + " " + sz[i];
                        }
                    }
                    this.item._label.font.setValue(fonts);
                }
            },
            LimitScreenSize: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            LineColor: {
                set: lodash.debounce(function (color) {
                    if (this._core.isnull(color)) return;
                    if (!this._core.isnull(color)) {
                        if (this._core.isHtmlColor(color)) {
                            color = this._Color.colorFromHtmlColor(color);
                        } else {
                            if (/^rgb/.test(color)) {
                                color = this._Color.rgbaStringToRgbaObj(color);
                            }
                            if (color.r > 1) {
                                color.r = color.r / 255;
                            }
                            if (color.g > 1) {
                                color.g = color.g / 255;
                            }
                            if (color.b > 1) {
                                color.b = color.b / 255;
                            }
                            if (color.a > 1) {
                                color.a = color.a / 255;
                            }
                            color = this._Color.createColor(color.r, color.g, color.b, color.a);
                        }
                    }
                    this.item.label.outlineColor = color;
                    //this.item.fillColor = color;
                }, 500),
                get: function () {
                    var color = this.item.label.outlineColor;
                    return this._Color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            },
            LineToGround: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            LockMode: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            MaxImageSize: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            MaxViewingHeight: {
                get: function () {
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        return this.item._label.distanceDisplayCondition._value.far;
                    }
                },
                set: function (far) {
                    var near = 0;
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        near = this.item._label.distanceDisplayCondition._value.near;
                    }
                    this.item._label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                }
            },
            MinViewingHeight: {
                get: function () {
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        return this.item._label.distanceDisplayCondition._value.near;
                    }
                },
                set: function (near) {
                    var far = 0;
                    if (this.item._label.distanceDisplayCondition != undefined) {
                        far = this.item._label.distanceDisplayCondition._value.far;
                    }
                    this.item._label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                }
            },
            MultilineJustification: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            PivotAlignment: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            Scale: {
                get: function () {
                    if (this.item._label.scale != undefined) {
                        return this.item.label.scale.getValue();
                    }
                },
                set: function (fontq) {
                    this.item.label.scale.setValue(fontq);
                }
            },
            TextAlignment: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            TextColor: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            TextOnImage: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            },
            Underline: {
                get: function () {
                    return "";
                },
                set: function (fontq) {
                }
            }
        }
    });

    /**
    *
    *   墙
    *
    * @alias wall
    * @constructor
    *
    * @param {viewer|object} viewer 传入数据。
    * @param {viewer|object} cesium 传入数据。
    *
    */
    function wall(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
        //this.curCanvas = "a";
    }

    /**
     * 创建wall
     * 
     * @param {string} [name] 名称
     * @param {object} [options] 名称
     */
    wall.prototype.createWall = function (name, Geometry, options, GroupID) {
        var defaultOptions = {
            show: true,
            minimumHeights: [100, 100, 100, 100, 100, 100, 100],
            maximumHeights: [2000, 2000, 2000, 2000, 2000, 2000, 2000],
            material: this._cesium.Color.AQUA.withAlpha(1)
        };
        if (this._core.isnull(options)) {
            console.log('options is required');
            return;
        }
        options = this._core.extend(defaultOptions, options, true);
        var cor = new Core();
        if (options && options.material == "ImageMaterialProperty") {
            options.material = cor.setImageMaterialProperty("../../img/arrow.png", this._cesium, 0, options.id);
        } else if (options && options.material == "DrawCanvasColorUpdown") {
            options.material = cor.setImageMaterialProperty("../../img/arrow.png", this._cesium, 1, options.id);
        }
        var pArray = [];
        if (!Geometry[0].x && !Geometry[0].y) {
            if (Geometry[0].length === 2) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1]));
                }
            } else if (Geometry[0].length === 3) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1], Geometry[i][2]));
                }
            }
        } else {
            if (Geometry[0].z !== undefined) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y, Geometry[i].z));
                }
            } else {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y));
                }
            }
        }
        options.positions = pArray;
        if (options.minHeight !== undefined) {
            options.minimumHeights = new Array(options.positions.length).fill(options.minHeight);
        }
        if (options.maxHeight !== undefined) {
            options.maximumHeights = new Array(options.positions.length).fill(options.maxHeight);
        }
        var wall = this._viewer.entities.add({
            name: name,
            id: this._core.getuid(),
            wall: options,
        });
        wall.positions = options.positions;
        this.item = wall;
        this._tree.insertGroupId({
            id: wall.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'wall',
            item: this
        }, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 
     * 用于command调用创建wall
     * 
     * @param {Array} [ponsitions] [x,y,z......]这是传入的参数
     * 
     * */
    wall.prototype.executeWall = function (name, GroupID) {
        var positions = [];
        var poly = undefined;
        var _this = this;
        var wallPoly = (function () {
            function _wall(positions) {
                this.options = {
                    id: _this._core.getuid(),
                    type: "wall",
                    wall: {
                        positions: [],
                        minimumHeights: [2000, 2000],
                        maximumHeights: [1000, 1000],
                        //material: _this._cesium.Color.AQUA.withAlpha(1)
                        material: _this._core.setImageMaterialProperty("img/arrow.png", _this._cesium, 1)
                    }
                };
                this.positions = positions;
                this._init();
            }
            _wall.prototype._init = function () {
                var _self = this;
                var _update = function () {
                    var dp = [];
                    for (var i = 0; i < _self.positions.length; i++) {
                        if (!positions[i]) return;
                        var ellipsoid = _this._viewer.scene.globe.ellipsoid;
                        var cartesian3 = new _this._cesium.Cartesian3(positions[i].x, positions[i].y, positions[i].z);
                        var cartographic = ellipsoid.cartesianToCartographic(cartesian3);
                        var lat = _this._cesium.Math.toDegrees(cartographic.latitude);
                        var lng = _this._cesium.Math.toDegrees(cartographic.longitude);
                        cartographic.height;
                        dp.push(lng);
                        dp.push(lat);
                        //_self.options.wall.minimumHeights.push(2000);
                        //dp.push(200);
                    }
                    //return _this._cesium.Cartesian3.fromDegreesArrayHeights(dp);//_self.positions;
                    return _this._cesium.Cartesian3.fromDegreesArray(dp);//_self.positions;
                };
                var _updatemaxheight = function () {
                    var heights = [];
                    for (var i = 0; i < _self.positions.length; i++) {
                        heights.push(2000);
                    }
                    return heights;
                };
                var _updateminheight = function () {
                    var heights = [];
                    for (var i = 0; i < _self.positions.length; i++) {
                        heights.push(1000);
                    }
                    return heights;
                };
                this.options.wall.maximumHeights = new _this._cesium.CallbackProperty(_updatemaxheight, false);
                this.options.wall.minimumHeights = new _this._cesium.CallbackProperty(_updateminheight, false);
                this.options.wall.positions = new _this._cesium.CallbackProperty(_update, false);
                var wall = _this._viewer.entities.add(this.options);
                _this.item = wall;
                _this._tree.insertGroupId({
                    id: this.options.id,
                    name: name,
                    pId: _this._core.isnull(GroupID) ? 0 : GroupID,
                    type: 'wall',
                    item: _this
                }, _this._core.isnull(GroupID) ? 0 : GroupID);
            };
            return _wall;
        })();
        var handler = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        handler.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.position, _this._viewer.scene.globe.ellipsoid);
            if (positions.length == 0) {
                positions.push(lodash.clone(cartesian));
            }
            positions.push(lodash.clone(cartesian));
        }, _this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        handler.setInputAction(function (movement) {
            var cartesian = _this._viewer.scene.camera.pickEllipsoid(movement.endPosition, _this._viewer.scene.globe.ellipsoid);
            if (positions.length >= 1) {
                if (!_this._cesium.defined(poly)) {
                    poly = new wallPoly(positions);
                } else {
                    positions.pop();
                    positions.push(cartesian);
                }
            }
        }, _this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        handler.setInputAction(function (movement) {
            handler.destroy();
            positions.pop();
        }, _this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
    };

    /**
    * 设置颜色变动
    */
    var curCanvas$1 = "a";
    var i$3 = 0;
    wall.prototype.drawCanvasImage = function (time, result) {
        var canvas = document.getElementById("canvas-" + curCanvas$1);
        var cwidth = 700;
        var cheight = 100;
        var ctx = canvas.getContext("2d");
        var img = new Image();
        img.src = "img/arrow.png";
        ctx.clearRect(0, 0, cwidth, cheight);
        img.onload = function () {
            if (i$3 <= cwidth) {
                ctx.drawImage(img, i$3, 0);
                ctx.drawImage(img, i$3 + 100, 0);
            } else
                i$3 = 0;
            i$3 += 5;
        };
        curCanvas$1 = curCanvas$1 === 'a' ? 'b' : 'a';
        return canvas;
    };
    /**
     * 设置wall的可见性
     */
    wall.prototype.setVisibility = function (b) {
        this.item.wall.show = b;
    };
    /**
     * 获取wall的可见性
     */
    wall.prototype.getVisibility = function () {
        return this.item.wall.show;
    };
    /**
     * 删除元素
     */
    wall.prototype.deleteObject = function () {
        this._viewer.entities.remove(this.item);
    };
    Object.defineProperties(wall.prototype, {
        /**
         * 获取或设置矩形
         */
        rectangle: {
            get: function () {
                return this.item.rectangle;
            },
            set: function (rectangle) {
                this.item.rectangle = rectangle;
            }
        }
    });

    Object.defineProperties(wall.prototype, {
        /**
         * 获取或设置线条
         */
        polyline: {
            get: function () {
                return this.item.polyline;
            },
            set: function (polyline) {
                this.item.polyline = polyline;
            }
        }
    });


    wall.prototype.setItem = function (item) {
        this.item = item;
    };
    //工程树添加
    wall.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    Object.defineProperties(wall.prototype, {
        /**
         * 获取或设置面
         */
        polygon: {
            get: function () {
                return this.item.polygon;
            },
            set: function (polygon) {
                this.item.polygon = polygon;
            }
        }
    });

    Object.defineProperties(wall.prototype, {
        /**
         * 获取或设置点
         */
        point: {
            get: function () {
                return this.item.point;
            },
            set: function (point) {
                this.item.point = point;
            }
        }
    });

    Object.defineProperties(wall.prototype, {
        /**
         * 获取或设置标签
         */
        label: {
            get: function () {
                return this.item.label;
            },
            set: function (label) {
                this.item.label = label;
            }
        }
    });

    Object.defineProperties(wall.prototype, {
        /**
         * 获取或设置模型
         */
        model: {
            get: function () {
                return this.item.model;
            },
            set: function (model) {
                this.item.model = model;
            }
        }
    });

    Object.defineProperties(wall.prototype, {
        /**
         * 获取或设置墙
         */
        wall: {
            get: function () {
                return this.item.wall;
            },
            set: function (wall) {
                this.item.wall = wall;
            }
        }
    });

    Object.defineProperties(wall.prototype, {
        /**
         * 获取墙的模板属性
         */
        wallTempOptions: {
            get: function () {
                return {
                    positions: [],//	Property		optional A Property specifying the array of Cartesian3 positions which define the top of the wall.
                    maximumHeights: [],//	Property		optional A Property specifying an array of heights to be used for the top of the wall instead of the height of each position.
                    minimumHeights: [],//	Property		optional A Property specifying an array of heights to be used for the bottom of the wall instead of the globe surface.
                    show: true,//	Property	true	optional A boolean Property specifying the visibility of the wall.
                    fill: true,//	Property	true	optional A boolean Property specifying whether the wall is filled with the provided material.
                    material: this._cesium.Color.WHITE,//	MaterialProperty	Color.WHITE	optional A Property specifying the material used to fill the wall.
                    outline: false,//	Property	false	optional A boolean Property specifying whether the wall is outlined.
                    outlineColor: this._cesium.Color.BLACK,//	Property	Color.BLACK	optional A Property specifying the Color of the outline.
                    outlineWidth: 1.0,//	Property	1.0	optional A numeric Property specifying the width of the outline.
                    granularity: this._cesium.Math.RADIANS_PER_DEGREE,//	Property	Cesium.Math.RADIANS_PER_DEGREE	optional A numeric Property specifying the angular distance between each latitude and longitude point.
                    shadows: ShadowMode.DISABLED,//	Property	ShadowMode.DISABLED	optional An enum Property specifying whether the wall casts or receives shadows from each light source.
                    distanceDisplayCondition: null
                }
            }
        }
    });

    /**
     *
     * 创建添加影像图层。
     *
     * @alias ImageryLayer
     * @constructor
     *
     * @param {Viewer} Viewer Cesium的viewer对象。
     *
     */
    function ImageryLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
        this._BaiduImageryProvider = new BaiduImageryProvider(viewer, cesium);
    }

    /**
         * 创建imagelayer图层
         * @param {String} name
         * @param {object|String} option
         * {
            url: "",//The URL of the ArcGIS MapServer service.
            token: "",//		optional The ArcGIS token used to authenticate with the ArcGIS MapServer service.
            usePreCachedTilesIfAvailable: true,//	optional If true, the server's pre-cached tiles are used if they are available. If false, any pre-cached tiles are ignored and the 'export' service is used.
            layers: "",//		optional A comma-separated list of the layers to show, or undefined if all layers should be shown.
            enablePickFeatures: true,//optional If true, ArcGisMapServerImageryProvider#pickFeatures will invoke the Identify service on the MapServer and return the features included in the response. If false, ArcGisMapServerImageryProvider#pickFeatures will immediately return undefined (indicating no pickable features) without communicating with the server. Set this property to false if you don't want this provider's features to be pickable. Can be overridden by setting the ArcGisMapServerImageryProvider#enablePickFeatures property on the object.
            rectangle: this._cesium.Rectangle.MAX_VALUE,//	optional The rectangle of the layer. This parameter is ignored when accessing a tiled layer.
            tilingScheme: new this._cesium.GeographicTilingScheme(),//	optional The tiling scheme to use to divide the world into tiles. This parameter is ignored when accessing a tiled server.
            credit: "",//	optional A credit for the data source, which is displayed on the canvas. This parameter is ignored when accessing a tiled server.
            tileWidth: 256,//	optional The width of each tile in pixels. This parameter is ignored when accessing a tiled server.
            tileHeight: 256,//	optional The height of each tile in pixels. This parameter is ignored when accessing a tiled server.
        }
         @param {String} GroupID
         @param {String} Description
         */
    ImageryLayer.prototype.createArcGisImageryLayer = function (name, option, GroupID, index, checked, disFnc) {
        var defaultOption = {
            url: '', //The URL of the ArcGIS MapServer service.
        };
        var options = null;
        if (this._core.isUrl(option)) {
            options = defaultOption;
            options.url = option;
        } else {
            options = this._core.extend(defaultOption, option, true);
        }
        if (this._core.isnull(name)) {
            name = '新建影像图层';
        }

        var imageryProvider = new this._cesium.ArcGisMapServerImageryProvider(options);
        // var imageLayer = new this._cesium.ImageryLayer(imageryProvider, {});
        let _option = {
            alpha: options.alpha,
            brightness: options.brightness,
            availability: options.availability,
        };
        //添加级别限制
        if (options.Level !== undefined || options.level !== undefined) {
            let level = this._core.defaultValue(options.Level, options.level);
            if (level.indexOf && level.indexOf(',') > -1) {
                level = level.split(',');
                _option.maximumTerrainLevel = level[1];
                _option.minimumTerrainLevel = level[0];
            } else {
                _option.minimumTerrainLevel = level;
            }
        }
        //添加时间段
        if (options.time) {
            _option.availability = new this._cesium.TimeIntervalCollection([
                new this._cesium.TimeInterval({
                    start: options.time.start ? this._cesium.JulianDate.fromDate(new Date(options.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                    stop: options.time.end ? this._cesium.JulianDate.fromDate(new Date(options.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE,
                }),
            ]);
        }
        this.availability = _option.availability;
        this.item = new this._cesium.ImageryLayer(imageryProvider, _option);
        this._viewer.imageryLayers.add(this.item, index);

        !checked && this.setVisibility(false);
        disFnc && typeof disFnc == 'function' && disFnc(this.item);

        var id = this._core.getuid();
        var obj = {
            id: options.id || id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ImageryProvider',
            smtype: 'arcgis',
            item: this,
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    ImageryLayer.prototype.createImageryLayerGrid = function (option) {
        var imageryLayers = this._viewer.imageryLayers;
        var layer = imageryLayers.addImageryProvider(new this._cesium.GridImageryProvider(option));
        this.item = layer;
        return this;
    };
    /**
         * 创建imagelayer图层
         * @param {String} name
         * @param {object|String} option
         * {
           url: "",	//Resource | String		The URL of the WMS service. The URL supports the same keywords as the UrlTemplateImageryProvider.
            layers: "",		//The layers to include, separated by commas.
            parameters: {
                service: 'WMS',
                format: 'image/png',
                transparent: true,

            },//	Object	WebMapServiceImageryProvider.DefaultParameters	optional Additional parameters to pass to the WMS server in the GetMap URL.
            //getFeatureInfoParameters	Object	WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters	optional Additional parameters to pass to the WMS server in the GetFeatureInfo URL.
            enablePickFeatures: true,//	optional If true, WebMapServiceImageryProvider#pickFeatures will invoke the GetFeatureInfo operation on the WMS server and return the features included in the response. If false, WebMapServiceImageryProvider#pickFeatures will immediately return undefined (indicating no pickable features) without communicating with the server. Set this property to false if you know your WMS server does not support GetFeatureInfo or if you don't want this provider's features to be pickable. Note that this can be dynamically overridden by modifying the WebMapServiceImageryProvider#enablePickFeatures property.
            //getFeatureInfoFormats	Array.<GetFeatureInfoFormat>	WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats	optional The formats in which to try WMS GetFeatureInfo requests.
            rectangle: this._cesium.Rectangle.MAX_VALUE,//	optional The rectangle of the layer.
            //tilingScheme	:	new this._cesium.GeographicTilingScheme(),//	optional The tiling scheme to use to divide the world into tiles.
            //ellipsoid	Ellipsoid		optional The ellipsoid. If the tilingScheme is specified, this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither parameter is specified, the WGS84 ellipsoid is used.
            tileWidth: 256,//	optional The width of each tile in pixels.
            tileHeight: 256,//	optional The height of each tile in pixels.
            minimumLevel: 0,//	optional The minimum level-of-detail supported by the imagery provider. Take care when specifying this that the number of tiles at the minimum level is small, such as four or less. A larger number is likely to result in rendering problems.
            maximumLevel: undefined,//		optional The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit. If not specified, there is no limit.
            crs: "",//		optional CRS specification, for use with WMS specification >= 1.3.0.
            srs: "",//		optional SRS specification, for use with WMS specification 1.1.0 or 1.1.1
            credit: "",		//optional A credit for the data source, which is displayed on the canvas.
            subdomains: "",// | Array.<String>	'abc'	optional The subdomains to use for the {s} placeholder in the URL template. If this parameter is a single string, each character in the string is a subdomain. If it is an array, each element in the array is a subdomain.
            //clock	Clock		optional A Clock instance that is used when determining the value for the time dimension. Required when options.times is specified.
            //times	TimeIntervalCollection		optional TimeIntervalCollection with its data property being an object containing time dynamic dimension and their values.
        }
         @param {String} GroupID
         @param {String} Description
         */
    ImageryLayer.prototype.createWebMapServerImageLayer = function (name, option, GroupID, index, checked, disFnc) {
        var defaultOption = {
            url: '',
            layers: '',
            parameters: {
                service: 'WMS',
                format: 'image/png',
                transparent: true,
            },
            //enablePickFeatures: true,
            //rectangle: this._cesium.Rectangle.MAX_VALUE,
            //tileWidth: 256,
            //tileHeight: 256,
            //minimumLevel: 0,
            //crs: "",
            //srs: "",
            //credit: "",
            //subdomains: "",
        };
        var options = null;
        if (this._core.isUrl(option)) {
            options = defaultOption;
            options.url = option;
        } else {
            options = this._core.extend(defaultOption, option, true);
        }
        if (this._core.isnull(name)) {
            name = '新建影像图层';
        }
        var imageryProvider = new this._cesium.WebMapServiceImageryProvider(options);
        let _option = {
            alpha: options.alpha,
            brightness: options.brightness,
            availability: options.availability,
        };
        //添加级别限制
        if (options.Level !== undefined || options.level !== undefined) {
            let level = this._core.defaultValue(options.Level, options.level);
            if (level.indexOf && level.indexOf(',') > -1) {
                level = level.split(',');
                _option.maximumTerrainLevel = level[1];
                _option.minimumTerrainLevel = level[0];
            } else {
                _option.minimumTerrainLevel = level;
            }
        }
        //添加时间段
        if (options.time) {
            _option.availability = new this._cesium.TimeIntervalCollection([
                new this._cesium.TimeInterval({
                    start: options.time.start ? this._cesium.JulianDate.fromDate(new Date(options.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                    stop: options.time.end ? this._cesium.JulianDate.fromDate(new Date(options.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE,
                }),
            ]);
        }
        this.availability = _option.availability;
        this.item = new this._cesium.ImageryLayer(imageryProvider, _option);
        this._viewer.imageryLayers.add(this.item, index);

        !checked && this.setVisibility(false);
        disFnc && typeof disFnc == 'function' && disFnc(this.item);

        var id = this._core.getuid();
        //ImageryProvider
        var obj = {
            id: options.id || id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ImageryProvider',
            smtype: 'wms',
            item: this,
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 加载矢量
     * @param {object} 对象
     */
    ImageryLayer.prototype.createMVTWithStyle = function (name, option, GroupID, disFnc) {
        //this._viewer.imageryLayers.addImageryProvider(de);
        GroupID = 0;
        this.item = this._viewer.imageryLayers.addImageryProvider(option);
        if (checked) ; else {
            this.setVisibility(false);
        }
        option.show = false;
        var id = this._core.getuid();
        var obj = {
            id: options.id || id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ImageryProvider',
            show: false,
            item: this,
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //this.item = this._viewer.imageryLayers.addImageryProvider(option);
        return this;
    };
    /**
         * 创建imagelayer图层
         * @param {String} name
         * @param {object|String} option
         * {
           url: "",	//Resource | String		The URL of the WMS service. The URL supports the same keywords as the UrlTemplateImageryProvider.
            layers: "",		//The layers to include, separated by commas.
            parameters: {
                service: 'WMS',
                format: 'image/png',
                transparent: true,

            },//	Object	WebMapServiceImageryProvider.DefaultParameters	optional Additional parameters to pass to the WMS server in the GetMap URL.
            //getFeatureInfoParameters	Object	WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters	optional Additional parameters to pass to the WMS server in the GetFeatureInfo URL.
            enablePickFeatures: true,//	optional If true, WebMapServiceImageryProvider#pickFeatures will invoke the GetFeatureInfo operation on the WMS server and return the features included in the response. If false, WebMapServiceImageryProvider#pickFeatures will immediately return undefined (indicating no pickable features) without communicating with the server. Set this property to false if you know your WMS server does not support GetFeatureInfo or if you don't want this provider's features to be pickable. Note that this can be dynamically overridden by modifying the WebMapServiceImageryProvider#enablePickFeatures property.
            //getFeatureInfoFormats	Array.<GetFeatureInfoFormat>	WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats	optional The formats in which to try WMS GetFeatureInfo requests.
            rectangle: this._cesium.Rectangle.MAX_VALUE,//	optional The rectangle of the layer.
            //tilingScheme	:	new this._cesium.GeographicTilingScheme(),//	optional The tiling scheme to use to divide the world into tiles.
            //ellipsoid	Ellipsoid		optional The ellipsoid. If the tilingScheme is specified, this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither parameter is specified, the WGS84 ellipsoid is used.
            tileWidth: 256,//	optional The width of each tile in pixels.
            tileHeight: 256,//	optional The height of each tile in pixels.
            minimumLevel: 0,//	optional The minimum level-of-detail supported by the imagery provider. Take care when specifying this that the number of tiles at the minimum level is small, such as four or less. A larger number is likely to result in rendering problems.
            maximumLevel: undefined,//		optional The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit. If not specified, there is no limit.
            crs: "",//		optional CRS specification, for use with WMS specification >= 1.3.0.
            srs: "",//		optional SRS specification, for use with WMS specification 1.1.0 or 1.1.1
            credit: "",		//optional A credit for the data source, which is displayed on the canvas.
            subdomains: "",// | Array.<String>	'abc'	optional The subdomains to use for the {s} placeholder in the URL template. If this parameter is a single string, each character in the string is a subdomain. If it is an array, each element in the array is a subdomain.
            //clock	Clock		optional A Clock instance that is used when determining the value for the time dimension. Required when options.times is specified.
            //times	TimeIntervalCollection		optional TimeIntervalCollection with its data property being an object containing time dynamic dimension and their values.
        }
         @param {String} GroupID
         @param {String} Description
         */
    ImageryLayer.prototype.createWebMapTileServerImageLayer = function (name, option, GroupID, index, checked, disFnc) {
        var defaultOption = {
            url: '', //	资源 | 串		WMTS GetTile操作的基本URL（用于KVP编码的请求）或tile-URL模板（用于RESTful请求）。tile-URL模板应包含以下变量：{style}，{TileMatrixSet}，{TileMatrix}，{TileRow}，{TileCol}。如果实际值是硬编码的或服务器不需要，则前两个是可选的。{s}关键字可用于指定子域。
        };
        var options = null;
        if (this._core.isUrl(option)) {
            options = defaultOption;
            options.url = option;
        } else {
            options = this._core.extend(defaultOption, option, true);
        }
        if (this._core.isnull(name)) {
            name = '新建影像图层';
        }


        let _option = {
            alpha: options.alpha,
            brightness: options.brightness,
            availability: options.availability,
        };

        //添加级别限制
        if (options.Level !== undefined || options.level !== undefined) {
            let level = this._core.defaultValue(options.Level, options.level);
            if (level.indexOf && level.indexOf(',') > -1) {
                level = level.split(',');
                _option.maximumTerrainLevel = level[1];
                _option.minimumTerrainLevel = level[0];
            } else {
                _option.minimumTerrainLevel = level;
            }
        }

        var imageryProvider;
        if (options.TD_SD) {
            //山东影像
            imageryProvider = new TDTWMTSImageProvider(options.url, false, _option.minimumTerrainLevel || 0, _option.maximumTerrainLevel || 21);
        } else {
            imageryProvider = new this._cesium.WebMapTileServiceImageryProvider(options);
        }

        //层级控制
        if (options.addLevel) {
            imageryProvider.addLevel = options.addLevel;
        }

        //添加时间段
        if (options.time) {
            _option.availability = new this._cesium.TimeIntervalCollection([
                new this._cesium.TimeInterval({
                    start: options.time.start ? this._cesium.JulianDate.fromDate(new Date(options.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                    stop: options.time.end ? this._cesium.JulianDate.fromDate(new Date(options.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE,
                }),
            ]);
        }
        this.availability = _option.availability;
        this.item = new this._cesium.ImageryLayer(imageryProvider, _option);
        this._viewer.imageryLayers.add(this.item, index);

        !checked && this.setVisibility(false);
        disFnc && typeof disFnc == 'function' && disFnc(this.item);

        var id = this._core.getuid();
        var obj = {
            id: options.id || id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ImageryProvider',
            smtype: 'skymap',
            item: this,
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    ImageryLayer.prototype.createUrlTemplateImageryProvider = function (name, option, GroupID, index, checked, disFnc) {
        var defaultOption = {
            url: '',
        };
        var options = null;
        if (this._core.isUrl(option)) {
            options = defaultOption;
            options.url = option;
        } else {
            options = this._core.extend(defaultOption, option, true);
        }
        if (this._core.isnull(name)) {
            name = '新建影像图层';
        }

        var imageryProvider = new this._cesium.UrlTemplateImageryProvider(options);
        let _option = {
            alpha: options.alpha,
            brightness: options.brightness,
            availability: options.availability,
        };
        //添加级别限制
        if (options.Level !== undefined || options.level !== undefined) {
            let level = this._core.defaultValue(options.Level, options.level);
            if (level.indexOf && level.indexOf(',') > -1) {
                level = level.split(',');
                _option.maximumTerrainLevel = level[1];
                _option.minimumTerrainLevel = level[0];
            } else {
                _option.minimumTerrainLevel = level;
            }
        }
        //添加时间段
        if (options.time) {
            _option.availability = new this._cesium.TimeIntervalCollection([
                new this._cesium.TimeInterval({
                    start: options.time.start ? this._cesium.JulianDate.fromDate(new Date(options.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                    stop: options.time.end ? this._cesium.JulianDate.fromDate(new Date(options.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE,
                }),
            ]);
        }
        this.availability = _option.availability;
        this.item = new this._cesium.ImageryLayer(imageryProvider, _option);
        this._viewer.imageryLayers.add(this.item, index);

        !checked && this.setVisibility(false);
        disFnc && typeof disFnc == 'function' && disFnc(this.item);

        var id = this._core.getuid();
        var obj = {
            id: options.id || id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ImageryProvider',
            smtype: 'goglemap',
            item: this,
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    //影像加载
    ImageryLayer.prototype.createImageryProvider = function (name, type, option, GroupID, index, checked, disFnc) {
        var defaultOptions = {
            //url: 'https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer',
        };
        var options = this._core.extend(defaultOptions, option, true);
        var de;
        if (type == 'arcgis') {
            de = new this._cesium.ArcGisMapServerImageryProvider(options);
        } else if (type == 'geoserver') {
            de = new this._cesium.WebMapServiceImageryProvider(options);
        } else if (type == 'wms') {
            de = new this._cesium.WebMapServiceImageryProvider(options);
        } else if (type == 'cesiumBlack') {
            de = new this._cesium.TileMapServiceImageryProvider(options);
        } else if (type == 'skymap') {
            de = new this._cesium.WebMapTileServiceImageryProvider(options);
        } else if (type == 'goglemap') {
            de = new this._cesium.UrlTemplateImageryProvider(options);
        } else if (type == 'BingMap') {
            de = new this._cesium.BingMapsImageryProvider(options);
        } else if (type == 'OpenStreetMap') {
            de = new this._cesium.OpenStreetMapImageryProvider(options);
        } else if (type == 'MapBox') {
            de = new this._cesium.MapboxImageryProvider(options);
        } else if (type == 'BaiduMap') {
            de = new this._BaiduImageryProvider.BaiduImageryProvider(options);
        }
        //de = new this._cesium.WebMapTileServiceImageryProvider(options);
        //this._viewer.imageryLayers.addImageryProvider(de);
        let _option = {
            alpha: options.alpha,
            brightness: options.brightness,
            availability: options.availability,
        };
        //添加级别限制
        if (options.Level !== undefined || options.level !== undefined) {
            let level = this._core.defaultValue(options.Level, options.level);
            if (level.indexOf && level.indexOf(',') > -1) {
                level = level.split(',');
                _option.maximumTerrainLevel = level[1];
                _option.minimumTerrainLevel = level[0];
            } else {
                _option.minimumTerrainLevel = level;
            }
        }
        //添加时间段
        if (options.time) {
            _option.availability = new this._cesium.TimeIntervalCollection([
                new this._cesium.TimeInterval({
                    start: options.time.start ? this._cesium.JulianDate.fromDate(new Date(options.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                    stop: options.time.end ? this._cesium.JulianDate.fromDate(new Date(options.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE,
                }),
            ]);
        }
        this.availability = _option.availability;
        this.item = new this._cesium.ImageryLayer(de, _option);
        this._viewer.imageryLayers.add(this.item, index);

        !checked && this.setVisibility(false);
        disFnc && typeof disFnc == 'function' && disFnc(this.item);

        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        var obj = {
            id: options.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ImageryProvider',
            checked: checked,
            item: this,
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    //缓存影像
    ImageryLayer.prototype.createCacheImageryProvider = function (name, option, GroupID, index, checked, disFnc) {
        var defaultOptions = {
            //url: 'https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer',
            fileExtension: 'jpg',
            cacheMaxLevel: 16,
        };
        index = index | 1;
        var options = this._core.extend(defaultOptions, option, true);

        let _cacheOption = {
            alpha: options.alpha,
            brightness: options.brightness,
            availability: options.availability,
            show: true,
        };
        let _hdOption = {
            alpha: options.alpha,
            brightness: options.brightness,
            availability: options.availability,
            show: true,
        };
        //添加时间段
        if (options.time) {
            _cacheOption.availability = new this._cesium.TimeIntervalCollection([
                new this._cesium.TimeInterval({
                    start: options.time.start ? this._cesium.JulianDate.fromDate(new Date(options.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                    stop: options.time.end ? this._cesium.JulianDate.fromDate(new Date(options.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE,
                }),
            ]);
            _hdOption.availability = new this._cesium.TimeIntervalCollection([
                new this._cesium.TimeInterval({
                    start: options.time.start ? this._cesium.JulianDate.fromDate(new Date(options.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                    stop: options.time.end ? this._cesium.JulianDate.fromDate(new Date(options.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE,
                }),
            ]);
        }
        //添加级别限制

        if (options.Level !== undefined || options.level !== undefined) {
            let level = this._core.defaultValue(options.Level, options.level);
            if (level.indexOf && level.indexOf(',') > -1) {
                level = level.split(',');
                if (level[1] > options.cacheMaxLevel) {
                    _cacheOption.show = true;
                    _hdOption.maximumTerrainLevel = level[1];
                    _hdOption.show = true;
                } else {
                    _cacheOption.show = true;
                    _hdOption.show = false;
                }
                if (level[0] > options.cacheMaxLevel) {
                    _cacheOption.show = false;
                    _hdOption.minimumTerrainLevel = level[0];
                    _hdOption.show = true;
                } else {
                    _cacheOption.show = true;
                    _hdOption.minimumTerrainLevel = options.cacheMaxLevel;
                }
            } else {
                if (level > options.cacheMaxLevel) {
                    _cacheOption.show = false;
                    _hdOption.minimumTerrainLevel = level;
                    _hdOption.show = true;
                } else {
                    _cacheOption.show = true;
                    _hdOption.minimumTerrainLevel = options.cacheMaxLevel;
                    _hdOption.show = true;
                }
            }
        } else {
            _cacheOption.show = true;
            _hdOption.minimumTerrainLevel = options.cacheMaxLevel;
            _hdOption.show = true;
        }
        this.availability = _cacheOption.availability;
        var cacheImg = null;
        if (_cacheOption.show) {
            cacheImg = new this._cesium.TileMapServiceImageryProvider({
                url: Cesium.buildModuleUrl(options.cacheUrl),
                fileExtension: options.fileExtension
            });
            this.item = new this._cesium.ImageryLayer(cacheImg, _cacheOption);
            this._viewer.imageryLayers.add(this.item, index);
        }
        if (!this.items) {
            this.items = [];
        }
        var hdImg = null;
        if (_hdOption.show) {
            options.minimumLevel = _hdOption.minimumTerrainLevel | options.cacheMaxLevel;
            if (_hdOption.maximumTerrainLevel) {
                options.maximumLevel = _hdOption.maximumTerrainLevel;
            }
            hdImg = new this._cesium.WebMapServiceImageryProvider(options);
            if (this.item) {
                var _nIndex = this.items.push(new this._cesium.ImageryLayer(hdImg, _hdOption));
                this._viewer.imageryLayers.add(this.items[_nIndex - 1], index + 1);
            } else {
                this.item = new this._cesium.ImageryLayer(hdImg, _hdOption);
                this._viewer.imageryLayers.add(this.item, index + 1);
            }
        }
        !checked && this.setVisibility(false);
        disFnc && typeof disFnc == 'function' && disFnc(this.item);

        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        var obj = {
            id: options.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ImageryProvider',
            checked: checked,
            item: this,
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    /**
     * 添加天地图
     * @param {bollean} b true|false
     */
    ImageryLayer.prototype.createPolylineImageryProviderer = function (name, option, GroupID, disFnc) {
        var defaultOptions = {
            url: 'https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer',
        };
        var options = this._core.extend(defaultOptions, option, true);
        var de = new this._cesium.WebMapTileServiceImageryProvider(options);
        //this._viewer.imageryLayers.addImageryProvider(de);
        this.item = this._viewer.imageryLayers.addImageryProvider(de);
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        var obj = {
            id: options.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'ImageryProvider',
            item: this,
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    //地形加载
    ImageryLayer.prototype.createterrainProvider = function (name, option, GroupID, disFnc) {
        var defaultOptions = {
            url: '',
        };
        var options = this._core.extend(defaultOptions, option, true);
        var terrainProvider = new this._cesium.CesiumTerrainProvider(options);
        //this._viewer.imageryLayers.addImageryProvider(de);
        this._viewer.terrainProvider = terrainProvider;
        this.item = this._viewer.terrainProvider;
        if (typeof disFnc == 'function') {
            disFnc(dataSource);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        var obj = {
            id: options.id,
            name: name,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'terrainProvider',
            item: this,
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * Image导出工程数据
     */
    ImageryLayer.prototype.export = function () {
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.item.imageryProvider.url;
        return {
            type: 'ImageryLayer',
            treeobj: {
                name: this.treeobj.name,
                type: this.treeobj.smtype,
            },
            style: {
                show: show,
                url: url,
            },
        };
    };
    //工程树添加
    ImageryLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 获取层级
     */
    ImageryLayer.prototype.getLevel = function () {
        var A = 40487.57;
        var B = 0.00007096758;
        var C = 91610.74;
        var D = -40467.74;

        var camera = this._viewer.camera,
            height,
            level;
        try {
            if (camera && camera.positionCartographic && camera.positionCartographic.height) {
                var groundHeightAtCameraPosition = this._viewer.scene.globe.getHeight(camera.positionCartographic);
                !groundHeightAtCameraPosition && (groundHeightAtCameraPosition = 0);
                height = camera.positionCartographic.height - groundHeightAtCameraPosition;
                level = Math.round(D + (A - D) / (1 + Math.pow(height / C, B)));
            } else {
                level = 0;
            }
        } catch (ex) { }
        return level;
    };
    /**
     * 设置影像图层的显示与隐藏
     * @param {bollean} b true|false
     */
    ImageryLayer.prototype.setVisibility = function (b) {
        this.isShow = b;
        this.item.show = b;

        if (this.item._availability && !b) {
            this.item._availability = undefined;
        } else if (this.availability && b) {
            this.item._availability = this.availability;
        }
        if (this.items) {
            for (var i = 0; i < this.items.length; i++) {
                this.items[i].show = b;
                if (this.items[i]._availability && !b) {
                    this.items[i]._availability = undefined;
                } else if (this.availability && b) {
                    this.items[i]._availability = this.availability;
                }
            }
        }
    };
    /**
     * 获取影像图层的显示与隐藏
     */
    ImageryLayer.prototype.getVisibility = function () {
        return this.item.show;
    };
    ImageryLayer.prototype.getType = function () {
        return {
            label: '影像',
            value: 'ImageryProvider',
        };
    };
    /**
     * 获取影像图层的显示与隐藏
     */
    ImageryLayer.prototype.deleteObject = function () {
        return this._viewer.imageryLayers.remove(this.item);
    };
    Object.defineProperties(ImageryLayer.prototype, {
        url: {
            set: function (url) { },
            get: function () { },
        },
    });

    ImageryLayer.prototype.setItem = function (item) {
        this.item = item;
    };

    var _slicedToArray$1 = function () {
        function sliceIterator(arr, i) {
            var _arr = [];
            var _n = true;
            var _d = false;
            var _e = undefined;
            try {
                for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"]) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        return function (arr, i) {
            if (Array.isArray(arr)) {
                return arr;
            } else if (Symbol.iterator in Object(arr)) {
                return sliceIterator(arr, i);
            } else {
                throw new TypeError("Invalid attempt to destructure non-iterable instance");
            }
        };
    }();

    var _typeof$3 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
        return typeof obj;
    } : function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };

    function _toConsumableArray$1(arr) {
        if (Array.isArray(arr)) {
            for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
                arr2[i] = arr[i];
            }
            return arr2;
        } else {
            return Array.from(arr);
        }
    }

    function GeoJSONVectorTileProviderPolymerization(viewer, cesium, options) {
        this._viewer = viewer;
        this._cesium = cesium;

        // Cesium.Viewer 实例
        this._viewer = null;

        // Cesium 对象
        this._Cesium = options.Cesium;

        this.UrlData = {
            output: options.output,
            resultmode: options.resultmode,
            uid: options.uid,
            st: options.st,
            words: options.words,
            area: options.area,
            callback: options.callback
        };

        //级别
        this.minLevel1 = options.minLevel1;
        //this.minLevel2 = options.minLevel2;
        this.minLevel3 = options.minLevel3;
        // 矢量切片服务接口
        this._url = options.url;

        // 矢量切片服务接口请求参数
        //this._urlParams = options.urlParams;

        // 矢量切片服务 URL 模板
        //this._urlTemplate = this._url + '?' + this._serialize(this._urlParams);
        this._urlTemplate = options.url;
        // 矢量切片服务数据范围
        this._rectangle = options.rectangle;

        // 最大视图等级
        this._maximumLevel = options.maximumLevel || 19;

        // 最小视图等级
        this._minimumLevel = options.minimumLevel || 1;

        this.dx = {};

        // Cesium.TilingScheme 实例
        this._tilingScheme = options.tilingScheme || new this._Cesium.GeographicTilingScheme();

        // 瓦片范围，以 level 索引
        this._tileRangeByLevel = {};

        // 摄像机 moveEnd 事件时间戳
        this._moveEndTimestamp = null;

        // provider 是否已销毁
        this._isRemoved = false;
        //当前进入的级别
        this.cluster = "city";

        //当前数据
        this.primitivecount = null;

        // 摄像机是否正在移动
        this._isCameraMoving = false;

        // 将被过滤的属性和值
        this._propertyToBeFiltered = null;
        this._valuesToBeFiltered = null;

        // 瓦片 primitive，以 tile key 索引
        this._primitiveByTile = {};

        // 最新视角下的瓦片标识列表
        this._tileKeys = [];

        // 瓦片层级限制
        this._lowerLevelLimit = options.lowerLevelLimit || 1;
        this._upperLevelLimit = options.upperLevelLimit || null;

        this._cameraMoveEndHandler = this._cameraMoveEndHandler.bind(this);
        this._cameraMoveStartHandler = this._cameraMoveStartHandler.bind(this);

        // 高度属性，以 id 索引
        this.heightById = {};

        // 计算瓦片范围
        var west = this._radianToDegree(this._rectangle.west);
        var south = this._radianToDegree(this._rectangle.south);
        var east = this._radianToDegree(this._rectangle.east);
        var north = this._radianToDegree(this._rectangle.north);

        for (var z = this._minimumLevel; z <= this._maximumLevel; z++) {
            var bottomLeftTile = this._lonLatToTileInWGS84([west, south], z);
            var topRightTile = this._lonLatToTileInWGS84([east, north], z);
            var minRow = Math.min(bottomLeftTile[0], topRightTile[0]);
            var maxRow = Math.max(bottomLeftTile[0], topRightTile[0]);
            var minCol = Math.min(bottomLeftTile[1], topRightTile[1]);
            var maxCol = Math.max(bottomLeftTile[1], topRightTile[1]);

            this._tileRangeByLevel[z] = {
                minCol: minCol,
                maxCol: maxCol,
                minRow: minRow,
                maxRow: maxRow
            };
        }

        this._tileRangeByLevel[0] = {
            minCol: 0,
            maxCol: 0,
            minRow: 0,
            maxRow: 0
        };

        this._primitiveCollection = new this._Cesium.PrimitiveCollection();



        this._stop = false;
    }
    /**
     * 序列化参数对象
     *
     * @param {Object} params 参数对象
     * @returns {String} 序列化字符串
     */
    GeoJSONVectorTileProviderPolymerization.prototype._serialize = function (params) {
        var queryArray = [];
        var encode = window.encodeURIComponent;

        for (var key in params) {
            var value = params[key];

            if ((typeof value === 'undefined' ? 'undefined' : _typeof$3(value)) === 'object') {
                queryArray.push(encode(key) + '=' + encode(JSON.stringify(value)));
            } else {
                queryArray.push(encode(key) + '=' + encode(params[key]));
            }
        }

        return queryArray.join('&');
    };

    /**
     * 模拟 fetch 接口
     *
     * @param {String} url 请求 URL
     * @param {Object} [options] 选项
     * @returns {Promise} 处理请求结果的 Promise
     *
     */
    GeoJSONVectorTileProviderPolymerization.prototype._fetch = function (url) {
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        var promise = new Promise(function (resolve, reject) {
            var xhr = new XMLHttpRequest();

            xhr.open(options.method || 'GET', url);

            if (options.headers) {
                for (var key in options.headers) {
                    xhr.setRequestHeader(key, options.headers[key]);
                }
            }

            xhr.onload = function () {
                if (xhr.readyState === 4 && xhr.status === 200) {
                    try {
                        var json = JSON.parse(xhr.responseText);

                        resolve(json);
                    } catch (e) {
                        reject(new Error('INVALID RESPONSE'));
                    }
                }
            };

            xhr.onerror = function (e) {
                reject(e);
            };

            xhr.onloadend = function (e) {
                if (e.target.status !== 200) {
                    reject(new Error('[' + e.target.status + ']request failed: ' + url));
                }
            };

            xhr.send(options.body || null);
        });

        return promise;
    };

    /**
     * 通过经纬度获取瓦片 X、Y 值 (WGS84)
     *
     * @param {Number[]} lonLat 经纬度
     * @param {Number} level 地图缩放等级
     * @returns {Number[]} 瓦片的 X、Y 值
     */
    GeoJSONVectorTileProviderPolymerization.prototype._lonLatToTileInWGS84 = function (lonLat, level) {
        var _lonLat = _slicedToArray$1(lonLat, 2),
            lon = _lonLat[0],
            lat = _lonLat[1];

        var tileX = Math.floor(Math.pow(2, level) * (90 - lat) / 180);
        var tileY = Math.floor(Math.pow(2, level) * (180 + lon) / 180);

        return [tileX, tileY];
    };

    /**
     * 弧度转角度
     *
     * @param {Number} radian 弧度值
     * @returns {Number} 角度值
     */
    GeoJSONVectorTileProviderPolymerization.prototype._radianToDegree = function (radian) {
        return radian / Math.PI * 180;
    };

    /**
     * 判断目标瓦片是否在数据范围内
     *
     * @param {QuadtreeTile} tile 瓦片对象
     * @returns {Boolean} 瓦片是否在数据范围内
     */
    GeoJSONVectorTileProviderPolymerization.prototype._isTileInRange = function (tile) {
        try {
            var _tileRangeByLevel$til = this._tileRangeByLevel[tile.level],
                minCol = _tileRangeByLevel$til.minCol,
                maxCol = _tileRangeByLevel$til.maxCol,
                minRow = _tileRangeByLevel$til.minRow,
                maxRow = _tileRangeByLevel$til.maxRow;

            return tile.x >= minCol && tile.x <= maxCol && tile.y >= minRow && tile.y <= maxRow;
        } catch (e) {
            return false;
        }
    };

    /**
     * 摄像机 moveStart 事件处理程序
     */
    GeoJSONVectorTileProviderPolymerization.prototype._cameraMoveStartHandler = function () {
        this._isCameraMoving = true;
    };

    /**
     * 处理数据请求回来的数据 创建不同的geometry
     */
    GeoJSONVectorTileProviderPolymerization.prototype._loadTile = function (json, cluster) {
        var geomInstances = [];
        var color = new this._Cesium.ColorGeometryInstanceAttribute(0.75, 0.75, 0.75, 1);
        var _this = this;
        json.features.forEach(function (feature) {
            if (_this._propertyToBeFiltered) {
                if (Array.isArray(_this._valuesToBeFiltered)) {
                    var value = feature.properties[_this._propertyToBeFiltered];

                    if (_this._valuesToBeFiltered.includes(value)) return;
                }
            }

            var geometryType = feature.geometry.type;

            if (geometryType === 'Polygon' || geometryType === 'MultiPolygon') {
                var coordinates = [];

                _this.heightById[feature.properties.house_id] = feature.properties.height;
                feature.geometry.coordinates.forEach(function (coords, index) {
                    coordinates.push([]);
                    coords.forEach(function (coordinate) {
                        if (coordinate.length > 2) {
                            coordinate.forEach(function (coord) {
                                if (coord.length >= 2) {
                                    var _coordinates$index;

                                    (_coordinates$index = coordinates[index]).push.apply(_coordinates$index, _toConsumableArray$1(coord));
                                }
                            });
                        } else {
                            var _coordinates$index2;

                            (_coordinates$index2 = coordinates[index]).push.apply(_coordinates$index2, _toConsumableArray$1(coordinate));
                        }
                    });
                    var polygonHierarchy = new _this._Cesium.PolygonHierarchy(_this._Cesium.Cartesian3.fromDegreesArray(coordinates[index]));
                    var center = _this._Cesium.BoundingSphere.fromPoints(polygonHierarchy.positions).center;
                    var height = _this._viewer.scene.globe.getHeight(_this._Cesium.Cartographic.fromCartesian(center)) || 0;
                    var geometry = new _this._Cesium.PolygonGeometry({
                        polygonHierarchy: polygonHierarchy,
                        height: height,
                        vertexFormat: _this._Cesium.PerInstanceColorAppearance.VERTEX_FORMAT,
                        //extrudedHeight: feature.properties.height + height
                        extrudedHeight: 1000
                    });
                    var geomInstance = new _this._Cesium.GeometryInstance({
                        geometry: geometry,
                        attributes: {
                            color: color
                        }
                    });

                    geomInstances.push(geomInstance);
                });
            } else {
                console.warn('GeoJSONVectorTileProviderPolymerization: geometry type "' + feature.geometry.type + '" detected, but is not going to be rendered');
            }
        });
        var primitive = new this._Cesium.Primitive({
            allowPicking: false,
            appearance: new this._Cesium.PerInstanceColorAppearance({
                translucent: false
            }),
            geometryInstances: geomInstances
        });
        return primitive;
    };

    /**
     * 摄像机 moveEnd 事件处理程序
     */
    GeoJSONVectorTileProviderPolymerization.prototype._cameraMoveEndHandler = function () {
        if (this._stop) return;
        var _this = this;
        var timestamp = Date.now();
        var tilesToRender = this._viewer.scene.globe._surface._tilesToRender;
        var levels = tilesToRender.map(function (tile) {
            return tile.level;
        });
        var minLevel = Math.min.apply(Math, _toConsumableArray$1(levels));
        var maxLevel = Math.max.apply(Math, _toConsumableArray$1(levels));
        _this._removeObsoletePrimitives(_this._primitiveByTile, []);
        if (maxLevel < this._lowerLevelLimit) {

            _this._tileKeys = [];
            _this._removeObsoletePrimitives(_this._primitiveByTile, []);
            tilesToRender = [];
        }
        if (this._upperLevelLimit && minLevel > this._upperLevelLimit) {
            _this._tileKeys = [];
            _this._removeObsoletePrimitives(_this._primitiveByTile, []);
            tilesToRender = [];

        }

        if (maxLevel - minLevel > 2) {
            tilesToRender = tilesToRender.filter(function (tile) {
                return tile.level >= maxLevel - 2;
            });
        }

        tilesToRender.sort(function (val1, val2) {
            return -(val1.level - val2.level);
        });
        tilesToRender = tilesToRender.filter(function (tile) {
            return _this._isTileInRange(tile);
        });

        if (this._upperLevelLimit) {
            tilesToRender = this._refineTiles(tilesToRender, this._upperLevelLimit);
        }

        this._isCameraMoving = false;
        this._moveEndTimestamp = timestamp;
        //this._tileKeys = [];
        //var 
        //if (this._primitiveByTile != null) {
        //    for (var tileKey in this._primitiveByTile) {
        //        this._viewer.scene.primitives.remove(this._primitiveByTile[tileKey]);
        //    }
        //}
        this._viewer.scene.primitives.remove(this.dx);
        this.dx = {};
        this._primitiveByTile = {};
        var newTileKeys = [];
        var tilesLength = 0;
        //tilesToRender.length;
        var returnCount = 0;
        var rectangle = this._viewer.camera.computeViewRectangle();
        // 计算瓦片范围
        var west1 = this._radianToDegree(rectangle.west);
        var south1 = this._radianToDegree(rectangle.south);
        var east1 = this._radianToDegree(rectangle.east);
        var north1 = this._radianToDegree(rectangle.north);
        this.UrlData.area = "RECT(" + west1 + " " + south1 + "," + east1 + " " + north1 + ")";
        var tileUrl = "";
        if (minLevel <= this.minLevel1 || minLevel == "Infinity") {
            this.cluster = "city";
            this.UrlData.cluster = this.cluster;
            tileUrl = this._urlTemplate + "?output=" + this.UrlData.output + "&resultmode=" + this.UrlData.resultmode + "&uid=" + this.UrlData.uid + "&st=" + this.UrlData.st + "&words=" + this.UrlData.words + "&area=" + this.UrlData.area + "&cluster=" + this.UrlData.cluster + "&callback=" + this.UrlData.callback;
            //var tileUrl =this._urlTemplate
        } else if (minLevel > this.minLevel1 && this.minLevel3 > minLevel) {
            this.cluster = "county";
            this.UrlData.cluster = this.cluster;
            tileUrl = this._urlTemplate + "?output=" + this.UrlData.output + "&resultmode=" + this.UrlData.resultmode + "&uid=" + this.UrlData.uid + "&st=" + this.UrlData.st + "&words=" + this.UrlData.words + "&area=" + this.UrlData.area + "&cluster=" + this.UrlData.cluster + "&callback=" + this.UrlData.callback;
        } else if (minLevel >= this.minLevel3) {
            this.cluster = "";
            tileUrl = this._urlTemplate + "?output=" + this.UrlData.output + "&resultmode=" + this.UrlData.resultmode + "&uid=" + this.UrlData.uid + "&st=" + this.UrlData.st + "&words=" + this.UrlData.words + "&area=" + this.UrlData.area + "&callback=" + this.UrlData.callback;
            //this.UrlData.cluster = this.cluster
        }
        _this._fetch(tileUrl).then(function (json) {
            //数据解析
            var primitive = _this._loadTile(json, _this.cluster);
            //_this._primitiveCollection.add(primitive);
            _this._primitiveCollection = primitive;
            //this.dx = primitive;
            //_this._viewer.scene.primitives.add(primitive);
            returnCount++;

            if (returnCount >= tilesLength) {
                _this._tileKeys = newTileKeys;
                _this._removeObsoletePrimitives(_this._primitiveByTile, newTileKeys);

            }
        }).catch(function (ex) {
            returnCount++;
            if (returnCount >= tilesLength) {
                _this._tileKeys = newTileKeys;
                _this._removeObsoletePrimitives(_this._primitiveByTile, newTileKeys);

            }
            if (ex.message !== 'DISCARD') ;
        });
        //tilesToRender.forEach(function (tile) {
        //    var tileKey = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
        //    newTileKeys.push(tileKey);
        //    _this._tileKeys.push(tileKey);

        //    if (_this._primitiveByTile[tileKey]) {
        //        //tilesLength--;
        //        return;
        //    }

        //    var tileUrl = _this._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
        //    tilesLength++;
        //    _this._fetch(tileUrl).then(function (json) {
        //        if (_this._isRemoved) throw new Error('DISCARD');
        //        if (_this._isCameraMoving) throw new Error('DISCARD');
        //        if (timestamp !== _this._moveEndTimestamp) throw new Error('DISCARD');

        //        var primitive = _this._loadTile(json);
        //        _this._primitiveCollection.add(primitive);
        //        //_this._viewer.scene.primitives.add(primitive);
        //        _this._primitiveByTile[tileKey] = primitive;
        //        returnCount++;

        //        if (returnCount >= tilesLength) {
        //            _this._tileKeys = newTileKeys;
        //            _this._removeObsoletePrimitives(_this._primitiveByTile, newTileKeys);

        //        }
        //        //if (tile.level <= _this._upperLevelLimit && Object.getOwnPropertyNames(_this._primitiveByTile).length > 5)
        //        //    _this._removeObsoletePrimitives(_this._primitiveByTile, _this._tileKeys);
        //    }).catch(function (ex) {
        //        returnCount++;
        //        if (returnCount >= tilesLength) {
        //            _this._tileKeys = newTileKeys;
        //            _this._removeObsoletePrimitives(_this._primitiveByTile, newTileKeys);

        //        }
        //        if (ex.message !== 'DISCARD') { }
        //    });
        //});



        /**
         *  删除之前加载的数据
         *
         */
        // this._removeObsoletePrimitives(this._primitiveByTile, this._tileKeys);
    };

    /**
     * 通过拆分、合并优化瓦片下载与渲染
     *
     * @param {Object[]} tiles 待处理的瓦片列表
     * @param {Number} targetLevel 目标优化层级
     * @returns {Object[]} 优化后的瓦片列表
     */
    GeoJSONVectorTileProviderPolymerization.prototype._refineTiles = function (tiles, targetLevel) {
        var newTiles = [];
        var tileKeys = [];

        tiles.forEach(function (tile) {
            var tileKey = 'Z' + tile.level + 'X' + tile.x + 'Y' + tile.y;

            if (tile.level < targetLevel - 1) {
                if (!tileKeys.includes(tileKey)) {
                    newTiles.push(tile);
                    tileKeys.push(tileKey);
                }
            } else if (tile.level === targetLevel - 1) {
                for (var i = 0; i < 2; i++) {
                    for (var j = 0; j < 2; j++) {
                        var _tileKey = 'Z' + (tile.level + 1) + 'X' + (tile.x * 2 + i) + 'Y' + (tile.y * 2 + j);

                        if (!tileKeys.includes(_tileKey)) {
                            newTiles.push({
                                x: tile.x * 2 + i,
                                y: tile.y * 2 + j,
                                level: tile.level + 1
                            });
                            tileKeys.push(_tileKey);
                        }
                    }
                }
            } else {
                var levelDiff = tile.level - targetLevel;

                if (levelDiff === 0) {
                    if (!tileKeys.includes(tileKey)) {
                        newTiles.push(tile);
                        tileKeys.push(tileKey);
                    }
                } else {
                    var factor = levelDiff * 2;
                    var targetX = Math.floor(tile.x / factor);
                    var targetY = Math.floor(tile.y / factor);
                    var _tileKey2 = 'Z' + targetLevel + 'X' + targetX + 'Y' + targetY;

                    if (!tileKeys.includes(_tileKey2)) {
                        newTiles.push({
                            x: targetX,
                            y: targetY,
                            level: targetLevel
                        });
                        tileKeys.push(_tileKey2);
                    }
                }
            }
        });

        return newTiles;
    };

    /**
     * 移除过期的瓦片
     *
     * @param {Object} primitiveByTile 瓦片 primitive，以 tileKey 索引
     * @param {String[]} tileKeys 当前有效的瓦片 keys
     */
    // GeoJSONVectorTileProviderPolymerization.prototype._removeObsoletePrimitives = function _removeObsoletePrimitives(primitiveByTile, tileKeys) {
    //     // for (var tileKey in primitiveByTile) {
    //     //     if (!tileKeys.includes(tileKey)) {
    //     //         var removed = this._viewer.scene.primitives.remove(primitiveByTile[tileKey]);

    //     //         if (removed) {
    //     //             delete primitiveByTile[tileKey];
    //     //         } else {}
    //     //     }
    //     // }
    // };

    GeoJSONVectorTileProviderPolymerization.prototype._removeObsoletePrimitives = function (primitiveByTile, tileKeys) {
        var deleteTileKeys = [];
        if (tileKeys.length > 0) {
            // deleteTileKeys = tileKeys.slice(0, Math.ceil(tileKeys.length / 10));
            deleteTileKeys = tileKeys;
        }
        for (var tileKey in primitiveByTile) {
            if (!deleteTileKeys.includes(tileKey)) {
                //var removed = this._viewer.scene.primitives.remove(primitiveByTile[tileKey]);
                //var removed = this._primitiveCollection.remove(primitiveByTile[tileKey]);
                if (removed) {
                    delete primitiveByTile[tileKey];
                }
            }
        }
    };

    /**
     * 将 provider 添加到指定 viewer
     *
     * @param {Cesium.Viewer} viewer 目标 viewer
     */
    GeoJSONVectorTileProviderPolymerization.prototype.addTo = function (viewer) {
        this._viewer = viewer;
        //this._viewer.scene.primitives.add(this._primitiveCollection);
        this._isRemoved = false;
        this._viewer.camera.moveEnd.addEventListener(this._cameraMoveEndHandler);
        this._viewer.camera.moveStart.addEventListener(this._cameraMoveStartHandler);
        this._cameraMoveEndHandler();
    };

    /**
     * 移除 provider
     */
    GeoJSONVectorTileProviderPolymerization.prototype.remove = function () {
        if (this._viewer) {
            for (var tileKey in this._primitiveByTile) {
                this._viewer.scene.primitives.remove(this._primitiveByTile[tileKey]);
            }
            this._primitiveByTile = {};
            this._viewer.camera.moveEnd.removeEventListener(this._cameraMoveEndHandler);
            this._viewer.camera.moveStart.removeEventListener(this._cameraMoveStartHandler);
            this._viewer = null;
            this._isRemoved = true;
        }
    };

    /**
     * 停止 刷新
     */
    GeoJSONVectorTileProviderPolymerization.prototype.setStatus = function (b) {
        this._stop = b;
    };
    /**
     * provider 是否已移除
     */
    GeoJSONVectorTileProviderPolymerization.prototype.isRemoved = function () {
        return this._isRemoved;
    };

    /**
     * 添加属性过滤
     *
     * @param {string} property 要过滤的属性名称
     * @param {any[]} values 要过滤的属性值
     * @param {Cesium.Rectangle} [rectangle] 要过滤的数据范围
     */
    GeoJSONVectorTileProviderPolymerization.prototype.filterBy = function (property, values, rectangle) {
        this._propertyToBeFiltered = property;
        this._valuesToBeFiltered = values;
    };

    /**
     * 移除属性过滤
     */
    GeoJSONVectorTileProviderPolymerization.prototype.removeFilter = function () {
        this._propertyToBeFiltered = null;
        this._valuesToBeFiltered = null;
    };

    /**
     *
     * 创建添加文本点Geojson要素图层。
     *
     * @alias LabelGeoJsonFeatureLayer
     * @constructor
     *
     * @param {Viewer} Viewer Cesium的viewer对象。
     *
     */
    function LabelGeoJsonFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this._Provider = undefined;
        this.labelCollections1 = [];
        this.labelCollections2 = [];
        this.labelCollections = this._cesium.PointPrimitiveCollection();
        this.gd = 0;
        this.model = [];
        //图例
        this.Legend = [];
        this.sj = true;
    }

    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *        Name: "",
            text: "",
            font_size: '30px',
            font_family:'sans-serif'
            stylet: this._cesium.LabelStyle.FILL,
            fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
            outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
            show: true,//	optional A boolean Property specifying the visibility of the label.
            showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
            backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
            near: 0,
            far: 5000
       }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    LabelGeoJsonFeatureLayer.prototype.createLabelPointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        //this._viewer.dataSources.add(dataSource);
        var that = this;
        dataSource.then(function (dataSource) {
            var defaultOptions = {
                Name: "",
                text: "",
                font: ' 30px sans-serif',
                stylet: that._cesium.LabelStyle.OUTLINE,
                fillColor: that._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                outlineColor: that._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                show: true, //	optional A boolean Property specifying the visibility of the label.
                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                backgroundColor: new that._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                backgroundPadding: new that._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                horizontalOrigin: that._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                verticalOrigin: that._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                eyeOffset: that._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                pixelOffset: that._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                heightReference: that._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                scaleByDistance: new that._cesium.NearFarScalar(0, 0, 1, 1)
            };
            option.material;
            //填充颜色设置
            if (!that._core.isnull(option) && !that._core.isnull(option.fillColor)) {
                if (/^\[/.test(option.fillColor) && option.fillColor.toString().charAt(0) == "[" && option.fillColor.toString().charAt(option.fillColor.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(option.fillColor)) {
                        option.fillColor = that._color.colorFromHtmlColor(option.fillColor);
                    } else {
                        if (/^rgb/.test(option.fillColor)) {
                            option.fillColor = that._color.rgbaStringToRgbaObj(option.fillColor);
                        }
                        if (option.fillColor.r > 1) {
                            option.fillColor.r = option.fillColor.r / 255;
                        }
                        if (option.fillColor.g > 1) {
                            option.fillColor.g = option.fillColor.g / 255;
                        }
                        if (option.fillColor.b > 1) {
                            option.fillColor.b = option.fillColor.b / 255;
                        }
                        if (option.fillColor.a > 1) {
                            option.fillColor.a = option.fillColor.a / 255;
                        }
                        option.fillColor = that._color.createColor(option.fillColor.r, option.fillColor.g, option.fillColor.b, option.fillColor.a);
                    }
                }
            }
            //填充颜色设置material
            if (!that._core.isnull(option) && !that._core.isnull(option.material)) {
                if (/^\[/.test(option.material) && option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(option.material)) {
                        option.material = that._color.colorFromHtmlColor(option.material);
                    } else {
                        if (/^rgb/.test(option.material)) {
                            option.material = that._color.rgbaStringToRgbaObj(option.material);
                        }
                        if (option.material.r > 1) {
                            option.material.r = option.fillColor.r / 255;
                        }
                        if (option.material.g > 1) {
                            option.material.g = option.fillColor.g / 255;
                        }
                        if (option.material.b > 1) {
                            option.material.b = option.material.b / 255;
                        }
                        if (option.material.a > 1) {
                            option.material.a = option.material.a / 255;
                        }
                        option.material = that._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                    }
                }
            }
            //边框颜色设置
            if (!that._core.isnull(option) && !that._core.isnull(option.outlineColor)) {
                if (/^\[/.test(option.outlineColor) && option.outlineColor.toString().charAt(0) == "[" && option.outlineColor.toString().charAt(option.outlineColor.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(option.outlineColor)) {
                        option.outlineColor = that._color.colorFromHtmlColor(option.outlineColor);
                    } else {
                        if (/^rgb/.test(option.outlineColor)) {
                            option.outlineColor = that._color.rgbaStringToRgbaObj(option.outlineColor);
                        }
                        if (option.outlineColor.r > 1) {
                            option.outlineColor.r = option.outlineColor.r / 255;
                        }
                        if (option.outlineColor.g > 1) {
                            option.outlineColor.g = option.outlineColor.g / 255;
                        }
                        if (option.outlineColor.b > 1) {
                            option.outlineColor.b = option.outlineColor.b / 255;
                        }
                        if (option.outlineColor.a > 1) {
                            option.outlineColor.a = option.outlineColor.a / 255;
                        }
                        option.outlineColor = that._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
                    }
                }
            }
            //背景颜色设置
            if (!that._core.isnull(option) && !that._core.isnull(option.backgroundColor)) {
                if (/^\[/.test(option.backgroundColor) && option.backgroundColor.toString().charAt(0) == "[" && option.backgroundColor.toString().charAt(option.backgroundColor.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(option.backgroundColor)) {
                        option.backgroundColor = that._color.colorFromHtmlColor(option.backgroundColor);
                    } else {
                        if (/^rgb/.test(option.backgroundColor)) {
                            option.backgroundColor = that._color.rgbaStringToRgbaObj(option.backgroundColor);
                        }
                        if (option.backgroundColor.r > 1) {
                            option.backgroundColor.r = option.backgroundColor.r / 255;
                        }
                        if (option.backgroundColor.g > 1) {
                            option.backgroundColor.g = option.backgroundColor.g / 255;
                        }
                        if (option.backgroundColor.b > 1) {
                            option.backgroundColor.b = option.backgroundColor.b / 255;
                        }
                        if (option.backgroundColor.a > 1) {
                            option.backgroundColor.a = option.backgroundColor.a / 255;
                        }
                        option.backgroundColor = that._color.createColor(option.backgroundColor.r, option.backgroundColor.g, option.backgroundColor.b, option.backgroundColor.a);
                    }
                }
            }
            var options = that._core.extend(defaultOptions, option, true);
            that.item = dataSource;
            var entities = dataSource.entities.values;
            if (that._core.isnull(option.near)) {
                option.near = 0;
            }
            if (that._core.isnull(option.far)) {
                option.far = 999999999;
            }
            var min = parseFloat(option.near);
            var max = parseFloat(option.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            if (that._core.isnull(option.font_size)) {
                option.font_size = "30px";
            }
            if (that._core.isnull(option.font_family)) {
                option.font_family = " sans-serif";
            }
            //options.font = option.font_size + " " + option.font_family;
            options.font = parseFloat(option.font_size) + "px " + option.font_family;
            var labelCollections = new that._cesium.LabelCollection();

            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                options.position = entity.position._value;
                options.text = "a label";
                //图例
                var col = "fillColor:" + options.fillColor.red * 255 + "," + options.fillColor.green * 255 + "," + options.fillColor.blue * 255
                    + ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                that.Legend.push(col);
                labelCollections.add(options);
            }
            var ps = that._viewer.scene.primitives.add(labelCollections);
            // if (checked == "false") {
            //     that.setVisibility(false);
            // }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        // if (this._core.isnull(options.id)) {
        //     options.id = this._core.getuid();
        // }
        var guid = this._core.getuid();
        if (this._core.isnull(name)) {
            name = "新建图层" + guid;
        }
        //导出工程树
        var obj = {
            id: guid,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'labelPointLayer',
            item: this,
            url: geojsonOrurl,
            style: options
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    //lable点数据聚合demo
    LabelGeoJsonFeatureLayer.prototype.createLabelPolymerizationGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        //数据解析
        var defaultOptions = {
            Name: "",
            text: "",
            font: ' 30px sans-serif',
            style: this._cesium.LabelStyle.FILL_AND_OUTLINE,
            fillColor: this._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
            outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
            show: true, //	optional A boolean Property specifying the visibility of the label.
            showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
            backgroundPadding: new this._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.RELATIVE_TO_GROUND, //	optional A Property specifying what the height is relative to.
            scaleByDistance: new this._cesium.NearFarScalar(0, 0, 1, 1)
        };
        var that = this;
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.fillColor)) {
            if (this._core.isHtmlColor(option.fillColor)) {
                option.fillColor = this._color.colorFromHtmlColor(option.fillColor);
            } else {
                if (/^rgb/.test(option.fillColor)) {
                    option.fillColor = this._color.rgbaStringToRgbaObj(option.fillColor);
                }
                if (option.fillColor.r > 1) {
                    option.fillColor.r = option.fillColor.r / 255;
                }
                if (option.fillColor.g > 1) {
                    option.fillColor.g = option.fillColor.g / 255;
                }
                if (option.fillColor.b > 1) {
                    option.fillColor.b = option.fillColor.b / 255;
                }
                if (option.fillColor.a > 1) {
                    option.fillColor.a = option.fillColor.a / 255;
                }
                option.fillColor = this._color.createColor(option.fillColor.r, option.fillColor.g, option.fillColor.b, option.fillColor.a);
            }
        }
        //边框颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (this._core.isHtmlColor(option.outlineColor)) {
                option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
            } else {
                if (/^rgb/.test(option.outlineColor)) {
                    option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                }
                if (option.outlineColor.r > 1) {
                    option.outlineColor.r = option.outlineColor.r / 255;
                }
                if (option.outlineColor.g > 1) {
                    option.outlineColor.g = option.outlineColor.g / 255;
                }
                if (option.outlineColor.b > 1) {
                    option.outlineColor.b = option.outlineColor.b / 255;
                }
                if (option.outlineColor.a > 1) {
                    option.outlineColor.a = option.outlineColor.a / 255;
                }
                option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
            }
        }
        //背景颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.backgroundColor)) {
            if (this._core.isHtmlColor(option.backgroundColor)) {
                option.backgroundColor = this._color.colorFromHtmlColor(option.backgroundColor);
            } else {
                if (/^rgb/.test(option.backgroundColor)) {
                    option.backgroundColor = this._color.rgbaStringToRgbaObj(option.backgroundColor);
                }
                if (option.backgroundColor.r > 1) {
                    option.backgroundColor.r = option.backgroundColor.r / 255;
                }
                if (option.backgroundColor.g > 1) {
                    option.backgroundColor.g = option.backgroundColor.g / 255;
                }
                if (option.backgroundColor.b > 1) {
                    option.backgroundColor.b = option.backgroundColor.b / 255;
                }
                if (option.backgroundColor.a > 1) {
                    option.backgroundColor.a = option.backgroundColor.a / 255;
                }
                option.backgroundColor = this._color.createColor(option.backgroundColor.r, option.backgroundColor.g, option.backgroundColor.b, option.backgroundColor.a);
            }
        }

        if (that._core.isnull(option.near)) {
            option.near = 0;
        }
        if (that._core.isnull(option.far)) {
            option.far = 999999999;
        }
        var options = this._core.extend(defaultOptions, option, true);
        //开始聚合
        ({
            camera: this._viewer.scene.camera,
            canvas: this._viewer.scene.canvas
        });
        //var dataSourcePromise = viewer.dataSources.add(Cesium.KmlDataSource.load('../../SampleData/kml/facilities/facilities.kml', optionsp));
        var dataSourcePromise = this._viewer.dataSources.add(this._cesium.GeoJsonDataSource.load(geojsonOrurl));
        //this._viewer.dataSources.add(dataSource);
        var that = this;
        dataSourcePromise.then(function (dataSource) {
            that.item = dataSource;
            var pixelRange = 45;
            var minimumClusterSize = 3;
            var enabled = true;
            //解析并加载数据
            var entities = dataSource.entities.values;
            if (that._core.isnull(options.font_size)) {
                options.font_size = "30";
            }
            if (that._core.isnull(options.font_family)) {
                options.font_family = " sans-serif";
            }
            options.font = options.font_size + "px " + options.font_family;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.font = that._core.extendgl(entity, option.font, options.font);
                options.style = parseInt(that._core.extendgl(entity, option.stylet, options.stylet));
                options.fillColor = that._core.extendgl(entity, option.fillColor, options.fillColor);
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.showBackground = that._core.extendgl(entity, option.showBackground, options.showBackground);
                options.backgroundColor = that._core.extendgl(entity, option.backgroundColor, options.backgroundColor);
                options.backgroundPadding = that._core.extendgl(entity, option.backgroundPadding, options.backgroundPadding);
                options.scale = parseFloat(that._core.extendgl(entity, option.scale, options.scale));
                options.horizontalOrigin = that._core.extendgl(entity, option.horizontalOrigin, options.horizontalOrigin);
                options.pointHeight = parseFloat(that._core.extendgl(entity, option.pointHeight, options.pointHeight));
                options.text = that._core.extendgl(entity, option.text, options.text);
                var min = parseFloat(that._core.extendgl(entity, options.near));
                var max = parseFloat(that._core.extendgl(entity, options.far));
                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                options.distanceDisplayCondition = distance;

                options.text = entity.properties[options.text] == null ? options.text : entity.properties[options.text]._value;

                // entity.billboard.image = "";
                entity.billboard.color = that._cesium.Color.WHITE.withAlpha(0);
                entity.label = new that._cesium.LabelGraphics(options);
                //获取数据结束
                //判断是否是公告栏
                //if (options.image != undefined && options.image != null && options.image.length > 0) {
                //    entity.billboard.image = options.image;
                //    entity.billboard.scale = options.scale;
                //    entity.billboard.heightReference = options.heightReference;
                //    entity.billboard.distanceDisplayCondition = options.distanceDisplayCondition;
                //} else if (options.layertype == "ellipsoidlayer") {
                //    //entity.billboard = undefined;
                //    entity.billboard.image = "";
                //    entity.name = name;
                //    var ellipsoid = {
                //        show: true,
                //        radii: new that._cesium.Cartesian3(options.long_axis, options.short_axis, options.long_axis),
                //        material: that._cesium.Color.fromRandom({
                //            alpha: 1.0
                //        })
                //    }
                //    entity.ellipsoid = new that._cesium.EllipsoidGraphics(ellipsoid);
                //    entity.ellipsoid.heightReference = options.heightReference;
                //    entity.ellipsoid.material = url;
                //} else {
                //    //entity.billboard = undefined;
                //    entity.billboard.image = "";
                //    var labels = {
                //        text: options.text,
                //        font: options.font,
                //        style: options.stylet,
                //        fillColor: options.fillColor,
                //        outlineColor: options.outlineColor,
                //        outlineWidth: options.outlineWidth,
                //        show: options.show,
                //        showBackground: options.showBackground,
                //        backgroundColor: options.backgroundColor,
                //        backgroundPadding: options.backgroundPadding,
                //        scale: options.scale,
                //        horizontalOrigin: options.horizontalOrigin,
                //        verticalOrigin: options.verticalOrigin,
                //        eyeOffset: options.eyeOffset,
                //        pixelOffset: options.pixelOffset,
                //        heightReference: options.heightReference,
                //        distanceDisplayCondition: options.distanceDisplayCondition,
                //        scaleByDistance: options.scaleByDistance
                //    };
                //    entity.label = new that._cesium.LabelGraphics(labels);
                //    //entity.label.text = entity.properties[options.text] == null ? options.text : entity.properties[options.text]._value;
                //    //entity.position._value.z += options.pointHeight;
                //}
                //坐标转化
                that._viewer.scene.globe.ellipsoid;
                var scartographic = that._cesium.Cartographic.fromCartesian(entity.position._value);
                var slongitude = that._cesium.Math.toDegrees(scartographic.longitude);
                var slatitude = that._cesium.Math.toDegrees(scartographic.latitude);
                var sheight = scartographic.height + options.pointHeight;//
                var posit = new that._cesium.Cartesian3.fromDegrees(slongitude, slatitude, sheight);
                entity.position._value = posit;
            }

            dataSource.clustering.enabled = enabled;
            dataSource.clustering.pixelRange = pixelRange;
            dataSource.clustering.minimumClusterSize = minimumClusterSize;

            var removeListener;

            var pinBuilder = new that._cesium.PinBuilder();
            pinBuilder.fromText('50+', that._cesium.Color.RED, 48).toDataURL();
            pinBuilder.fromText('40+', that._cesium.Color.ORANGE, 48).toDataURL();
            pinBuilder.fromText('30+', that._cesium.Color.YELLOW, 48).toDataURL();
            pinBuilder.fromText('20+', that._cesium.Color.GREEN, 48).toDataURL();
            pinBuilder.fromText('10+', that._cesium.Color.BLUE, 48).toDataURL();

            var singleDigitPins = new Array(8);
            for (var i = 0; i < singleDigitPins.length; ++i) {
                singleDigitPins[i] = pinBuilder.fromText('' + (i + 2), that._cesium.Color.VIOLET, 48).toDataURL();
            }

            function customStyle() {
                if (that._cesium.defined(removeListener)) {
                    removeListener();
                    removeListener = undefined;
                } else {
                    removeListener = dataSource.clustering.clusterEvent.addEventListener(function (clusteredEntities, cluster) {
                        cluster.label.show = false;
                        cluster.point.show = false;
                        cluster.billboard.show = true;
                        cluster.billboard.id = cluster.label.id;
                        cluster.billboard.verticalOrigin = that._cesium.VerticalOrigin.BOTTOM;
                        if (clusteredEntities.length >= 50) {
                            //cluster.billboard.image = pin50;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.RED, 48).toDataURL();
                        } else if (clusteredEntities.length >= 40) {
                            //cluster.billboard.image = pin40;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.ORANGE, 48).toDataURL();
                        } else if (clusteredEntities.length >= 30) {
                            //cluster.billboard.image = pin30;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.YELLOW, 48).toDataURL();
                        } else if (clusteredEntities.length >= 20) {
                            //cluster.billboard.image = pin20;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.GREEN, 48).toDataURL();
                        } else if (clusteredEntities.length >= 10) {
                            //cluster.billboard.image = pin10;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.BLUE, 48).toDataURL();
                        } else {
                            cluster.billboard.image = singleDigitPins[clusteredEntities.length - 2];
                        }
                    });
                }

                // force a re-cluster with the new styling
                var pixelRange = dataSource.clustering.pixelRange;
                dataSource.clustering.pixelRange = 0;
                dataSource.clustering.pixelRange = pixelRange;
                if (!checked) {
                    that.setVisibility(checked);
                }
            }

            customStyle();
            var viewModel = {
                pixelRange: pixelRange,
                minimumClusterSize: minimumClusterSize
            };
            that._cesium.knockout.track(viewModel);
            //var toolbar = document.getElementById('toolbar');
            //Cesium.knockout.applyBindings(viewModel, toolbar);
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        // if (this._core.isnull(options.id)) {
        //     options.id = this._core.getuid();
        // }
        var guid = this._core.getuid();
        if (this._core.isnull(name)) {
            name = "新建图层" + guid;
        }
        //导出工程树
        var obj = {
            id: guid,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'labelPointLayer',
            item: this,
            url: geojsonOrurl,
            //style: options
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };

    //point点数据聚合demo
    LabelGeoJsonFeatureLayer.prototype.createPointPolymerizationGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        //数据解析
        var defaultOptions = {
            color: this._cesium.Color.WHITE, //	optional A Property specifying the Color of the point.
            pixelSize: 1, //optional A numeric Property specifying the size in pixels.
            outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the Color of the outline.
            outlineWidth: 0, //	optional A numeric Property specifying the the outline width in pixels.
            show: true, //	optional A boolean Property specifying the visibility of the point.
            scaleByDistance: new this._cesium.NearFarScalar(0, 0, 1, 1)
        };
        //字体填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.color)) {
            if (option.color.toString().charAt(0) == "[" && option.color.toString().charAt(option.color.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.color)) {
                    option.color = this._color.colorFromHtmlColor(option.color);
                } else {
                    if (/^rgb/.test(option.color)) {
                        option.color = this._color.rgbaStringToRgbaObj(option.color);
                    }
                    if (option.color.r > 1) {
                        option.color.r = option.color.r / 255;
                    }
                    if (option.color.g > 1) {
                        option.color.g = option.color.g / 255;
                    }
                    if (option.color.b > 1) {
                        option.color.b = option.color.b / 255;
                    }
                    if (option.color.a > 1) {
                        option.color.a = option.color.a / 255;
                    }
                    option.color = this._color.createColor(option.color.r, option.color.g, option.color.b, option.color.a);
                }
            }
        }
        if (!this._core.isnull(option) && !this._core.isnull(option.outlineColor)) {
            if (option.outlineColor.toString().charAt(0) == "[" && option.outlineColor.toString().charAt(option.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.outlineColor)) {
                    option.outlineColor = this._color.colorFromHtmlColor(option.outlineColor);
                } else {
                    if (/^rgb/.test(option.outlineColor)) {
                        option.outlineColor = this._color.rgbaStringToRgbaObj(option.outlineColor);
                    }
                    if (option.outlineColor.r > 1) {
                        option.outlineColor.r = option.outlineColor.r / 255;
                    }
                    if (option.outlineColor.g > 1) {
                        option.outlineColor.g = option.outlineColor.g / 255;
                    }
                    if (option.outlineColor.b > 1) {
                        option.outlineColor.b = option.outlineColor.b / 255;
                    }
                    if (option.outlineColor.a > 1) {
                        option.outlineColor.a = option.outlineColor.a / 255;
                    }
                    option.outlineColor = this._color.createColor(option.outlineColor.r, option.outlineColor.g, option.outlineColor.b, option.outlineColor.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        //开始聚合
        ({
            camera: this._viewer.scene.camera,
            canvas: this._viewer.scene.canvas
        });
        //var dataSourcePromise = viewer.dataSources.add(Cesium.KmlDataSource.load('../../SampleData/kml/facilities/facilities.kml', optionsp));
        var dataSourcePromise = this._viewer.dataSources.add(this._cesium.GeoJsonDataSource.load(geojsonOrurl));
        //this._viewer.dataSources.add(dataSource);
        var that = this;
        dataSourcePromise.then(function (dataSource) {
            that.item = dataSource;
            var pixelRange = 45;
            var minimumClusterSize = 3;
            var enabled = true;
            //解析并加载数据
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                //获取数据开始
                options.color = that._core.extendgl(entity, option.color, options.color);
                options.pixelSize = parseInt(that._core.extendgl(entity, option.pixelSize, options.pixelSize));
                options.outlineColor = that._core.extendgl(entity, option.outlineColor, options.outlineColor);
                options.outlineWidth = parseFloat(that._core.extendgl(entity, option.outlineWidth, options.outlineWidth));
                options.show = that._core.extendgl(entity, option.show, options.show);
                options.height = parseFloat(that._core.extendgl(entity, option.height, options.height));
                options.scaleByDistance = that._core.extendgl(entity, option.scaleByDistance, options.scaleByDistance);
                var min = parseFloat(that._core.extendgl(entity, options.minDistanceDisplay));
                var max = parseFloat(that._core.extendgl(entity, options.maxDistanceDisplay));
                var distance = new that._cesium.DistanceDisplayCondition(min, max);
                //获取数据结束
                //entity.billboard = undefined;
                entity.billboard.image = "";
                options.distanceDisplayCondition = distance;
                entity.point = new that._cesium.PointGraphics(options);

                options.pointHeight = that._core.extendgl(entity, option.pointHeight, options.pointHeight);
                options.pointHeight = parseFloat(options.pointHeight);
                //坐标转化
                that._viewer.scene.globe.ellipsoid;
                var scartographic = that._cesium.Cartographic.fromCartesian(entity.position._value);
                var slongitude = that._cesium.Math.toDegrees(scartographic.longitude);
                var slatitude = that._cesium.Math.toDegrees(scartographic.latitude);
                var sheight = scartographic.height + options.pointHeight;//
                var posit = new that._cesium.Cartesian3.fromDegrees(slongitude, slatitude, sheight);
                entity.position._value = posit;

                //entity.point.distanceDisplayCondition = new that._cesium.DistanceDisplayCondition(10, 1000000.0);
            }

            dataSource.clustering.enabled = enabled;
            dataSource.clustering.pixelRange = pixelRange;
            dataSource.clustering.minimumClusterSize = minimumClusterSize;

            var removeListener;

            var pinBuilder = new that._cesium.PinBuilder();
            pinBuilder.fromText('50+', that._cesium.Color.RED, 48).toDataURL();
            pinBuilder.fromText('40+', that._cesium.Color.ORANGE, 48).toDataURL();
            pinBuilder.fromText('30+', that._cesium.Color.YELLOW, 48).toDataURL();
            pinBuilder.fromText('20+', that._cesium.Color.GREEN, 48).toDataURL();
            pinBuilder.fromText('10+', that._cesium.Color.BLUE, 48).toDataURL();

            var singleDigitPins = new Array(8);
            for (var i = 0; i < singleDigitPins.length; ++i) {
                singleDigitPins[i] = pinBuilder.fromText('' + (i + 2), that._cesium.Color.VIOLET, 48).toDataURL();
            }

            function customStyle() {
                if (that._cesium.defined(removeListener)) {
                    removeListener();
                    removeListener = undefined;
                } else {
                    removeListener = dataSource.clustering.clusterEvent.addEventListener(function (clusteredEntities, cluster) {
                        cluster.label.show = false;
                        cluster.point.show = false;
                        cluster.billboard.show = true;
                        cluster.billboard.id = cluster.label.id;
                        cluster.billboard.verticalOrigin = that._cesium.VerticalOrigin.BOTTOM;
                        if (clusteredEntities.length >= 50) {
                            //cluster.billboard.image = pin50;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.RED, 48).toDataURL();
                        } else if (clusteredEntities.length >= 40) {
                            //cluster.billboard.image = pin40;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.ORANGE, 48).toDataURL();
                        } else if (clusteredEntities.length >= 30) {
                            //cluster.billboard.image = pin30;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.YELLOW, 48).toDataURL();
                        } else if (clusteredEntities.length >= 20) {
                            //cluster.billboard.image = pin20;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.GREEN, 48).toDataURL();
                        } else if (clusteredEntities.length >= 10) {
                            //cluster.billboard.image = pin10;
                            cluster.billboard.image = pinBuilder.fromText(clusteredEntities.length, that._cesium.Color.BLUE, 48).toDataURL();
                        } else {
                            cluster.billboard.image = singleDigitPins[clusteredEntities.length - 2];
                        }
                    });
                }

                // force a re-cluster with the new styling
                var pixelRange = dataSource.clustering.pixelRange;
                dataSource.clustering.pixelRange = 0;
                dataSource.clustering.pixelRange = pixelRange;
                if (!checked) {
                    that.setVisibility(checked);
                }
            }

            customStyle();
            var viewModel = {
                pixelRange: pixelRange,
                minimumClusterSize: minimumClusterSize
            };
            that._cesium.knockout.track(viewModel);
            //var toolbar = document.getElementById('toolbar');
            //Cesium.knockout.applyBindings(viewModel, toolbar);
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        // if (this._core.isnull(options.id)) {
        //     options.id = this._core.getuid();
        // }
        var guid = this._core.getuid();
        if (this._core.isnull(name)) {
            name = "新建图层" + guid;
        }
        //导出工程树
        var obj = {
            id: guid,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'pointLayer',
            item: this,
            url: geojsonOrurl,
            //style: options
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    //标签聚合视野移动XP
    LabelGeoJsonFeatureLayer.prototype._cameraMoveEndHandler = function () {
        var currentMagnitude = this._viewer.camera.getMagnitude();
        if (currentMagnitude < this.gd) {
            if (this.sj) {
                this._viewer.scene.primitives.remove(this.labelCollections);
                this.labelCollections = new this._cesium.LabelCollection();
                for (var i = 0; i < this.labelCollections1.length; i++) {
                    this.labelCollections.add(this.labelCollections1[i]);
                }
                this._viewer.scene.primitives.add(this.labelCollections);
                this.sj = false;
            }
        } else {
            this._viewer.scene.primitives.remove(this.labelCollections);
            new this._cesium.BillboardCollection();
            for (var i = 0; i < this.labelCollections2.length; i++) {
                this.BillboardCollections.add(this.labelCollections2[i]);
            }
            this._viewer.scene.primitives.add(this.BillboardCollections);
            this.sj = true;
        }
    };
    //lable聚合（标签聚合）XP
    LabelGeoJsonFeatureLayer.prototype.createLabelpolymerizationGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var data = geojsonOrurl;
        this._viewer.scene.primitives;
        this._cameraMoveEndHandler = this._cameraMoveEndHandler.bind(this);
        this._viewer.camera.moveEnd.addEventListener(this._cameraMoveEndHandler);
        this.gd = option.height;
        new this._cesium.BillboardCollection();
        //var labelCollections = new sgworld._cesium.LabelCollection();
        var map = {},
            dest = [];
        for (var i = 0; i < data.length; i++) {
            var position = new this._cesium.Cartesian3.fromDegrees(data[i].lng, data[i].lat, 100);
            var p = {
                position: position,
                text: data[i].name
            };
            this.labelCollections1.push(p);
            var ai = data[i];
            if (!map[ai[option.adminname]]) {
                dest.push({
                    adminname: ai[option.adminname],
                    name: ai.name,
                    showBackground: true,
                    lat: ai.lat,
                    lng: ai.lng,
                    data: [ai]
                });
                map[ai[option.adminname]] = ai;
            } else {
                for (var j = 0; j < dest.length; j++) {
                    var dj = dest[j];
                    if (dj.adminname == ai[option.adminname]) {
                        dj.data.push(ai);
                        break;
                    }
                }
            }
        }
        for (var i = 0; i < dest.length; i++) {
            var position = new this._cesium.Cartesian3.fromDegrees(dest[i].lng, dest[i].lat, 100);
            var p = {
                position: position,
                image: pinBuilder.fromText(dest[i].data.length + "", this._cesium.Color.BLACK, 48).toDataURL()
            };
            this.labelCollections2.push(p);
            this.BillboardCollections.add(p);
        }
        //sgworld.Viewer.scene.primitives.add(labelCollections1);
        this._viewer.scene.primitives.add(this.BillboardCollections);

    };
    //标签lable聚合完善
    LabelGeoJsonFeatureLayer.prototype.createLabelpolymerizationGeoJsonFeatureLayers = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**name, geoOptions, styleOption, GroupID, checked, disFnc
         * 默认样式
         */
        var defaultOptions = {
            height: 0,
            material: this._cesium.Color.WHITE,
            size: 50,
            fill: this._cesium.Color.RED
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            upperLevelLimit: 21,
            lowerLevelLimit: 0,
            minLevel1: geoOptions.minLevel1,
            minLevel3: geoOptions.minLevel3,
            rectangle: this._cesium.Rectangle.fromDegrees(118.74324788700017, 32.036708147800084, 118.7994917630001, 32.07298490959994),
            Cesium: this._cesium,
            output: geoOptions.output,
            resultmode: geoOptions.resultmode,
            uid: geoOptions.uid,
            st: geoOptions.st,
            words: geoOptions.words,
            area: geoOptions.area,
            callback: geoOptions.callback,
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else if (/^http/.test(styleOption.material)) ; else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.fill)) {
            if (styleOption.fill.toString().charAt(0) == "[" && styleOption.fill.toString().charAt(styleOption.fill.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.fill)) {
                    styleOption.fill = this._color.colorFromHtmlColor(styleOption.fill);
                } else if (/^http/.test(styleOption.fill)) ; else {
                    if (/^rgb/.test(styleOption.fill)) {
                        styleOption.fill = this._color.rgbaStringToRgbaObj(styleOption.fill);
                    }
                    if (styleOption.fill.r > 1) {
                        styleOption.fill.r = styleOption.fill.r / 255;
                    }
                    if (styleOption.fill.g > 1) {
                        styleOption.fill.g = styleOption.fill.g / 255;
                    }
                    if (styleOption.fill.b > 1) {
                        styleOption.fill.b = styleOption.fill.b / 255;
                    }
                    if (styleOption.fill.a > 1) {
                        styleOption.fill.a = styleOption.fill.a / 255;
                    }
                    styleOption.fill = this._color.createColor(styleOption.fill.r, styleOption.fill.g, styleOption.fill.b, styleOption.fill.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        var that = this;
        //this.options=options;
        /**
         * 请求矢量切片
         */

        var geoJSONVectorTileProvider = new GeoJSONVectorTileProviderPolymerization(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json, cluster) {
            that._viewer.scene.primitives.remove(that.labelCollections);
            //测试
            //var labelCollections = null;
            if (cluster == "") {
                that.labelCollections = new that._cesium.PointPrimitiveCollection();
            } else {
                that.labelCollections = new that._cesium.BillboardCollection();
            }
            var pinBuilder = new that._cesium.PinBuilder();
            json.result.features.forEach(function (feature) {
                var entity = {};
                if (feature.lng != undefined) {
                    var position = new that._cesium.Cartesian3.fromDegrees(feature.lng, feature.lat, options.height);
                    if (cluster == "") {
                        entity = {
                            id: feature,
                            color: options.material,
                            position: position
                        };
                    } else {
                        entity = {
                            position: position,
                            image: pinBuilder.fromText(feature.count + "", options.fill, options.size).toDataURL(),
                            verticalOrigin: that._cesium.VerticalOrigin.BOTTOM
                        };
                    }
                    that.labelCollections.add(entity);
                }
            });
            that._viewer.scene.primitives.add(that.labelCollections);
            that.item = that.labelCollections;
            return that.labelCollections;
            //that._viewer.scene.primitives.add(that.labelCollections);
        };
        //this.item = geoJSONVectorTileProvider._primitiveCollection;
        //this.item = that.labelCollections;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geoOptions] geojosn对象或者地址
     * {
     *   url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
     *       layer:'nanjing',
            upperLevelLimit: 13,
            lowerLevelLimit: 13,
            minx:118.51721649800015,
            miny:31.863232407499936,
            maxx:118.91648798400001,
            maxy:32.27649160409993
     * }
     * @param {object} [option] 参数对象{
     *        Name: "",
            text: "",
            font_size: '30px',
            font_family:'sans-serif'
            stylet: this._cesium.LabelStyle.FILL,
            fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
            outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
            show: true,//	optional A boolean Property specifying the visibility of the label.
            showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
            backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
            near: 0,
            far: 5000
       }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    LabelGeoJsonFeatureLayer.prototype.createLabelGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {

        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        styleOption.material;
        //填充颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.fillColor)) {
            if (/^\[/.test(styleOption.fillColor) && styleOption.fillColor.toString().charAt(0) == "[" && styleOption.fillColor.toString().charAt(styleOption.fillColor.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.fillColor)) {
                    styleOption.fillColor = that._color.colorFromHtmlColor(styleOption.fillColor);
                } else {
                    if (/^rgb/.test(styleOption.fillColor)) {
                        styleOption.fillColor = that._color.rgbaStringToRgbaObj(styleOption.fillColor);
                    }
                    if (styleOption.fillColor.r > 1) {
                        styleOption.fillColor.r = styleOption.fillColor.r / 255;
                    }
                    if (styleOption.fillColor.g > 1) {
                        styleOption.fillColor.g = styleOption.fillColor.g / 255;
                    }
                    if (styleOption.fillColor.b > 1) {
                        styleOption.fillColor.b = styleOption.fillColor.b / 255;
                    }
                    if (styleOption.fillColor.a > 1) {
                        styleOption.fillColor.a = styleOption.fillColor.a / 255;
                    }
                    styleOption.fillColor = that._color.createColor(styleOption.fillColor.r, styleOption.fillColor.g, styleOption.fillColor.b, styleOption.fillColor.a);
                }
            }
        }
        //填充颜色设置material
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.material)) {
            if (/^\[/.test(styleOption.material) && styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = that._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = that._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = that._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        //边框颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.outlineColor)) {
            if (/^\[/.test(styleOption.outlineColor) && styleOption.outlineColor.toString().charAt(0) == "[" && styleOption.outlineColor.toString().charAt(styleOption.outlineColor.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.outlineColor)) {
                    styleOption.outlineColor = that._color.colorFromHtmlColor(styleOption.outlineColor);
                } else {
                    if (/^rgb/.test(styleOption.outlineColor)) {
                        styleOption.outlineColor = that._color.rgbaStringToRgbaObj(styleOption.outlineColor);
                    }
                    if (styleOption.outlineColor.r > 1) {
                        styleOption.outlineColor.r = styleOption.outlineColor.r / 255;
                    }
                    if (styleOption.outlineColor.g > 1) {
                        styleOption.outlineColor.g = styleOption.outlineColor.g / 255;
                    }
                    if (styleOption.outlineColor.b > 1) {
                        styleOption.outlineColor.b = styleOption.outlineColor.b / 255;
                    }
                    if (styleOption.outlineColor.a > 1) {
                        styleOption.outlineColor.a = styleOption.outlineColor.a / 255;
                    }
                    styleOption.outlineColor = that._color.createColor(styleOption.outlineColor.r, styleOption.outlineColor.g, styleOption.outlineColor.b, styleOption.outlineColor.a);
                }
            }
        }
        //背景颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.backgroundColor)) {
            if (/^\[/.test(styleOption.backgroundColor) && styleOption.backgroundColor.toString().charAt(0) == "[" && styleOption.backgroundColor.toString().charAt(styleOption.backgroundColor.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.backgroundColor)) {
                    styleOption.backgroundColor = that._color.colorFromHtmlColor(styleOption.backgroundColor);
                } else {
                    if (/^rgb/.test(styleOption.backgroundColor)) {
                        styleOption.backgroundColor = that._color.rgbaStringToRgbaObj(styleOption.backgroundColor);
                    }
                    if (styleOption.backgroundColor.r > 1) {
                        styleOption.backgroundColor.r = styleOption.backgroundColor.r / 255;
                    }
                    if (styleOption.backgroundColor.g > 1) {
                        styleOption.backgroundColor.g = styleOption.backgroundColor.g / 255;
                    }
                    if (styleOption.backgroundColor.b > 1) {
                        styleOption.backgroundColor.b = styleOption.backgroundColor.b / 255;
                    }
                    if (styleOption.backgroundColor.a > 1) {
                        styleOption.backgroundColor.a = styleOption.backgroundColor.a / 255;
                    }
                    styleOption.backgroundColor = that._color.createColor(styleOption.backgroundColor.r, styleOption.backgroundColor.g, styleOption.backgroundColor.b, styleOption.backgroundColor.a);
                }
            }
        }
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;

        geoJSONVectorTileProvider._loadTile = function (json) {
            var defaultOptions = {
                Name: "",
                text: "",
                font: ' 30px sans-serif',
                style: that._cesium.LabelStyle.FILL_AND_OUTLINE,
                fillColor: that._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                outlineColor: that._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                show: true, //	optional A boolean Property specifying the visibility of the label.
                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                backgroundColor: new that._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                backgroundPadding: new that._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                horizontalOrigin: that._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                verticalOrigin: that._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                eyeOffset: that._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                pixelOffset: that._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                heightReference: that._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                scaleByDistance: new that._cesium.NearFarScalar(0, 0, 1, 1),
                maxDistanceDisplay: 99999999, //最大可视化距离
                minDistanceDisplay: 0, //最小可视化距离
                far: 99999999, //最大可视化距离
                near: 0, //最小可视化距离
            };

            var options = that._core.extend(defaultOptions, styleOption, true);

            if (that._core.isnull(styleOption.near)) {
                styleOption.near = 0;
            }
            if (that._core.isnull(styleOption.far)) {
                styleOption.far = 999999999;
            }
            var min = parseFloat(styleOption.near);
            var max = parseFloat(styleOption.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            //options.pointHeight = parseFloat(that._core.extendgl(entity, option.pointHeight, options.pointHeight));
            if (that._core.isnull(styleOption.font_size)) {
                styleOption.font_size = "30px";
            }
            if (that._core.isnull(styleOption.font_family)) {
                styleOption.font_family = " sans-serif";
            }
            //options.font = option.font_size + " " + option.font_family;
            options.font = parseFloat(styleOption.font_size) + "px " + styleOption.font_family;
            var labelCollections;
            if (options.image != undefined && options.image != null) {
                labelCollections = new that._cesium.BillboardCollection();
            } else {
                labelCollections = new that._cesium.LabelCollection();
            }
            json.features.forEach(function (feature) {
                options.id = feature;
                //options.position = that._cesium.Cartesian3.fromDegreesArray(feature.geometry.coordinates)[0];
                //修改xp
                var sheight = options.pointHeight;
                if (/^\[/.test(sheight) && /\]$/.test(sheight)) {
                    var heightStr = sheight.replace(/\[/, '').replace(/\]/, '');
                    sheight = parseFloat(feature.properties[heightStr]);
                } else if (sheight != undefined && sheight != '') {
                    sheight = parseFloat(sheight);
                } else if (feature.properties.height != undefined) {
                    sheight = parseFloat(feature.properties.height);
                }
                options.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                //填充色
                if (/^\[/.test(styleOption.fillColor) && /\]$/.test(styleOption.fillColor)) {
                    var material = styleOption.fillColor.replace(/\[/, '').replace(/\]/, '');
                    options.fillColor = feature.properties[material];
                    //填充颜色设置
                    if (that._core.isHtmlColor(options.fillColor)) {
                        options.fillColor = that._color.colorFromHtmlColor(options.fillColor);
                    } else {
                        if (/^rgb/.test(options.fillColor)) {
                            options.fillColor = that._color.rgbaStringToRgbaObj(options.fillColor);
                        }
                        if (options.fillColor.r > 1) {
                            options.fillColor.r = options.fillColor.r / 255;
                        }
                        if (options.fillColor.g > 1) {
                            options.fillColor.g = options.fillColor.g / 255;
                        }
                        if (options.fillColor.b > 1) {
                            options.fillColor.b = options.fillColor.b / 255;
                        }
                        if (options.fillColor.a > 1) {
                            options.fillColor.a = options.fillColor.a / 255;
                        }
                        options.fillColor = that._color.createColor(options.fillColor.r, options.fillColor.g, options.fillColor.b, options.fillColor.a);
                    }
                }
                //边框色
                if (/^\[/.test(styleOption.outlineColor) && /\]$/.test(styleOption.outlineColor)) {
                    var material = styleOption.outlineColor.replace(/\[/, '').replace(/\]/, '');
                    options.outlineColor = feature.properties[material];
                    //填充颜色设置
                    if (that._core.isHtmlColor(options.outlineColor)) {
                        options.outlineColor = that._color.colorFromHtmlColor(options.outlineColor);
                    } else {
                        if (/^rgb/.test(options.outlineColor)) {
                            options.outlineColor = that._color.rgbaStringToRgbaObj(options.outlineColor);
                        }
                        if (options.outlineColor.r > 1) {
                            options.outlineColor.r = options.outlineColor.r / 255;
                        }
                        if (options.outlineColor.g > 1) {
                            options.outlineColor.g = options.outlineColor.g / 255;
                        }
                        if (options.outlineColor.b > 1) {
                            options.outlineColor.b = options.outlineColor.b / 255;
                        }
                        if (options.outlineColor.a > 1) {
                            options.outlineColor.a = options.outlineColor.a / 255;
                        }
                        options.outlineColor = that._color.createColor(options.outlineColor.r, options.outlineColor.g, options.outlineColor.b, options.outlineColor.a);
                    }
                }
                //if (feature.properties.name != undefined) {
                //    options.text = feature.properties.name;
                //} else if (feature.properties.NAME != undefined) {
                //    options.text = feature.properties.NAME;
                //}
                //图例
                var col = "fillColor:" + options.fillColor.red * 255 + "," + options.fillColor.green * 255 + "," + options.fillColor.blue * 255
                    + ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                that.Legend.push(col);
                if (/^\[/.test(styleOption.text) && /\]$/.test(styleOption.text)) {
                    var material = styleOption.text.replace(/\[/, '').replace(/\]/, '');
                    options.text = feature.properties[material];
                }

                labelCollections.add(options);
            });

            //var primitive = that._viewer.scene.primitives.add(labelCollections);
            //dx = primitive;
            return labelCollections;
        };

        //添加时间段
        if (styleOption && styleOption.time) {
            geoJSONVectorTileProvider.availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
        }

        this.item = geoJSONVectorTileProvider._primitiveCollection;
        //this.item = dx;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'labelPointLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        if (typeof disFnc == 'function')
            disFnc(this.item);
        return this;
    };

    //富文本lable普通加载
    LabelGeoJsonFeatureLayer.prototype.createLabelRichtextGeoJsonFeatureLayerProvider = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        this._viewer.dataSources.add(dataSource);
        var that = this;
        //数据存储
        var pointPrimitive = new this._cesium.PointPrimitiveCollection();
        that.optiontext = [];
        dataSource.then(function (dataSource) {
            that.item = dataSource;
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                var text;
                //获取数据开始
                if (/^\[/.test(option.text) && /\]$/.test(option.text)) {
                    var extrudedHeight = option.text.replace(/\[/, '').replace(/\]/, '');
                    text = entity.properties[extrudedHeight]._value;
                } else {
                    text = option.text;
                }
                that.optiontext.push(text);
                entity.billboard = undefined;
                //坐标转化
                that._viewer.scene.globe.ellipsoid;
                var scartographic = that._cesium.Cartographic.fromCartesian(entity.position._value);
                var slongitude = that._cesium.Math.toDegrees(scartographic.longitude);
                var slatitude = that._cesium.Math.toDegrees(scartographic.latitude);
                var sheight = scartographic.height + option.pointHeight;//

                var position = [slongitude, slatitude, sheight];
                var id = that._core.getuid();
                var Cartesian3;
                if (position instanceof Array) {
                    if (position.length === 2) {
                        Cartesian3 = that._cesium.Cartesian3.fromDegrees(position[0], position[1]);
                    } else if (position.length === 3) {
                        Cartesian3 = that._cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]);
                    }
                } else {
                    if (position.z) {
                        Cartesian3 = that._cesium.Cartesian3.fromDegrees(position.x, position.y, position.z);
                    } else {
                        Cartesian3 = that._cesium.Cartesian3.fromDegrees(position.x, position.y);
                    }
                }
                var ids = 'DivPoint' + id;
                pointPrimitive.add({
                    id: ids,
                    position: Cartesian3,
                    color: that._cesium.Color.YELLOW,
                    description: option.text
                });
            }
            that.item = pointPrimitive;
            that.pointPrimitive = that._viewer.scene.primitives.add(pointPrimitive);
            var firstAdd = true;
            //div
            var divPoint, CanvasCoordinates, pointPosition;
            that.pointPrimitive.update = function () {
                for (var i = 0, item, divPointHtml; i < that.pointPrimitive.length; i++) {
                    item = that.pointPrimitive.get(i);
                    pointPosition = item.position;
                    CanvasCoordinates = that._viewer.scene.cartesianToCanvasCoordinates(pointPosition);
                    if (!CanvasCoordinates) return;
                    divPoint = document.getElementById(item.id);
                    if (!divPoint) {
                        divPointHtml = '<div id="' + item.id + '" style="position: absolute; width: 200px; height: 134px;left: 0px; top: 0px; pointer-events:none; background: url(' + window.SmartEarthRootUrl + configData$1.divpoint1 + ');transform: matrix(1, 0, 0, 1, 0, 0); transform-origin: left bottom 0px;">\n' +
                            '                   <div class="title" style="position: inherit;top: 22px;left: 70px;font-size: 14px;text-align: left;color: rgba(255,255,255,1);text-shadow: 0 0 9px rgba(0,0,0,.75)">' + that.optiontext[i] + '</div>\n' +
                            '           </div>';
                        $('.cesium-viewer').append(divPointHtml);
                        divPoint = document.getElementById(item.id);
                    }
                    if (item.description) {
                        divPoint.style.transform = 'matrix(1, 0, 0, 1, ' + (CanvasCoordinates.x) + ', ' + (CanvasCoordinates.y - 157) + ')';
                    } else {
                        divPoint.style.transform = 'matrix(1, 0, 0, 1, ' + (CanvasCoordinates.x) + ', ' + (CanvasCoordinates.y - 134) + ')';
                    }

                }
                if (firstAdd) {
                    if (checked) ; else {
                        that.setVisibility(false);
                    }
                    firstAdd = false;
                }
            };
            //this.item.type = 'DivPoint';

            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(dataSource);
            }
        });
        if (this._core.isnull(option.id)) {
            option.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "富文本";
        }
        //导出工程树
        var obj = {
            id: option.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'DivPoint',
            item: this,
            url: geojsonOrurl,
            style: option
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    //富文本lable矢量切片加载
    LabelGeoJsonFeatureLayer.prototype.createLabelRichtextGeoJsonFeatureLayerProviderLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {

        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            var pointPrimitive = new that._cesium.PointPrimitiveCollection();
            that.optiontext = [];
            json.features.forEach(function (feature) {
                var sheight = options.pointHeight;
                if (feature.properties.height != undefined) {
                    sheight = parseFloat(feature.properties.height) + sheight;
                }
                if (/^\[/.test(options.pointHeight) && /\]$/.test(options.pointHeight)) {
                    var extrudedHeight = options.pointHeight.replace(/\[/, '').replace(/\]/, '');
                    sheight = parseFloat(feature.properties[extrudedHeight]);
                }
                styleOption.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                if (/^\[/.test(styleOption.text) && /\]$/.test(styleOption.text)) {
                    var material = styleOption.text.replace(/\[/, '').replace(/\]/, '');
                    styleOption.text = feature.properties[material];
                }
                var id = that._core.getuid();
                var ids = 'DivPoint' + id;
                pointPrimitive.add({
                    id: ids,
                    position: Cartesian3,
                    color: that._cesium.Color.YELLOW,
                    description: styleOption.text
                });
                that.optiontext.push(option.text);
            });
            that.pointPrimitive = that._viewer.scene.primitives.add(pointPrimitive);
            var divPoint, CanvasCoordinates, pointPosition;
            var firstAdd = true;
            that.pointPrimitive.update = function () {
                for (var i = 0, item, divPointHtml; i < that.pointPrimitive.length; i++) {
                    item = that.pointPrimitive.get(i);
                    pointPosition = item.position;
                    CanvasCoordinates = that._viewer.scene.cartesianToCanvasCoordinates(pointPosition);
                    if (!CanvasCoordinates) return;
                    divPoint = document.getElementById(item.id);
                    if (!divPoint) {
                        divPointHtml = '<div id="' + item.id + '" style="position: absolute; width: 200px; height: 134px;left: 0px; top: 0px; pointer-events:none; background: url(' + window.SmartEarthRootUrl + configData$1.divpoint1 + ');transform: matrix(1, 0, 0, 1, 0, 0); transform-origin: left bottom 0px;">\n' +
                            '                   <div class="title" style="position: inherit;top: 22px;left: 70px;font-size: 14px;text-align: left;color: rgba(255,255,255,1);text-shadow: 0 0 9px rgba(0,0,0,.75)">' + that.optiontext[i] + '</div>\n' +
                            '           </div>';
                        $('.cesium-viewer').append(divPointHtml);
                        divPoint = document.getElementById(item.id);
                    }
                    if (item.description) {
                        divPoint.style.transform = 'matrix(1, 0, 0, 1, ' + (CanvasCoordinates.x) + ', ' + (CanvasCoordinates.y - 157) + ')';
                    } else {
                        divPoint.style.transform = 'matrix(1, 0, 0, 1, ' + (CanvasCoordinates.x) + ', ' + (CanvasCoordinates.y - 134) + ')';
                    }

                }
                if (firstAdd) {
                    if (checked) ; else {
                        that.setVisibility(false);
                    }
                    firstAdd = false;
                }
            };
            that.item = pointPrimitive;
            return "";
        };
        //this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "富文本" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'DivPoint',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        if (typeof disFnc == 'function')
            disFnc(this.item);
        return this;
    };
    /**
    * 矢量切片加载（模型点加载）优化版
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    * 薛鹏 2020/07/30
    */
    //模型点加载
    LabelGeoJsonFeatureLayer.prototype.createModelGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            // rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        styleOption.material;
        //填充颜色设置material
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.color)) {
            if (/^\[/.test(styleOption.color) && styleOption.color.toString().charAt(0) == "[" && styleOption.color.toString().charAt(styleOption.color.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.color)) {
                    styleOption.color = that._color.colorFromHtmlColor(styleOption.color);
                } else {
                    if (/^rgb/.test(styleOption.color)) {
                        styleOption.color = that._color.rgbaStringToRgbaObj(styleOption.color);
                    }
                    if (styleOption.color.r > 1) {
                        styleOption.color.r = styleOption.color.r / 255;
                    }
                    if (styleOption.color.g > 1) {
                        styleOption.color.g = styleOption.color.g / 255;
                    }
                    if (styleOption.color.b > 1) {
                        styleOption.color.b = styleOption.color.b / 255;
                    }
                    if (styleOption.color.a > 1) {
                        styleOption.color.a = styleOption.color.a / 255;
                    }
                    styleOption.color = that._color.createColor(styleOption.color.r, styleOption.color.g, styleOption.color.b, styleOption.color.a);
                }
            }
        }
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            var defaultOptions = {
                url: "",        //如果为bgltf则为.bgltf
                modelMatrix: that._cesium.Transforms.eastNorthUpToFixedFrame(origin),
                color: that._cesium.Color.DARKSALMON,
                //lightColor: that._cesium.Color.DARKSALMON,
                scale: 2.0,   //放大倍数
                //distanceDisplayCondition: attribute.distanceDisplayCondition
            };

            var options = that._core.extend(defaultOptions, styleOption, true);

            if (that._core.isnull(styleOption.near)) {
                styleOption.near = 0;
            }
            if (that._core.isnull(styleOption.far)) {
                styleOption.far = 999999999;
            }
            var min = parseFloat(styleOption.near);
            var max = parseFloat(styleOption.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            var collection = new that._cesium.PrimitiveCollection();
            json.features.forEach(function (feature) {
                options.id = feature;
                //修改xp
                var sheight = options.height;
                if (feature.properties.height != undefined) {
                    sheight = parseFloat(feature.properties.height);
                }
                if (/^\[/.test(options.height) && /\]$/.test(options.height)) {
                    var extrudedHeight = options.height.replace(/\[/, '').replace(/\]/, '');
                    sheight = parseFloat(feature.properties[extrudedHeight]);
                }
                options.modelMatrix = that._cesium.Transforms.eastNorthUpToFixedFrame(that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight));
                var mol = that._cesium.Model.fromGltf({
                    id: feature,
                    url: options.uri,        //如果为bgltf则为.bgltf
                    color: options.color,
                    //lightColor: options.lightColor,
                    modelMatrix: options.modelMatrix,
                    scale: options.scale,   //放大倍数
                    heightReference: parseInt(options.heightReference),
                    distanceDisplayCondition: options.distanceDisplayCondition
                });
                //var models = that._viewer.scene.primitives.add(mol);
                //that.model.push(mol);
                //this.labelCollections1

                collection.add(mol);
            });
            //that.item = that.model;
            return collection;
            //var primitive = that._viewer.scene.primitives.add(labelCollections);
            //dx = primitive;
        };
        this.item = geoJSONVectorTileProvider._primitiveCollection;

        //this.item = dx;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        if (!checked) {
            this.setVisibility(false);
        }
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'modelLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        if (typeof disFnc == 'function')
            disFnc(this.item);
        return this;
    };
    LabelGeoJsonFeatureLayer.prototype.createPointGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {

        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        //填充颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.color)) {
            if (/^\[/.test(styleOption.color) && styleOption.color.toString().charAt(0) == "[" && styleOption.color.toString().charAt(styleOption.color.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.color)) {
                    styleOption.color = that._color.colorFromHtmlColor(styleOption.color);
                } else {
                    if (/^rgb/.test(styleOption.color)) {
                        styleOption.color = that._color.rgbaStringToRgbaObj(styleOption.color);
                    }
                    if (styleOption.color.r > 1) {
                        styleOption.color.r = styleOption.color.r / 255;
                    }
                    if (styleOption.color.g > 1) {
                        styleOption.color.g = styleOption.color.g / 255;
                    }
                    if (styleOption.color.b > 1) {
                        styleOption.color.b = styleOption.color.b / 255;
                    }
                    if (styleOption.color.a > 1) {
                        styleOption.color.a = styleOption.color.a / 255;
                    }
                    styleOption.color = that._color.createColor(styleOption.color.r, styleOption.color.g, styleOption.color.b, styleOption.color.a);
                }
            }
        }
        //边框颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.outlineColor)) {
            if (/^\[/.test(styleOption.outlineColor) && styleOption.outlineColor.toString().charAt(0) == "[" && styleOption.outlineColor.toString().charAt(styleOption.outlineColor.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.outlineColor)) {
                    styleOption.outlineColor = that._color.colorFromHtmlColor(styleOption.outlineColor);
                } else {
                    if (/^rgb/.test(styleOption.outlineColor)) {
                        styleOption.outlineColor = that._color.rgbaStringToRgbaObj(styleOption.outlineColor);
                    }
                    if (styleOption.outlineColor.r > 1) {
                        styleOption.outlineColor.r = styleOption.outlineColor.r / 255;
                    }
                    if (styleOption.outlineColor.g > 1) {
                        styleOption.outlineColor.g = styleOption.outlineColor.g / 255;
                    }
                    if (styleOption.outlineColor.b > 1) {
                        styleOption.outlineColor.b = styleOption.outlineColor.b / 255;
                    }
                    if (styleOption.outlineColor.a > 1) {
                        styleOption.outlineColor.a = styleOption.outlineColor.a / 255;
                    }
                    styleOption.outlineColor = that._color.createColor(styleOption.outlineColor.r, styleOption.outlineColor.g, styleOption.outlineColor.b, styleOption.outlineColor.a);
                }
            }
        }
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            var defaultOptions = {
                Name: "",
                text: "",
                font: ' 30px sans-serif',
                pixelSize: 10.0,
                style: that._cesium.LabelStyle.OUTLINE,
                fillColor: that._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                outlineColor: that._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                show: true, //	optional A boolean Property specifying the visibility of the label.
                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                backgroundColor: new that._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                backgroundPadding: new that._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                horizontalOrigin: that._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                verticalOrigin: that._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                eyeOffset: that._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                pixelOffset: that._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                heightReference: that._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                scaleByDistance: new that._cesium.NearFarScalar(0, 0, 1, 1)
            };
            styleOption.material;

            //背景颜色设置
            if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.backgroundColor)) {
                if (/^\[/.test(styleOption.backgroundColor) && styleOption.backgroundColor.toString().charAt(0) == "[" && styleOption.backgroundColor.toString().charAt(styleOption.backgroundColor.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(styleOption.backgroundColor)) {
                        styleOption.backgroundColor = that._color.colorFromHtmlColor(styleOption.backgroundColor);
                    } else {
                        if (/^rgb/.test(styleOption.backgroundColor)) {
                            styleOption.backgroundColor = that._color.rgbaStringToRgbaObj(styleOption.backgroundColor);
                        }
                        if (styleOption.backgroundColor.r > 1) {
                            styleOption.backgroundColor.r = styleOption.backgroundColor.r / 255;
                        }
                        if (styleOption.backgroundColor.g > 1) {
                            styleOption.backgroundColor.g = styleOption.backgroundColor.g / 255;
                        }
                        if (styleOption.backgroundColor.b > 1) {
                            styleOption.backgroundColor.b = styleOption.backgroundColor.b / 255;
                        }
                        if (styleOption.backgroundColor.a > 1) {
                            styleOption.backgroundColor.a = styleOption.backgroundColor.a / 255;
                        }
                        styleOption.backgroundColor = that._color.createColor(styleOption.backgroundColor.r, styleOption.backgroundColor.g, styleOption.backgroundColor.b, styleOption.backgroundColor.a);
                    }
                }
            }
            var options = that._core.extend(defaultOptions, styleOption, true);

            if (that._core.isnull(styleOption.near)) {
                styleOption.near = 0;
            }
            if (that._core.isnull(styleOption.far)) {
                styleOption.far = 999999999;
            }
            var min = parseFloat(styleOption.near);
            var max = parseFloat(styleOption.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            //options.pointHeight = parseFloat(that._core.extendgl(entity, option.pointHeight, options.pointHeight));
            if (that._core.isnull(styleOption.font_size)) {
                styleOption.font_size = "30px";
            }
            if (that._core.isnull(styleOption.font_family)) {
                styleOption.font_family = " sans-serif";
            }
            //options.font = option.font_size + " " + option.font_family;
            options.font = parseFloat(styleOption.font_size) + "px " + styleOption.font_family;
            // var labelCollections = new that._cesium.LabelCollection();
            var labelCollections = new that._cesium.PointPrimitiveCollection();
            json.features.forEach(function (feature) {
                options.id = feature;
                //options.position = that._cesium.Cartesian3.fromDegreesArray(feature.geometry.coordinates)[0];
                //修改xp
                var sheight = 0.0;
                if (/^\[/.test(options.pointHeight) && /\]$/.test(options.pointHeight)) {
                    var heightStr = options.pointHeight.replace(/\[/, '').replace(/\]/, '');
                    sheight = parseFloat(feature.properties[heightStr]);
                } else if (options.pointHeight !== undefined && options.pointHeight !== '') {
                    sheight = parseFloat(options.pointHeight);
                } else if (feature.properties.height != undefined) {
                    sheight = parseFloat(feature.properties.height);
                }
                //填充色
                if (/^\[/.test(styleOption.color) && /\]$/.test(styleOption.color)) {
                    var material = styleOption.color.replace(/\[/, '').replace(/\]/, '');
                    options.color = feature.properties[material];
                    //填充颜色设置
                    if (that._core.isHtmlColor(options.color)) {
                        options.color = that._color.colorFromHtmlColor(options.color);
                    } else {
                        if (/^rgb/.test(options.color)) {
                            options.color = that._color.rgbaStringToRgbaObj(options.color);
                        }
                        if (options.color.r > 1) {
                            options.color.r = options.color.r / 255;
                        }
                        if (options.color.g > 1) {
                            options.color.g = options.color.g / 255;
                        }
                        if (options.color.b > 1) {
                            options.color.b = options.color.b / 255;
                        }
                        if (options.color.a > 1) {
                            options.color.a = options.color.a / 255;
                        }
                        options.color = that._color.createColor(options.color.r, options.color.g, options.color.b, options.color.a);
                    }
                }
                //边框色
                if (/^\[/.test(styleOption.outlineColor) && /\]$/.test(styleOption.outlineColor)) {
                    var material = styleOption.outlineColor.replace(/\[/, '').replace(/\]/, '');
                    options.outlineColor = feature.properties[material];
                    //填充颜色设置
                    if (that._core.isHtmlColor(options.outlineColor)) {
                        options.outlineColor = that._color.colorFromHtmlColor(options.outlineColor);
                    } else {
                        if (/^rgb/.test(options.outlineColor)) {
                            options.outlineColor = that._color.rgbaStringToRgbaObj(options.outlineColor);
                        }
                        if (options.outlineColor.r > 1) {
                            options.outlineColor.r = options.outlineColor.r / 255;
                        }
                        if (options.outlineColor.g > 1) {
                            options.outlineColor.g = options.outlineColor.g / 255;
                        }
                        if (options.outlineColor.b > 1) {
                            options.outlineColor.b = options.outlineColor.b / 255;
                        }
                        if (options.outlineColor.a > 1) {
                            options.outlineColor.a = options.outlineColor.a / 255;
                        }
                        options.outlineColor = that._color.createColor(options.outlineColor.r, options.outlineColor.g, options.outlineColor.b, options.outlineColor.a);
                    }
                }
                options.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                options.text = feature.properties.name;
                var p = {
                    show: options.show,
                    position: options.position,
                    pixelSize: options.pixelSize,
                    color: options.color,
                    outlineColor: options.outlineColor,
                    outlineWidth: options.outlineWidth,
                    id: feature
                };
                //图例
                var col = "color:" + options.color.red * 255 + "," + options.color.green * 255 + "," + options.color.blue * 255
                    + ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                that.Legend.push(col);
                labelCollections.add(p);
            });

            //var primitive = that._viewer.scene.primitives.add(labelCollections);
            //dx = primitive;
            return labelCollections;
        };
        this.item = geoJSONVectorTileProvider._primitiveCollection;
        //this.item = dx;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'pointLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        if (typeof disFnc == 'function')
            disFnc(this.item);
        return this;
    };
    LabelGeoJsonFeatureLayer.prototype.createPointGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 请求矢量切片
         */
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        var that = this;
        //填充颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.color)) {
            if (/^\[/.test(styleOption.color) && styleOption.color.toString().charAt(0) == "[" && styleOption.color.toString().charAt(styleOption.color.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.color)) {
                    styleOption.color = that._color.colorFromHtmlColor(styleOption.color);
                } else {
                    if (/^rgb/.test(styleOption.color)) {
                        styleOption.color = that._color.rgbaStringToRgbaObj(styleOption.color);
                    }
                    if (styleOption.color.r > 1) {
                        styleOption.color.r = styleOption.color.r / 255;
                    }
                    if (styleOption.color.g > 1) {
                        styleOption.color.g = styleOption.color.g / 255;
                    }
                    if (styleOption.color.b > 1) {
                        styleOption.color.b = styleOption.color.b / 255;
                    }
                    if (styleOption.color.a > 1) {
                        styleOption.color.a = styleOption.color.a / 255;
                    }
                    styleOption.color = that._color.createColor(styleOption.color.r, styleOption.color.g, styleOption.color.b, styleOption.color.a);
                }
            }
        }
        //边框颜色设置
        if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.outlineColor)) {
            if (/^\[/.test(styleOption.outlineColor) && styleOption.outlineColor.toString().charAt(0) == "[" && styleOption.outlineColor.toString().charAt(styleOption.outlineColor.length - 1) == "]") ; else {
                if (that._core.isHtmlColor(styleOption.outlineColor)) {
                    styleOption.outlineColor = that._color.colorFromHtmlColor(styleOption.outlineColor);
                } else {
                    if (/^rgb/.test(styleOption.outlineColor)) {
                        styleOption.outlineColor = that._color.rgbaStringToRgbaObj(styleOption.outlineColor);
                    }
                    if (styleOption.outlineColor.r > 1) {
                        styleOption.outlineColor.r = styleOption.outlineColor.r / 255;
                    }
                    if (styleOption.outlineColor.g > 1) {
                        styleOption.outlineColor.g = styleOption.outlineColor.g / 255;
                    }
                    if (styleOption.outlineColor.b > 1) {
                        styleOption.outlineColor.b = styleOption.outlineColor.b / 255;
                    }
                    if (styleOption.outlineColor.a > 1) {
                        styleOption.outlineColor.a = styleOption.outlineColor.a / 255;
                    }
                    styleOption.outlineColor = that._color.createColor(styleOption.outlineColor.r, styleOption.outlineColor.g, styleOption.outlineColor.b, styleOption.outlineColor.a);
                }
            }
        }
        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        geoJSONVectorTileProvider._loadTile = function (json) {
            var defaultOptions = {
                Name: "",
                text: "",
                font: ' 30px sans-serif',
                pixelSize: 10.0,
                style: that._cesium.LabelStyle.OUTLINE,
                fillColor: that._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                outlineColor: that._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                show: true, //	optional A boolean Property specifying the visibility of the label.
                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                backgroundColor: new that._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                backgroundPadding: new that._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                horizontalOrigin: that._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                verticalOrigin: that._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                eyeOffset: that._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                pixelOffset: that._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                heightReference: that._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                scaleByDistance: new that._cesium.NearFarScalar(0, 0, 1, 1)
            };
            styleOption.material;

            //背景颜色设置
            if (!that._core.isnull(styleOption) && !that._core.isnull(styleOption.backgroundColor)) {
                if (/^\[/.test(styleOption.backgroundColor) && styleOption.backgroundColor.toString().charAt(0) == "[" && styleOption.backgroundColor.toString().charAt(styleOption.backgroundColor.length - 1) == "]") ; else {
                    if (that._core.isHtmlColor(styleOption.backgroundColor)) {
                        styleOption.backgroundColor = that._color.colorFromHtmlColor(styleOption.backgroundColor);
                    } else {
                        if (/^rgb/.test(styleOption.backgroundColor)) {
                            styleOption.backgroundColor = that._color.rgbaStringToRgbaObj(styleOption.backgroundColor);
                        }
                        if (styleOption.backgroundColor.r > 1) {
                            styleOption.backgroundColor.r = styleOption.backgroundColor.r / 255;
                        }
                        if (styleOption.backgroundColor.g > 1) {
                            styleOption.backgroundColor.g = styleOption.backgroundColor.g / 255;
                        }
                        if (styleOption.backgroundColor.b > 1) {
                            styleOption.backgroundColor.b = styleOption.backgroundColor.b / 255;
                        }
                        if (styleOption.backgroundColor.a > 1) {
                            styleOption.backgroundColor.a = styleOption.backgroundColor.a / 255;
                        }
                        styleOption.backgroundColor = that._color.createColor(styleOption.backgroundColor.r, styleOption.backgroundColor.g, styleOption.backgroundColor.b, styleOption.backgroundColor.a);
                    }
                }
            }
            var options = that._core.extend(defaultOptions, styleOption, true);

            if (that._core.isnull(styleOption.near)) {
                styleOption.near = 0;
            }
            if (that._core.isnull(styleOption.far)) {
                styleOption.far = 999999999;
            }
            var min = parseFloat(styleOption.near);
            var max = parseFloat(styleOption.far);
            var distance = new that._cesium.DistanceDisplayCondition(min, max);
            options.distanceDisplayCondition = distance;
            //options.pointHeight = parseFloat(that._core.extendgl(entity, option.pointHeight, options.pointHeight));
            if (that._core.isnull(styleOption.font_size)) {
                styleOption.font_size = "30px";
            }
            if (that._core.isnull(styleOption.font_family)) {
                styleOption.font_family = " sans-serif";
            }
            //options.font = option.font_size + " " + option.font_family;
            options.font = parseFloat(styleOption.font_size) + "px " + styleOption.font_family;
            // var labelCollections = new that._cesium.LabelCollection();
            var labelCollections = new that._cesium.PointPrimitiveCollection();
            json.features.forEach(function (feature) {
                options.id = feature;
                //options.position = that._cesium.Cartesian3.fromDegreesArray(feature.geometry.coordinates)[0];
                //修改xp
                var sheight = 0.0;
                if (/^\[/.test(options.pointHeight) && /\]$/.test(options.pointHeight)) {
                    var heightStr = options.pointHeight.replace(/\[/, '').replace(/\]/, '');
                    sheight = parseFloat(feature.properties[heightStr]);
                } else if (options.pointHeight !== undefined && options.pointHeight !== '') {
                    sheight = parseFloat(options.pointHeight);
                } else if (feature.properties.height != undefined) {
                    sheight = parseFloat(feature.properties.height);
                }
                //填充色
                if (/^\[/.test(styleOption.color) && /\]$/.test(styleOption.color)) {
                    var material = styleOption.color.replace(/\[/, '').replace(/\]/, '');
                    options.color = feature.properties[material];
                    //填充颜色设置
                    if (that._core.isHtmlColor(options.color)) {
                        options.color = that._color.colorFromHtmlColor(options.color);
                    } else {
                        if (/^rgb/.test(options.color)) {
                            options.color = that._color.rgbaStringToRgbaObj(options.color);
                        }
                        if (options.color.r > 1) {
                            options.color.r = options.color.r / 255;
                        }
                        if (options.color.g > 1) {
                            options.color.g = options.color.g / 255;
                        }
                        if (options.color.b > 1) {
                            options.color.b = options.color.b / 255;
                        }
                        if (options.color.a > 1) {
                            options.color.a = options.color.a / 255;
                        }
                        options.color = that._color.createColor(options.color.r, options.color.g, options.color.b, options.color.a);
                    }
                }
                //边框色
                if (/^\[/.test(styleOption.outlineColor) && /\]$/.test(styleOption.outlineColor)) {
                    var material = styleOption.outlineColor.replace(/\[/, '').replace(/\]/, '');
                    options.outlineColor = feature.properties[material];
                    //填充颜色设置
                    if (that._core.isHtmlColor(options.outlineColor)) {
                        options.outlineColor = that._color.colorFromHtmlColor(options.outlineColor);
                    } else {
                        if (/^rgb/.test(options.outlineColor)) {
                            options.outlineColor = that._color.rgbaStringToRgbaObj(options.outlineColor);
                        }
                        if (options.outlineColor.r > 1) {
                            options.outlineColor.r = options.outlineColor.r / 255;
                        }
                        if (options.outlineColor.g > 1) {
                            options.outlineColor.g = options.outlineColor.g / 255;
                        }
                        if (options.outlineColor.b > 1) {
                            options.outlineColor.b = options.outlineColor.b / 255;
                        }
                        if (options.outlineColor.a > 1) {
                            options.outlineColor.a = options.outlineColor.a / 255;
                        }
                        options.outlineColor = that._color.createColor(options.outlineColor.r, options.outlineColor.g, options.outlineColor.b, options.outlineColor.a);
                    }
                }
                options.position = new that._cesium.Cartesian3.fromDegrees(feature.geometry.coordinates[0], feature.geometry.coordinates[1], sheight);
                options.text = feature.properties.name;
                var p = {
                    show: options.show,
                    position: options.position,
                    pixelSize: options.pixelSize,
                    color: options.color,
                    outlineColor: options.outlineColor,
                    outlineWidth: options.outlineWidth,
                    id: feature
                };
                //图例
                var col = "color:" + options.color.red * 255 + "," + options.color.green * 255 + "," + options.color.blue * 255
                    + ";outlineColor:" + options.outlineColor.red * 255 + "," + options.outlineColor.green * 255 + "," + options.outlineColor.blue * 255;
                that.Legend.push(col);
                labelCollections.add(p);
            });

            //var primitive = that._viewer.scene.primitives.add(labelCollections);
            //dx = primitive;
            return labelCollections;
        };
        this.item = geoJSONVectorTileProvider._primitiveCollection;
        //this.item = dx;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(styleOption.id)) {
            styleOption.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + styleOption.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: styleOption.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'pointLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        if (typeof disFnc == 'function')
            disFnc(this.item);
        return this;
    };
    //工程树添加
    LabelGeoJsonFeatureLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 返回图例
     * @returns {object}
     */
    LabelGeoJsonFeatureLayer.prototype.getLegend = function () {
        var legend = [];
        if (this.Legend != null) {
            legend = this._core.unique(this.Legend);
        }
        return legend;
    };
    /**
     * 删除数据
     */
    LabelGeoJsonFeatureLayer.prototype.deleteObject = function () {
        if (this._Provider != undefined) {
            this._Provider.setStatus(false);
        }
        if (this.items != undefined && this.items != null && this.items.length > 0) {
            for (var i = 0; i < this.items.length; i++) {
                this._viewer.scene.primitives.remove(this.items[i]);
            }
        } else {
            this._viewer.scene.primitives.remove(this.item);
        }
        if (this.treeobj.type === 'DivPoint' && this.item && this.item._pointPrimitives != undefined && this.item._pointPrimitives != null) {
            for (var i = 0; i < this.item._pointPrimitives.length; i++) {
                var divPoint = document.getElementById(this.item._pointPrimitives[i].id);
                divPoint && divPoint.remove();
            }
        }
        try {
            this._Provider.remove();
        } catch (ex) {
        }
    };
    /**
     * 导出工程数据
     */
    LabelGeoJsonFeatureLayer.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url
            }
        };
    };
    /**
     * 设置数据是否刷新
     */
    LabelGeoJsonFeatureLayer.prototype.setRefresh = function (b) {
        try {
            if (this._Provider) {
                this._Provider.setStatus(!b);
            }
        } catch (ex) {
        }
    };
    /**
     * 设置数据显示隐藏
     */
    LabelGeoJsonFeatureLayer.prototype.setVisibility = function (b) {
        if (this.treeobj != undefined && this.treeobj.type === 'DivPoint' && this.item && this.item._pointPrimitives != undefined && this.item._pointPrimitives != null) {
            for (var i = 0; i < this.item._pointPrimitives.length; i++) {
                var divPoint = document.getElementById(this.item._pointPrimitives[i].id);
                divPoint && (divPoint.style.display = b ? 'block' : 'none');
            }
        }
        if (this.item != undefined) {
            this.item.show = b;
        }
        if (this._Provider) {
            this._Provider.setStatus(!b);
        }

    };

    Object.defineProperties(LabelGeoJsonFeatureLayer.prototype, {
        /**
         * 设置geojson图层的显示文本
         * @param {String}  text [text]
         */
        labelText: {
            set: lodash.debounce(function (text) {
                var text1 = text;
                if (this._core.isnull(text)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(text)) {
                            text1 = text.replace(/\[/, '').replace(/\]/, '');
                            text1 = entities[i].properties[text1]._value;
                        }
                        if (!entities[i].label) {
                            try {
                                entities[i].point.show = false;
                            } catch (ex) { }
                            entities[i].label = new this._cesium.LabelGraphics({
                                text: text1,
                                font: '30px sans-serif',
                                style: this._cesium.LabelStyle.FILL,
                                fillColor: this._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                                outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                                show: true, //	optional A boolean Property specifying the visibility of the label.
                                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                                backgroundColor: new this._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                                backgroundPadding: new this._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                heightReference: this._cesium.HeightReference.NONE //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            entities[i].label.text = text1;
                            try {
                                entities[i].point.show = false;
                            } catch (ex) { }
                        }
                    }
                }
            }, 500)
        },
        /**
         * 设置geojson图层显示文本的样式
         * @param {object} labelStyle
         */
        labelStyles: {
            set: lodash.debounce(function (labelStyle) {
                if (this._core.isnull(labelStyle)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.style = labelStyle;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).style;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return entities[0].label.style;
                }
            }
        },
        labelFont: {
            set: lodash.debounce(function (font_family) {
                if (this._core.isnull(font_family)) return;
                var entities = this.item.entities && this.item.entities.values;
                font_family = font_family.toString().replace(/px/g, '');
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                var font = entities[0].label.font;
                var font_size = 16;
                if (font) {
                    font = font._value.trimLeft().trimRight();
                    font_size = font.split('px')[0];
                }
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.font = font_size + "px " + font_family;
                    }
                }
            }, 500)
        },

        /**
         * 设置geojson图层显示文本的样式
         * @param {Float} fontsize
         */
        labelFontSize1: {
            set: lodash.debounce(function (fontsize) {
                if (this._core.isnull(fontsize)) return;
                var entities = this.item.entities && this.item.entities.values;
                fontsize = fontsize.toString().replace(/px/g, '');
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                var font = entities[0].label.font;
                var font_family = 'sans-serif';
                if (font) {
                    font = font._value.trimLeft().trimRight();
                    font_family = font.split('px')[1];
                }
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.font = fontsize + "px  " + font_family;
                    }
                }
            }, 500)
        },
        /**
         * 设置geojson图层显示文本的样式
         * @param {Float} fontsize
         */
        labelFontSize: {
            set: lodash.debounce(function (fontsize) {
                if (this._core.isnull(fontsize)) return;
                var entities = this.item.entities && this.item.entities.values;
                fontsize = fontsize.toString().replace(/px/g, '');
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.font = fontsize + "px  sans-serif";
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).font;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return parseFloat(entities[0].label.font);
                }
            }
        },
        /**
         * 设置geojson图层显示文本的填充色
         * @param {object} color
         */
        labelFillColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.fillColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).fillColor;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var color = entities[0].label.fillColor;
                    return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            }
        },
        /**
         * 设置geojson图层显示文本边框的填充色
         * @param {object} color
         */
        labelOutlineColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.outlineColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).outlineColor;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var color = entities[0].label.outlineColor;
                    try {
                        return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置geojson图层显示文本边框的宽度
         * @param {Float} width [width]
         */
        labelOutlineWidth: {
            set: lodash.debounce(function (width) {
                if (this._core.isnull(width)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(width)) {
                            width = width.replace(/\[/, '').replace(/\]/, '');
                            width = entities[i].properties[width];
                        }
                        entities[i].label.outlineWidth = width;
                    }
                }
            }, 200),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).outlineWidth;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var width = entities[0].label.outlineWidth;
                    if (width) {
                        return width._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的背景色
         * @param {object} color
         */
        labelBackgroundColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.backgroundColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).backgroundColor;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var color = entities[0].label.backgroundColor;
                    return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                }
            }
        },
        /**
         * 设置geojson图层显示文本是否显示背景色
         * @param {boolean} b
         */
        labelBackground: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.showBackground = b;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).background;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return entities[0].label.background;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的大小
         * @param {Float} scale [scale]
         */
        labelScale: {
            set: lodash.debounce(function (scale) {
                if (this._core.isnull(scale)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(scale)) {
                            scale = scale.replace(/\[/, '').replace(/\]/, '');
                            scale = entities[i].properties[scale];
                        }
                        entities[i].label.scale = scale;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).scale;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var scale = entities[0].label.scale;
                    if (scale) {
                        return scale._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的水平布局方式
         * @param {object} horizontalOrigin
         */
        labelHorizontalOrigin: {
            set: lodash.debounce(function (horizontalOrigin) {
                if (this._core.isnull(horizontalOrigin)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.horizontalOrigin = parseInt(horizontalOrigin);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).horizontalOrigin;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var horizontalOrigin = entities[0].label.horizontalOrigin;
                    if (horizontalOrigin)
                        return horizontalOrigin._value;
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的水平布局方式
         * @param {object} verticalOrigin
         */
        labelVerticalOrigin: {
            set: lodash.debounce(function (verticalOrigin) {
                if (this._core.isnull(verticalOrigin)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.verticalOrigin = parseInt(verticalOrigin);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).verticalOrigin;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var verticalOrigin = entities[0].label.verticalOrigin;
                    if (verticalOrigin)
                        return verticalOrigin._value;
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的高度类型
         * @param {object} verticalOrigin
         */
        labelHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).heightReference;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var heightReference = entities[0].label.heightReference;
                    if (heightReference)
                        return heightReference._value;
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的最大可视距离
         * @param {Float} far
         */
        labelDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var near = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, parseInt(far));
                        entities[i].label.scaleByDistance = new this._cesium.NearFarScalar(near, 1, parseInt(far), 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.far : Number.MAX_VALUE;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var far = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    return far;
                }
            }
        },
        /**
         * 设置geojson图层显示文本的最小可视距离
         * @param {Float} near
         */
        labelDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var far = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].label.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(parseInt(near), far);
                        entities[i].label.scaleByDistance = new this._cesium.NearFarScalar(parseInt(near), 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.near : 0;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    var near = entities[0].label.distanceDisplayCondition ? entities[0].label.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         *
         *
         */
        labelHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude);
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude);
                // var height=this._cesium.Math.toDegrees( Cartographic.height);
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        },
        /**
         * 设置geojson图层的label显示隐藏
         *
         *
         */
        labelShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities && this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id)) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].label && b) {
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                            entities[i].label = new this._cesium.LabelGraphics({
                                text: "label",
                                font: '30px sans-serif',
                                style: this._cesium.LabelStyle.FILL,
                                fillColor: this._cesium.Color.WHITE, //	optional A Property specifying the fill Color.
                                outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the outline Color.
                                outlineWidth: 1.0, //	optional A numeric Property specifying the outline width.
                                show: true, //	optional A boolean Property specifying the visibility of the label.
                                showBackground: false, //	optional A boolean Property specifying the visibility of the background behind the label.
                                backgroundColor: new this._cesium.Color(0.165, 0.165, 0.165, 0.8), //optional A Property specifying the background Color.
                                backgroundPadding: new this._cesium.Cartesian2(7, 5), //optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the text.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                heightReference: this._cesium.HeightReference.NONE //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            if (entities[i].label)
                                entities[i].label.show = b;

                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).show;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].label == undefined) return;
                if (entities && entities.length > 0 && entities[0].label) {
                    return entities[0].label.show;
                }
            }
        },

        /**
         * 模型图层的显示隐藏
         * @param {boolean} b
         */
        modelShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities && this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id)) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (entities[i].label) entities[i].label.show = !b;
                        if (entities[i].point) entities[i].point.show = !b;
                        if (entities[i].billboard) entities[i].billboard.show = !b;
                        if (!entities[i].model && b) {
                            entities[i].model = new this._cesium.ModelGraphics({
                                //uri: "glb/gltf",
                                show: true,
                                scale: 1.0,
                                minimumPixelSize: 0.0,
                                incrementallyLoadTextures: true,
                                runAnimations: true,
                                clampAnimations: true,
                                shadows: this._cesium.ShadowMode.ENABLED,
                                heightReference: this._cesium.HeightReference.NONE,
                                color: this._cesium.Color.WHITE
                            });
                        } else {
                            if (entities[i].model)
                                entities[i].model.show = b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).show;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    return entities[0].model.show;
                }
            }
        },
        /**
         * 模型图层的模型地址
         * @param {String} uri [uri]
         */
        modelUri: {
            set: lodash.debounce(function (uri) {
                if (this._core.isnull(uri)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].model) {
                            if (/^\[/.test(uri)) {
                                var uris = uri.split('[');
                                if (uris.length > 1) {
                                    uri = uris[0] + uris[1].replace(/\[/, '').replace(/\]/, '');
                                } else {
                                    uri = uri.replace(/\[/, '').replace(/\]/, '');
                                    uri = entities[i].properties[uri];
                                }
                            }
                            entities[i].model = new this._cesium.ModelGraphics({
                                uri: uri,
                                show: true,
                                scale: 1.0,
                                minimumPixelSize: 0.0,
                                incrementallyLoadTextures: true,
                                runAnimations: true,
                                clampAnimations: true,
                                shadows: this._cesium.ShadowMode.ENABLED,
                                heightReference: this._cesium.HeightReference.NONE,
                                color: this._cesium.Color.WHITE
                            });
                        } else {
                            entities[i].model.uri = uri;
                        }
                    }
                }
            }, 500)
        },
        /**
         * 模型图层的模型显示比例
         * @param {Float} scale [scale]
         */
        modelScale: {
            set: lodash.debounce(function (scale) {
                if (this._core.isnull(scale)) return;
                scale = parseFloat(scale);
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(scale)) {
                            scale = scale.replace(/\[/, '').replace(/\]/, '');
                            scale = entities[i].properties[scale];
                        }
                        entities[i].model.scale = scale;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).scale;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var scale = entities[0].model.scale;
                    if (scale) {
                        return scale._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 模型图层的模型的阴影
         * @param {Float} shadows sgworld.ShadowMode.*
         */
        modelShadows: {
            set: lodash.debounce(function (shadows) {
                if (this._core.isnull(shadows)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.shadows = shadows;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).shadows;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    return entities[0].model.shadows;
                }
            }
        },
        /**
         * 模型图层的模型的高度类型
         * @param {object} heightReference sgworld.HeightReference.*
         */
        modelHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).heightReference;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var heightReference = entities[0].model.heightReference;
                    if (heightReference) {
                        return heightReference._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层模型的最大可视距离
         * @param {Float} far
         */
        modelDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var near = entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.far : Number.MAX_VALUE;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                }
            }
        },
        /**
         * 设置geojson图层点模型最小可视距离
         * @param {Float} near
         */
        modelDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var far = entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.near : 0;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var near = entities[0].model.distanceDisplayCondition ? entities[0].model.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层模型颜色
         * @param {object} color
         */
        modelColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.color = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).color;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var color = entities[0].model.color;
                    try {
                        return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置geojson图层模型高亮颜色
         * @param {object} color
         */
        modelLightColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].model.lightColor = color;
                    }
                }
            }, 100),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).lightColor;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].model == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var lightColor = entities[0].model.lightColor;
                    try {
                        return this._color.toHtmlColor('rgb(' + lightColor._value.red * 255 + ',' + lightColor._value.green * 255 + ',' + lightColor._value.blue * 255 + ',' + lightColor._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         */
        modelHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude)
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude)
                // var height=this._cesium.Math.toDegrees( Cartographic.height)
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        },

        /**
         * 设置位置点的颜色
         * @param {object} color
         */
        pointColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.color = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).color;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var fillColor = entities[0].point.color;
                    try {
                        return this._color.toHtmlColor('rgb(' + fillColor._value.red * 255 + ',' + fillColor._value.green * 255 + ',' + fillColor._value.blue * 255 + ',' + fillColor._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置位置点的颜色
         * @param {boolean} b
         */
        pointShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities && this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id) ) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].point && b) {
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                            entities[i].point = new this._cesium.PointGraphics({
                                color: this._cesium.Color.WHITE, //	optional A Property specifying the Color of the point.
                                pixelSize: 1, //optional A numeric Property specifying the size in pixels.
                                outlineColor: this._cesium.Color.BLACK, //	optional A Property specifying the Color of the outline.
                                outlineWidth: 0, //	optional A numeric Property specifying the the outline width in pixels.
                                show: true //	optional A boolean Property specifying the visibility of the point.
                            });
                        } else {
                            if (entities[i].point)
                                entities[i].point.show = b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).show;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    return entities[0].point.show;
                }
            }
        },
        /**
         * 设置位置点的大小
         * @param {Float} pixelSize [pixelSize]
         */
        pointPixelSize: {
            set: lodash.debounce(function (pixelSize) {
                if (this._core.isnull(pixelSize)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(pixelSize)) {
                            pixelSize = pixelSize.replace(/\[/, '').replace(/\]/, '');
                            pixelSize = entities[i].properties[pixelSize];
                        }
                        entities[i].point.pixelSize = pixelSize;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).pixelSize;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var pixelSize = entities[0].point.pixelSize;
                    if (pixelSize) {
                        return pixelSize._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置点的边框颜色
         * @param {object} color
         */
        pointOutlineColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.outlineColor = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         var color = primitive.get(0).outlineColor;
                //         return this._color.toHtmlColor('rgb(' + color.red * 255 + ',' + color.green * 255 + ',' + color.blue * 255 + ',' + color.alpha * 255 + ')');
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var outlineColor = entities[0].point.outlineColor;
                    try {
                        return this._color.toHtmlColor('rgb(' + outlineColor._value.red * 255 + ',' + outlineColor._value.green * 255 + ',' + outlineColor._value.blue * 255 + ',' + outlineColor._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * 设置点的边框宽度
         * @param {Float} width [width]
         */
        pointOutlineWidth: {
            set: lodash.debounce(function (width) {
                if (this._core.isnull(width)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(width)) {
                            width = width.replace(/\[/, '').replace(/\]/, '');
                            width = entities[i].properties[width];
                        }
                        entities[i].point.outlineWidth = width;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).outlineWidth;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var outlineWidth = entities[0].point.outlineWidth;
                    if (outlineWidth) {
                        return outlineWidth._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置点的高度类型
         * @param {object} heightReference
         */
        pointHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).heightReference;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var heightReference = entities[0].point.heightReference;
                    if (heightReference) {
                        return heightReference._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层点的最大可视距离
         * @param {Float} far
         */
        pointDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var near = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                        entities[i].point.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.far : Number.MAX_VALUE;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var far = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    return far;
                }
            }
        },
        /**
         * 设置geojson图层点的最小可视距离
         * @param {Float} verticalOrigin
         */
        pointDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var far = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].point.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);

                        entities[i].point.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                // if (!entities && this.item._primitives) {
                //     var primitive = this.item._primitives[0];
                //     if (primitive.get(0)) {
                //         return primitive.get(0).distanceDisplayCondition ? primitive.get(0).distanceDisplayCondition.nera : 0;
                //     }
                //     return;
                // }
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].point == undefined) return;
                if (entities && entities.length > 0 && entities[0].point) {
                    var near = entities[0].point.distanceDisplayCondition ? entities[0].point.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         */
        pointHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude)
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude)
                // var height=this._cesium.Math.toDegrees( Cartographic.height)
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        },

        /**
         * 控制billboard的显示隐藏
         * @param {boolean} b
         */
        billboardShow: {
            set: lodash.debounce(function (b) {
                // if (this._core.isnull(b)) return;
                var entities = this.item.entities && this.item.entities.values;
                // if (entities && !/^point.fid/.test(entities[0]._id)) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (!entities[i].billboard && b) {
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].model) entities[i].model.show = !b;
                            entities[i].billboard = new this._cesium.BillboardGraphics({
                                //image: "",//	Property		optional A Property specifying the Image, URI, or Canvas to use for the billboard.
                                show: true, //	optional A boolean Property specifying the visibility of the billboard.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the image size.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //	optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                rotation: 0, //	optional A numeric Property specifying the rotation about the alignedAxis.
                                alignedAxis: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the unit vector axis of rotation.
                                width: undefined, //		optional A numeric Property specifying the width of the billboard in pixels, overriding the native size.
                                height: undefined, //		optional A numeric Property specifying the height of the billboard in pixels, overriding the native size.
                                color: this._cesium.Color.WHITE, //	optional A Property specifying the tint Color of the image.
                                heightReference: this._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            if (entities[i].billboard)
                                entities[i].billboard.show = b;
                            if (entities[i].point) entities[i].point.show = !b;
                            if (entities[i].label) entities[i].label.show = !b;
                            if (entities[i].billboard) entities[i].billboard.show = !b;
                        }
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    return entities[0].billboard.show;
                }
            }
        },
        /**
         * 控制billboard的图片
         * @param {string} image [image]
         */
        billboardImage: {
            set: lodash.debounce(function (image) {
                if (this._core.isnull(image)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0) {
                    for (var i = 0; i < entities.length; i++) {
                        if (/^\[/.test(image)) {
                            var images = image.split('[');
                            if (images.length > 1) {
                                image = images[0] + images[1].replace(/\[/, '').replace(/\]/, '');
                            } else {
                                image = image.replace(/\[/, '').replace(/\]/, '');
                                image = entities[i].properties[image];
                            }
                        }
                        if (!entities[i].billboard) {
                            entities[i].billboard = new this._cesium.BillboardGraphics({
                                image: image, //	Property		optional A Property specifying the Image, URI, or Canvas to use for the billboard.
                                show: true, //	optional A boolean Property specifying the visibility of the billboard.
                                scale: 1.0, //optional A numeric Property specifying the scale to apply to the image size.
                                horizontalOrigin: this._cesium.HorizontalOrigin.CENTER, //	optional A Property specifying the HorizontalOrigin.
                                verticalOrigin: this._cesium.VerticalOrigin.CENTER, //	optional A Property specifying the VerticalOrigin.
                                eyeOffset: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the eye offset.
                                pixelOffset: this._cesium.Cartesian2.ZERO, //	optional A Cartesian2 Property specifying the pixel offset.
                                rotation: 0, //	optional A numeric Property specifying the rotation about the alignedAxis.
                                alignedAxis: this._cesium.Cartesian3.ZERO, //	optional A Cartesian3 Property specifying the unit vector axis of rotation.
                                width: undefined, //		optional A numeric Property specifying the width of the billboard in pixels, overriding the native size.
                                height: undefined, //		optional A numeric Property specifying the height of the billboard in pixels, overriding the native size.
                                color: this._cesium.Color.WHITE, //	optional A Property specifying the tint Color of the image.
                                heightReference: this._cesium.HeightReference.NONE, //	optional A Property specifying what the height is relative to.
                            });
                        } else {
                            entities[i].billboard.image = image;
                        }
                    }
                }
            }, 500)
        },
        /**
         * 控制billboard的图片scale
         * @param {Float} scale
         */
        billboardScale: {
            set: lodash.debounce(function (scale) {
                if (this._core.isnull(scale)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.scale = scale;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var scale = entities[0].billboard.scale;
                    if (scale) {
                        return scale._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 控制billboard的图片horizontalOrigin
         * @param {Float} horizontalOrigin
         */
        billboardHorizontalOrigin: {
            set: lodash.debounce(function (horizontalOrigin) {
                if (this._core.isnull(horizontalOrigin)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.horizontalOrigin = horizontalOrigin;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    return entities[0].billboard.horizontalOrigin;
                }
            }
        },
        /**
         * 控制billboard的图片verticalOrigin
         * @param {Float} verticalOrigin
         */
        billboardVerticalOrigin: {
            set: lodash.debounce(function (verticalOrigin) {
                if (this._core.isnull(verticalOrigin)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.verticalOrigin = verticalOrigin;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    return entities[0].billboard.verticalOrigin;
                }
            }
        },
        /**
         * 控制billboard的图片width
         * @param {Float} width
         */
        billboardWidth: {
            set: lodash.debounce(function (width) {
                if (this._core.isnull(width)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.width = width;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var width = entities[0].billboard.width;
                    if (width) {
                        return width._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 控制billboard的图片height
         * @param {Float} height
         */
        billboardHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.height = height;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var height = entities[0].billboard.height;
                    if (height) {
                        return height._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 控制billboard的图片color
         * @param {object} color
         */
        billboardColor: {
            set: lodash.debounce(function (color) {
                if (this._core.isnull(color)) return;
                if (!this._core.isnull(color)) {
                    if (this._core.isHtmlColor(color)) {
                        color = this._color.colorFromHtmlColor(color);
                    } else {
                        if (/^rgb/.test(color)) {
                            color = this._color.rgbaStringToRgbaObj(color);
                        }
                        if (color.r > 1) {
                            color.r = color.r / 255;
                        }
                        if (color.g > 1) {
                            color.g = color.g / 255;
                        }
                        if (color.b > 1) {
                            color.b = color.b / 255;
                        }
                        if (color.a > 1) {
                            color.a = color.a / 255;
                        }
                        color = this._color.createColor(color.r, color.g, color.b, color.a);
                    }
                }
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.color = color;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var color = entities[0].billboard.color;
                    try {
                        return this._color.toHtmlColor('rgb(' + color._value.red * 255 + ',' + color._value.green * 255 + ',' + color._value.blue * 255 + ',' + color._value.alpha * 255 + ')');
                    } catch (ex) { }
                }
            }
        },
        /**
         * billboard图层的高度类型
         * @param {object} heightReference sgworld.HeightReference.*
         */
        billboardHeightReference: {
            set: lodash.debounce(function (heightReference) {
                if (this._core.isnull(heightReference)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.heightReference = heightReference;
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].model) {
                    var heightReference = entities[0].billboard.heightReference;
                    if (heightReference) {
                        return heightReference._value;
                    }
                    return undefined;
                }
            }
        },
        /**
         * 设置geojson图层模型的最大可视距离
         * @param {Float} far
         */
        billboardDistanceDisplayMaxCondition: {
            set: lodash.debounce(function (far) {
                if (this._core.isnull(far)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var near = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.near : 0;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                        entities[i].billboard.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var far = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    return far;
                }
            }
        },
        /**
         * 设置geojson图层点模型最小可视距离
         * @param {Float} near
         */
        billboardDistanceDisplayMinCondition: {
            set: lodash.debounce(function (near) {
                if (this._core.isnull(near)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var far = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.far : Number.MAX_VALUE;
                    for (var i = 0; i < entities.length; i++) {
                        entities[i].billboard.distanceDisplayCondition = new this._cesium.DistanceDisplayCondition(near, far);
                        entities[i].billboard.scaleByDistance = new this._cesium.NearFarScalar(near, 1, far, 0);
                    }
                }
            }, 500),
            get: function () {
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].billboard == undefined) return;
                if (entities && entities.length > 0 && entities[0].billboard) {
                    var near = entities[0].billboard.distanceDisplayCondition ? entities[0].billboard.distanceDisplayCondition._value.near : 0;
                    return near;
                }
            }
        },
        /**
         * 设置geojson图层的label显示高度
         */
        billboardPHeight: {
            set: lodash.debounce(function (height) {
                if (this._core.isnull(height)) return;
                var entities = this.item.entities && this.item.entities.values;
                if (entities && !/^point.fid/.test(entities[0]._id) && entities[0].position == undefined) return;
                if (entities && entities.length > 0 && entities[0].position) {
                    for (var i = 0; i < entities.length; i++) {
                        var Cartographic = this._cesium.Cartographic.fromCartesian(entities[i].position._value);
                        var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                        var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                        // longitude = this._cesium.Math.toDegrees(longitude);
                        // latitude = this._cesium.Math.toDegrees(latitude);
                        //// 转回去
                        var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, height);
                        entities[i].position = position;
                    }
                }
            }, 500),
            get: function () {
                // var Cartographic=this._cesium.Cartographic.fromCartesian(entities[0].position);
                // var longitude=this._cesium.Math.toDegrees( Cartographic.longitude)
                // var latitude=this._cesium.Math.toDegrees( Cartographic.latitude)
                // var height=this._cesium.Math.toDegrees( Cartographic.height)
                // longitude=this._cesium.Math.toDegrees(longitude);
                // latitude=this._cesium.Math.toDegrees(latitude);
                // height=this._cesium.Math.toDegrees(height);
                //// 转回去
                // this._cesium.Cartesian3.fromDegrees(longitude,latitude, height)
                return 0;
            }
        }
    });

    /**
     *
     *   3dtiles模型
     *
     * @alias SE3DTileset
     * @constructor
     *
     * @param {Viewer} Viewer 地图视图。
     *
     */
    function SE3DTileset(Viewer) {
        this._viewer = Viewer;
        this._cesium = Cesium;
        this._core = new Core();
        this._tree = tree;
        this._color = new Color(this._viewer, this._cesium);
        this.modelEditData = {
            lon: 0,
            lat: 0,
            height: 0,
            scale: 1,
            r_x: 0,
            r_y: 0,
            r_z: 0,
            rootTransform: undefined
        };
    }

    /**
     * 创建模型
     *
     * @param {string} [name] 名称
     * @param {string} [url] 模型路径
     * @param {object} [option] 模型参数（同Cesium3DTileset参数，参考 http://cesium.xin/cesium/Documentation/Cesium3DTileset.html）
     * @param {object} [option.id] 模型id
     * @param {object} [option.Level] 模型显示层级
     * @param {object} [option.time] 模型存在的时间段
     * @param {String} [option.time.start] 模型存在的起始时间
     * @param {String} [option.time.end] 模型存在的结束时间
     * @param {object} [style] 模型样式
     * @param {Boolean} [style.effects=false] 模型特效（常用于建筑白膜特效）
     * @param {Number} [style.effectsMaxHeight=150] 模型特效最大高度（常用于建筑白膜特效）
     * @param {String} [style.fShaderBody] 模型特效Shader
     * @param {Number} [style.groundHeight] 模型高度（用于模型坐标正确，高度不正确的情况，groundHeight: 100）
     * @param {Array} [style.groundCenter] 模型中心位置（用于模型坐标和高度都不正确的情况，groundCenter: [112, 32, 50]）
     * @param {Object} [style.edit] 模型编辑参数（用于模型编辑，修改模型经纬度高度、旋转角、比例）
     * @param {Number} [style.edit.lon] 经度
     * @param {Number} [style.edit.lat] 纬度
     * @param {Number} [style.edit.height] 高度
     * @param {Number} [style.edit.scale] 比例
     * @param {Number} [style.edit.r_x] X反方向旋转角
     * @param {Number} [style.edit.r_y] Y反方向旋转角
     * @param {Number} [style.edit.r_z] Z反方向旋转角
     * @param {string} [GroupID] 所在组
     * @param {Boolean} [checked] 是否显示
     * @param {object} [func] 回调函数
     * 
     */
    SE3DTileset.prototype.create3DTilesets = function (name, url, option, style, GroupID, checked, func) {
        var defaultOption = {
            url: url, //	Resource | String | Promise.<Resource> | Promise.<String>		The url to a tileset JSON file.
        };
        if (typeof option.lightColor === 'string') {
            let str = option.lightColor.split(',');
            option.lightColor = new this._cesium.Cartesian3(str[0], str[1], str[2]);
        }    var options = this._core.extend(defaultOption, option, true);

        //添加时间段
        if (options.time) {
            options.availability = new this._cesium.TimeIntervalCollection([new this._cesium.TimeInterval({
                start: options.time.start ? this._cesium.JulianDate.fromDate(new Date(options.time.start)) : this._cesium.Iso8601.MINIMUM_VALUE,
                stop: options.time.end ? this._cesium.JulianDate.fromDate(new Date(options.time.end)) : this._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this.availability = options.availability;
        }

        if (style.effects) {
            options.fShaderBody = style.fShaderBody || this.getEffectsShader(style.effectsMaxHeight);
        }

        var tileset = new this._cesium.Cesium3DTileset(options);
        var _this = this;
        var modelId = options.id || _this._core.getuid();
        tileset.id = modelId;
        tileset.Level = options.Level;

        _this.item = tileset;

        setTimeout(function () {
            var sd = _this._viewer.scene.primitives.add(tileset);
            //属性添加
            if (style.maximumscreenspaceerror != undefined) {
                tileset.maximumScreenSpaceError = style.maximumscreenspaceerror;
            }
            if (options.maximumscreenspaceerror != undefined) {
                tileset.maximumScreenSpaceError = options.maximumscreenspaceerror;
            }
            if (options.maximumMemoryUsage != undefined) {
                tileset.maximumMemoryUsage = options.maximumMemoryUsage;
            }
            if (style.pointcloudshading != undefined) {
                tileset.pointCloudShading.maximumAttenuation = _this.checkZero(style.pointcloudshading.maximumattenuation); // Will be based on maximumScreenSpaceError instead
                tileset.pointCloudShading.baseResolution = style.pointcloudshading.baseresolution;
                tileset.pointCloudShading.geometricErrorScale = style.pointcloudshading.geometricerrorscale;
                tileset.pointCloudShading.attenuation = style.pointcloudshading.attenuation;
                tileset.pointCloudShading.eyeDomeLighting = style.pointcloudshading.eyedomelighting;
                tileset.pointCloudShading.eyeDomeLightingStrength = style.eyeDomeLightingStrength;
                tileset.pointCloudShading.eyeDomeLightingRadius = style.eyeDomeLightingRadius;
            }

            tileset.readyPromise.then(function (tileset) {
                if (style.groundheight != undefined) {
                    _this.setHeight(style.groundheight);
                }
                if (style.groundHeight != undefined) {
                    _this.setHeight(style.groundHeight);
                }

                if (style.groundCenter) {
                    _this.setPosition(style.groundCenter);
                }

                if (!_this.boundingSphereCenter) {
                    _this.getCenter();
                    var cartographic = _this._cesium.Cartographic.fromCartesian(_this.boundingSphereCenter);
                    _this.modelEditData.lon = _this._cesium.Math.toDegrees(cartographic.longitude);
                    _this.modelEditData.lat = _this._cesium.Math.toDegrees(cartographic.latitude);
                    _this.modelEditData.height = cartographic.height;
                }

                if (style.edit) {
                    _this.setEditData(style.edit);
                }
                //if (style.material != undefined && style.material != null) {
                //    setTimeout(() => {
                //        _this.material = style.material;
                //    }, 1000);

                //}
                if (typeof func == 'function')
                    func(_this);
            }).otherwise(function (error) {
                console.log(error);
            });

            if (tileset.Level) {
                _this.Level = 0;
                _this._viewer.scene.preRender.addEventListener(function () {
                    if (_this.isShow && _this._viewer.camera.positionCartographic && _this.oldCameraHeight !== _this._viewer.camera.positionCartographic.height) {
                        _this.oldCameraHeight = _this._viewer.camera.positionCartographic.height;
                        _this.Level = _this.getLevel();
                        if (_this.Level > tileset.Level && !tileset.show) {
                            tileset.show = true;
                        } else if (_this.Level < tileset.Level && tileset.show) {
                            tileset.show = false;
                        }
                    }
                });
            }

            //修改
            _this.sd = sd;
            if (checked) {
                _this.isShow = true;
            } else {
                _this.setVisibility(false);
            }
            var styles = _this.setStyle(style);
            tileset.style = new _this._cesium.Cesium3DTileStyle(styles);

        });
        if (_this._core.isnull(name)) {
            name = "新建模型";
        }
        var obj = {
            id: modelId,
            name: name,
            checked: checked,
            pId: _this._core.isnull(GroupID) ? 0 : GroupID,
            type: '3DTilesets',
            item: _this
        };
        _this.setTreeobj(obj);
        _this._tree.insertGroupId(obj, _this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 获取模型所在层级
     */
    SE3DTileset.prototype.getLevel = function () {
        var A = 40487.57;
        var B = 0.00007096758;
        var C = 91610.74;
        var D = -40467.74;

        var camera = this._viewer.camera, height, level;
        try {
            if (camera && camera.positionCartographic && camera.positionCartographic.height) {
                var groundHeightAtCameraPosition = this._viewer.scene.globe.getHeight(camera.positionCartographic);
                !groundHeightAtCameraPosition && (groundHeightAtCameraPosition = 0);
                height = camera.positionCartographic.height - groundHeightAtCameraPosition;
                level = Math.round(D + (A - D) / (1 + Math.pow(height / C, B)));
            } else {
                level = 0;
            }
        }
        catch (ex) { }
        return level;
    };
    /**
     * 设置模型的显示隐藏
     * 
     * @param {Boolean} [b] 是否显示模型
     */
    SE3DTileset.prototype.setVisibility = function (b) {
        this.isShow = b;
        this.item.show = b;
        if (this.item._availability && !b) {
            this.item._availability = undefined;
        } else if (this.availability && b) {
            this.item._availability = this.availability;
        }
    };
    /**
     * 点云模型
     */
    SE3DTileset.prototype.checkZero = function (b) {
        var newValueFloat = parseFloat(b);
        return (newValueFloat === 0.0) ? undefined : newValueFloat;
    };
    /**
     * 获取模型的显示隐藏状态
     */
    SE3DTileset.prototype.getVisibility = function () {
        return this.item.show;
    };
    /**
     * 删除模型
     */
    SE3DTileset.prototype.deleteObject = function () {
        try {
            this._viewer.scene.primitives.remove(this.item);
        } catch (ex) {
            console.log(ex.message);
        }
    };
    /**
     * 复原模型编辑前状态
     */
    SE3DTileset.prototype.restore = function () {
        this.modelEditData = {
            lon: 0,
            lat: 0,
            height: 0,
            scale: 1,
            r_x: 0,
            r_y: 0,
            r_z: 0,
            rootTransform: this.modelEditData.rootTransform,
            originalMatrix: this.modelEditData.originalMatrix
        };
        let cartographic = this._cesium.Cartographic.fromCartesian(this.boundingSphereCenter);
        this.modelEditData.lon = this._cesium.Math.toDegrees(cartographic.longitude);
        this.modelEditData.lat = this._cesium.Math.toDegrees(cartographic.latitude);
        this.modelEditData.height = cartographic.height;
        if (this.modelEditData.rootTransform.equals(Cesium.Matrix4.IDENTITY)) {
            this.item.modelMatrix = this.modelEditData.originalMatrix.clone();
        } else {
            this.item._root.transform = this.modelEditData.originalMatrix.clone();
        }
        if (this.moveModelEnd) {
            this.moveModelEnd();
            this.moveModelEnd = undefined;
        }
        this.rotatePointPosition = undefined;
        this.moveEndCenter = undefined;
    };

    /**
     * 设置模型高度
     * 
     * @param {Number} [height] 模型高度
     */
    SE3DTileset.prototype.setHeight = function (height) {
        height = Number(height);
        if (isNaN(height)) {
            return;
        }
        if (this.item != undefined && this.item.boundingSphere != undefined) {
            if (!this.boundingSphereCenter) {
                this.getCenter();
            }

            var cartographic = this._cesium.Cartographic.fromCartesian(this.boundingSphereCenter);

            this.modelEditData.lon = this._cesium.Math.toDegrees(cartographic.longitude);
            this.modelEditData.lat = this._cesium.Math.toDegrees(cartographic.latitude);
            this.modelEditData.height = cartographic.height;

            var surface = this._cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, 0.0);
            var offset = this._cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, height);
            var translation = this._cesium.Cartesian3.subtract(offset, surface, new this._cesium.Cartesian3());
            this.item.modelMatrix = this._cesium.Matrix4.fromTranslation(translation);
        }
    };

    /**
     * 设置模型位置
     * 
     * @param {Array} [position] [x,y,z]
     * @param {Boolean} [defaultHeight] 是否使用默认高度
     */
    SE3DTileset.prototype.setPosition = function (position, defaultHeight) {
        //创建平移矩阵方法二
        if (this.item != undefined && this.item.boundingSphere != undefined) {
            if (!this.boundingSphereCenter) {
                this.getCenter();
            }
            this.modelEditData.lon = position[0];
            this.modelEditData.lat = position[1];
            this.modelEditData.height = defaultHeight ? this.boundingSphereCenterHeight : position[2];

            this.setEditData();
        }
    };

    /**
     * 设置模型编辑属性
     * 
     * @param {Object} [data] 模型编辑参数
     * @param {Number} [data.lon] 经度
     * @param {Number} [data.lat] 纬度
     * @param {Number} [data.height] 高度
     * @param {Number} [data.scale] 比例
     * @param {Number} [data.r_x] X反方向旋转角
     * @param {Number} [data.r_y] Y反方向旋转角
     * @param {Number} [data.r_z] Z反方向旋转角
     */
    SE3DTileset.prototype.setEditData = function (data) {
        if (this.item != undefined && this.item.boundingSphere != undefined) {
            if (!this.boundingSphereCenter) {
                this.getCenter();
            }

            if (data) {
                this.modelEditData = this._core.extend(this.modelEditData, data, true);
            }

            if (this.modelEditData.rootTransform.equals(Cesium.Matrix4.IDENTITY)) {
                var surface = this.boundingSphereCenter;
                var offset = this._cesium.Cartesian3.fromDegrees(this.modelEditData.lon, this.modelEditData.lat, this.modelEditData.height);
                var translation = this._cesium.Cartesian3.subtract(offset, surface, new this._cesium.Cartesian3());
                this.item.modelMatrix = this._cesium.Matrix4.fromTranslation(translation);
                return;
            }

            var mx = Cesium.Matrix3.fromRotationX(
                Cesium.Math.toRadians(this.modelEditData.r_x)
            );
            var my = Cesium.Matrix3.fromRotationY(
                Cesium.Math.toRadians(this.modelEditData.r_y)
            );
            var mz = Cesium.Matrix3.fromRotationZ(
                Cesium.Math.toRadians(this.modelEditData.r_z)
            );
            var rotationX = Cesium.Matrix4.fromRotationTranslation(mx);
            var rotationY = Cesium.Matrix4.fromRotationTranslation(my);
            var rotationZ = Cesium.Matrix4.fromRotationTranslation(mz);

            //平移 修改经纬度
            var position = Cesium.Cartesian3.fromDegrees(
                this.modelEditData.lon,
                this.modelEditData.lat,
                this.modelEditData.height
            );
            var m = Cesium.Transforms.eastNorthUpToFixedFrame(position);

            //旋转、平移矩阵相乘
            Cesium.Matrix4.multiply(m, rotationX, m);
            Cesium.Matrix4.multiply(m, rotationY, m);
            Cesium.Matrix4.multiply(m, rotationZ, m);

            //缩放 修改缩放比例
            var scale = Cesium.Matrix4.fromUniformScale(this.modelEditData.scale);
            Cesium.Matrix4.multiply(m, scale, m);

            //赋值给tileset
            this.item._root.transform = m;
        }
    };

    SE3DTileset.prototype.getCenter = function () {
        if (!this.boundingSphereCenter) {
            var cartographic = this._cesium.Cartographic.fromCartesian(this.item.boundingSphere.center);
            this.boundingSphereCenter = this.item.boundingSphere.center.clone();
            this.boundingSphereCenterHeight = cartographic.height;
            this.boundingSphereRadius = this.item.boundingSphere.radius;
            this.modelEditData.rootTransform = this.item._root.transform.clone();
            if (this.modelEditData.rootTransform.equals(Cesium.Matrix4.IDENTITY)) {
                this.modelEditData.originalMatrix = this.item.modelMatrix.clone();
            } else {
                this.modelEditData.originalMatrix = this.item._root.transform.clone();
            }
        }
    };

    // 三点计算角度
    SE3DTileset.prototype.arge = function (pointA, pointB, pointC) {
        var lengthAB = Math.sqrt(Math.pow(pointA.x - pointB.x, 2) +
            Math.pow(pointA.y - pointB.y, 2)),
            lengthAC = Math.sqrt(Math.pow(pointA.x - pointC.x, 2) +
                Math.pow(pointA.y - pointC.y, 2)),
            lengthBC = Math.sqrt(Math.pow(pointB.x - pointC.x, 2) +
                Math.pow(pointB.y - pointC.y, 2));
        var cosA = (Math.pow(lengthAB, 2) + Math.pow(lengthAC, 2) - Math.pow(lengthBC, 2)) /
            (2 * lengthAB * lengthAC);
        return Math.round(Math.acos(cosA) * 180 / Math.PI);
    };
    /**
     * 鼠标移动模型
     * 
     * @param {Object} [option] 移动参数
     * @param {String} [option.moveImg] 移动图标
     * @param {Boolean} [option.rotate=false] 是否开启旋转
     * @param {String} [option.rotateImg] 旋转图标
     * @param {Object} [option.callback] 回调函数
     * @param {Function} [option.callback.move] 移动回调函数
     * @param {Function} [option.callback.rotate] 移动回调函数
     * 
     */
    SE3DTileset.prototype.moveModel = function (option = {}) {
        var that = this;
        var viewer = this._viewer;
        // 创建监听的handler
        if (this.moveHandler) {
            this.moveHandler.destroy();
            this.moveHandler = undefined;
            this._viewer.entities.remove(this.movePoint);
            this._viewer.entities.remove(this.rotatePoint);
        }
        var move = false;
        var rotate = false;
        var ray, cartesian, cartographic, lng, lat, _lng, _lat;
        var a, b, c;
        if (!that.moveEndCenter) {
            cartographic = that._cesium.Cartographic.fromCartesian(this.boundingSphereCenter);
            that.moveEndCenter = {
                lon: this.modelEditData.lon,
                lat: this.modelEditData.lat
            };
        }
        lng = that.moveEndCenter.lon;
        lat = that.moveEndCenter.lat;
        _lng = _lat = 0;

        var movePoint = this._viewer.entities.add({
            name: "tilesetMovePoint",
            position: new that._cesium.CallbackProperty(function () {
                return that._cesium.Cartesian3.fromDegrees(lng + _lng, lat + _lat, that.boundingSphereCenterHeight);
            }, false),
            billboard: {
                image: option.moveImg || window.SmartEarthRootUrl + configData$1.move,
                color: this._cesium.Color.BLUE,
                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                scaleByDistance: new Cesium.NearFarScalar(0, 1, 1000000, 0)
            }
        });

        if (!this.rotatePointPosition) {
            this.rotatePointPosition = {
                lon: that.moveEndCenter.lon + 0.000009 * this.boundingSphereRadius,
                lat: that.moveEndCenter.lat
            };
        }
        var rotatePoint = this._viewer.entities.add({
            show: option.rotate ? true : false,
            name: "tilesetRotatePoint",
            position: new that._cesium.CallbackProperty(function () {
                return that._cesium.Cartesian3.fromDegrees(that.rotatePointPosition.lon, that.rotatePointPosition.lat, that.boundingSphereCenterHeight);
            }, false),
            billboard: {
                image: option.rotateImg || window.SmartEarthRootUrl + configData$1.rotate,
                color: this._cesium.Color.BLUE,
                disableDepthTestDistance: Number.POSITIVE_INFINITY,
                scaleByDistance: new Cesium.NearFarScalar(0, 1, 1000000, 0)
            }
        });
        rotatePoint.oldPosition = {
            lon: that.moveEndCenter.lon + 0.000009 * this.boundingSphereRadius,
            lat: that.moveEndCenter.lat
        };
        this.movePoint = movePoint;
        this.rotatePoint = rotatePoint;
        this.moveHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        var tooltip = that._core.CreateTooltip();
        this.moveHandler.setInputAction(function (event) {
            // 通过屏幕坐标获取当前位置的实体信息
            var pickedObject = viewer.scene.pick(event.position);
            if (that._cesium.defined(pickedObject)) {
                if (!move && !rotate && (pickedObject.id == movePoint || pickedObject.tileset == that.item || (pickedObject.primitive && pickedObject.primitive.tileset == that.item) || (pickedObject.content && pickedObject.content.tileset == that.item))) {
                    ray = viewer.camera.getPickRay(event.position);
                    ray && (cartesian = viewer.scene.globe.pick(ray, viewer.scene));

                    if (cartesian) {
                        cartographic = that._cesium.Cartographic.fromCartesian(cartesian);
                        lng = that._cesium.Math.toDegrees(cartographic.longitude);
                        lat = that._cesium.Math.toDegrees(cartographic.latitude);
                        _lng = that.moveEndCenter.lon - lng;
                        _lat = that.moveEndCenter.lat - lat;
                    }
                    movePoint.oldPosition = {
                        lon: lng + _lng,
                        lat: lat + _lat
                    };
                    rotatePoint.oldPosition = {
                        lon: that.rotatePointPosition.lon,
                        lat: that.rotatePointPosition.lat
                    };
                    move = true;
                    defaultEvent(false);
                    tooltip.show(false);
                } else if (!move && !rotate && pickedObject.id == rotatePoint) {
                    a = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, movePoint.position.getValue());
                    b = that._cesium.SceneTransforms.wgs84ToWindowCoordinates(that._viewer.scene, that._cesium.Cartesian3.fromDegrees(lng + _lng + 0.000009 * that.boundingSphereRadius, lat + _lat, that.boundingSphereCenterHeight));
                    rotate = true;
                    defaultEvent(false);
                    tooltip.show(false);
                }
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);

        // 对鼠标移动事件的监听
        this.moveHandler.setInputAction(function (event) {
            if (move) {
                ray = viewer.camera.getPickRay(event.endPosition);
                ray && (cartesian = viewer.scene.globe.pick(ray, viewer.scene));

                if (cartesian) {
                    cartographic = that._cesium.Cartographic.fromCartesian(cartesian);
                    lng = that._cesium.Math.toDegrees(cartographic.longitude);
                    lat = that._cesium.Math.toDegrees(cartographic.latitude);
                    that.rotatePointPosition = {
                        lon: rotatePoint.oldPosition.lon + (lng + _lng - movePoint.oldPosition.lon),
                        lat: rotatePoint.oldPosition.lat + (lat + _lat - movePoint.oldPosition.lat)
                    };
                    that.modelEditData.lon = lng + _lng;
                    that.modelEditData.lat = lat + _lat;
                    that.setEditData();
                    option.callback && option.callback.move && option.callback.move();
                }
            } else if (rotate) {
                ray = viewer.camera.getPickRay(event.endPosition);
                ray && (cartesian = viewer.scene.globe.pick(ray, viewer.scene));

                if (cartesian) {
                    cartographic = that._cesium.Cartographic.fromCartesian(cartesian);
                    that.rotatePointPosition = {
                        lon: that._cesium.Math.toDegrees(cartographic.longitude),
                        lat: that._cesium.Math.toDegrees(cartographic.latitude)
                    };
                    c = event.endPosition;
                    let angle = that.arge(a, b, c);

                    if (that.rotatePointPosition.lat - lat - _lat < 0) {
                        angle = -angle;
                    }
                    that.rotateZ(angle);
                    option.callback && option.callback.rotate && option.callback.rotate(angle);
                }
            } else {
                // 通过屏幕坐标获取当前位置的实体信息
                var pickedObject = viewer.scene.pick(event.endPosition);
                if (that._cesium.defined(pickedObject)) {
                    if (!move && !rotate && (pickedObject.id == movePoint || pickedObject.tileset == that.item || (pickedObject.primitive && pickedObject.primitive.tileset == that.item) || (pickedObject.content && pickedObject.content.tileset == that.item))) {
                        tooltip.showAt(event.endPosition, '点击拖拽移动模型，右键结束编辑');
                    } else if (!move && !rotate && pickedObject.id == rotatePoint) {
                        tooltip.showAt(event.endPosition, '点击拖拽旋转模型，右键结束编辑');
                    } else {
                        tooltip.show(false);
                    }
                } else {
                    tooltip.show(false);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        // 对鼠标抬起事件的监听
        this.moveHandler.setInputAction(function (event) {
            move = false;
            rotate = false;
            // 恢复地球的旋转和缩放
            defaultEvent(true);
            that.moveEndCenter = {
                lon: lng + _lng,
                lat: lat + _lat
            };
        }, this._cesium.ScreenSpaceEventType.LEFT_UP);
        this.moveHandler.setInputAction(function (event) {
            that.moveModelEnd();
            that.moveModelEnd = undefined;
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        this.moveModelEnd = () => {
            that.moveHandler.destroy();
            that._viewer.entities.remove(movePoint);
            that._viewer.entities.remove(rotatePoint);
            // 恢复地球的旋转和缩放
            defaultEvent(true);
            tooltip.show(false);
        };

        function defaultEvent(isOpen) {
            var scene = viewer.scene;
            scene.screenSpaceCameraController.enableRotate = isOpen;
            scene.screenSpaceCameraController.enableTranslate = isOpen;
            scene.screenSpaceCameraController.enableZoom = isOpen;
            scene.screenSpaceCameraController.enableTilt = isOpen;
            scene.screenSpaceCameraController.enableLook = isOpen;
        }
    };

    /**
     * 裁剪模型
     * 
     * @param {Object} [option] 参数
     * @param {Number} [option.start] 起始位置
     * @param {Function} [option.end] 结束的回调函数
     */
    SE3DTileset.prototype.clippingModel = function (option = {}) {
        var that = this;
        var viewer = this._viewer;
        // 创建监听的handler
        if (this.moveHandler) {
            this.moveHandler.destroy();
            this.moveHandler = undefined;
            this._viewer.entities.remove(this.movePoint);
            this._viewer.entities.remove(this.rotatePoint);
        }
        if (this.clippingHandler) {
            this.clippingHandler.destroy();
            this.clippingHandler = undefined;
            that.planeEntities && that.planeEntities.forEach(item => {
                that._viewer.entities.remove(item);
            });
            that.planeEntities = [];
        }

        that.planeEntities = [];

        if (!this.targetY) {
            if (option.start) {
                this.targetY = option.start;
            } else {
                this.targetY = 0;
            }
        }
        var selectedPlane;
        if (!this.clippingPlanes) {
            this.clippingPlanes = new this._cesium.ClippingPlaneCollection({
                planes: [
                    new this._cesium.ClippingPlane(
                        new this._cesium.Cartesian3(0.0, 0.0, -1.0),
                        0.0
                    ),
                ],
                edgeWidth: 1.0,
            });
            this.item.clippingPlanes = this.clippingPlanes;
        }
        if (!this.boundingSphereCenter) {
            this.getCenter();
        }
        var boundingSphere = this.item.boundingSphere;
        var radius = this.boundingSphereRadius;

        if (
            !this._cesium.Matrix4.equals(
                this.item.root.transform,
                this._cesium.Matrix4.IDENTITY
            )
        ) {
            var transformCenter = this._cesium.Matrix4.getTranslation(
                this.item.root.transform,
                new Cesium.Cartesian3()
            );
            var transformCartographic = this._cesium.Cartographic.fromCartesian(
                transformCenter
            );
            var boundingSphereCartographic = this._cesium.Cartographic.fromCartesian(
                this.item.boundingSphere.center
            );
            var height =
                boundingSphereCartographic.height -
                transformCartographic.height;
            this.clippingPlanes.modelMatrix = this._cesium.Matrix4.fromTranslation(
                new this._cesium.Cartesian3(0.0, 0.0, height)
            );
        }

        for (var i = 0; i < this.clippingPlanes.length; ++i) {
            var plane = this.clippingPlanes.get(i);
            var planeEntity = viewer.entities.add({
                name: 'modelClippingPlane',
                position: boundingSphere.center,
                plane: {
                    dimensions: new Cesium.Cartesian2(
                        radius * 1.2,
                        radius * 1.2
                    ),
                    material: Cesium.Color.WHITE.withAlpha(0.1),
                    plane: new Cesium.CallbackProperty(
                        createPlaneUpdateFunction(plane),
                        false
                    ),
                    outline: true,
                    outlineColor: Cesium.Color.WHITE,
                },
            });
            that.planeEntities.push(planeEntity);
        }


        this.clippingHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        var tooltip = that._core.CreateTooltip();
        this.clippingHandler.setInputAction(function (event) {
            // 通过屏幕坐标获取当前位置的实体信息
            var pickedObject = viewer.scene.pick(event.position);
            if (that._cesium.defined(pickedObject)) {
                if (pickedObject.id && pickedObject.id.name === 'modelClippingPlane') {
                    selectedPlane = pickedObject.id.plane;
                    selectedPlane.material = that._cesium.Color.WHITE.withAlpha(0.05);
                    selectedPlane.outlineColor = that._cesium.Color.WHITE;
                    viewer.scene.screenSpaceCameraController.enableInputs = false;
                }
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);

        // 对鼠标移动事件的监听
        this.clippingHandler.setInputAction(movement => {
            if (Cesium.defined(selectedPlane)) {
                let deltaY = movement.startPosition.y - movement.endPosition.y;
                this.targetY += deltaY * 0.1;
                tooltip.showAt(movement.endPosition, '移动鼠标平移裁切面');
            } else {
                tooltip.showAt(movement.endPosition, '长按左键上下拖动裁切面，右键取消');
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        // 对鼠标抬起事件的监听
        this.clippingHandler.setInputAction(event => {
            if (Cesium.defined(selectedPlane)) {
                selectedPlane.material = Cesium.Color.WHITE.withAlpha(0.1);
                selectedPlane.outlineColor = Cesium.Color.WHITE;
                selectedPlane = undefined;
            }
            viewer.scene.screenSpaceCameraController.enableInputs = true;
        }, this._cesium.ScreenSpaceEventType.LEFT_UP);

        this.clippingHandler.setInputAction(event => {
            that.endClipping();
            option.end && option.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        this.endClipping = () => {
            that.clippingHandler.destroy();
            tooltip.show(false);
            that.planeEntities && that.planeEntities.forEach(item => {
                that._viewer.entities.remove(item);
            });
            that.planeEntities = [];
        };

        function createPlaneUpdateFunction(plane) {
            return function () {
                plane.distance = that.targetY;
                return plane;
            };
        }
    };

    /**
     * 设置模型旋转沿着x轴
     * @param {float} [RotateX] 角度
     */
    SE3DTileset.prototype.rotateX = function (RotateX) {
        this.modelEditData.r_x = RotateX;
        this.setEditData();
    };
    /**
     * 设置模型旋转沿着y轴
     * @param {float} [RotateY] 角度
     */
    SE3DTileset.prototype.rotateY = function (RotateY) {
        this.modelEditData.r_y = RotateY;
        this.setEditData();
    };
    /**
     * 设置模型旋转沿着z轴
     * @param {float} [RotateZ] 角度
     */
    SE3DTileset.prototype.rotateZ = function (RotateZ) {
        this.modelEditData.r_z = RotateZ;
        this.setEditData();
    };

    // 工程树添加
    SE3DTileset.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    Object.defineProperties(SE3DTileset.prototype, {
        style: {
            get: function () {
                return this.item.style;
            }
        }

    });

    SE3DTileset.prototype.export = function () {
        var url = this.item.url;
        var show = this.item.show;
        var shadows = this.item.shadows;
        return {
            type: '3DTilesets',
            treeobj: {
                name: this.treeobj.name
            },
            style: {
                url: url,
                show: show,
                shadows: shadows
            }
        }
    };
    // 工程树添加
    SE3DTileset.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    SE3DTileset.prototype.setItem = function (item) {
        this.item = item;
    };
    SE3DTileset.prototype.setShowStyle = function (style) {
        this.item.style;
        this.item.style = new this._cesium.Cesium3DTileStyle({
            show: true
        });
    };
    SE3DTileset.prototype.setStyle = function (style) {
        var conditions = [];
        var cesium3DTileStyle = {
            color: undefined,
            show: true
        };
        var show = true;
        if (style.colors instanceof Array) {
            for (var i = 0; i < style.colors.length; i++) {
                var colors = [];
                var color = style.colors[i].color;
                var condition = style.colors[i].condition;
                if (/^\[/.test(condition)) {
                    condition = condition.replace(/^\[/, '${').replace(/\]/, '}');
                }
                //填充颜色设置
                if (this._core.isHtmlColor(color)) {
                    color = this._color.colorFromHtmlColor(color);
                } else {
                    if (/^rgb/.test(color)) {
                        color = this._color.rgbaStringToRgbaObj(color);
                    }
                    if (color.r > 1) {
                        color.r = color.r / 255;
                    }
                    if (color.g > 1) {
                        color.g = color.g / 255;
                    }
                    if (color.b > 1) {
                        color.b = color.b / 255;
                    }
                    if (color.a > 1) {
                        color.a = color.a / 255;
                    }
                    color = this._color.createColor(color.r, color.g, color.b, color.a);

                }
                colors.push(condition);
                colors.push(color);
                conditions.push(colors);
            }
            cesium3DTileStyle.color = {};
            cesium3DTileStyle.color.conditions = conditions;
        } else {
            if (style.colors) {
                //修改
                //style.colors = style.colors.replace(/^\[/, '${').replace(/\]/, '}');
                //var color = style.colors;
                //if (/^rgb/.test(style.colors)) {
                //    color = this._color.rgbaStringToRgbaObj(style.colors);
                //}
                //if (color.r > 1) {
                //    color.r = color.r / 255;
                //}
                //if (color.g > 1) {
                //    color.g = color.g / 255;
                //}
                //if (color.b > 1) {
                //    color.b = color.b / 255;
                //}
                //if (color.a > 1) {
                //    color.a = color.a / 255;
                //}
                //color = this._color.createColor(color.r, color.g, color.b, color.a);
                //if (color)
                //    cesium3DTileStyle.color = color;
                //else
                cesium3DTileStyle.color = style.colors;
            }
        }
        if (style.show && /\[/.test(style.show)) {
            show = style.show.replace(/^\[/, '${').replace(/\]/, '}');
        } else if (style.show) {
            show = style.show;
        }

        cesium3DTileStyle.show = show;
        return cesium3DTileStyle;
        //tileset.style = new this._cesium.Cesium3DTileStyle(cesium3DTileStyle);
        //this.item.style = new this._cesium.Cesium3DTileStyle(cesium3DTileStyle);
    };

    Object.defineProperties(SE3DTileset.prototype, {
        luminanceAtZenith: {
            get: function () {
                return this.item.luminanceAtZenith
            },
            set: function (luminanceAtZenith) {
                this.item.luminanceAtZenith = luminanceAtZenith;
            }
        },
        groundHeight: {
            get: function () {
                if (this.item != undefined && this.item.boundingSphere != undefined) {
                    var cartographic = this._cesium.Cartographic.fromCartesian(this.item.boundingSphere.center);
                    return cartographic.altitude;
                }
                return 0;
            },
            set: function (height) {
                height = Number(height);
                if (isNaN(height)) {
                    return;
                }
                if (this.item != undefined && this.item.boundingSphere != undefined) {
                    var cartographic = this._cesium.Cartographic.fromCartesian(this.item.boundingSphere.center);
                    var surface = this._cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, 0.0);
                    var offset = this._cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, height);
                    var translation = this._cesium.Cartesian3.subtract(offset, surface, new this._cesium.Cartesian3());
                    this.item.modelMatrix = this._cesium.Matrix4.fromTranslation(translation);
                }
            }
        },
        lon: {
            get: function () {
                return this.modelEditData.lon;
            },
            set: function (lon) {
                this.modelEditData.lon = lon;
                this.setEditData();
            }
        },
        lat: {
            get: function () {
                return this.modelEditData.lat;
            },
            set: function (lat) {
                this.modelEditData.lat = lat;
                this.setEditData();
            }
        },
        height: {
            get: function () {
                return this.modelEditData.height;
            },
            set: function (height) {
                this.modelEditData.height = height;
                this.setEditData();
            }
        },
        scale: {
            get: function () {
                return this.modelEditData.scale;
            },
            set: function (scale) {
                this.modelEditData.scale = scale;
                this.setEditData();
            }
        },
        material: {
            set: function (color) {
                //填充颜色设置
                if (this._core.isHtmlColor(color)) ; else {
                    if (/^rgb/.test(color)) {
                        color = this._color.rgbaStringToRgbaObj(color);
                    }
                    // if (color.r > 1) {
                    //     color.r = color.r / 255;
                    // }
                    // if (color.g > 1) {
                    //     color.g = color.g / 255;
                    // }
                    // if (color.b > 1) {
                    //     color.b = color.b / 255;
                    // }
                    // if (color.a > 1) {
                    //     color.a = color.a / 255;
                    // }
                    color = 'rgba(' + color.r + ',' + color.g + ',' + color.b + ',' + color.a + ')';

                }
                this.item.style = new this._cesium.Cesium3DTileStyle({ color: "color('" + color + "')" });
            }
        },
        dynamicScreenSpaceErrorDensity: {
            get: function () {
                return this.item.dynamicScreenSpaceErrorDensity;
            },
            set: function (dynamicScreenSpaceErrorDensity) {
                this.item.dynamicScreenSpaceErrorDensity = dynamicScreenSpaceErrorDensity;
            }
        },
        shadows: {
            get: function () {
                return this.item.shadows;
            },
            set: function (shadows) {
                this.item.shadows = shadows;
            }
        },
        classificationType: {
            get: function () {
                return this.item.classificationType;
            },
            set: function (classificationTypeValue) {
                this.item.classificationType = classificationTypeValue;
            }
        },
        dynamicScreenSpaceErrorHeightFalloff: {
            get: function () {
                return this.item.dynamicScreenSpaceErrorHeightFalloff;
            },
            set: function (dynamicScreenSpaceErrorHeightFalloff) {
                this.item.dynamicScreenSpaceErrorHeightFalloff = dynamicScreenSpaceErrorHeightFalloff;
            }
        },
        dynamicScreenSpaceErrorFactor: {
            get: function () {
                return this.item.dynamicScreenSpaceErrorFactor;
            },
            set: function (dynamicScreenSpaceErrorFactor) {
                this.item.dynamicScreenSpaceErrorFactor = dynamicScreenSpaceErrorFactor;
            }
        },
        imageBasedLightingFactor_x: {
            get: function () {
                return this.item.imageBasedLightingFactor == undefined ? 0 : this.item.imageBasedLightingFactor.x;
            },
            set: function (x) {
                this.item.imageBasedLightingFactor = new this._cesium.Cartesian2(x, this.item.imageBasedLightingFactor_y);
            }
        },
        imageBasedLightingFactor_y: {
            get: function () {
                return this.item.imageBasedLightingFactor == undefined ? 0 : this.item.imageBasedLightingFactor.y;
            },
            set: function (y) {
                this.item.imageBasedLightingFactor = new this._cesium.Cartesian2(y, this.item.imageBasedLightingFactor_y);
            }
        }
    });

    SE3DTileset.prototype.getEffectsShader = function (maxHeight = 150) {
        maxHeight = parseInt(maxHeight);
        let shaders = `    float vtxf_a11 = fract(czm_frameNumber / 120.0) * 3.14159265 * 2.0; \n
                float vtxf_a12 = v_elevationPos.z / ${maxHeight / 2}.0 + sin(vtxf_a11) * 0.1; \n
                gl_FragColor *= vec4(vtxf_a12, vtxf_a12, vtxf_a12, 1.0); \n
                float vtxf_a13 = fract(czm_frameNumber / 240.0); \n

                float vtxf_h = clamp(v_elevationPos.z / ${maxHeight}.0, 0.0, 1.0); \n
                vtxf_a13 = abs(vtxf_a13 - 0.5) * 2.0; \n
                float vtxf_diff = step(0.005, abs(vtxf_h - vtxf_a13)); \n
                gl_FragColor.rgb += gl_FragColor.rgb * (1.0 - vtxf_diff); \n`;
        return shaders;
    };

    /**
     * 当前图层加载类型
     */
    SE3DTileset.prototype.getType = function () {
        return {
            label: "模型",
            value: "3DTileset"
        };
    };

    var getPointRelativePosition$1 = function (e, t, n, r) {
        var o = t.west,
            u = t.east,
            a = t.south,
            f = t.north,
            l = u - o,
            c = f - a,
            h = e.longitude * 180 / Math.PI,
            p = e.latitude * 180 / Math.PI;
        return e.normalizedLongitude = (h - o) / l * n, e.normalizedLatitude = (p - a) / c * r, e

    };
    var convertToXYVertices$1 = function (e, t, n, r) {
        var i = [],
            s = e[0].longitude !== undefined;
        e.forEach(function (e) {
            var o = [],
                u = s ? e : viewer$3.scene.globe.ellipsoid.cartesianToCartographic(e);
            u = getPointRelativePosition$1(u, t, n, r);
            o.push(u.normalizedLongitude);
            o.push(u.normalizedLatitude);
            i.push(o);
        });
        return i;
    };
    var fillArrayFromVerticesAndHeight$1 = function (e, t, n) {
        var r = 32,
            i = t.west * Cesium.Math.DEGREES_PER_RADIAN,
            s = t.east * Cesium.Math.DEGREES_PER_RADIAN,
            o = t.south * Cesium.Math.DEGREES_PER_RADIAN,
            u = t.north * Cesium.Math.DEGREES_PER_RADIAN,
            a = new Cesium.Rectangle(i, o, s, u),
            f = convertToXYVertices$1(e, a, r, r),
            l = drawPolygonOnCanvas$1(f, "#FF0000", r, r);
        return l;
        //this.getMaskArrayFromCanvasPolygon(l, r, n)
    };
    var drawPolygonOnCanvas$1 = function (e, t, n, r, i) {
        if (i === undefined) {
            var i = document.createElement("canvas");
            i.width = n, i.height = r;
        }
        var s = i.getContext("2d");
        if (e.length <= 0) return;
        s.moveTo(e[0][0], e[0][1]);
        for (var o = 0; o < e.length; o++) s.lineTo(e[o][0], e[o][1]);
        t != null && t != undefined && (s.fillStyle = t, s.fill());
        return i;
    };
    function r$2(e, t) {
        return Math.floor(Math.random() * (t - e + 1)) + e
    }
    function lj$1() {
        var scriptObjs = document.scripts;
        var url = "./js/sfsterrainprovider/ParseElevationWorker.js";
        for (var i = 0; i < scriptObjs.length; i++) {
            var jssz = scriptObjs[i].src.split("/");
            var dx = jssz[jssz.length - 1];
            if (dx == "SmartEarth.js") {
                url = scriptObjs[i].outerHTML.split("\"")[1].replace("SmartEarth.js", 'Workers/ParseElevationWorker.js');
            } else if (dx == "SmartEarth.min.js") {
                url = scriptObjs[i].outerHTML.split("\"")[1].replace("SmartEarth.min.js", 'Workers/ParseElevationWorker.js');
            }
        }
        return url;
    }

    function i$2(e, t) {
        var n = Cesium.when.defer();
        return r$2 = fillArrayFromVerticesAndHeight$1(e.vertices, t, e.heights[0]),
            r$2.timeStamp = e.timeStamp,
            r$2.mtHeight = e.heights,
            r$2.mtType = e.mtType,
            r$2.fromKML = e.fromKML,
            r$2.rect = e.rectangle,
            r$2.level = e.level,
            n.resolve(r$2),
            n
    }
    function o(e, t) {
        var n = Cesium.when.defer()
            , s = [];
        return e.forEach(function (e) {
            s.push(i$2(e, t));
        }),
            Cesium.when.all(s, function (e) {
                e[0].lenght
                    ; var i = function (e, t) {
                        return t.timeStamp - e.timeStamp
                    };
                if (e.length === 1)
                    n.resolve(e[0]);
                else {
                    var s = e.sort(i)
                        , o = s.shift();
                    s.forEach(function (e) {
                        o.forEach(function (t, n) {
                            t === r$2 && e[n] !== r$2 && (o[n] = e[n]);
                        });
                    }),
                        n.resolve(o);
                }
            }),
            n
    }
    var viewer$3;

    /**
    *
    * sgs地形(7.2.3)
    *
    * @alias SFSTerrainProvider
    * @constructor
    *
    */
    function SFSTerrainProvider723(_viewer, t) {
        viewer$3 = _viewer;
        if (!Cesium.defined(t))
            throw new Cesium.DeveloperError("options is required.");
        this._errorEvent = new Cesium.Event,
            this._modelFloorMasks = {},
            this._credit = t.credit,
            typeof this._credit == "string" && (this._credit = new Cesium.Credit(this._credit)),
            t.heightMapWidth = Cesium.defaultValue(t.heightMapWidth, 32),
            t.heightMapHeight = Cesium.defaultValue(t.heightMapHeight, 32),
            this._options = t,
            this.readyPromise = Cesium.when.resolve(!0),
            this._subdomains = t.subdomains,
            t.firstRequestUrl = t.url.replace("{s}", this.sTag(0, 0, 0)),
            this._firstRequest = t.firstRequestUrl + "?" + "request=GetMap&Version=1.3.0&Service=WMS&CRS=EPSG:4326&bbox=-90,-180,90,180&height=32&width=32&optimizedOnly=0&v=1&layers=" + t.layerName + "&Styles=&Format=image/mpt";
        var n = this
            , r = t.pngOnly;
        t.maxTerrainLevel !== undefined && isNaN(t.maxTerrainLevel) && (t.maxTerrainLevel = undefined),
            // SmartEarth 修改
            // this._maxTerrainLevel = Cesium.defaultValue(t.maxTerrainLevel, TerraExplorer.__maxTerrainLevel),
            this._maxTerrainLevel = Cesium.defaultValue(t.maxTerrainLevel, 30),
            r ? n.setFormatMPT(!1) : $.ajax({
                url: t.cacheUrl ? t.cacheUrl + '/0/0/0.mpt' : this._firstRequest,
                success: function (e) {
                    var t = Cesium.defined(e.childNodes) && e.childNodes.length > 0 ? !0 : !1;
                    // if (!!t || !!TerraExplorer.browser.isIE)
                    if (!!t || false)
                        return n.setFormatMPT(!1),
                            null;
                    n.setFormatMPT(!0);
                },
                error: function () {
                    return n.setFormatMPT(!1),
                        null
                },
                async: !1
            });
        if (t.cacheUrl) {
            this.isCache = true;
            this.cacheLevel = t.cacheLevel || 16;
            this._cacheUrl = t.cacheUrl + '/{z}/{x}/{y}.mpt';
        }
        this._urlTemplate = t.url + "?" + "request=GetMap&Version=1.3.0&Service=WMS&v=1&CRS=EPSG:4326&bbox={south},{west},{north},{east}&height={height}&width={width}&optimizedOnly={optimizedOnly}&layers=" + t.layerName + "&Styles=&Format=image/" + this._format;
        this._allElevationLayers = null,
            this._tilingScheme = new Cesium.GeographicTilingScheme,
            this._levelZeroMaximumGeometricError = Cesium.TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap(this._tilingScheme.ellipsoid, t.heightMapWidth * 4, this._tilingScheme.getNumberOfXTilesAtLevel(0)),
            this._workerPool = new WorkerPool({
                // SmartEarth 修改
                // workerPath: "./js/sfsterrainprovider/ParseElevationWorker.js"
                workerPath: lj$1()
            }),
            this._pendingRequests = 0,
            this._requestGridSize = 8,
            this._requestsCache = {},
            this._requestsCacheKeys = [],
            this.errorEvent.addEventListener(function (e) { }, this);
    }SFSTerrainProvider723._geometricErrorFactor = 2;

    Object.defineProperties(SFSTerrainProvider723.prototype, {
        errorEvent: {
            get: function () {
                return this._errorEvent
            }
        },
        credit: {
            get: function () {
                return this._credit
            }
        },
        hasVertexNormals: {
            get: function () {
                return !1
            }
        },
        tilingScheme: {
            get: function () {
                return this._tilingScheme
            }
        },
        ready: {
            get: function () {
                return !0
            }
        },
        hasWaterMask: {
            get: function () {
                return !1
            }
        },
        heightMapHeight: {
            get: function () {
                return this._options.heightMapHeight
            }
        },
        heightMapWidth: {
            get: function () {
                return this._options.heightMapWidth
            }
        },
        pendingRequests: {
            get: function () {
                return this._pendingRequests
            }
        }
    });
    SFSTerrainProvider723.prototype.setFormatMPT = function (e) {
        if (e && this.pngOnly)
            return;
        var t = this._format;
        this._format = e ? "mpt" : "png";
        if (t === this._format)
            return;
        this._isMPT = e,
            this._urlTemplate !== undefined && (this._urlTemplate = this._urlTemplate.replace("image/" + t, "image/" + this._format));
    };
    SFSTerrainProvider723.prototype.getLevelMaximumGeometricError = function (e) {
        return this._levelZeroMaximumGeometricError / (1 << e) * SFSTerrainProvider723._geometricErrorFactor
    };

    SFSTerrainProvider723.prototype.createKeyFromTile = function (e, t, n) {
        return e + "_" + t + "_" + n
    };

    SFSTerrainProvider723.prototype.getTileDataAvailable = function (e, t, n) {
        var r = Math.min(this._maxTerrainLevel, 25);
        // SmartEarth 修改
        // return this._isMPT ? TerraExplorer.__useNotOptimizedSLTerrain16 ? undefined : !0 : n < r ? !0 : !1
        return this._isMPT ? !0 : n < r ? !0 : !1
    };

    SFSTerrainProvider723.prototype.requestFactorForLevel = function (e) {
        var t = Math.log(this._requestGridSize) / Math.log(2);
        return t = Math.min(t, e),
            Math.pow(2, t)
    };

    SFSTerrainProvider723.prototype.getRequestBaseTerrainUrl = function (e, t, n, r) {
        return this.getRequestUrl(e, t, n, r)
    };

    SFSTerrainProvider723.prototype.getRequestElevationLayer = function (e, t, n) {
        return this.getRequestUrl(e, t, n, !1, !0)
    };

    SFSTerrainProvider723.prototype.getRequestUrl = function (e, t, n, r, i) {
        var s = n
            , o = r != undefined ? this.requestFactorForLevel(n) : 1
            , e = r != undefined ? (e - e % o) / o : e
            , t = r != undefined ? (t - t % o) / o : t
            , n = r != undefined ? n - Math.log(o) / Math.log(2) : n;
        if (this.isCache && n !== 0 && n <= this.cacheLevel) {
            return this._cacheUrl.replace("{x}", e).replace("{y}", t).replace("{z}", n);
        }
        var u = this.tilingScheme.tileXYToNativeRectangle(e, t, n)
            , a = this.heightMapWidth * o === 256 && r ? 1 : 0;
        i && (a = 0);
        var f = this._urlTemplate.replace("{south}", u.south).replace("{north}", u.north).replace("{west}", u.west).replace("{east}", u.east).replace("{optimizedOnly}", a).replace("{width}", this.heightMapWidth * o).replace("{height}", this.heightMapHeight * o).replace("{s}", this.sTag(e, t, n));
        return f + "&level=" + n + "&origLevel=" + s
    };

    SFSTerrainProvider723.prototype.isT_Inside_E = function (e, t) {
        return e.west >= t.west * Cesium.Math.DEGREES_PER_RADIAN && e.east <= t.east * Cesium.Math.DEGREES_PER_RADIAN && e.south >= t.south * Cesium.Math.DEGREES_PER_RADIAN && e.north <= t.north * Cesium.Math.DEGREES_PER_RADIAN ? !0 : !1
    };

    SFSTerrainProvider723.prototype.isT_Intersects_E = function (e, t) {
        var n = e.west * Cesium.Math.RADIANS_PER_DEGREE
            , r = e.east * Cesium.Math.RADIANS_PER_DEGREE
            , i = e.south * Cesium.Math.RADIANS_PER_DEGREE
            , s = e.north * Cesium.Math.RADIANS_PER_DEGREE
            , o = new Cesium.Rectangle(n, i, r, s)
            , u = Cesium.Rectangle.intersection(o, t, new Cesium.Rectangle);
        return u
    };

    SFSTerrainProvider723.prototype.sTag = function (e, t, n) {
        if (this._subdomains == undefined)
            return "";
        var r = (e + t + n) % this._subdomains.length;
        return this._subdomains[r]
    };

    SFSTerrainProvider723.prototype.refreshElevationLayer = function (e) {
        if (e.rectangle && viewer$3.scene.globe._surface._levelZeroTiles !== undefined) {
            var t = this.findDirectParent(e.rectangle, !0);
            t.freeResources();
        }
    };

    SFSTerrainProvider723.prototype.findDirectParent = function (e, t) {
        var n = function (e, t, r) {
            var i = r ? 4.1 : 2.1;
            if (e._rectangle.width <= t.width * i && Cesium.Rectangle.contains(e._rectangle, Cesium.Rectangle.center(t)))
                return e;
            var s = e.children.length;
            for (var o = 0; o < s; o++) {
                var u = e.children[o];
                if (Cesium.Rectangle.contains(u._rectangle, Cesium.Rectangle.center(t)))
                    return n(u, t, r)
            }
            return null
        };
        if (e.width == Math.PI)
            return null;
        for (var r = 0; r < viewer$3.scene.globe._surface._levelZeroTiles.length; r++) {
            var i = n(viewer$3.scene.globe._surface._levelZeroTiles[r], e, t);
            if (i)
                return i
        }
        return null
    };

    SFSTerrainProvider723.prototype.isTileAvailable = function (e, t, n) {
        var r = this._tilingScheme.tileXYToRectangle(e, t, n, new Cesium.Rectangle)
            , i = this.findDirectParent(r);
        if (i && i.data && i.data.terrainData) {
            if (!(i.data.terrainData._childTileMask > 0))
                return !1;
            var s = i.children.length;
            for (var o = 0; o < s; o++) {
                var u = i.children[o];
                if (Cesium.Rectangle.equals(u._rectangle, r))
                    return i.data.terrainData._childTileMask & 1 << o
            }
        }
        return !0
    };

    SFSTerrainProvider723.prototype.markTileAsUnavailable = function (e, t, n) {
        var r = this._tilingScheme.tileXYToRectangle(e, t, n, new Cesium.Rectangle)
            , i = this.findDirectParent(r);
        i && i.data && i.data.terrainData && i.data.terrainData._childTileMask > 0 && $.each(i.children, function (e, t) {
            if (Cesium.Rectangle.equals(t._rectangle, r)) {
                switch (e) {
                    case 0:
                        i.data.terrainData._childTileMask &= -5;
                        break;
                    case 1:
                        i.data.terrainData._childTileMask &= -9;
                        break;
                    case 2:
                        i.data.terrainData._childTileMask &= -2;
                        break;
                    case 3:
                        i.data.terrainData._childTileMask &= -3;
                        break;
                }
                return !1
            }
            return !0
        });
    };

    SFSTerrainProvider723.prototype.requestBaseTerrainTileGeometry = function (e, t, n, r) {
        return this.requestTileGeometryBuffers(e, t, n, r)
    };

    SFSTerrainProvider723.prototype.requestElevationLayerTileGeometry = function (e, t, n, r, i) {
        return this.requestTileGeometryBuffers(e, t, n, r, i)
    };

    SFSTerrainProvider723.prototype.requestTileGeometryBuffers = function (e, n, r, i, s) {
        var o = this
            , u = 15
            , a = {};
        a.requestedRectangle = this.tilingScheme.tileXYToNativeRectangle(e, n, r),
            a.layer = s;
        var f, l, c, h, p = Cesium.when.defer(), f = this.requestTileHeightBuffer(e, n, r, i, undefined, s);
        return f === undefined ? undefined : (l = this.requestTileHeightBuffer(e + 1, n, r, i, !0, s),
            c = this.requestTileHeightBuffer(e, n + 1, r, i, !0, s),
            h = this.requestTileHeightBuffer(e + 1, n + 1, r, i, !0, s),
            Cesium.when.all([f, l, c, h], function (e) {
                var g; {
                    if (e[0].myReject != undefined && e[0].myReject) {
                        p.reject();
                        return
                    }
                    var n = o.heightMapWidth + 1
                        , r = o.heightMapHeight + 1
                        , i = new Float32Array(n * r)
                        , s = e[0].isFloor;
                    for (var f = 0; f < n; f++)
                        for (var l = 0; l < r; l++) {
                            var c = f
                                , h = l
                                , d = 0;
                            l === n - 1 && (h = 0,
                                d = 1,
                                s && (d = 0,
                                    h = n - 2)),
                                f === r - 1 && (c = 0,
                                    d = 2);
                            var v = f * n + l
                                , m = c * o.heightMapWidth + h;
                            e[d] !== null && (e[d].myReject == undefined || !e[d].myReject) && (i[v] = e[d][m]);
                        }
                    if (e[3].myReject == undefined || !e[3].myReject)
                        i[n * r - 1] = e[3][0];
                    var g = o.arrayToHeightmapTerrainData(i, n, r, u);
                    a.buffer = g,
                        p.resolve(a);
                }
            }).otherwise(function () {
                p.reject();
            }),
            p)
    };

    SFSTerrainProvider723.prototype.requestTileGeometry = function (e, t, n, r) {
        var i = this
            , s = []
            , o = i.tilingScheme.tileXYToNativeRectangle(e, t, n);
        this._allElevationLayers != null && this._allElevationLayers.length > 0 && n > 7 ? $(this._allElevationLayers).each(function (u, a) {
            var f = a.show;
            if (f) {
                var l = a.rectangle;
                i.isT_Inside_E(o, l) ? (i.setFormatMPT(!1),
                    s.push(i.requestElevationLayerTileGeometry(e, t, n, r, a))) : i.isT_Intersects_E(o, l) != undefined ? (i.setFormatMPT(!1),
                        s.push(i.requestElevationLayerTileGeometry(e, t, n, r, a)),
                        s.push(i.requestBaseTerrainTileGeometry(e, t, n, r))) : (i.setFormatMPT(!0),
                            s.push(i.requestBaseTerrainTileGeometry(e, t, n, r)));
            } else
                i.setFormatMPT(!0),
                    s.push(i.requestBaseTerrainTileGeometry(e, t, n, r));
        }) : (i.setFormatMPT(!0),
            s.push(i.requestBaseTerrainTileGeometry(e, t, n, r)));
        var u = Cesium.when.defer();
        return Cesium.when.all(s, function (e) {
            if (e.length === 1)
                e.layer !== undefined && console.log("missing scale and offset"),
                    u.resolve(e[0].buffer);
            else if (e.length > 1) {
                var t = $.grep(e, function (e) {
                    return e.layer !== undefined
                })
                    , n = $.grep(e, function (e) {
                        return e.layer === undefined
                    });
                if (t.length === 0)
                    u.resolve(e[0].buffer);
                else {
                    var r = t[t.length - 1]
                        , s = n[n.length - 1]
                        , o = {
                            tolerance: r.layer.nullTolerance,
                            nullValueNumber: r.layer.nullValueNumber,
                            verticesX: r.layer.polygonVerticesX,
                            verticesY: r.layer.polygonVerticesY,
                            scale: Cesium.defaultValue(r.layer.scale, 1),
                            offset: Cesium.defaultValue(r.layer.offset, 0)
                        };
                    u.resolve(i.mergeBuffers(s.buffer, r.buffer, o, s.requestedRectangle));
                }
            } else
                u.reject();
        }).otherwise(function () {
            u.reject();
        }),
            u
    };

    SFSTerrainProvider723.prototype.mergeBuffers = function (e, t, n, r) {
        var i, s, o, u, a, f = 33, l = 33, c = r.west, h = r.north; r.east; r.south; var v = r.width / f, m = r.height / l, g = n.scale, y = n.offset, b = n.nullValueNumber, w = n.tolerance, E = b !== undefined && w !== undefined;
        if (E)
            var S = Cesium.defaultValue(n.nullValueNumber, 0)
                , x = Cesium.defaultValue(Number(n.tolerance), 0);
        var T = new Float32Array(f * l);
        for (i = 0,
            a = h; i < l; i++,
            a += m)
            for (s = 0,
                u = c; s < f; s++,
                u += v)
                o = i * f + s,
                    E ? T[o] = !t._buffer[o] || t._buffer[o] >= S - x && t._buffer[o] <= S + x ? e._buffer[o] : t._buffer[o] * g + y : T[o] = t._buffer[o] ? t._buffer[o] * g + y : e._buffer[o];
        return this.arrayToHeightmapTerrainData(T, f, l, 15)
    };

    SFSTerrainProvider723.prototype.requestTileHeightBuffer = function (e, n, r, i, u, a) {
        if (isNaN(e + n + r))
            return;
        if (!Cesium.defined(i) || i === !1)
            i = new Cesium.Request({
                defer: !0
            });
        var l = i.defer == 0;
        u = Cesium.defaultValue(l, !1);
        var c = Cesium.when.defer();
        var T; {
            var h;
            if (a !== undefined)
                a.getUrlFromSTag = function (e, t, n) {
                    return a.subdomains === undefined ? a.url : a.subdomains[0] + "/SG"
                }
                    ,
                    h = this.getRequestElevationLayer(e, n, r).replace(this._options.url, a.getUrlFromSTag(e, n, r) + "/Elevation").replace(this._options.layerName, a.name),
                    a.format === "mpt" && (h = h.replace("image/png", "image/mpt"));
            else {
                h = this.getRequestBaseTerrainUrl(e, n, r, l || u);
                var p = viewer$3.terrainProvider.tilingScheme.tileXYToRectangle(e, n, r)
                    , d = viewer$3.terrainProvider._modifyTerrainObjects
                    , v = Cesium.when.defer();
                if (d !== undefined) {
                    var m = [];
                    d.forEach(function (e) {
                        e.show && Cesium.Rectangle.intersection(p, e.rectangle, new Cesium.Rectangle) != undefined && m.push(e);
                    });
                    if (m.length > 0)
                        if (m.length === 1 && m[0].modelFloorBestLevel && r > m[0].modelFloorBestLevel)
                            v.resolve("NoMerge");
                        else {
                            var g = o(m, p);
                            Cesium.when(g, function (e) {
                                v.resolve(e);
                            }).otherwise(function (e) {
                                console.log(e);
                            });
                        }
                    else
                        v.resolve("NoMerge");
                } else
                    v.resolve("NoMerge");
                var y = Cesium.when.defer()
                    // , b = $.grep(TerraExplorer.internal.Project.MeshLayers, function(e) {
                    , b = $.grep([], function (e) {
                        return e._selectedTiles.length > 0
                    });
                if (b.length === 1 && b[0].level && r > b[0].level)
                    y.resolve("NoFloor");
                else {
                    var w = !1
                        , E = 32
                        , S = 65535;
                    b.forEach(function (e) {
                        if (e.ready && e.show && e.rootFloorRectangle !== undefined && Cesium.Rectangle.intersection(p, e.rootFloorRectangle) !== undefined) {
                            var t = new Uint16Array(E * E), n = p.west; p.south; var i = (p.east - p.west) / 32, s = (p.north - p.south) / 32, o;
                            for (var u = 0; u < E; u++)
                                for (var a = 0; a < E; a++) {
                                    var f = n + i * a + i / 2
                                        , l = p.north - s * u - s / 2
                                        , c = new Cesium.Cartographic(f, l);
                                    o = S;
                                    var h = e.getHRMTFP(e, c, !0);
                                    h != undefined && h.content && h.content._model && h.content._model.floor && (o = h.content._model.floor.getHeight(c.longitude, c.latitude)),
                                        o !== S ? (o += 1.5,
                                            t[u * E + a] = o) : t[u * E + a] = o;
                                }
                            w = !0,
                                y.resolve(t);
                        }
                    }),
                        w || y.resolve("NoFloor");
                }
                viewer$3.scene.globe.ellipsoid;
            }
            if (this._requestsCache.hasOwnProperty(h) === !1) {
                this._requestsCache[h] = {},
                    this._requestsCacheKeys.push(h);
                if (this._requestsCacheKeys.length > 100) {
                    for (var T = 0; T < 50; T++)
                        delete this._requestsCache[this._requestsCacheKeys[T]];
                    this._requestsCacheKeys.splice(0, 50);
                }
            } else {
                var N = this._requestsCacheKeys.indexOf(h);
                this._requestsCacheKeys.splice(N, 1),
                    this._requestsCacheKeys.push(h);
            }
            var C = this._requestsCache[h];
            if (C.dataLoaded === undefined) {
                l ? C.dataLoaded = Cesium.Resource.fetchArrayBuffer(h) : C.dataLoaded = Cesium.Resource.fetchArrayBuffer(h);
                if (!Cesium.defined(C.dataLoaded))
                    return undefined
            }

            // // SmartEarth 修改 地形压平
            // var tileRectangle = viewer.terrainProvider.tilingScheme.tileXYToRectangle(e, n, i);
            // var modifyTerrainObjects = viewer.terrainProvider._modifyTerrainObjects;
            // var terraCanvas = null;
            // var nowModifyTerrain = null;
            // if (modifyTerrainObjects != undefined && modifyTerrainObjects.length > 0) {
            //     modifyTerrainObjects.forEach(function (object) {
            //         if (object.show) {
            //             var intersection = Cesium.Rectangle.intersection(tileRectangle, object.rectangle, new Cesium.Rectangle);
            //             if (intersection) {
            //                 nowModifyTerrain = object;
            //                 terraCanvas = fillArrayFromVerticesAndHeight(nowModifyTerrain.vertices, tileRectangle, nowModifyTerrain.heights[0]);
            //             }
            //         }
            //     });
            // }

            var k = this;
            this._pendingRequests++,
                Cesium.when(C.dataLoaded, function (t) {
                    C.workerFinished === undefined && (C.workerFinished = k._workerPool.queueWorkItem({
                        buffer: t,
                        isElevation: a !== undefined,
                        level: r
                    })),
                        Cesium.when.all([C.workerFinished, v, y], function (t) {
                            var i = t[1] !== undefined && t[1] !== "NoMerge"
                                , s = t[2] !== undefined && t[2] !== "NoFloor";
                            if (!!t[0].rejected) {
                                var l = k.heightMapWidth * k.heightMapHeight
                                    , h = new Int16Array(l)
                                    ;
                                for (var u = 0; u < l; u++)
                                    h[u] = 300;
                                return r > 2 && (h.myReject = !0),
                                    c.resolve(h),
                                    c
                            }
                            var o = k.extractTileHeightBuffer(t[0].buffer, e, n, r);

                            // // SmartEarth 修改 地形压平
                            // if (terraCanvas != null) {
                            //     var cond = terraCanvas.getContext("2d");
                            //     var imgData = cond.getImageData(0, 0, 32, 32).data;

                            //     for (var ui = 0; ui < 32; ui++)
                            //         for (var ai = 0; ai < 32; ai++) {
                            //             var fr = ui * 32 + ai;
                            //             var lr = (32 - 1 - ui) * 32 + ai;
                            //             if (imgData[fr * 4] !== 0) {
                            //                 r[lr] = nowModifyTerrain.heights[0];
                            //             }
                            //         }
                            // }

                            k._pendingRequests--;
                            if (i)
                                for (var u = 0; u < 32; u++)
                                    for (var a = 0; a < 32; a++) {
                                        var f = u * 32 + a;
                                        o[f] = t[1].mtHeight[0];
                                        // SmartEarth 修改 地形压平
                                        // t[1].fromKML ? o[f] = t[1][f] === 1 ? o[f] : t[1].mtType == 1 ? o[f] + t[1].mtHeight : t[1].mtType == 2 ? Math.min(o[f], t[1].mtHeight) : t[1].mtType == 3 ? Math.max(o[f], t[1].mtHeight) : t[1].mtHeight : o[f] = t[1][f] === 1 ? o[f] : t[1].mtType == 1 ? o[f] + t[1][f] : t[1].mtType == 2 ? Math.min(o[f], t[1][f]) : t[1].mtType == 3 ? Math.max(o[f], t[1][f]) : t[1][f]
                                    }
                            if (s) {
                                for (var u = 0; u < 32; u++)
                                    for (var a = 0; a < 32; a++) {
                                        var f = u * 32 + a;
                                        // SmartEarth 修改
                                        // o[f] = t[2][f] === 65535 ? o[f] : t[2][f]
                                        o[f] = t[2][f] === 65535 || t[2][f] > 10500 ? o[f] : t[2][f];
                                    }
                                o.isFloor = !0;
                            }
                            c.resolve(o);
                        }).otherwise(function () {
                            var e = k.heightMapWidth * k.heightMapHeight
                                , t = new Int16Array(e)
                                ;
                            for (var i = 0; i < e; i++)
                                t[i] = 300;
                            return r > 2 && (t.myReject = !0),
                                c.resolve(t),
                                c
                        });
                }).otherwise(function () {
                    k._pendingRequests--,
                        c.reject();
                });
        }
        return c
    };

    SFSTerrainProvider723.prototype.extractTileHeightBuffer = function (e, t, n, r) {
        try {
            var i = this.requestFactorForLevel(r)
                , s = t % i
                , o = n % i
                // SmartEarth 修改
                //   , u = new Int16Array(this.heightMapWidth * this.heightMapHeight)
                , u = new Float32Array(this.heightMapWidth * this.heightMapHeight)
                , a = 1e6
                , f = -1e5;
            for (var l = 0; l < this.heightMapHeight; l++)
                for (var c = 0; c < this.heightMapWidth; c++) {
                    var h = l + o * this.heightMapHeight
                        , p = c + s * this.heightMapWidth
                        , d = l * this.heightMapWidth + c
                        , v = h * this.heightMapWidth * i + p;
                    e[v] > f && (f = e[v]),
                        e[v] < a && (a = e[v]),
                        u[d] = e[v];
                }
        } catch (m) {
            console.log(m.message);
        }
        return u
    };

    SFSTerrainProvider723.prototype.arrayToHeightmapTerrainData = function (e, t, n, r) {
        Cesium.defined(e) === !1 && (e = new Int16Array(t * n));
        var i = {
            buffer: e,
            width: t,
            height: n,
            childTileMask: r
        };
        return new Cesium.HeightmapTerrainData(i)
    };

    var getPointRelativePosition = function (e, t, n, r) {
        var o = t.west,
            u = t.east,
            a = t.south,
            f = t.north,
            l = u - o,
            c = f - a,
            h = e.longitude * 180 / Math.PI,
            p = e.latitude * 180 / Math.PI;
        return e.normalizedLongitude = (h - o) / l * n, e.normalizedLatitude = (p - a) / c * r, e

    };
    var convertToXYVertices = function (e, t, n, r) {
        var i = [],
            s = e[0].longitude !== undefined;
        e.forEach(function (e) {
            var o = [],
                u = s ? e : viewer$2.scene.globe.ellipsoid.cartesianToCartographic(e);
            u = getPointRelativePosition(u, t, n, r);
            o.push(u.normalizedLongitude);
            o.push(u.normalizedLatitude);
            i.push(o);
        });
        return i;
    };
    var fillArrayFromVerticesAndHeight = function (e, t, n) {
        var r = 32,
            i = t.west * Cesium.Math.DEGREES_PER_RADIAN,
            s = t.east * Cesium.Math.DEGREES_PER_RADIAN,
            o = t.south * Cesium.Math.DEGREES_PER_RADIAN,
            u = t.north * Cesium.Math.DEGREES_PER_RADIAN,
            a = new Cesium.Rectangle(i, o, s, u),
            f = convertToXYVertices(e, a, r, r),
            l = drawPolygonOnCanvas(f, "#FF0000", r, r);
        return l;
        //this.getMaskArrayFromCanvasPolygon(l, r, n)
    };
    var drawPolygonOnCanvas = function (e, t, n, r, i) {
        if (i === undefined) {
            var i = document.createElement("canvas");
            i.width = n, i.height = r;
        }
        var s = i.getContext("2d");
        if (e.length <= 0) return;
        s.moveTo(e[0][0], e[0][1]);
        for (var o = 0; o < e.length; o++) s.lineTo(e[o][0], e[o][1]);
        t != null && t != undefined && (s.fillStyle = t, s.fill());
        return i;
    };
    function lj() {
        var scriptObjs = document.scripts;
        var url = "./js/sfsterrainprovider/ParseElevationWorker.js";
        for (var i = 0; i < scriptObjs.length; i++) {
            var jssz = scriptObjs[i].src.split("/");
            var dx = jssz[jssz.length - 1];
            if (dx == "SmartEarth.js") {
                url = scriptObjs[i].outerHTML.split("\"")[1].replace("SmartEarth.js", 'Workers/ParseElevationWorker.js');
            } else if (dx == "SmartEarth.min.js") {
                url = scriptObjs[i].outerHTML.split("\"")[1].replace("SmartEarth.min.js", 'Workers/ParseElevationWorker.js');
            }
        }
        return url;
    }
    var viewer$2;

    /**
    *
    * sgs地形
    *
    * @alias SFSTerrainProvider
    * @constructor
    *
    */
    function SFSTerrainProvider(_viewer, t) {
        viewer$2 = _viewer;
        if (!Cesium.defined(t)) throw new Cesium.DeveloperError("options is required.");
        this._errorEvent = new Cesium.Event, this._credit = t.credit, typeof this._credit == "string" && (this._credit = new Cesium.Credit(this._credit)), t.heightMapWidth = Cesium.defaultValue(t.heightMapWidth, 32), t.heightMapHeight = Cesium.defaultValue(t.heightMapHeight, 32), this._options = t, this._subdomains = t.subdomains, t.url = t.url.replace("{s}", this.sTag(0, 0, 0));
        this._firstRequest = t.url + "?" + "request=GetMap&Version=1.3.0&Service=WMS&CRS=EPSG:4326&bbox=-90,-180,90,180&height=32&width=32&optimizedOnly=0&layers=" + t.layerName + "&Styles=&Format=image/mpt";
        t.token && (this._firstRequest += '&token=' + t.token);
        this._requestVertexNormals = Cesium.defaultValue(t.requestVertexNormals, false);
        var n = this;
        $.ajax({
            url: this._firstRequest,
            success: function (e) {
                var t = Cesium.defined(e.childNodes) && e.childNodes.length > 0 ? !0 : !1;
                if (!!t) return n._isMPT = !1, n._format = "png", null;
                n._isMPT = !0, n._format = "mpt";
            },
            error: function () {
                return n._isMPT = !1, n._format = "png", null
            },
            async: !1
        });
        this._urlTemplate = t.url + "?" + "request=GetMap&Version=1.3.0&Service=WMS&CRS=EPSG:4326&bbox={south},{west},{north},{east}&height={height}&width={width}&optimizedOnly={optimizedOnly}&layers=" + t.layerName + "&Styles=&Format=image/" + this._format;
        t.token && (this._urlTemplate += '&token=' + t.token);
        this._tilingScheme = new Cesium.GeographicTilingScheme, this._levelZeroMaximumGeometricError = Cesium.TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap(this._tilingScheme.ellipsoid, t.heightMapWidth * 4, this._tilingScheme.getNumberOfXTilesAtLevel(0)), this._workerPool = new WorkerPool({
            workerPath: lj()
        }), this._pendingRequests = 0, this._requestGridSize = 8, this._requestsCache = {}, this._requestsCacheKeys = [], this.errorEvent.addEventListener(function (e) { }, this);
    }
    SFSTerrainProvider._geometricErrorFactor = 2;
    Object.defineProperties(SFSTerrainProvider.prototype, {
        errorEvent: {
            get: function () {
                return this._errorEvent
            }
        },
        credit: {
            get: function () {
                return this._credit
            }
        },
        requestVertexNormals: {
            get: function () {
                return this._requestVertexNormals;
            }
        },
        hasVertexNormals: {
            get: function () {
                return this._requestVertexNormals
            }
        },
        tilingScheme: {
            get: function () {
                return this._tilingScheme
            }
        },
        ready: {
            get: function () {
                return !0
            }
        },
        hasWaterMask: {
            get: function () {
                return !1
            }
        },
        heightMapHeight: {
            get: function () {
                return this._options.heightMapHeight
            }
        },
        heightMapWidth: {
            get: function () {
                return this._options.heightMapWidth
            }
        },
        pendingRequests: {
            get: function () {
                return this._pendingRequests
            }
        }
    });
    SFSTerrainProvider.prototype.getLevelMaximumGeometricError = function (e) {
        return this._levelZeroMaximumGeometricError / (1 << e) * SFSTerrainProvider._geometricErrorFactor
    };
    SFSTerrainProvider.prototype.createKeyFromTile = function (e, t, n) {
        return e + "_" + t + "_" + n
    };
    SFSTerrainProvider.prototype.getTileDataAvailable = function (e, t, n) {
        return this._isMPT ? undefined : n < 16 ? !0 : !1
    };
    SFSTerrainProvider.prototype.requestFactorForLevel = function (e) {
        var t = Math.log(this._requestGridSize) / Math.log(2);
        return t = Math.min(t, e), Math.pow(2, t)
    };
    SFSTerrainProvider.prototype.getRequestUrl = function (e, t, n, r) {
        var i = this.requestFactorForLevel(n);
        e = (e - e % i) / i, t = (t - t % i) / i, n -= Math.log(i) / Math.log(2);
        var s = this.tilingScheme.tileXYToNativeRectangle(e, t, n),
            o = this.heightMapWidth * i === 256 && r ? 1 : 0,
            u = this._urlTemplate.replace("{south}", s.south).replace("{north}", s.north).replace("{west}", s.west).replace("{east}", s.east).replace("{optimizedOnly}", o).replace("{width}", this.heightMapWidth * i).replace("{height}", this.heightMapHeight * i).replace("{s}", this.sTag(e, t, n));
        return u
    };
    SFSTerrainProvider.prototype.sTag = function (e, t, n) {
        if (this._subdomains == undefined) return "";
        var r = (e + t + n) % this._subdomains.length;
        return this._subdomains[r]
    };
    SFSTerrainProvider.prototype.findDirectParent = function (e) {
        var t = function (e, n) {
            if (e._rectangle.width <= n.width * 2.1 && Cesium.Rectangle.contains(e._rectangle, Cesium.Rectangle.center(n))) return e;
            var r = e.children.length;
            for (var i = 0; i < r; i++) {
                var s = e.children[i];
                if (Cesium.Rectangle.contains(s._rectangle, Cesium.Rectangle.center(n))) return t(s, n)
            }
            return null
        };
        if (e.width == Math.PI) return null;
        for (var n = 0; n < viewer$2.scene.globe._surface._levelZeroTiles.length; n++) {
            var r = t(viewer$2.scene.globe._surface._levelZeroTiles[n], e);
            if (r) return r
        }
        return null
    };
    SFSTerrainProvider.prototype.isTileAvailable = function (e, t, n) {
        var r = this._tilingScheme.tileXYToRectangle(e, t, n, new Cesium.Rectangle),
            i = this.findDirectParent(r);
        if (i && i.data && i.data.terrainData) {
            if (!(i.data.terrainData._childTileMask > 0)) return !1;
            var s = i.children.length;
            for (var o = 0; o < s; o++) {
                var u = i.children[o];
                if (Cesium.Rectangle.equals(u._rectangle, r)) return i.data.terrainData._childTileMask & 1 << o
            }
        }
        return !0
    };
    SFSTerrainProvider.prototype.markTileAsUnavailable = function (e, t, n) {
        var r = this._tilingScheme.tileXYToRectangle(e, t, n, new Cesium.Rectangle),
            i = this.findDirectParent(r);
        i && i.data && i.data.terrainData && i.data.terrainData._childTileMask > 0 && $.each(i.children, function (e, t) {
            if (Cesium.Rectangle.equals(t._rectangle, r)) {
                switch (e) {
                    case 0:
                        i.data.terrainData._childTileMask &= -5;
                        break;
                    case 1:
                        i.data.terrainData._childTileMask &= -9;
                        break;
                    case 2:
                        i.data.terrainData._childTileMask &= -2;
                        break;
                    case 3:
                        i.data.terrainData._childTileMask &= -3;
                        break;
                }
                return !1
            }
            return !0
        });
    };
    SFSTerrainProvider.prototype.requestTileGeometry = function (e, n, r, i) {
        var s = this.requestTileHeightBuffer(e, n, r, i);
        if (s === undefined) return undefined;
        var o = this,
            u = 15,
            a = this.requestTileHeightBuffer(e + 1, n, r, i, !0),
            f = this.requestTileHeightBuffer(e, n + 1, r, i, !0),
            l = this.requestTileHeightBuffer(e + 1, n + 1, r, i, !0),
            c = Cesium.when.defer();
        return Cesium.when.all([s, a, f, l], function (i) {
            var b; {
                if (i[0].myReject != undefined && i[0].myReject) {
                    o.markTileAsUnavailable(e, n, r), c.reject();
                    return
                }
                var s = o.heightMapWidth + 1,
                    a = o.heightMapHeight + 1,
                    f = new Float32Array(s * a);
                for (var l = 0; l < s; l++) for (var h = 0; h < a; h++) {
                    var p = l,
                        d = h,
                        v = 0;
                    h === s - 1 && (d = 0, v = 1), l === a - 1 && (p = 0, v = 2);
                    var m = l * s + h,
                        g = p * o.heightMapWidth + d;
                    i[v] !== null && (i[v].myReject == undefined || !i[v].myReject) && (f[m] = i[v][g]);
                }
                if (i[3].myReject == undefined || !i[3].myReject) f[s * a - 1] = i[3][0];
                var b = o.arrayToHeightmapTerrainData(f, s, a, u);
                c.resolve(b);
            }
        }).otherwise(function () {
            c.reject();
        }), c
    };
    SFSTerrainProvider.prototype.requestTileHeightBuffer = function (e, n, i, s, o) {
        if (isNaN(e + n + i)) return;
        if (!Cesium.defined(s) || s === !1) s = new Cesium.Request({
            defer: !0
        });
        var u = s.defer == 0;
        o = Cesium.defaultValue(u, !1);
        var a = Cesium.when.defer();
        var l; {
            var f = this.getRequestUrl(e, n, i, u || o);
            if (this._requestsCache.hasOwnProperty(f) === !1) {
                this._requestsCache[f] = {}, this._requestsCacheKeys.push(f);
                if (this._requestsCacheKeys.length > 100) {
                    for (var l = 0; l < 50; l++) delete this._requestsCache[this._requestsCacheKeys[l]];
                    this._requestsCacheKeys.splice(0, 50);
                }
            } else {
                var c = this._requestsCacheKeys.indexOf(f);
                this._requestsCacheKeys.splice(c, 1), this._requestsCacheKeys.push(f);
            }
            var p = this._requestsCache[f];
            if (p.dataLoaded === undefined) {
                u ? p.dataLoaded = Cesium.RequestScheduler.request(f, Cesium.loadArrayBuffer) : p.dataLoaded = Cesium.loadArrayBuffer(f);
                if (!Cesium.defined(p.dataLoaded)) return undefined
            }



            var tileRectangle = viewer$2.terrainProvider.tilingScheme.tileXYToRectangle(e, n, i);
            var modifyTerrainObjects = viewer$2.terrainProvider._modifyTerrainObjects;
            var terraCanvas = null;
            var nowModifyTerrain = null;
            if (modifyTerrainObjects != undefined && modifyTerrainObjects.length > 0) {
                modifyTerrainObjects.forEach(function (object) {
                    if (object.show) {
                        var intersection = Cesium.Rectangle.intersection(tileRectangle, object.rectangle, new Cesium.Rectangle);
                        if (intersection) {
                            nowModifyTerrain = object;
                            terraCanvas = fillArrayFromVerticesAndHeight(nowModifyTerrain.vertices, tileRectangle, nowModifyTerrain.heights[0]);
                        }
                    }
                });
            }


            var d = this;
            this._pendingRequests++, Cesium.when(p.dataLoaded, function (t) {
                p.workerFinished === undefined && (p.workerFinished = d._workerPool.queueWorkItem({
                    buffer: t
                })), Cesium.when(p.workerFinished, function (t) {
                    if (!!t.rejected) {
                        var s = d.heightMapWidth * d.heightMapHeight,
                            o = new Int16Array(s);

                        for (var f = 0; f < s; f++) o[f] = 300;
                        return i > 2 && (d.markTileAsUnavailable(e, n, i), o.myReject = !0), a.resolve(o), a
                    }
                    var r = d.extractTileHeightBuffer(t.buffer, e, n, i);

                    if (terraCanvas != null) {
                        var cond = terraCanvas.getContext("2d");
                        var imgData = cond.getImageData(0, 0, 32, 32).data;

                        for (var ui = 0; ui < 32; ui++)
                            for (var ai = 0; ai < 32; ai++) {
                                var fr = ui * 32 + ai;
                                var lr = (32 - 1 - ui) * 32 + ai;
                                if (imgData[fr * 4] !== 0) {
                                    r[lr] = nowModifyTerrain.heights[0];
                                }
                            }
                    }

                    d._pendingRequests--, a.resolve(r);
                });
            }).otherwise(function () {
                d._pendingRequests--, a.reject();
            });
        }
        return a
    };
    SFSTerrainProvider.prototype.extractTileHeightBuffer = function (e, t, n, r) {
        try {
            var i = this.requestFactorForLevel(r),
                s = t % i,
                o = n % i,
                u = new Int16Array(this.heightMapWidth * this.heightMapHeight),
                a = 1e6,
                f = -1e5;
            for (var l = 0; l < this.heightMapHeight; l++) for (var c = 0; c < this.heightMapWidth; c++) {
                var h = l + o * this.heightMapHeight,
                    p = c + s * this.heightMapWidth,
                    d = l * this.heightMapWidth + c,
                    v = h * this.heightMapWidth * i + p;
                e[v] > f && (f = e[v]), e[v] < a && (a = e[v]), u[d] = e[v];
            }
        } catch (m) {
            console.log(m.message);
        }
        return u
    };
    SFSTerrainProvider.prototype.arrayToHeightmapTerrainData = function (e, t, n, r) {
        Cesium.defined(e) === !1 && (e = new Int16Array(t * n));
        var i = {
            buffer: e,
            width: t,
            height: n,
            childTileMask: r
        };
        return new Cesium.HeightmapTerrainData(i)
    };

    /**
     *
     *   地形
     *
     * @alias Terrain
     * @constructor
     *
     * @param {viewer|object} viewer 传入数据。
     *
     */
    function Terrain(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        //this._SFSTerrainProvider = new SFSTerrainProvider();
        this._tree = tree;
        this._url = "";
        this._show = true;
    }
    //添加地形
    Terrain.prototype.createTerrainLayer = function (name, option, GroupID, checked, Description, lex) {
        if (lex == "Topography") {
            this.createTerrain(name, option, GroupID, checked, Description);
        } else if (lex == "sgs") {
            this.createSFSTerrain(name, option, GroupID, checked, Description);
        } else if (lex == "Arcgis") {
            this.createArcGISTerrain(name, option, GroupID, checked, Description);
        } else if (Description == "Cesium") {
            this.createCesiumTerrain(name, option, GroupID, checked);
        }
    };
    /**
     * 创建地形
     *
     * @param {string} [name] 名称
     * @param {string} [url] 路径
     * @param {string} [option] 地址
     * @param {string} [GroupID] 所在组
     * @param {string} [Description] 描述
     */
    Terrain.prototype.createTerrain = function (name, option, GroupID, checked, Description) {

        var defaultOption = {
            url: "",//	Resource | String | Promise.<Resource> | Promise.<String>		The URL of the Cesium terrain server.
            requestVertexNormals: false,//	optional Flag that indicates if the client should request additional lighting information from the server, in the form of per vertex normals if available.
            requestWaterMask: false,//	optional Flag that indicates if the client should request per tile water masks from the server, if available.
            requestMetadata: true,//	optional Flag that indicates if the client should request per tile metadata from the server, if available.
            credit: "",//	optional A credit for the data source, which is displayed on the canvas.
        };

        this.name = name;
        this.option = option;
        this.GroupID = GroupID;
        this.checked = checked;
        this.Description = Description;
        this.type = "createTerrain";

        var options = null;
        if (this._core.isUrl(option)) {
            options = defaultOption;
            options.url = option;
        } else {
            options = this._core.extend(defaultOption, option, true);
        }
        this._options = options;
        this._url = options.url;

        if (checked) {
            tree.setVisibility(GroupID, false, this._viewer, this._cesium);
            //that.setVisibility(false);
        } else {
            var obj = {
                id: option.id || this._core.getuid(),
                name: name,
                checked: checked,
                pId: this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'terrain',
                item: this
            };
            this.setTreeobj(obj);
            this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
            return this;
        }

        var terrain = new this._cesium.CesiumTerrainProvider(options);
        this._viewer.scene.terrainProvider = terrain;
        this.item = terrain;
        this._show = true;
        var obj = {
            id: option.id || this._core.getuid(),
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'terrain',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建Cesium全球地形
     *
     * @param {string} [name] 名称
     * @param {string} [url] 路径
     * @param {string} [option] 地址
     * @param {string} [GroupID] 所在组
     */
    Terrain.prototype.createCesiumTerrain = function (name, option, GroupID, checked) {
        this.name = name;
        this.option = option;
        this.GroupID = GroupID;
        this.checked = checked;
        this.type = "createCesiumTerrain";
        var defaultOption = {
            requestVertexNormals: true
        };
        var options = this._core.extend(defaultOption, option, true);

        this._options = options;
        var terrain = Cesium.createWorldTerrain(options);
        this.type = 'Cesium';
        this.item = terrain;
        if (checked) {
            tree.setVisibility(GroupID, false, this._viewer, this._cesium);
            //that.setVisibility(false);
        } else {
            // this.setVisibility(false);
            var obj = {
                id: option.id || this._core.getuid(),
                name: name,
                checked: checked,
                pId: this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'terrain',
                item: this
            };
            this.setTreeobj(obj);
            this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
            return this;
        }
        this._viewer.scene.terrainProvider = terrain;
        this._show = true;
        var obj = {
            id: option.id || this._core.getuid(),
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'terrain',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * sgs地下加载（7.2.3）
     * @param {*} name 
     * @param {*} option 
     * @param {*} GroupID 
     * @param {*} checked 
     * @param {*} Description 
     */
    Terrain.prototype.createSFSTerrain = function (name, option, GroupID, checked, Description) {
        //this.GroupId = GroupId;
        var terrainProvider = new SFSTerrainProvider723(this._viewer, {
            url: option.url,
            layerName: option.layerName,
            requestVertexNormals: option.requestVertexNormals,
            token: option.token,
            cacheUrl: option.cacheUrl,
            cacheLevel: option.cacheLevel
        });
        this.name = name;
        this.option = option;
        this.GroupID = GroupID;
        this.checked = checked;
        this.Description = Description;
        this.type = "createSFSTerrain";

        this.type = 'SGS';
        this._url = option.url;
        this.layerName = option.layerName;
        this.requestVertexNormals = option.requestVertexNormals;
        if (checked) {
            tree.setVisibility(GroupID, false, this._viewer, this._cesium);
            //that.setVisibility(false);
        } else {
            // this.setVisibility(false);
            this._show = true;
            var obj = {
                id: option.id || this._core.getuid(),
                name: name,
                checked: checked,
                pId: this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'terrain',
                item: this
            };
            this.setTreeobj(obj);
            this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
            return this;
        }

        this._viewer.terrainProvider = terrainProvider;
        this.item = terrainProvider;
        this._show = true;
        var obj = {
            id: option.id || this._core.getuid(),
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'terrain',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     *  sgs地下加载（7.1）
     * @param {*} name 
     * @param {*} option 
     * @param {*} GroupID 
     * @param {*} checked 
     * @param {*} Description 
     */
    Terrain.prototype.createSFSTerrain71 = function (name, option, GroupID, checked, Description) {
        //this.GroupId = GroupId;
        var terrainProvider = new SFSTerrainProvider(this._viewer, {
            url: option.url,
            layerName: option.layerName,
            // requestVertexNormals: option.requestVertexNormals,
            // token: option.token,
            // cacheUrl: option.cacheUrl,
            // cacheLevel: option.cacheLevel
        });
        this.name = name;
        this.option = option;
        this.GroupID = GroupID;
        this.checked = checked;
        this.Description = Description;
        this.type = "createSFSTerrain";

        this.type = 'SGS71';
        this._url = option.url;
        this.layerName = option.layerName;
        this.requestVertexNormals = option.requestVertexNormals;
        if (checked) {
            tree.setVisibility(GroupID, false, this._viewer, this._cesium);
            //that.setVisibility(false);
        } else {
            // this.setVisibility(false);
            this._show = true;
            var obj = {
                id: option.id || this._core.getuid(),
                name: name,
                checked: checked,
                pId: this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'terrain',
                item: this
            };
            this.setTreeobj(obj);
            this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
            return this;
        }

        this._viewer.terrainProvider = terrainProvider;
        this.item = terrainProvider;
        this._show = true;
        var obj = {
            id: option.id || this._core.getuid(),
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'terrain',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 创建地形ArcGIS
     *
     * @param {string} [name] 名称
     * @param {string} [url] 路径
     * @param {string} [option] 地址
     * @param {string} [GroupID] 所在组
     * @param {string} [Description] 描述
     */
    Terrain.prototype.createArcGISTerrain = function (name, option, GroupID, checked, Description) {
        var defaultOption = {
            url: ""
        };
        this.name = name;
        this.option = option;
        this.GroupID = GroupID;
        this.checked = checked;
        this.Description = Description;
        this.type = 'createArcGISTerrain';

        var options = null;
        if (this._core.isUrl(option)) {
            options = defaultOption;
            options.url = option;
        } else {
            options = this._core.extend(defaultOption, option, true);
        }
        this.type = 'ArcGIS';
        this._url = options.url;
        var terrain = new this._cesium.ArcGISTiledElevationTerrainProvider(options);

        if (checked) {
            tree.setVisibility(GroupID, false, this._viewer, this._cesium);
            //that.setVisibility(false);
        } else {
            // this.setVisibility(false);
            this._show = true;
            var obj = {
                id: option.id || this._core.getuid(),
                name: name,
                checked: checked,
                pId: this._core.isnull(GroupID) ? 0 : GroupID,
                type: 'terrain',
                item: this
            };
            this.setTreeobj(obj);
            this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
            return this;
        }

        this._viewer.terrainProvider = terrain;
        this.item = terrain;

        this._show = true;
        var obj = {
            id: option.id || this._core.getuid(),
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'terrain',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    Terrain.prototype.getType = function () {
        return {
            label: "影像",
            value: "TerrainProvider"
        };
    };
    /**
     * Terrain导出工程数据
     */
    Terrain.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.item._layers[0].resource.url;
        return {
            type: 'TerrainLayer',
            treeobj: { id: this.treeobj.id, name: this.treeobj.name, pId: this.treeobj.pId, type: this.treeobj.type },
            style: {
                show: show,
                url: url
            }
        };
    };
    /**
     * 设置模型的显示隐藏
     * @param {boolean} [b] true|false
     */
    Terrain.prototype.setVisibility = function (b) {
        //tree.setVisibility(this.GroupID, false, this._viewer, this._cesium);
        var terrain;
        if (b) {
            tree.setVisibility(this.GroupID, false, this._viewer, this._cesium);
            var options;
            if (this.type === 'SGS') {
                options = this.option;
                terrain = new SFSTerrainProvider723(this._viewer, {
                    url: options.url,
                    layerName: options.layerName,
                    requestVertexNormals: options.requestVertexNormals,
                    token: options.token,
                    cacheUrl: options.cacheUrl,
                    cacheLevel: options.cacheLevel
                });
            } else if (this.type === 'SGS71') {
                options = this.option;
                terrain = new SFSTerrainProvider(this._viewer, {
                    url: options.url,
                    layerName: options.layerName,
                    requestVertexNormals: options.requestVertexNormals,
                    token: options.token,
                    cacheUrl: options.cacheUrl,
                    cacheLevel: options.cacheLevel
                });
            } else if (this.type === 'ArcGIS') ; else if (this.type === 'Cesium') {
                terrain = Cesium.createWorldTerrain(this._options);
            } else {
                var option = this._options;
                var defaultOption = {
                    url: "",//	Resource | String | Promise.<Resource> | Promise.<String>		The URL of the Cesium terrain server.
                    requestVertexNormals: false,//	optional Flag that indicates if the client should request additional lighting information from the server, in the form of per vertex normals if available.
                    requestWaterMask: false,//	optional Flag that indicates if the client should request per tile water masks from the server, if available.
                    requestMetadata: true,//	optional Flag that indicates if the client should request per tile metadata from the server, if available.
                    credit: "",//	optional A credit for the data source, which is displayed on the canvas.
                };
                if (this._core.isUrl(option)) {
                    options = defaultOption;
                    options.url = option;
                } else {
                    options = this._core.extend(defaultOption, option, true);
                }
                terrain = new this._cesium.CesiumTerrainProvider(options);
            }
            this._show = true;
            this.item = terrain;
            this._viewer.scene.terrainProvider = terrain;
        } else {
            terrain = new this._cesium.EllipsoidTerrainProvider({});
            this.item = terrain;
            this._show = false;
            this._viewer.scene.terrainProvider = terrain;
        }
    };
    /**
     * 获取模型的显示隐藏
     */
    Terrain.prototype.getVisibility = function () {
        return this._show;
    };
    /**
     * Terrain导出工程数据
     */
    //Terrain.prototype.export = function () {
    //    var show = this.item.show == undefined ? undefined : this.item.show;
    //    var url = this.item._layers[0].resource.url;
    //    return {
    //        type: 'TerrainLayer',
    //        treeobj: { name: this.treeobj.name },
    //        style: {
    //            show: show,
    //            url: url
    //        }
    //    };
    //}
    //工程树添加
    Terrain.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 删除模型
     */
    Terrain.prototype.deleteObject = function () {
        try {
            this.item = new this._cesium.EllipsoidTerrainProvider({});
            this._viewer.scene.terrainProvider = this.item;
        } catch (ex) {
            console.log(ex.message);
        }
    };

    Object.defineProperties(Terrain.prototype, {});

    /**
     *
     * 管线Geosjon要素图层
     *
     * @alias VolumeGeoJsonFeatureLayer
     * @constructor
     *
     */
    function VolumeGeoJsonFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this.item = { show: true };
        this._primitive = undefined;
        this._Provider = undefined;
        //图例
        this.Legend = [];
        this.datas = [];
        //矢量切片数据存储
        this.PrimitiveData = [];
        this.PrimitiveObj = {
            key: "",
            data: {}
        };
        this.Primitivekey = [];
        //请求前
        this.tilesLength = 0;
        //请求后
        this.returnCount = 0;

        //数据删除
        // 瓦片 primitive，以 tile key 索引
        this._primitiveByTile = {};
        // 最新视角下的瓦片标识列表
        this._tileKeys = [];
        this._primitiveCollection = new this._cesium.PrimitiveCollection();
        /**
         * 是否强制清楚缓存
         */
        this._cache = false;
        this._forceRefreshPrvimitive = null;
    }
    /**
    * 创建VolumeGeoJsonFeatureLayer
    *
    * @param {String} [name] 图层名称。
    * @param {object|String} [geojsonOrurl] geojosn对象或者地址
    * @param {object} [option] 参数对象{
    *     height: 0,//	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
          extrudedHeight: 0,//		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
          heightReference: this._cesium.HeightReference.NONE,//		optional A Property specifying what the extrudedHeight is relative to.
          show: true,//	optional A boolean Property specifying the visibility of the polygon.
          fill: true,//	optional A boolean Property specifying whether the polygon is filled with the provided material.
          material: this._cesium.Color.WHITE,//optional A Property specifying the material used to fill the polygon.
          outline: false,//optional A boolean Property specifying whether the polygon is outlined.
          outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the Color of the outline.
          outlineWidth: 1.0,//optional A numeric Property specifying the width of the outline.
          stRotation: 0.0,//	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
          granularity: this._cesium.Math.RADIANS_PER_DEGREE,//	optional A numeric Property specifying the angular distance between each latitude and longitude point.
          perPositionHeight: false,	//optional A boolean specifying whether or not the the height of each position is used.
          closeTop: true,	//optional When false, leaves off the top of an extruded polygon open.
          closeBottom: true,//	optional When false, leaves off the bottom of an extruded polygon open.
          shadows: this._cesium.ShadowMode.DISABLED,//	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
          near: 0,
          far: 5000
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    VolumeGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayer = function (layername, url, option, max, min, GroupID, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
        };
        //填充颜色设置
        if (!this._core.isnull(option) && !this._core.isnull(option.material)) {
            if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(option.material)) {
                    option.material = this._color.colorFromHtmlColor(option.material);
                } else {
                    if (/^rgb/.test(option.material)) {
                        option.material = this._color.rgbaStringToRgbaObj(option.material);
                    }
                    if (option.material.r > 1) {
                        option.material.r = option.material.r / 255;
                    }
                    if (option.material.g > 1) {
                        option.material.g = option.material.g / 255;
                    }
                    if (option.material.b > 1) {
                        option.material.b = option.material.b / 255;
                    }
                    if (option.material.a > 1) {
                        option.material.a = option.material.a / 255;
                    }
                    option.material = this._color.createColor(option.material.r, option.material.g, option.material.b, option.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, option, true);
        if (this._core.isnull(max)) {
            max = 16;
        }
        if (this._core.isnull(min)) {
            min = 14;
        }
        if (url == undefined)
            console.log('url is required');
        if (layername == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var that = this;
        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = tile;
            if (tile.state === that._cesium.QuadtreeTileLoadState.START) {
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                /**
                 * 限定级别刷新
                 */
                if (tile.level >= min && tile.level < max) {
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    /**
                     * 判断相同级别的数据是否已经请求
                     */
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new that._cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new that._cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });

                        tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                tile.data.geometryPrimitive.update(frameState, []);
                            //if (tile.data.geometryPrimitive._ready) {
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }
                    /**
                     * 保存已经下载的数据
                     */
                    downLoadTiles.push({
                        level: tile.level,
                        x: tile.x,
                        y: tile.y,
                        data: undefined
                    });
                    /**
                     * 请求区块数据
                     */
                    (function (tile) {
                        //'http://192.168.1.40:8090/geoserver/gwc/service/wmts?REQUEST=GetTile&SERVICE=WMTS&VERSION=1.0.0&LAYER=skyline:nanjing&STYLE=&TILEMATRIX=EPSG:4490:' +
                        //tile.level + '&TILEMATRIXSET=EPSG:4490&FORMAT=application/json;type=geojson&TILECOL=' + tile.x + '&TILEROW=' + tile.y
                        // $.ajax({
                        that._core.xhr({
                            url: url + '?REQUEST=GetTile&SERVICE=WMTS&VERSION=1.0.0&LAYER=' + layername + '&STYLE=&TILEMATRIX=EPSG:4490:' +
                                tile.level + '&TILEMATRIXSET=EPSG:4490&FORMAT=application/json;type=geojson&TILECOL=' + tile.x + '&TILEROW=' + tile.y,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                var geometries = [];

                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                        }
                                    }
                                }

                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    fun(data.features[i].geometry.coordinates[0]);
                                    var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                    options.positions = pos;
                                    var geometryInstance = new that._cesium.GeometryInstance({
                                        geometry: new that._cesium.PolylineVolumeGeometry({
                                            polylinePositions: options.positions
                                        }),
                                        attributes: {
                                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.WHITE)
                                        }
                                    });
                                    geometries.push(geometryInstance);
                                }
                                var tempTiles = lodash.filter(downLoadTiles, function (o) {
                                    return o.x == tile.x && o.y == tile.y;
                                });
                                tempTiles[0].data = geometries;
                                tile.data.geometryPrimitive = new that._cesium.Primitive({
                                    geometryInstances: geometries,
                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                        flat: true,
                                        translucent: true,
                                        faceForward: true,
                                        closed: true
                                    }),
                                    shadows: that._cesium.ShadowMode.ENABLED
                                });
                                //});
                            },
                            error: function () {
                                downLoadTiles = lodash.remove(downLoadTiles, function (o) {
                                    return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                                });
                            },
                            complete: function () {
                                tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                                    if (tile.data.geometryPrimitive)
                                        tile.data.geometryPrimitive.update(frameState, []);
                                    //if (tile.data.geometryPrimitive._ready) {
                                    tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            }
                        });
                    })(tile);

                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            tile.data.geometryPrimitive.update(frameState, []);
                        //if (tile.data.geometryPrimitive._ready) {
                        tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        //}
                    }
                }
            }
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
    };
    /**
     * 创建VolumeGeoJsonFeatureLayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *       radius: 2,
            material: "#FFFFFF",
            show: true
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    VolumeGeoJsonFeatureLayer.prototype.createVolumeGeoJsonFeatureLayer1 = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var defaultOptions = {
            polylinePositions: undefined,
            shapePositions: undefined,
            ellipsoid: this._cesium.Ellipsoid.WGS84,
            granularity: this._cesium.Math.RADIANS_PER_DEGREE,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            cornerType: this._cesium.CornerType.ROUNDED
        };
        // var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        var that = this;
        var geometries = [];

        defaultOptions.shapePositions = this.computeCircle(option.radius);
        dataSource.then(function (dataSource) {
            //填充颜色设置
            var material = that._cesium.Color.WHITE;
            if (!that._core.isnull(option) && !that._core.isnull(option.material)) {
                if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") {
                    material = option.material.replace(/\[/, '').replace('/\]/', '');
                } else {
                    material = lodash.clone(option.material);
                }
                {
                    if (that._core.isHtmlColor(material)) {
                        material = that._color.colorFromHtmlColor(option.material);
                    } else {
                        if (/^rgb/.test(material)) {
                            material = that._color.rgbaStringToRgbaObj(material);
                        }
                        if (material.r > 1) {
                            material.r = material.r / 255;
                        }
                        if (material.g > 1) {
                            material.g = material.g / 255;
                        }
                        if (material.b > 1) {
                            material.b = material.b / 255;
                        }
                        if (material.a > 1) {
                            material.a = material.a / 255;
                        }
                        material = that._color.createColor(material.r, material.g, material.b, material.a);
                    }
                }
            }
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                defaultOptions.polylinePositions = entity.polyline.positions._value;

                var extrudedPolyline = new that._cesium.PolylineVolumeGeometry(defaultOptions);
                var geometry = that._cesium.PolylineVolumeGeometry.createGeometry(extrudedPolyline);
                var geometryInstance = new that._cesium.GeometryInstance({
                    geometry: geometry,
                    // attributes: {
                    //     color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(material),
                    // }
                });
                geometries.push(geometryInstance);
            }
            //图例
            var col = "material:" + material.red * 255 + "," + material.green * 255 + "," + material.blue * 255;
            that.Legend.push(col);
            var ps = that._viewer.scene.primitives.add(new that._cesium.Primitive({
                geometryInstances: geometries,
                appearance: new that._cesium.MaterialAppearance({
                    material: new that._cesium.Material({
                        fabric: {
                            type: 'Color',
                            uniforms: {
                                color: material
                            }
                        }
                    }),
                    faceForward: true,
                    flat: false
                }),
                // appearance: new that._cesium.PerInstanceColorAppearance({
                //     flat: true,
                //     translucent: true,
                //     faceForward: true,
                //     closed: true
                // }),
                // shadows: Cesium.ShadowMode.ENABLED
            }));
            that.item = ps;
            if (option.show == false) {
                ps.show = false;
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        if (this._core.isnull(option.id)) {
            option.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建管状图层" + option.id;
        }
        //导出工程树
        var obj = {
            id: option.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineVolumeLayer',
            item: this,
            url: geoOptions.url,
            style: option
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 生成管状数据
     * @param {Float} radians
     */
    VolumeGeoJsonFeatureLayer.prototype.computeCircle = function (radius) {
        if (this._core.isnull(radius)) {
            radius = 4;
        }
        var positions = [];
        for (var i = 0; i < 360; i++) {
            var radians = this._cesium.Math.toRadians(i);
            positions.push(new this._cesium.Cartesian2(radius * Math.cos(radians), radius * Math.sin(radians)));
        }
        return positions;
    };
    /**
     * geojson管线矢量图层
     * @param {String} [name] 图层名称
     * @param {object} [geoOptions] geojosn图层
     *       url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
     *       layer:'nanjing',
     upperLevelLimit: 13,
     lowerLevelLimit: 13,
     minx:118.51721649800015,
     miny:31.863232407499936,
     maxx:118.91648798400001,
     maxy:32.27649160409993
     * @param {object} [styleOption] 图层样式
     material: this._cesium.Color.WHITE, //    optional A Property specifying the material used to draw the polyline.
     radius:3
     * @param {Float}  [GroupID] 组itemID
     * @param {object} [disFnc] 回调函数
     */
    VolumeGeoJsonFeatureLayer.prototype.createVolumeGeoJsonFeatureLayerProvider1 = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var that = this;
        /**
         * 默认样式
         */
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.RECEIVE_ONLY, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        //this.options=options;
        /**
         * 请求矢量切片
         */

        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        var _this = this;
        geoJSONVectorTileProvider._loadTile = function (json) {
            //测试
            var collection = new _this._cesium.PrimitiveCollection();
            //图例
            _this.Legend = [];
            json.features.forEach(function (feature) {

                var pos = [];
                //fun(feature.geometry.coordinates);
                if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                    var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                    options.material = feature.properties[material];
                    //填充颜色设置
                    if (that._core.isHtmlColor(options.material)) {
                        options.material = that._color.colorFromHtmlColor(options.material);
                    } else {
                        if (/^rgb/.test(options.material)) {
                            options.material = that._color.rgbaStringToRgbaObj(options.material);
                        }
                        if (options.material.r > 1) {
                            options.material.r = options.material.r / 255;
                        }
                        if (options.material.g > 1) {
                            options.material.g = options.material.g / 255;
                        }
                        if (options.material.b > 1) {
                            options.material.b = options.material.b / 255;
                        }
                        if (options.material.a > 1) {
                            options.material.a = options.material.a / 255;
                        }
                        options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                    }
                }
                //var pos = _this._cesium.Cartesian3.fromDegreesArray(newArr);

                for (var i = 0; i < feature.geometry.coordinates.length; i++) {
                    var up = feature.geometry.coordinates[i];

                    if (up.length > 0) {
                        if (Array.isArray(up[0])) {
                            for (var j = 0; j < up.length; j++) {
                                var child = up[j];
                                var childFt = _this._cesium.Cartesian3.fromDegrees(child[0], child[1], options.height);
                                pos.push(childFt);
                            }
                        } else {
                            var ft = _this._cesium.Cartesian3.fromDegrees(up[0], up[1], options.height);
                            pos.push(ft);
                        }
                    }

                    //var ft=_this._cesium.Cartesian3.fromDegrees(up[0],up[1],options.height);
                    //pos.push(ft);
                }
                options.position = pos;
                feature.positions = pos;
                if (options.slttype == "0" || options.slttype == 0) {
                    options.shape = _this._core.computeCircle(options.radius);
                } else if (options.slttype == "1" || options.slttype == 1) {
                    options.shape = _this._core.starPositions(options.number, options.exradius, options.inradius);
                } else if (options.slttype == "2" || options.slttype == 2) {
                    var x = options.orth_width / 2;
                    var y = options.orth_height / 2;
                    options.shape = [new _this._cesium.Cartesian2(-x, -y),
                    new _this._cesium.Cartesian2(x, -y),
                    new _this._cesium.Cartesian2(x, y),
                    new _this._cesium.Cartesian2(-x, y)];
                }
                //options.shape = _this.computeCircle(styleOption.radius);
                var dx = {
                    polylinePositions: options.position,
                    shapePositions: options.shape,
                    cornerType: options.cornerType,
                    VertexFormat: {
                        bitangent: true,
                        color: true,
                        position: true,
                        st: true,
                        normal: true,
                        tangent: true
                    }
                };
                var volime = new _this._cesium.PolylineVolumeGeometry(dx);
                //var geometry = _this._cesium.PolylineVolumeGeometry.createGeometry(volime);
                var geometryInstance = new _this._cesium.GeometryInstance({
                    id: feature,
                    geometry: volime,
                    attributes: {
                        color: new _this._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                    }
                });
                //图例
                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                _this.Legend.push(col);
                //geomInstances.push(geometryInstance);
                var primitive = new _this._cesium.Primitive({
                    allowPicking: true,
                    appearance: new _this._cesium.MaterialAppearance({
                        material: new _this._cesium.Material({
                            fabric: {
                                type: 'Color',
                                uniforms: {
                                    // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                    color: options.material
                                }
                            }
                        }),
                        faceForward: true,
                        flat: false
                    }),
                    shadows: options.shadows,
                    geometryInstances: geometryInstance
                });
                collection.add(primitive);
            });
            return collection;
        };
        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineVolumeLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
    };

    /**
    * geojson管线矢量图层
    * @param {String} [name] 图层名称
    * @param {object} [geoOptions] geojosn图层
    *       url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
    *       layer:'nanjing',
    upperLevelLimit: 13,
    lowerLevelLimit: 13,
    minx:118.51721649800015,
    miny:31.863232407499936,
    maxx:118.91648798400001,
    maxy:32.27649160409993
    * @param {object} [styleOption] 图层样式
    material: this._cesium.Color.WHITE, //    optional A Property specifying the material used to draw the polyline.
    radius:3
    * @param {Float}  [GroupID] 组itemID
    * @param {object} [disFnc] 回调函数
    * 
    * update
    * 张恒
    * 20200520
    */
    VolumeGeoJsonFeatureLayer.prototype.createVolumeGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var that = this;
        /**
         * 默认样式
         */
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.RECEIVE_ONLY, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            radiusScale: 1
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: this._core.defaultValue(geoOptions.srs, 'EPSG:4490') + ':{z}',
                TILEMATRIXSET: this._core.defaultValue(geoOptions.srs, 'EPSG:4490'),
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);

        if (typeof options.radius === 'string' && options.radius.indexOf('[') > -1 && options.radius.indexOf(']') > -1) {
            options.radius = options.radius.replace('[', '');
            options.radius = options.radius.replace(']', '');
            options.shape = undefined;
        } else {
            if (options.slttype == "0" || options.slttype == 0) {
                options.shape = this._core.computeCircle(options.radius);
                var x = options.radius / 2;
                var y = options.radius / 2;
                options.shape1 = [new this._cesium.Cartesian2(-x, -y),
                new this._cesium.Cartesian2(x, -y),
                new this._cesium.Cartesian2(x, y),
                new this._cesium.Cartesian2(-x, y)];
            } else if (options.slttype == "1" || options.slttype == 1) {
                options.shape = this._core.starPositions(options.number, options.exradius, options.inradius);
            } else if (options.slttype == "2" || options.slttype == 2) {
                var x = options.orth_width / 2;
                var y = options.orth_height / 2;
                options.shape = [new this._cesium.Cartesian2(-x, -y),
                new this._cesium.Cartesian2(x, -y),
                new this._cesium.Cartesian2(x, y),
                new this._cesium.Cartesian2(-x, y)];
            }
        }

        //this.options=options;
        /**
         * 请求矢量切片
         */
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider._minimumHeight = parseFloat(styleOption.height || 0);
        // this._Provider.canRefine = function (tile, frameState, occluders) {
        //     if (tile.level < this._normalTile)
        //         return true;
        //     return false;
        // }
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this.item.show = checked;
        this._Provider.loadTile = function (frameState, tile) {
            (function (frameState, tile, that) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    //var levelError = that.getLevelMaximumGeometricError(tile.level);
                    // if (tile.level < 16) {
                    if (that.item.show === 0 || that.item.show === false || that.item.show === '' || that.item.show === undefined) {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        return;
                    }
                    if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                        var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }
                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                if (data == undefined) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    return;
                                }
                                if (!options.shape && typeof options.radius === 'string' && data.features.length > 0) {
                                    let radius;
                                    if (data.features[0] && data.features[0].properties[options.radius]) {
                                        radius = data.features[0].properties[options.radius];
                                        if (radius.indexOf && (radius.indexOf('*') > -1 || radius.indexOf('x') > -1 || radius.indexOf('X') > -1)) {
                                            if (radius.indexOf('*') > -1) {
                                                radius = radius.split('*');
                                            } else if (radius.indexOf('X') > -1) {
                                                radius = radius.split('X');
                                            } else if (radius.indexOf('x') > -1) {
                                                radius = radius.split('x');
                                            }
                                            let x = parseFloat(radius[0]) * options.radiusScale;
                                            let y = parseFloat(radius[1]) * options.radiusScale;
                                            options.shape = [new that._cesium.Cartesian2(-x, -y),
                                            new that._cesium.Cartesian2(x, -y),
                                            new that._cesium.Cartesian2(x, y),
                                            new that._cesium.Cartesian2(-x, y)
                                            ];
                                            // if (options.connect) {
                                            //     options.connect = false;
                                            //     // x += 0.05;
                                            //     // y += 0.05;
                                            //     // options.connectShape = [new that._cesium.Cartesian2(-x, -y),
                                            //     // new that._cesium.Cartesian2(x, -y),
                                            //     // new that._cesium.Cartesian2(x, y),
                                            //     // new that._cesium.Cartesian2(-x, y)
                                            //     // ];
                                            //     // options.connectRadius = {
                                            //     //     x: x,
                                            //     //     y: y
                                            //     // }
                                            // }
                                        } else {
                                            options.shape = that._core.computeCircle(radius * options.radiusScale);
                                            // if (options.connect) {
                                            //     options.connectRadius = radius * options.radiusScale + 0.02;
                                            //     options.connectShape1 = that._core.computeCircle(options.connectRadius);
                                            //     options.connectShape2 = that._core.computeCircle(options.connectRadius + 0.04);
                                            // }
                                        }
                                    } else {
                                        options.shape = that._core.computeCircle(0.5);
                                        // if (options.connect) {
                                        //     options.connectRadius = 0.52;
                                        //     options.connectShape1 = that._core.computeCircle(options.connectRadius);
                                        //     options.connectShape2 = that._core.computeCircle(options.connectRadius + 0.04);
                                        // }
                                    }
                                }
                                //图例
                                that.Legend = [];
                                var geometryInstance = [];
                                for (var k = 0; k < data.features.length; k++) {
                                    var feature = data.features[k];
                                    if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                                        var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                                        options.material = feature.properties[material];
                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.material)) {
                                            options.material = that._color.colorFromHtmlColor(options.material);
                                        } else {
                                            if (/^rgb/.test(options.material)) {
                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                            }
                                            if (options.material.r > 1) {
                                                options.material.r = options.material.r / 255;
                                            }
                                            if (options.material.g > 1) {
                                                options.material.g = options.material.g / 255;
                                            }
                                            if (options.material.b > 1) {
                                                options.material.b = options.material.b / 255;
                                            }
                                            if (options.material.a > 1) {
                                                options.material.a = options.material.a / 255;
                                            }
                                            options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                                        }
                                    }
                                    var pos = [];
                                    var colors = [];
                                    var minH = parseFloat(styleOption.height || 0);
                                    for (var i = 0; i < feature.geometry.coordinates.length; i++) {
                                        var up = feature.geometry.coordinates[i];

                                        if (up.length > 0) {
                                            if (Array.isArray(up[0])) {
                                                for (var j = 0; j < up.length; j++) {
                                                    var child = up[j];
                                                    minH = minH < (child[2] || 0) ? (child[2] || 0) : minH;
                                                    var childFt = that._cesium.Cartesian3.fromDegrees(child[0], child[1], options.height);
                                                    pos.push(childFt);
                                                    colors.push(options.material);
                                                }
                                            } else {
                                                minH = minH < (up[2] || 0) ? (up[2] || 0) : minH;
                                                var ft = that._cesium.Cartesian3.fromDegrees(up[0], up[1], options.height);
                                                pos.push(ft);
                                                colors.push(options.material);
                                            }
                                        }
                                    }
                                    tile._minimumHeight = minH;
                                    options.position = pos;
                                    feature.positions = pos;
                                    var shape = "";
                                    var volime = "";
                                    if (options.slttype == "0" || options.slttype == 0) {
                                        if (tile.level >= parseFloat(styleOption.level_max) - 8 && parseFloat(styleOption.level_max) > 19) {
                                            shape = options.shape;
                                            var dx = {
                                                polylinePositions: options.position,
                                                shapePositions: shape,
                                                cornerType: options.cornerType,
                                                VertexFormat: {
                                                    bitangent: true,
                                                    color: true,
                                                    position: true,
                                                    st: true,
                                                    normal: true,
                                                    tangent: true
                                                }
                                            };
                                            volime = new that._cesium.PolylineVolumeGeometry(dx);
                                        }
                                        else if (tile.level >= parseFloat(styleOption.level_max) - 4 && parseFloat(styleOption.level_max) > 16) {
                                            shape = options.shape;
                                            var dx = {
                                                polylinePositions: options.position,
                                                shapePositions: shape,
                                                cornerType: options.cornerType,
                                                VertexFormat: {
                                                    bitangent: true,
                                                    color: true,
                                                    position: true,
                                                    st: true,
                                                    normal: true,
                                                    tangent: true
                                                }
                                            };
                                            volime = new that._cesium.PolylineVolumeGeometry(dx);
                                        }
                                        else if (tile.level >= parseFloat(styleOption.level_max) - 4) {
                                            shape = options.shape;
                                            var dx = {
                                                polylinePositions: options.position,
                                                shapePositions: shape,
                                                cornerType: options.cornerType,
                                                VertexFormat: {
                                                    bitangent: true,
                                                    color: true,
                                                    position: true,
                                                    st: true,
                                                    normal: true,
                                                    tangent: true
                                                }
                                            };
                                            volime = new that._cesium.PolylineVolumeGeometry(dx);
                                        }
                                        else {
                                            shape = "";
                                            //线
                                            var Polyline = {
                                                positions: options.position,
                                                width: 1,
                                                vertexFormat: that._cesium.PolylineColorAppearance.VERTEX_FORMAT,
                                                colors: colors
                                                //arcType: options.arcType
                                            };
                                            volime = new that._cesium.PolylineGeometry(Polyline);
                                        }
                                    } else {
                                        shape = options.shape;
                                        var dx = {
                                            polylinePositions: options.position,
                                            shapePositions: shape,
                                            cornerType: options.cornerType,
                                            VertexFormat: {
                                                bitangent: true,
                                                color: true,
                                                position: true,
                                                st: true,
                                                normal: true,
                                                tangent: true
                                            }
                                        };
                                        volime = new that._cesium.PolylineVolumeGeometry(dx);
                                    }
                                    // let connect = [];
                                    // if (options.connect && pos.length > 1 && isPolylineVolume) {
                                    //     let startConnectP1 = that._core.getPointFromTwoPointCenter([pos[0], pos[1]], 0.15, that._cesium);
                                    //     let startConnectP2 = that._core.getPointFromTwoPointCenter([pos[0], pos[1]], 0.18, that._cesium);
                                    //     let endConnectP1 = that._core.getPointFromTwoPointCenter([pos[pos.length - 1], pos[pos.length - 2]], 0.15, that._cesium);
                                    //     let endConnectP2 = that._core.getPointFromTwoPointCenter([pos[pos.length - 1], pos[pos.length - 2]], 0.18, that._cesium);
                                    //     let startConnect1 = new that._cesium.PolylineVolumeGeometry({
                                    //         polylinePositions: [pos[0], startConnectP1],
                                    //         shapePositions: options.connectShape1,
                                    //         cornerType: options.cornerType,
                                    //         VertexFormat: {
                                    //             bitangent: true,
                                    //             color: true,
                                    //             position: true,
                                    //             st: true,
                                    //             normal: true,
                                    //             tangent: true
                                    //         }
                                    //     });
                                    //     connect.push(startConnect1);
                                    //     let startConnect2 = new that._cesium.PolylineVolumeGeometry({
                                    //         polylinePositions: [startConnectP1, startConnectP2],
                                    //         shapePositions: options.connectShape2,
                                    //         cornerType: options.cornerType,
                                    //         VertexFormat: {
                                    //             bitangent: true,
                                    //             color: true,
                                    //             position: true,
                                    //             st: true,
                                    //             normal: true,
                                    //             tangent: true
                                    //         }
                                    //     });
                                    //     connect.push(startConnect2);

                                    //     let endConnect1 = new that._cesium.PolylineVolumeGeometry({
                                    //         polylinePositions: [pos[pos.length - 1], endConnectP1],
                                    //         shapePositions: options.connectShape1,
                                    //         cornerType: options.cornerType,
                                    //         VertexFormat: {
                                    //             bitangent: true,
                                    //             color: true,
                                    //             position: true,
                                    //             st: true,
                                    //             normal: true,
                                    //             tangent: true
                                    //         }
                                    //     });
                                    //     connect.push(endConnect1);
                                    //     let endConnect2 = new that._cesium.PolylineVolumeGeometry({
                                    //         polylinePositions: [endConnectP1, endConnectP2],
                                    //         shapePositions: options.connectShape2,
                                    //         cornerType: options.cornerType,
                                    //         VertexFormat: {
                                    //             bitangent: true,
                                    //             color: true,
                                    //             position: true,
                                    //             st: true,
                                    //             normal: true,
                                    //             tangent: true
                                    //         }
                                    //     });
                                    //     connect.push(endConnect2);
                                    // }

                                    //options.shape = _this.computeCircle(styleOption.radius);
                                    //var geometry = _this._cesium.PolylineVolumeGeometry.createGeometry(volime);
                                    var geome = new that._cesium.GeometryInstance({
                                        id: feature,
                                        geometry: volime,
                                        attributes: {
                                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                        }
                                    });
                                    if (shape == "") {
                                        geome = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: volime
                                        });
                                    }
                                    geometryInstance.push(geome);
                                    // connect.length && connect.forEach(item => {
                                    //     let _geome = new that._cesium.GeometryInstance({
                                    //         id: feature,
                                    //         geometry: item,
                                    //         attributes: {
                                    //             color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                    //         }
                                    //     });
                                    //     geometryInstance.push(_geome);
                                    // });
                                }
                                //图例
                                var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                that.Legend.push(col);
                                /**
                                 * 请求到的数据为空
                                 */
                                if (geometryInstance.length == 0) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                }

                                var primitive = null;
                                if (shape == "") {
                                    primitive = new that._cesium.Primitive({
                                        appearance: new that._cesium.PolylineColorAppearance(),
                                        geometryInstances: geometryInstance
                                    });
                                } else {
                                    primitive = new that._cesium.Primitive({
                                        allowPicking: true,
                                        appearance: new that._cesium.PerInstanceColorAppearance({
                                            translucent: false,
                                            vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                            fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                        }),
                                        shadows: options.shadows,
                                        geometryInstances: geometryInstance
                                    });
                                }
                                tile.data.geometryPrimitive = primitive;
                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    tile.data.geometryPrimitive.update(frameState, []);
                                    //if (tile.data.geometryPrimitive._ready) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            },
                            error: function () {
                                if (tile.count == undefined) {
                                    tile.count = 0;
                                }
                                tile.count += 1;
                                if (tile.count >= 2) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    // return;
                                }
                                else {
                                    tile.state = Cesium.QuadtreeTileLoadState.START;
                                }
                            }
                        });

                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }
            })(frameState, tile, that);
        };

        this._primitive = new this._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);

        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineVolumeLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    var _typeof$2 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
        return typeof obj;
    } : function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    /**
    * 序列化参数对象
    *
    * @param {Object} params 参数对象
    * @returns {String} 序列化字符串
    */
    VolumeGeoJsonFeatureLayer.prototype._serialize = function (params) {
        var queryArray = [];
        var encode = window.encodeURIComponent;

        for (var key in params) {
            var value = params[key];

            if ((typeof value === 'undefined' ? 'undefined' : _typeof$2(value)) === 'object') {
                queryArray.push(encode(key) + '=' + encode(JSON.stringify(value)));
            } else {
                queryArray.push(encode(key) + '=' + encode(params[key]));
            }
        }

        return queryArray.join('&');
    };
    //矢量切片优化(管线)
    VolumeGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayerOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.RECEIVE_ONLY,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        //var options = this._core.extend(defaultOptions, styleOption, true);
        var that = this;
        var options = this._core.extend(defaultOptions, styleOption, true);
        if (options.slttype == "0" || options.slttype == 0) {
            options.shape = that._core.computeCircle(options.radius);
        } else if (options.slttype == "1" || options.slttype == 1) {
            options.shape = that._core.starPositions(options.number, options.exradius, options.inradius);
        } else if (options.slttype == "2" || options.slttype == 2) {
            var x = options.orth_width / 2;
            var y = options.orth_height / 2;
            options.shape = [new that._cesium.Cartesian2(-x, -y),
            new that._cesium.Cartesian2(x, -y),
            new that._cesium.Cartesian2(x, y),
            new that._cesium.Cartesian2(-x, y)];
        }
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = null;
            this.tile = tile;
            //var _this = this;
            //解决内存溢出
            if (tile.state === this._cesium.QuadtreeTileLoadState.START && that.item.show) {
                var key = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    if (!that.Primitivekey.includes(key)) {
                        /**
                         * 请求区块数据
                         */
                        (function (tile) {

                            // Create random lines at the root level.
                            var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                            that.tilesLength++;

                            if (that._cache) {
                                tileUrl += '&' + that._core.getuid();
                            }
                            // $.ajax({
                            that._core.xhr({
                                url: tileUrl,
                                type: "get",
                                dataType: "json",
                                success: function (data) {
                                    var geometries = [];
                                    var collection = new that._cesium.PrimitiveCollection();
                                    //图例
                                    that.Legend = [];
                                    function fun(arr) {
                                        for (var i = 0; i < arr.length; i++) {
                                            if (Array.isArray(arr[i])) {
                                                fun(arr[i]);
                                            } else {
                                                newArr.push(arr[i]);
                                            }
                                        }
                                    }
                                    function createobj() {
                                        if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                                            var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                                            options.material = feature.properties[material];
                                            //填充颜色设置
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.r > 1) {
                                                    options.material.r = options.material.r / 255;
                                                }
                                                if (options.material.g > 1) {
                                                    options.material.g = options.material.g / 255;
                                                }
                                                if (options.material.b > 1) {
                                                    options.material.b = options.material.b / 255;
                                                }
                                                if (options.material.a > 1) {
                                                    options.material.a = options.material.a / 255;
                                                }
                                                options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                                            }
                                        }
                                        var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                        options.position = pos;
                                        feature.positions = pos;
                                        //options.shape = _this.computeCircle(styleOption.radius);
                                        var dx = {
                                            polylinePositions: options.position,
                                            shapePositions: options.shape,
                                            cornerType: options.cornerType
                                        };
                                        var volime = new that._cesium.PolylineVolumeGeometry(dx);
                                        //var geometry = _this._cesium.PolylineVolumeGeometry.createGeometry(volime);
                                        var geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: volime,
                                            attributes: {
                                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material)
                                            }
                                        });
                                        //图例
                                        var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                        that.Legend.push(col);
                                        geometries.push(geometryInstance);
                                        //geomInstances.push(geometryInstance);
                                        var primitive = new that._cesium.Primitive({
                                            allowPicking: true,
                                            appearance: new that._cesium.MaterialAppearance({
                                                material: new that._cesium.Material({
                                                    fabric: {
                                                        type: 'Color',
                                                        uniforms: {
                                                            // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                                            color: options.material
                                                        }
                                                    }
                                                }),
                                                faceForward: true,
                                                flat: false
                                            }),
                                            shadows: options.shadows,
                                            geometryInstances: geometryInstance
                                        });
                                        collection.add(primitive);
                                    }
                                    for (var i = 0; i < data.features.length; i++) {
                                        var newArr = [];
                                        var feature = data.features[i];

                                        //fun(data.features[i].geometry.coordinates[0]);
                                        //解析坐标
                                        if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                            if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                                for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                    newArr = [];
                                                    feature.geometry.coordinates[j].pop();
                                                    fun(feature.geometry.coordinates[j]);
                                                    if (newArr.length > 2) {
                                                        createobj();
                                                    }
                                                }
                                            } else {
                                                fun(feature.geometry.coordinates);
                                                if (newArr.length > 2) {
                                                    createobj();
                                                }
                                            }
                                        }
                                    }
                                    if (geometries.length > 0) {
                                        //var Primitive = new that._cesium.Primitive({
                                        //    geometryInstances: geometries,
                                        //    appearance: new that._cesium.PerInstanceColorAppearance({
                                        //        translucent: false,
                                        //        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                        //        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                        //    })
                                        //});
                                        that.PrimitiveObj.data = collection;
                                        that.PrimitiveObj.key = that.Primitivekey[that.returnCount];
                                        var Obj = {
                                            key: that.Primitivekey[that.returnCount],
                                            data: collection
                                        };
                                        that.PrimitiveData.push(Obj);
                                        that._primitiveCollection.add(collection);
                                        //_primitiveCollection
                                        that._viewer.scene.primitives.add(collection);

                                        that.datas.push(collection);
                                        that.returnCount++;
                                        that._primitiveByTile[key] = collection;
                                    }
                                    //});
                                },
                                error: function () {
                                    downLoadTiles = lodash.remove(downLoadTiles, function (o) {
                                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                                    });
                                },
                                complete: function (XHR, TS) {
                                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                                        if (tile.data.geometryPrimitive)
                                            //tile.data.geometryPrimitive.update(frameState);
                                            //if (tile.data.geometryPrimitive._ready) {
                                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                                        tile.renderable = true;
                                        //}
                                    }
                                }
                            });
                        })(tile);
                    }
                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            //tile.data.geometryPrimitive.update(frameState);
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                    }
                    return;
                }
            }
        };

        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider,
            tileCacheSize: 1,
            maximumScreenSpaceError: 3
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }

    };
    //工程树添加
    VolumeGeoJsonFeatureLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
      * 移除过期的瓦片
      *
      * @param {Object} primitiveByTile 瓦片 primitive，以 tileKey 索引
      * @param {String[]} tileKeys 当前有效的瓦片 keys
      */
    VolumeGeoJsonFeatureLayer.prototype._removeObsoletePrimitives = function (primitiveByTile, tileKeys) {
        var deleteTileKeys = [];
        if (tileKeys.length > 0) {
            // deleteTileKeys = tileKeys.slice(0, Math.ceil(tileKeys.length / 10));
            deleteTileKeys = tileKeys;
        }
        for (var tileKey in primitiveByTile) {
            if (!deleteTileKeys.includes(tileKey)) {
                //var removed = this._viewer.scene.primitives.remove(primitiveByTile[tileKey]);
                var removed = this._primitiveCollection.remove(primitiveByTile[tileKey]);
                if (removed) {
                    delete primitiveByTile[tileKey];
                }
            }
        }
    };
    /**
    * 导出工程数据
    */
    VolumeGeoJsonFeatureLayer.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url
            }
        };
    };
    /**
     * 删除数据
     */
    VolumeGeoJsonFeatureLayer.prototype.deleteObject = function () {
        this._viewer.scene.primitives.remove(this.item);
        try {
            this._Provider.remove();
        } catch (ex) {
        }
    };
    /**
     * 返回图例
     * @returns {object}
     */
    VolumeGeoJsonFeatureLayer.prototype.getLegend = function () {
        var legend = [];
        if (this.Legend != null) {
            legend = this._core.unique(this.Legend);
        }
        return legend;
    };
    /**
     * 设置数据是否刷新
     */
    VolumeGeoJsonFeatureLayer.prototype.setRefresh = function (b) {
        try {
            if (this._Provider) {
                this._Provider.setStatus(!b);
            }
        } catch (ex) {
        }
    };
    /**
     * 设置数据显示隐藏
     */
    VolumeGeoJsonFeatureLayer.prototype.setVisibility = function (b) {
        this.item.show = b;
        if (this._Provider) {
            this._Provider.setStatus(b);
        }
    };
    /**
     * 是否强制清除缓存
     * @param {Boolean} b 
     */
    VolumeGeoJsonFeatureLayer.prototype.isCache = function (b) {
        this._cache = b;
    };
    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    VolumeGeoJsonFeatureLayer.prototype.edit = function (open, option) {
        this.isEditting = open;
        this.editoption = option;
        return this._Provider && this._Provider.edit && this._Provider.edit(open, option);
    };
    /**
     * 设置数据是否刷新
     */
    VolumeGeoJsonFeatureLayer.prototype.forceRefresh = function () {
        try {
            // this._cache = true;
            // if (!this._forceRefreshPrvimitive)
            //     this._forceRefreshPrvimitive = loadsh.cloneDeep(this._primitive)
            // var temp = loadsh.cloneDeep(this._forceRefreshPrvimitive)
            // this._viewer.scene.primitives.remove(this._primitive);
            // this._viewer.scene.primitives.add(temp);
            // this._viewer.scene.primitivesQuadTrees.push(temp);
            // // this.edit(this.isEditting, this.editoption);
            // // temp._tileProvider.edit(this.isEditting, this.editoption);

            for (var i = 0; i < this._Provider.quadtree._levelZeroTiles.length; i++) {
                this._Provider.quadtree._levelZeroTiles[i].freeResources();
            }
        } catch (ex) {
        }
    };

    /**
     *
     * 多边形切片Geojsonu要素图层
     *
     * @alias PolygonVectorGeoJsonFeatureLayer
     * @constructor
     *
     */
    function PolygonVectorGeoJsonFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this.item = { show: true };
        this._option = undefined;
        this._primitive = undefined;
        this._Provider = undefined;
        //图例
        this.Legend = [];
        this.datas = [];
        //矢量切片数据存储
        this.PrimitiveData = [];
        this.PrimitiveObj = {
            key: "",
            data: {}
        };
        this.Primitivekey = [];
        //请求前
        this.tilesLength = 0;
        //请求后
        this.returnCount = 0;
        /**
         * 是否强制清楚缓存
         */
        this._cache = false;
        this._forceRefreshPrvimitive = null;
    }

    var _typeof$1 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
        return typeof obj;
    } : function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
    /**
     * 序列化参数对象
     *
     * @param {Object} params 参数对象
     * @returns {String} 序列化字符串
     */
    PolygonVectorGeoJsonFeatureLayer.prototype._serialize = function (params) {
        var queryArray = [];
        var encode = window.encodeURIComponent;

        for (var key in params) {
            var value = params[key];

            if ((typeof value === 'undefined' ? 'undefined' : _typeof$1(value)) === 'object') {
                queryArray.push(encode(key) + '=' + encode(JSON.stringify(value)));
            } else {
                queryArray.push(encode(key) + '=' + encode(params[key]));
            }
        }

        return queryArray.join('&');
    };
    /**
     * 创建VolumeGeoJsonFeatureLayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *     height: 0,//	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
          extrudedHeight: 0,//		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
          heightReference: this._cesium.HeightReference.NONE,//		optional A Property specifying what the extrudedHeight is relative to.
          show: true,//	optional A boolean Property specifying the visibility of the polygon.
          fill: true,//	optional A boolean Property specifying whether the polygon is filled with the provided material.
          material: this._cesium.Color.WHITE,//optional A Property specifying the material used to fill the polygon.
          outline: false,//optional A boolean Property specifying whether the polygon is outlined.
          outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the Color of the outline.
          outlineWidth: 1.0,//optional A numeric Property specifying the width of the outline.
          stRotation: 0.0,//	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
          granularity: this._cesium.Math.RADIANS_PER_DEGREE,//	optional A numeric Property specifying the angular distance between each latitude and longitude point.
          perPositionHeight: false,	//optional A boolean specifying whether or not the the height of each position is used.
          closeTop: true,	//optional When false, leaves off the top of an extruded polygon open.
          closeBottom: true,//	optional When false, leaves off the bottom of an extruded polygon open.
          shadows: this._cesium.ShadowMode.DISABLED,//	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
          near: 0,
          far: 5000
        }
     * @param {Function} [disFnc] 回调函数layername, url, option, GroupID, disFnc
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。name, geoOptions, styleOption, GroupID, checked, disFnc
     */
    PolygonVectorGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };

        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }

        this._option = this._core.extend(defaultOptions, styleOption, true);

        //if (this._core.isnull(option.level_max)) {
        //    max = 16;
        //}
        //if (this._core.isnull(option.level_min )) {
        //    min = 14;
        //}
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = tile;
            if (tile.state === this._cesium.QuadtreeTileLoadState.START && that.item.show) {
                'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                // if (that._Provider._reTilesKey.indexOf(key) < 0) {
                //    that._Provider._reTilesKey.push(key);
                //    that._Provider._reTiles.push(tile);
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };

                // 
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new that._cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new that._cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });

                        tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                tile.data.geometryPrimitive.update();
                            //if (tile.data.geometryPrimitive._ready) {
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }

                    downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                    /**
                     * 请求区块数据
                     */
                    (function (tile) {

                        // Create random lines at the root level.
                        var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
                        // $.ajax({

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                var geometries = [];
                                //图例
                                that.Legend = [];

                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                        }
                                    }
                                }

                                function createobj() {
                                    if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                        var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                    } else {
                                        options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                    }
                                    options.material = that._option.material;
                                    if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                        var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                        options.material = feature.properties[material];

                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.material)) {
                                            options.material = that._color.colorFromHtmlColor(options.material);
                                        } else {
                                            if (/^rgb/.test(options.material)) {
                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                            }
                                            if (options.material.red > 1) {
                                                options.material.red = options.material.red / 255;
                                            }
                                            if (options.material.green > 1) {
                                                options.material.green = options.material.green / 255;
                                            }
                                            if (options.material.blue > 1) {
                                                options.material.blue = options.material.blue / 255;
                                            }
                                            if (options.material.alpha > 1) {
                                                options.material.a = options.material.alpha / 255;
                                            }
                                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                        }
                                    } else {
                                        if (that._option.material) {
                                            options.material = that._option.material;
                                        }
                                        if (options.material) {
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }

                                        }
                                    }
                                    var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                    //if (pos.length < 5) {
                                    //    var fr="11"
                                    //}
                                    //if (pos.length < 6) {
                                    //    var fr = "12"
                                    //}
                                    options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                    //边界面
                                    ////var extrudedPolygon = new Cesium.PolygonGeometry(options);
                                    //var extrudedPolygon = new Cesium.PolygonOutlineGeometry(options);

                                    //extrudedPolygon = Cesium.PolygonOutlineGeometry.createGeometry(extrudedPolygon);
                                    //// var geometry = Cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                    //var geometryInstance = new Cesium.GeometryInstance({
                                    //    id: feature,
                                    //    geometry: extrudedPolygon,
                                    //    attributes: {
                                    //        color: new Cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                    //    }
                                    //});
                                    //基础面
                                    var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                    var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                    var geometryInstance = new that._cesium.GeometryInstance({
                                        id: feature,
                                        geometry: geometry,
                                        attributes: {
                                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                        }
                                    });
                                    //线
                                    //pos.pop();
                                    //var ployline={
                                    //    positions: pos,
                                    //    width: 10,
                                    //    vertexFormat: that._cesium.PolylineColorAppearance.VERTEX_FORMAT
                                    //}
                                    ////var posp = that._cesium.Cartesian3.fromDegreesArrayHeights(newArrs);
                                    ////posp.pop();
                                    ////var extrudedPolygon = new Cesium.PolylineGeometry(pos);
                                    //var extrudedPolygon = new Cesium.PolylineGeometry(ployline);
                                    //var geometry = Cesium.PolylineGeometry.createGeometry(extrudedPolygon);
                                    //var clo = options.material;
                                    //if (options.outlineColor != undefined) {
                                    //    clo = that._color.createColorTransformation(options.outlineColor);
                                    //}
                                    //var geometryInstance = new Cesium.GeometryInstance({
                                    //    geometry: geometry,
                                    //    attributes: {
                                    //        color: new Cesium.ColorGeometryInstanceAttribute.fromColor(clo),
                                    //    }
                                    //});
                                    //图例
                                    var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                    that.Legend.push(col);
                                    geometries.push(geometryInstance);
                                    //geometries.push(geometryInstance1);
                                }

                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    var feature = data.features[i];

                                    //fun(data.features[i].geometry.coordinates[0]);
                                    //解析坐标
                                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                newArr = [];
                                                feature.geometry.coordinates[j].pop();
                                                fun(feature.geometry.coordinates[j]);
                                                createobj();
                                            }
                                        } else {
                                            fun(feature.geometry.coordinates);
                                            createobj();
                                        }
                                    }
                                }
                                //var Primitive= new Cesium.Primitive({
                                //    geometryInstances: geometries,
                                //    appearance: new Cesium.PerInstanceColorAppearance({
                                //        translucent: false,
                                //        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                //        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                //    }),
                                //    shadows: that._option.shadows
                                //});
                                //that._viewer.scene.primitives.add(Primitive);
                                tile.data.geometryPrimitive = new that._cesium.Primitive({
                                    geometryInstances: geometries,
                                    appearance: new that._cesium.PerInstanceColorAppearance({
                                        translucent: false,
                                        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                    }),
                                    shadows: that._option.shadows
                                });
                                //});
                            },
                            error: function () {
                                downLoadTiles = lodash.remove(downLoadTiles, function (o) {
                                    return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                                });
                            },
                            complete: function (XHR, TS) {
                                tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                                    if (tile.data.geometryPrimitive)
                                        tile.data.geometryPrimitive.update(frameState);
                                    //if (tile.data.geometryPrimitive._ready) {
                                    tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            }
                        });
                    })(tile);
                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            tile.data.geometryPrimitive.update(frameState, []);
                        //if (tile.data.geometryPrimitive._ready) {
                        tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        //}
                    }
                    // Add more detail to parent lines at every other level.
                    return;
                }

                //  }
            }
            //if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
            //    if (tile.data.geometryPrimitive && tile.data.geometryPrimitive.update) {
            //        tile.data.geometryPrimitive.update(frameState, []);
            //        if (tile.data.geometryPrimitive._ready) {
            //            tile.state = Cesium.QuadtreeTileLoadState.DONE;
            //            tile.renderable = true;
            //        }
            //    } else {
            //        tile.state = Cesium.QuadtreeTileLoadState.DONE;
            //        tile.renderable = true;
            //    }
            //}

        };

        this._primitive = new that._cesium.QuadtreePrimitive({
            tileProvider: this._Provider
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        //添加时间段
        if (styleOption && styleOption.time) {
            this._Provider._availability = new that._cesium.TimeIntervalCollection([new that._cesium.TimeInterval({
                start: styleOption.time.start ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.start)) : that._cesium.Iso8601.MINIMUM_VALUE,
                stop: styleOption.time.end ? that._cesium.JulianDate.fromDate(new Date(styleOption.time.end)) : that._cesium.Iso8601.MAXIMUM_VALUE
            })]);
            this._Provider.isAvailable = function (time) {
                if (!Cesium.defined(time)) {
                    throw new Cesium.DeveloperError("time is required.");
                }
                //>>includeEnd('debug');

                var availability = this._availability;
                return !Cesium.defined(availability) || availability.contains(time);
            };
        }

        primitives.add(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }

    };
    //矢量切片优化
    PolygonVectorGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayerOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: this._cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: this._cesium.ArcType.GEODESIC,
            material: this._cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        //请求
        //var tilesLength = 0;
        //结束请求前
        //var returnCount = 0;
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = null;
            this.tile = tile;
            //解决内存溢出
            if (tile.state === this._cesium.QuadtreeTileLoadState.START && that.item.show) {
                var key = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new that._cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new that._cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: that._cesium.ShadowMode.ENABLED
                        });

                        tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                //tile.data.geometryPrimitive.update();
                                //if (tile.data.geometryPrimitive._ready) {
                                tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }
                    if (that.PrimitiveData.length > 0) {
                        for (var i = 0; i < that.PrimitiveData.length; i++) {
                            if (that.PrimitiveData[i].key == key) {
                                that.Primitivekey.push(key);
                                return;
                            }
                        }
                    }
                    if (!that.Primitivekey.includes(key)) {
                        that.Primitivekey.push(key);
                        downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                        /**
                         * 请求区块数据
                         */
                        (function (tile) {

                            // Create random lines at the root level.
                            var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                            if (that._cache) {
                                tileUrl += '&' + that._core.getuid();
                            }

                            that.tilesLength++;
                            // $.ajax({
                            that._core.xhr({
                                url: tileUrl,
                                type: "get",
                                dataType: "json",
                                success: function (data) {
                                    var geometries = [];
                                    //图例
                                    that.Legend = [];
                                    function fun(arr) {
                                        for (var i = 0; i < arr.length; i++) {
                                            if (Array.isArray(arr[i])) {
                                                fun(arr[i]);
                                            } else {
                                                newArr.push(arr[i]);
                                            }
                                        }
                                    }
                                    function createobj() {
                                        if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                            var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                            options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                        }
                                        options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                        options.material = that._option.material;
                                        if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                            var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                            options.material = feature.properties[material];

                                            //填充颜色设置
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }
                                        } else {
                                            if (that._option.material) {
                                                options.material = that._option.material;
                                            }
                                            if (options.material) {
                                                if (that._core.isHtmlColor(options.material)) {
                                                    options.material = that._color.colorFromHtmlColor(options.material);
                                                } else {
                                                    if (/^rgb/.test(options.material)) {
                                                        options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                    }
                                                    if (options.material.red > 1) {
                                                        options.material.red = options.material.red / 255;
                                                    }
                                                    if (options.material.green > 1) {
                                                        options.material.green = options.material.green / 255;
                                                    }
                                                    if (options.material.blue > 1) {
                                                        options.material.blue = options.material.blue / 255;
                                                    }
                                                    if (options.material.alpha > 1) {
                                                        options.material.a = options.material.alpha / 255;
                                                    }
                                                    options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                                }

                                            }
                                        }
                                        var pos = that._cesium.Cartesian3.fromDegreesArray(newArr);
                                        options.polygonHierarchy = new that._cesium.PolygonHierarchy(pos);
                                        //基础面
                                        var extrudedPolygon = new that._cesium.PolygonGeometry(options);
                                        //var geometry = that._cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                        var geometryInstance = new that._cesium.GeometryInstance({
                                            id: feature,
                                            geometry: extrudedPolygon,
                                            attributes: {
                                                color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                            }
                                        });
                                        //图例
                                        var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                        that.Legend.push(col);
                                        geometries.push(geometryInstance);
                                        //geometries.push(geometryInstance1);
                                    }
                                    for (var i = 0; i < data.features.length; i++) {
                                        var newArr = [];
                                        var feature = data.features[i];

                                        //fun(data.features[i].geometry.coordinates[0]);
                                        //解析坐标
                                        if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                            if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                                for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                                    newArr = [];
                                                    feature.geometry.coordinates[j].pop();
                                                    fun(feature.geometry.coordinates[j]);
                                                    createobj();
                                                }
                                            } else {
                                                fun(feature.geometry.coordinates);
                                                createobj();
                                            }
                                        }
                                    }
                                    var Primitive = new that._cesium.Primitive({
                                        geometryInstances: geometries,
                                        appearance: new that._cesium.PerInstanceColorAppearance({
                                            translucent: false,
                                            vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                            fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                        }),
                                        shadows: that._option.shadows
                                    });
                                    that.PrimitiveObj.data = Primitive;
                                    that.PrimitiveObj.key = that.Primitivekey[that.returnCount];
                                    var Obj = {
                                        key: that.Primitivekey[that.returnCount],
                                        data: Primitive
                                    };
                                    that.PrimitiveData.push(Obj);
                                    that._viewer.scene.primitives.add(Primitive);
                                    that.datas.push(Primitive);
                                    that.returnCount++;
                                    if (that.returnCount >= that.tilesLength) {
                                        that.returnCount = 0;
                                        that.tilesLength = 0;
                                        //that.removeObsoletePrimitives();
                                        that.Primitivekey = [];
                                    }
                                    //});
                                },
                                error: function () {
                                    downLoadTiles = lodash.remove(downLoadTiles, function (o) {
                                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                                    });
                                },
                                complete: function (XHR, TS) {
                                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                                        if (tile.data.geometryPrimitive)
                                            //tile.data.geometryPrimitive.update(frameState);
                                            //if (tile.data.geometryPrimitive._ready) {
                                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                                        tile.renderable = true;
                                        //}
                                    }
                                }
                            });
                        })(tile);
                    }
                } else {
                    tile.state = that._cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === that._cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            //tile.data.geometryPrimitive.update(frameState);
                            tile.state = that._cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                    }
                    return;
                }
            }
        };

        this._primitive = new that._cesium.QuadtreePrimitive({
            tileProvider: this._Provider
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }

    };
    /**
     山东项目数据加载
     */
    PolygonVectorGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayersd = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };

        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.outlineColor)) {
            if (styleOption.outlineColor.toString().charAt(0) == "[" && styleOption.outlineColor.toString().charAt(styleOption.outlineColor.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.outlineColor)) {
                    styleOption.outlineColor = this._color.colorFromHtmlColor(styleOption.outlineColor);
                } else {
                    if (/^rgb/.test(styleOption.outlineColor)) {
                        styleOption.outlineColor = this._color.rgbaStringToRgbaObj(styleOption.outlineColor);
                    }
                    if (styleOption.outlineColor.r > 1) {
                        styleOption.outlineColor.r = styleOption.outlineColor.r / 255;
                    }
                    if (styleOption.outlineColor.g > 1) {
                        styleOption.outlineColor.g = styleOption.outlineColor.g / 255;
                    }
                    if (styleOption.outlineColor.b > 1) {
                        styleOption.outlineColor.b = styleOption.outlineColor.b / 255;
                    }
                    if (styleOption.outlineColor.a > 1) {
                        styleOption.outlineColor.a = styleOption.outlineColor.a / 255;
                    }
                    styleOption.outlineColor = this._color.createColor(styleOption.outlineColor.r, styleOption.outlineColor.g, styleOption.outlineColor.b, styleOption.outlineColor.a);
                }
            }
        }
        this._option = this._core.extend(defaultOptions, styleOption, true);

        //if (this._core.isnull(option.level_max)) {
        //    max = 16;
        //}
        //if (this._core.isnull(option.level_min )) {
        //    min = 14;
        //}
        if (geoOptions == undefined)
            console.log('geoOptions is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 0,
            vertexFormat: Cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: Cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: Cesium.ArcType.GEODESIC,
            material: Cesium.Color.RED
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);
        //http://192.168.1.40:8090/geoserver/swagger/ows?service=WFS&version=1.0.0&request=GetFeature&typeName=swagger%3Aquanguoxianjie&outputFormat=application%2Fjson
        //http://192.168.1.40:8090/geoserver/swagger/wms?service=WMS&version=1.1.0&request=GetMap&layers=swagger%3Alaishanqu&bbox=73.62%2C16.7%2C134.77%2C53.56&width=768&height=462&srs=EPSG%3A4490&format=application%2Fjson%3Btype%3Dgeojson

        //var julo = geoOptions.url.split("geoserver")[0] + "geoserver/swagger/ows?service=WFS&version=1.0.0&request=GetFeature&typeName=" + defaultGeoOptions.urlParams.LAYER + "&outputFormat=application%2Fjson";
        var julo = geoOptions.url.split("geoserver")[0] + "geoserver/polygon/ows?service=WFS&version=1.0.0&request=GetFeature&typeName=" + defaultGeoOptions.urlParams.LAYER + "&outputFormat=application%2Fjson";
        var urlzt = julo;

        // $.ajax({
        that._core.xhr({
            url: urlzt,
            type: "get",
            async: false,
            dataType: "json",
            success: function (data) {
                that.datas = data.features;
            }
        });
        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = tile;
            if (tile.state === Cesium.QuadtreeTileLoadState.START && that.item.show) {
                'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                // if (that._Provider._reTilesKey.indexOf(key) < 0) {
                //    that._Provider._reTilesKey.push(key);
                //    that._Provider._reTiles.push(tile);
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };

                // 
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new Cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new Cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: Cesium.ShadowMode.ENABLED
                        });

                        tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                tile.data.geometryPrimitive.update();
                            //if (tile.data.geometryPrimitive._ready) {
                            tile.state = Cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }

                    downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                    /**
                     * 请求区块数据
                     */
                    (function (tile) {

                        // Create random lines at the root level.
                        var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }
                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                var geometries1 = [];
                                //图例
                                that.Legend = [];

                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            if (arr[i].length == 3) {
                                                arr[i].splice(2, 1);
                                                arr[i].push(this._option.height);
                                            }
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                        }
                                    }
                                }

                                function createobj() {
                                    if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                        var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                        options.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                    } else {
                                        options.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                    }
                                    options.material = that._option.material;
                                    if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                        var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                        options.material = feature.properties[material];

                                        //填充颜色设置
                                        if (that._core.isHtmlColor(options.material)) {
                                            options.material = that._color.colorFromHtmlColor(options.material);
                                        } else {
                                            if (/^rgb/.test(options.material)) {
                                                options.material = that._color.rgbaStringToRgbaObj(options.material);
                                            }
                                            if (options.material.red > 1) {
                                                options.material.red = options.material.red / 255;
                                            }
                                            if (options.material.green > 1) {
                                                options.material.green = options.material.green / 255;
                                            }
                                            if (options.material.blue > 1) {
                                                options.material.blue = options.material.blue / 255;
                                            }
                                            if (options.material.alpha > 1) {
                                                options.material.a = options.material.alpha / 255;
                                            }
                                            options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                        }
                                    } else {
                                        if (that._option.material) {
                                            options.material = that._option.material;
                                        }
                                        if (options.material) {
                                            if (that._core.isHtmlColor(options.material)) {
                                                options.material = that._color.colorFromHtmlColor(options.material);
                                            } else {
                                                if (/^rgb/.test(options.material)) {
                                                    options.material = that._color.rgbaStringToRgbaObj(options.material);
                                                }
                                                if (options.material.red > 1) {
                                                    options.material.red = options.material.red / 255;
                                                }
                                                if (options.material.green > 1) {
                                                    options.material.green = options.material.green / 255;
                                                }
                                                if (options.material.blue > 1) {
                                                    options.material.blue = options.material.blue / 255;
                                                }
                                                if (options.material.alpha > 1) {
                                                    options.material.a = options.material.alpha / 255;
                                                }
                                                options.material = that._color.createColor(options.material.red, options.material.green, options.material.blue, options.material.alpha);
                                            }

                                        }
                                    }
                                    var pos = Cesium.Cartesian3.fromDegreesArrayHeights(newArr);
                                    //if (pos.length < 5) {
                                    //    var fr="11"
                                    //}
                                    //if (pos.length < 6) {
                                    //    var fr = "12"
                                    //}
                                    options.polygonHierarchy = new Cesium.PolygonHierarchy(pos);
                                    //边界面
                                    //var extrudedPolygon = new Cesium.PolygonGeometry(options);
                                    //var extrudedPolygon = new Cesium.PolygonOutlineGeometry(options);

                                    //extrudedPolygon = Cesium.PolygonOutlineGeometry.createGeometry(extrudedPolygon);
                                    //// var geometry = Cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                    //var geometryInstance = new Cesium.GeometryInstance({
                                    //    id: feature,
                                    //    geometry: extrudedPolygon,
                                    //    attributes: {
                                    //        color: new Cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                    //    }
                                    //});
                                    //基础面
                                    //var extrudedPolygon = new Cesium.PolygonGeometry(options);
                                    //var geometry = Cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                    //var geometryInstance = new Cesium.GeometryInstance({
                                    //    id: feature,
                                    //    geometry: geometry,
                                    //    attributes: {
                                    //        color: new Cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                                    //    }
                                    //});
                                    //线
                                    //var pos = Cesium.Cartesian3.fromDegreesArray(newArr);
                                    var pos = Cesium.Cartesian3.fromDegreesArrayHeights(newArr);
                                    var polyline = {
                                        positions: pos,
                                        width: that._option.outlineWidth,
                                        color: Cesium.ColorGeometryInstanceAttribute.fromColor(that._option.outlineColor)
                                    };
                                    var geometry = new Cesium.PolylineGeometry(polyline);
                                    var geometryInstance1 = new Cesium.GeometryInstance({
                                        geometry: geometry
                                    });
                                    //geometries_line.push(geometryInstance);
                                    //图例
                                    var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                    that.Legend.push(col);
                                    //geometries.push(geometryInstance);
                                    geometries1.push(geometryInstance1);
                                }

                                //修改数据对比解析
                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    var sj = data.features[i].id;
                                    var jl = parseInt(sj.split(".")[1]) + 1;
                                    var feature = that.datas[jl];
                                    //var feature = that.datas[k];
                                    //解析坐标
                                    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                        if (Array.isArray(feature.geometry.coordinates[0][0][0])) {
                                            for (var j = 0; j < feature.geometry.coordinates[0].length; j++) {
                                                newArr = [];
                                                //feature.geometry.coordinates[j].pop();
                                                fun(feature.geometry.coordinates[0][j]);
                                                createobj();
                                            }
                                        }
                                    }
                                }

                                //that._viewer.scene.primitives.add(new Cesium.Primitive({
                                //    geometryInstances: geometries1,
                                //    appearance: new Cesium.PolylineColorAppearance()
                                //}));
                                //for (var i = 0; i < data.features.length; i++) {
                                //    var newArr = [];
                                //    var feature = data.features[i];

                                //    //fun(data.features[i].geometry.coordinates[0]);
                                //    //解析坐标
                                //    if (Array.isArray(feature.geometry.coordinates) && feature.geometry.coordinates.length > 0) {
                                //        if (Array.isArray(feature.geometry.coordinates[0][0])) {
                                //            for (var j = 0; j < feature.geometry.coordinates.length; j++) {
                                //                newArr = [];
                                //                feature.geometry.coordinates[j].pop();
                                //                fun(feature.geometry.coordinates[j])
                                //                createobj(newArr);
                                //            }
                                //        } else {
                                //            fun(feature.geometry.coordinates);
                                //            createobj(newArr);
                                //        }
                                //    }
                                //}


                                //var Primitive= new Cesium.Primitive({
                                //    geometryInstances: geometries,
                                //    appearance: new Cesium.PerInstanceColorAppearance({
                                //        translucent: false,
                                //        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                //        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                //    }),
                                //    shadows: that._option.shadows
                                //});
                                //that._viewer.scene.primitives.add(Primitive);
                                var colect = new Cesium.PrimitiveCollection();
                                //colect.add(new Cesium.Primitive({
                                //    geometryInstances: geometries,
                                //    appearance: new Cesium.PerInstanceColorAppearance({
                                //        translucent: false,
                                //        vertexShaderSource: that._core.Shaders("vertexShaderSource"),
                                //        fragmentShaderSource: that._core.Shaders("fragmentShaderSource")
                                //    }),
                                //    shadows: that._option.shadows
                                //}));
                                colect.add(new Cesium.Primitive({
                                    geometryInstances: geometries1,
                                    appearance: new Cesium.PolylineColorAppearance()
                                }));
                                tile.data.geometryPrimitive = colect;
                                //});
                            },
                            error: function () {
                                downLoadTiles = lodash.remove(downLoadTiles, function (o) {
                                    return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                                });
                            },
                            complete: function (XHR, TS) {
                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    if (tile.data.geometryPrimitive)
                                        tile.data.geometryPrimitive.update(frameState);
                                    //if (tile.data.geometryPrimitive._ready) {
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                    //}
                                }
                            }
                        });
                    })(tile);
                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            tile.data.geometryPrimitive.update(frameState, []);
                        //if (tile.data.geometryPrimitive._ready) {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        //}
                    }
                    // Add more detail to parent lines at every other level.
                    return;
                }

                //  }
            }
            //if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
            //    if (tile.data.geometryPrimitive && tile.data.geometryPrimitive.update) {
            //        tile.data.geometryPrimitive.update(frameState, []);
            //        if (tile.data.geometryPrimitive._ready) {
            //            tile.state = Cesium.QuadtreeTileLoadState.DONE;
            //            tile.renderable = true;
            //        }
            //    } else {
            //        tile.state = Cesium.QuadtreeTileLoadState.DONE;
            //        tile.renderable = true;
            //    }
            //}

        };

        this._primitive = new that._cesium.QuadtreePrimitive({
            tileProvider: this._Provider
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this;
    };

    //单体化layername, url, option, GroupID, disFnc
    PolygonVectorGeoJsonFeatureLayer.prototype.createVolumeVectorGeoJsonFeatureLayerDth = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
        };

        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };

        this._option = this._core.extend(defaultOptions, styleOption, true);
        if (geoOptions == undefined)
            console.log('url is required');
        if (name == undefined) {
            console.log('layername is required');
        }
        /**
         * 已经下载数据集合
         */
        var downLoadTiles = [];
        var options = {
            polygonHierarchy: undefined,
            height: 0,
            extrudedHeight: 100,
            vertexFormat: Cesium.VertexFormat.DEFAULT,
            stRotation: 0.0,
            ellipsoid: Cesium.Ellipsoid.WGS84, //	optional The ellipsoid to be used as a reference.
            perPositionHeight: true, //	optional Use the height of options.positions for each position instead of using options.height to determine the height.
            closeTop: true, //	optional When false, leaves off the top of an extruded polygon open.
            closeBottom: true, //optional When false, leaves off the bottom of an extruded polygon open.
            arcType: Cesium.ArcType.GEODESIC,
            material: Cesium.Color.WHITE
        };
        var that = this;
        // 矢量切片服务 URL 模板
        this._urlTemplate = geoOptions.url + '?' + this._serialize(defaultGeoOptions.urlParams);

        this._Provider = new VectorTileProvider(this._viewer, this._cesium);
        this._Provider._normalTile = styleOption.level_max - 1;
        this._Provider.loadTile = function (frameState, tile) {
            this.tile = tile;
            if (tile.state === Cesium.QuadtreeTileLoadState.START && that.item.show) {
                'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
                tile.data = {
                    lines: [],
                    geometryPrimitive: undefined
                };

                // 
                if (tile.level >= styleOption.level_min && tile.level < styleOption.level_max && that.item.show) {
                    /**
                     * 保存已经下载的数据
                     */
                    var tiles = lodash.filter(downLoadTiles, function (o) {
                        return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                    });
                    if (tiles.length != 0 && tiles[0].data && tiles[0].data.length > 0) {
                        tile.data.geometryPrimitive = new Cesium.Primitive({
                            geometryInstances: tiles[0].data,
                            appearance: new Cesium.PerInstanceColorAppearance({
                                flat: true,
                                translucent: true,
                                faceForward: true,
                                closed: true
                            }),
                            shadows: Cesium.ShadowMode.ENABLED
                        });

                        tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                        if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                            if (tile.data.geometryPrimitive)
                                tile.data.geometryPrimitive.update(frameState, []);
                            //if (tile.data.geometryPrimitive._ready) {
                            tile.state = Cesium.QuadtreeTileLoadState.DONE;
                            tile.renderable = true;
                            //}
                        }

                        return;
                    }

                    downLoadTiles.push({ level: tile.level, x: tile.x, y: tile.y, data: undefined });
                    /**
                     * 请求区块数据
                     */
                    (function (tile) {
                        var tileUrl = that._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);

                        if (that._cache) {
                            tileUrl += '&' + that._core.getuid();
                        }

                        // $.ajax({
                        that._core.xhr({
                            url: tileUrl,
                            type: "get",
                            dataType: "json",
                            success: function (data) {
                                var geometries = [];
                                //图例
                                that.Legend = [];
                                //数据集合
                                var collection = new that._cesium.PrimitiveCollection();

                                function fun(arr) {
                                    for (var i = 0; i < arr.length; i++) {
                                        if (Array.isArray(arr[i])) {
                                            fun(arr[i]);
                                        } else {
                                            newArr.push(arr[i]);
                                        }
                                    }
                                }

                                for (var i = 0; i < data.features.length; i++) {
                                    var newArr = [];
                                    var feature = data.features[i];

                                    fun(data.features[i].geometry.coordinates[0]);

                                    if (/^\[/.test(that._option.extrudedHeight) && /\]$/.test(that._option.extrudedHeight)) {
                                        var extrudedHeight = that._option.extrudedHeight.replace(/\[/, '').replace(/\]/, '');
                                        that._option.extrudedHeight = parseFloat(feature.properties[extrudedHeight]);
                                    } else {
                                        that._option.extrudedHeight = parseFloat(that._option.extrudedHeight);
                                    }
                                    if (that._option.heightReference == 1) {
                                        delete that._option.height;
                                    }
                                    if (that._option.extrudedHeightReference == 1) {
                                        delete that._option.extrudedHeight;
                                    }
                                    if (/^\[/.test(that._option.material) && /\]$/.test(that._option.material)) {
                                        var material = that._option.material.replace(/\[/, '').replace(/\]/, '');
                                        that._option.material = feature.properties[material];
                                        //填充颜色设置
                                        if (that._core.isHtmlColor(that._option.material)) {
                                            that._option.material = that._color.colorFromHtmlColor(that._option.material);
                                        } else {
                                            if (/^rgb/.test(that._option.material)) {
                                                that._option.material = that._color.rgbaStringToRgbaObj(that._option.material);
                                            }
                                            if (that._option.material.red > 1) {
                                                that._option.material.red = that._option.material.red / 255;
                                            }
                                            if (that._option.material.green > 1) {
                                                that._option.material.green = that._option.material.green / 255;
                                            }
                                            if (that._option.material.blue > 1) {
                                                that._option.material.blue = that._option.material.blue / 255;
                                            }
                                            if (that._option.material.alpha > 1) {
                                                that._option.material.a = that._option.material.alpha / 255;
                                            }
                                            that._option.material = that._color.createColor(that._option.material.red, that._option.material.green, that._option.material.blue, that._option.material.alpha);
                                        }
                                    } else {
                                        if (that._option.material) {
                                            that._option.material = that._option.material;
                                        }
                                        if (that._option.material) {
                                            if (that._core.isHtmlColor(that._option.material)) {
                                                that._option.material = that._color.colorFromHtmlColor(that._option.material);
                                            } else {
                                                if (/^rgb/.test(that._option.material)) {
                                                    that._option.material = that._color.rgbaStringToRgbaObj(that._option.material);
                                                }
                                                if (that._option.material.red > 1) {
                                                    that._option.material.red = that._option.material.red / 255;
                                                }
                                                if (that._option.material.green > 1) {
                                                    that._option.material.green = that._option.material.green / 255;
                                                }
                                                if (that._option.material.blue > 1) {
                                                    that._option.material.blue = that._option.material.blue / 255;
                                                }
                                                if (that._option.material.alpha > 1) {
                                                    that._option.material.a = that._option.material.alpha / 255;
                                                }
                                                that._option.material = that._color.createColor(that._option.material.red, that._option.material.green, that._option.material.blue, that._option.material.alpha);
                                            }

                                        }
                                    }

                                    var pos = Cesium.Cartesian3.fromDegreesArray(newArr);
                                    feature.positions = pos;
                                    that._option.polygonHierarchy = new Cesium.PolygonHierarchy(pos);
                                    var extrudedPolygon = new Cesium.PolygonGeometry(that._option);
                                    var geometry = Cesium.PolygonGeometry.createGeometry(extrudedPolygon);
                                    //图例
                                    var col = "material:" + options.material.red * 255 + "," + options.material.green * 255 + "," + options.material.blue * 255;
                                    that.Legend.push(col);
                                    new Cesium.GeometryInstance({
                                        id: feature,  //拾取属性修改
                                        geometry: geometry,
                                        attributes: {
                                            color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(that._option.material)
                                        }
                                    });
                                    var primitive = new Cesium.ClassificationPrimitive({
                                        geometryInstances: geometries,
                                        appearance: new Cesium.PerInstanceColorAppearance({
                                            closed: true,
                                            flat: false
                                        }),
                                        classificationType: that._option.classificationType,
                                        shadows: Cesium.ShadowMode.ENABLED
                                    });
                                    collection.add(primitive);
                                }
                                tile.data.geometryPrimitive = collection;
                            },
                            error: function () {
                                downLoadTiles = lodash.remove(downLoadTiles, function (o) {
                                    return o.x == tile.x && o.y == tile.y && o.level == tile.level;
                                });
                            },
                            complete: function () {
                                tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                                if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                    if (tile.data.geometryPrimitive)
                                        tile.data.geometryPrimitive.update(frameState, []);
                                    tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                    tile.renderable = true;
                                }
                            }
                        });
                    })(tile);
                } else {
                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                    if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                        if (tile.data.geometryPrimitive)
                            tile.data.geometryPrimitive.update(frameState, []);
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                    }
                    return;
                }
            }
        };

        this._primitive = new that._cesium.QuadtreePrimitive({
            tileProvider: this._Provider
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(that._option.id)) {
            that._option.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + that._option.id;
        }
        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: that._option.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polygonLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
    };

    /**
     * 创建VolumeGeoJsonFeatureLayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *       radius: 2,
            material: "#FFFFFF",
            show: true
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    PolygonVectorGeoJsonFeatureLayer.prototype.createVolumeGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var defaultOptions = {
            polylinePositions: undefined,
            shapePositions: undefined,
            ellipsoid: this._cesium.Ellipsoid.WGS84,
            granularity: this._cesium.Math.RADIANS_PER_DEGREE,
            vertexFormat: this._cesium.VertexFormat.DEFAULT,
            cornerType: this._cesium.CornerType.ROUNDED
        };
        // var options = this._core.extend(defaultOptions, option, true);
        if (geojsonOrurl == undefined)
            console.log('geojson is required');
        var dataSource = null;
        if (geojsonOrurl.then) {
            dataSource = geojsonOrurl;
        } else {
            dataSource = this._cesium.GeoJsonDataSource.load(geojsonOrurl);
        }
        var that = this;
        var geometries = [];

        defaultOptions.shapePositions = this.computeCircle(option.radius);
        dataSource.then(function (dataSource) {
            //填充颜色设置
            var material = that._cesium.Color.WHITE;
            if (!that._core.isnull(option) && !that._core.isnull(option.material)) {
                if (option.material.toString().charAt(0) == "[" && option.material.toString().charAt(option.material.length - 1) == "]") {
                    material = option.material.replace(/\[/, '').replace('/\]/', '');
                } else {
                    material = lodash.clone(option.material);
                }
                {
                    if (that._core.isHtmlColor(material)) {
                        material = that._color.colorFromHtmlColor(option.material);
                    } else {
                        if (/^rgb/.test(material)) {
                            material = that._color.rgbaStringToRgbaObj(material);
                        }
                        if (material.r > 1) {
                            material.r = material.r / 255;
                        }
                        if (material.g > 1) {
                            material.g = material.g / 255;
                        }
                        if (material.b > 1) {
                            material.b = material.b / 255;
                        }
                        if (material.a > 1) {
                            material.a = material.a / 255;
                        }
                        material = that._color.createColor(material.r, material.g, material.b, material.a);
                    }
                }
            }
            var entities = dataSource.entities.values;
            for (var i = 0; i < entities.length; i++) {
                var entity = entities[i];
                defaultOptions.polylinePositions = entity.polyline.positions._value;

                var extrudedPolyline = new that._cesium.PolylineVolumeGeometry(defaultOptions);
                var geometry = that._cesium.PolylineVolumeGeometry.createGeometry(extrudedPolyline);
                var geometryInstance = new that._cesium.GeometryInstance({
                    geometry: geometry,
                    // attributes: {
                    //     color: new that._cesium.ColorGeometryInstanceAttribute.fromColor(material),
                    // }
                });
                geometries.push(geometryInstance);
            }
            var ps = that._viewer.scene.primitives.add(new that._cesium.Primitive({
                geometryInstances: geometries,
                appearance: new that._cesium.MaterialAppearance({
                    material: new that._cesium.Material({
                        fabric: {
                            type: 'Color',
                            uniforms: {
                                color: material
                            }
                        }
                    }),
                    faceForward: true,
                    flat: false
                }),
                // appearance: new that._cesium.PerInstanceColorAppearance({
                //     flat: true,
                //     translucent: true,
                //     faceForward: true,
                //     closed: true
                // }),
                // shadows: Cesium.ShadowMode.ENABLED
            }));
            that.item = ps;
            if (option.show == false) {
                ps.show = false;
            }
            //执行回调函数
            if (typeof disFnc == 'function') {
                disFnc(ps);
            }
        });
        if (this._core.isnull(option.id)) {
            option.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建管状图层" + option.id;
        }
        //导出工程树
        var obj = {
            id: option.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineVolumeLayer',
            item: this,
            url: geoOptions.url,
            style: option
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        return this;
    };
    /**
     * 生成管状数据
     * @param {Float} radians
     */
    PolygonVectorGeoJsonFeatureLayer.prototype.computeCircle = function (radius) {
        if (this._core.isnull(radius)) {
            radius = 4;
        }
        var positions = [];
        for (var i = 0; i < 360; i++) {
            var radians = this._cesium.Math.toRadians(i);
            positions.push(new this._cesium.Cartesian2(radius * Math.cos(radians), radius * Math.sin(radians)));
        }
        return positions;
    };
    /**
     * geojson管线矢量图层
     * @param {String} [name] 图层名称
     * @param {object} [geoOptions] geojosn图层
     *       url: 'http://192.168.1.40:8090/geoserver/gwc/service/wmts',
     *       layer:'nanjing',
     upperLevelLimit: 13,
     lowerLevelLimit: 13,
     minx:118.51721649800015,
     miny:31.863232407499936,
     maxx:118.91648798400001,
     maxy:32.27649160409993
     * @param {object} [styleOption] 图层样式
     material: this._cesium.Color.WHITE, //    optional A Property specifying the material used to draw the polyline.
     radius:3
     * @param {Float}  [GroupID] 组itemID
     * @param {object} [disFnc] 回调函数
     */
    PolygonVectorGeoJsonFeatureLayer.prototype.createVolumeGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        /**
         * 默认样式
         */
        var defaultOptions = {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.RECEIVE_ONLY, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
        };
        var defaultGeoOptions = {
            url: geoOptions.url,
            urlParams: {
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: geoOptions.layer,
                STYLE: '',
                TILEMATRIX: 'EPSG:4490:{z}',
                TILEMATRIXSET: 'EPSG:4490',
                FORMAT: 'application/json;type=geojson',
                TILECOL: '{x}',
                TILEROW: '{y}'
            },
            upperLevelLimit: geoOptions.upperLevelLimit,
            lowerLevelLimit: geoOptions.lowerLevelLimit,
            // rectangle: this._cesium.Rectangle.fromDegrees(geoOptions.minx, geoOptions.miny, geoOptions.maxx, geoOptions.maxy),
            Cesium: this._cesium
        };
        //填充颜色设置
        if (!this._core.isnull(styleOption) && !this._core.isnull(styleOption.material)) {
            if (styleOption.material.toString().charAt(0) == "[" && styleOption.material.toString().charAt(styleOption.material.length - 1) == "]") ; else {
                if (this._core.isHtmlColor(styleOption.material)) {
                    styleOption.material = this._color.colorFromHtmlColor(styleOption.material);
                } else {
                    if (/^rgb/.test(styleOption.material)) {
                        styleOption.material = this._color.rgbaStringToRgbaObj(styleOption.material);
                    }
                    if (styleOption.material.r > 1) {
                        styleOption.material.r = styleOption.material.r / 255;
                    }
                    if (styleOption.material.g > 1) {
                        styleOption.material.g = styleOption.material.g / 255;
                    }
                    if (styleOption.material.b > 1) {
                        styleOption.material.b = styleOption.material.b / 255;
                    }
                    if (styleOption.material.a > 1) {
                        styleOption.material.a = styleOption.material.a / 255;
                    }
                    styleOption.material = this._color.createColor(styleOption.material.r, styleOption.material.g, styleOption.material.b, styleOption.material.a);
                }
            }
        }
        var options = this._core.extend(defaultOptions, styleOption, true);
        //this.options=options;
        /**
         * 请求矢量切片
         */

        var geoJSONVectorTileProvider = new GeoJSONVectorTileProvider(this._viewer, this._cesium, defaultGeoOptions);
        this._Provider = geoJSONVectorTileProvider;
        var _this = this;
        geoJSONVectorTileProvider._loadTile = function (json) {
            //测试
            var collection = new _this._cesium.PrimitiveCollection();
            json.features.forEach(function (feature) {

                var pos = [];
                //fun(feature.geometry.coordinates);
                if (/^\[/.test(styleOption.material) && /\]$/.test(styleOption.material)) {
                    var material = styleOption.material.replace(/\[/, '').replace(/\]/, '');
                    options.material = feature.properties[material];
                    //填充颜色设置
                    if (that._core.isHtmlColor(options.material)) {
                        options.material = that._color.colorFromHtmlColor(options.material);
                    } else {
                        if (/^rgb/.test(options.material)) {
                            options.material = that._color.rgbaStringToRgbaObj(options.material);
                        }
                        if (options.material.r > 1) {
                            options.material.r = options.material.r / 255;
                        }
                        if (options.material.g > 1) {
                            options.material.g = options.material.g / 255;
                        }
                        if (options.material.b > 1) {
                            options.material.b = options.material.b / 255;
                        }
                        if (options.material.a > 1) {
                            options.material.a = options.material.a / 255;
                        }
                        options.material = that._color.createColor(options.material.r, options.material.g, options.material.b, options.material.a);
                    }
                }
                //var pos = _this._cesium.Cartesian3.fromDegreesArray(newArr);

                for (var i = 0; i < feature.geometry.coordinates.length; i++) {
                    var up = feature.geometry.coordinates[i];

                    if (up.length > 0) {
                        if (Array.isArray(up[0])) {
                            for (var j = 0; j < up.length; j++) {
                                var child = up[j];
                                var childFt = _this._cesium.Cartesian3.fromDegrees(child[0], child[1], options.height);
                                pos.push(childFt);
                            }
                        } else {
                            var ft = _this._cesium.Cartesian3.fromDegrees(up[0], up[1], options.height);
                            pos.push(ft);
                        }
                    }

                    //var ft=_this._cesium.Cartesian3.fromDegrees(up[0],up[1],options.height);
                    //pos.push(ft);
                }
                options.position = pos;
                feature.positions = pos;
                if (options.slttype == "0" || options.slttype == 0) {
                    options.shape = _this._core.computeCircle(options.radius);
                } else if (options.slttype == "1" || options.slttype == 1) {
                    options.shape = _this._core.starPositions(options.number, options.exradius, options.inradius);
                } else if (options.slttype == "2" || options.slttype == 2) {
                    var x = options.orth_width / 2;
                    var y = options.orth_height / 2;
                    options.shape = [new _this._cesium.Cartesian2(-x, -y),
                    new _this._cesium.Cartesian2(x, -y),
                    new _this._cesium.Cartesian2(x, y),
                    new _this._cesium.Cartesian2(-x, y)];
                }
                //options.shape = _this.computeCircle(styleOption.radius);
                var dx = {
                    polylinePositions: options.position,
                    shapePositions: options.shape,
                    cornerType: options.cornerType,
                    VertexFormat: {
                        bitangent: true,
                        color: true,
                        position: true,
                        st: true,
                        normal: true,
                        tangent: true
                    }
                };
                var volime = new _this._cesium.PolylineVolumeGeometry(dx);
                var geometry = _this._cesium.PolylineVolumeGeometry.createGeometry(volime);
                var geometryInstance = new _this._cesium.GeometryInstance({
                    id: feature,
                    geometry: geometry,
                    attributes: {
                        color: new _this._cesium.ColorGeometryInstanceAttribute.fromColor(options.material),
                    }
                });
                //geomInstances.push(geometryInstance);
                var primitive = new _this._cesium.Primitive({
                    allowPicking: true,
                    appearance: new _this._cesium.MaterialAppearance({
                        material: new _this._cesium.Material({
                            fabric: {
                                type: 'Color',
                                uniforms: {
                                    // color: Cesium.Color.fromRandom({ alpha: 1.0 })
                                    color: options.material
                                }
                            }
                        }),
                        faceForward: true,
                        flat: false
                    }),
                    shadows: options.shadows,
                    geometryInstances: geometryInstance
                });
                collection.add(primitive);
            });
            return collection;
        };
        this.item = geoJSONVectorTileProvider._primitiveCollection;
        geoJSONVectorTileProvider.addTo(this._viewer);
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        this.west = geoOptions.minx;
        this.south = geoOptions.miny;
        this.east = geoOptions.maxx;
        this.north = geoOptions.maxy;
        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: checked,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'polylineVolumeLayer',
            item: this,
            url: geoOptions.url,
            style: styleOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
    };
    //工程树添加
    PolygonVectorGeoJsonFeatureLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
     * 导出工程数据
     */
    PolygonVectorGeoJsonFeatureLayer.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url
            }
        };
    };
    /**
     * 删除数据
     */
    PolygonVectorGeoJsonFeatureLayer.prototype.deleteObject = function () {
        this._viewer.scene.primitives.remove(this.item);
        try {
            this._Provider.remove();
        } catch (ex) {
        }
    };
    /**
     * 设置数据是否刷新
     */
    PolygonVectorGeoJsonFeatureLayer.prototype.setRefresh = function (b) {
        try {
            if (this._Provider) {
                this._Provider.setStatus(b);
            }
        } catch (ex) {
        }
    };
    /**
     * 设置数据显示隐藏
     */
    PolygonVectorGeoJsonFeatureLayer.prototype.setVisibility = function (b) {
        try {
            if (this.item != undefined && this.item.show != undefined) {
                this.item.show = b;
            }
            if (this._Provider) {
                this._Provider.setStatus(b);
            }
        } catch (ex) {
        }
    };

    /**
     * 是否强制清除缓存
     * @param {Boolean} b 
     */
    PolygonVectorGeoJsonFeatureLayer.prototype.isCache = function (b) {
        this._cache = b;
    };

    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    PolygonVectorGeoJsonFeatureLayer.prototype.edit = function (open, option) {
        this.isEditting = open;
        this.editoption = option;
        return this._Provider && this._Provider.edit && this._Provider.edit(open, option);
    };
    /**
    * 设置数据是否刷新
    */
    PolygonVectorGeoJsonFeatureLayer.prototype.forceRefresh = function () {
        try {
            // this._cache = true;
            // if (!this._forceRefreshPrvimitive)
            //     this._forceRefreshPrvimitive = loadsh.cloneDeep(this._primitive)
            // var temp = loadsh.cloneDeep(this._forceRefreshPrvimitive)
            // this._viewer.scene.primitives.remove(this._primitive);
            // this._viewer.scene.primitives.add(temp);
            // this._viewer.scene.primitivesQuadTrees.push(temp);
            // // this.edit(this.isEditting, this.editoption);
            // // temp._tileProvider.edit(this.isEditting, this.editoption);

            for (var i = 0; i < this._Provider.quadtree._levelZeroTiles.length; i++) {
                this._Provider.quadtree._levelZeroTiles[i].freeResources();
            }
        } catch (ex) {
        }
    };

    /**
     *
     * 天空盒子
     *
     * @alias SkyBox
     * @constructor
     *
     */
    function SkyBox(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this.SkyBoxFS = "uniform samplerCube u_cubeMap;\nvarying vec3 v_texCoord;\nvoid main()\n{\nvec4 color = textureCube(u_cubeMap, normalize(v_texCoord));\ngl_FragColor = vec4(czm_gammaCorrect(color).rgb, czm_morphTime);\n}\n";
        this.SkyBoxVS = "attribute vec3 position;\nuniform mat3 u_rotateMatrix;\nvarying vec3 v_texCoord;\nvoid main()\n{\nvec3 p = czm_viewRotation * u_rotateMatrix * (czm_temeToPseudoFixed * (czm_entireFrustum.y * position));\ngl_Position = czm_projection * vec4(p, 1.0);\nv_texCoord = position.xyz;\n}\n";
    }

    /**
     * 设置空间背景图。
     * @param {Object} [URL] 背景图。
     *
     */
    SkyBox.prototype.setSpaceBackground = function (URL) {
        this.clear && this.clear();
        this._viewer.container.style.backgroundImage = 'url(' + URL + ')';
        this._viewer.scene.backgroundColor = new this._cesium.Color(0.0, 0.0, 0.0, 0.0);
        this._viewer.scene.skyAtmosphere.show = false;
        this._viewer.scene.skyBox && (this._viewer.scene.skyBox.show = false);

        this.clear = () => {
            this._viewer.container.style.backgroundImage = 'unset';
            this._viewer.scene.skyBox && (this._viewer.scene.skyBox.show = true);
            this._viewer.scene.backgroundColor = new this._cesium.Color(0.0, 0.0, 0.0, 1.0);
            this._viewer.scene.skyAtmosphere.show = true;
        };
        return this;
    };

    /**
     * 向三维场景中添加天空盒子。
     * @param {Boolean} [NearGround] 是否近地。
     * @param {Object} [Images] 天空盒子图。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    SkyBox.prototype.SkyBox = function (NearGround, Images) {
        if (!this.defaultSky) {
            this.defaultSky = this._viewer.scene.skyBox;
            this.defaultSky && !this.defaultSky.show && (this.defaultSky.show = true);
        }

        this.NearGround = NearGround;
        var _this = this;
        var viewer = this._viewer;
        var SkyBox = this.getSkyBox(Images);
        this._SkyBox = SkyBox;
        viewer.scene.skyBox = SkyBox;

        if (NearGround) {
            this._viewer.scene.postRender.addEventListener(isNearGround);
        }

        function isNearGround() {
            var e = viewer.camera.position; // < 23e4
            if (_this._cesium.Cartographic.fromCartesian(e).height < 23e4) {
                SkyBox && (viewer.scene.skyBox = SkyBox);
                viewer.scene.skyAtmosphere.show = false;
            } else {
                _this.defaultSky && (viewer.scene.skyBox = _this.defaultSky);
                viewer.scene.skyAtmosphere.show = true;
            }
        }

        this.clear = function () {
            _this.defaultSky && (_this._viewer.scene.skyBox = _this.defaultSky);
            _this.defaultSky = undefined;
            _this._viewer.scene.skyAtmosphere.show = true;
            if (_this.NearGround) {
                _this._viewer.scene.postRender.removeEventListener(isNearGround);
            }
            _this.clear = undefined;
        };

        return this;
    };


    /**
     * 获取天空盒子。
     *
     */
    SkyBox.prototype.getSkyBox = function (images) {
        var _this = this;
        var SkyBox = new this._cesium.SkyBox({
            sources: images
        });
        if (this.NearGround) {
            SkyBox.update = function (e, t) {
                var i = this;
                if (this.show && (e.mode === _this._cesium.SceneMode.SCENE3D || e.mode === _this._cesium.SceneMode.MORPHING) && e.passes.render) {
                    var r = e.context;
                    if (this._sources !== this.sources) {
                        this._sources = this.sources;
                        var n = this.sources;
                        "string" == typeof n.positiveX ? _this._cesium.loadCubeMap(r, this._sources).then(function (e) {
                            i._cubeMap = i._cubeMap && i._cubeMap.destroy(),
                                i._cubeMap = e;
                        }) : (this._cubeMap = this._cubeMap && this._cubeMap.destroy(),
                            this._cubeMap = new _this._cesium.CubeMap({
                                context: r,
                                source: n
                            }));
                    }
                    var a = this._command;
                    if (!_this._cesium.defined(a.vertexArray)) {
                        a.uniformMap = {
                            u_cubeMap: function () {
                                return i._cubeMap
                            },
                            u_rotateMatrix: function () {
                                return _this.NearGround ? (a.modelMatrix = _this._cesium.Transforms.eastNorthUpToFixedFrame(e.camera._positionWC),
                                    _this._cesium.Matrix4.getMatrix3(a.modelMatrix, new _this._cesium.Matrix3)) : _this._cesium.Matrix3.IDENTITY
                            }
                        };
                        var o = _this._cesium.BoxGeometry.createGeometry(_this._cesium.BoxGeometry.fromDimensions({
                            dimensions: new _this._cesium.Cartesian3(2, 2, 2),
                            vertexFormat: _this._cesium.VertexFormat.POSITION_ONLY
                        }))
                            , s = this._attributeLocations = _this._cesium.GeometryPipeline.createAttributeLocations(o);
                        a.vertexArray = _this._cesium.VertexArray.fromGeometry({
                            context: r,
                            geometry: o,
                            attributeLocations: s,
                            bufferUsage: _this._cesium.BufferUsage.STATIC_DRAW
                        }),
                            a.renderState = _this._cesium.RenderState.fromCache({
                                blending: _this._cesium.BlendingState.ALPHA_BLEND
                            });
                    }
                    if (!_this._cesium.defined(a.shaderProgram) || this._useHdr !== t) {
                        var l = new _this._cesium.ShaderSource({
                            defines: [t ? "HDR" : ""],
                            sources: [_this.SkyBoxFS]
                        });
                        a.shaderProgram = _this._cesium.ShaderProgram.fromCache({
                            context: r,
                            vertexShaderSource: _this.SkyBoxVS,
                            fragmentShaderSource: l,
                            attributeLocations: this._attributeLocations
                        }),
                            this._useHdr = t;
                    }
                    if (_this._cesium.defined(this._cubeMap))
                        return a
                }
            };
        }
        return SkyBox;
    };

    /**
     *
     * 这个方法用于实现流场
     *
     * @alias FlowField
     * @constructor
     *
     */
    function FlowField(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
    }

    /**
     * 这个方法用于添加风场
     *@param {string} [url] 风场配置文件url
     *@param {Object} [option] 参数。{
     *     color:颜色，默认'#ffffff'
     *     speed:速度，默认0.15
     *     num:粒子数，默认2000
     *     maxAge:最大存活时间，默认10
     *     brighten:亮度，默认1.5
     *}
     */
    FlowField.prototype.createWindField = function (url, option) {
        var _this = this;
        this.WindFieldOption = {
            color: this._cesium.Color.WHITE,
            speed: 0.15,   //速度
            num: 2000,    //粒子数
            maxAge: 10,   //最大存活时间
            brighten: 1.5 //亮度
        };
        if (!option) {
            option = {};
        }
        option.color && (option.color = this._cesium.Color.fromCssColorString(option.color));

        this.WindFieldOption = this._core.extend(this.WindFieldOption, option, false);

        this.destroy();
        this.windData = undefined;
        this.windField = undefined;
        this.particles = [];
        this.lines = undefined;
        this.timer = undefined;
        this.primitives = this._viewer.scene.primitives;

        $.ajax({
            type: "get",
            async: false,
            url: url,
            dataType: "json",
            success: function (response) {
                _this.windData = response;
                _this._init();

                _this.timer = setInterval(function () {
                    _this.animate();
                }, 200);
            },
            error: function (errorMsg) {
                console.log("请求风场数据失败!");
            }
        });
        return this;
    };

    FlowField.prototype._init = function () {
        // 创建风场网格
        this.windField = this.createField();
        // 创建风场粒子
        for (var i = 0; i < this.WindFieldOption.num; i++) {
            this.particles.push(this.randomParticle(new Particle()));
        }
    };

    FlowField.prototype.createField = function () {
        var data = this._parseWindJson();
        return new WindField(data);
    };

    FlowField.prototype.animate = function () {
        var self = this,
            field = self.windField,
            particles = self.particles;

        var instances = [],
            nextX = null,
            nextY = null,
            uv = null;
        particles.forEach(function (particle) {
            if (particle.age <= 0) {
                self.randomParticle(particle);
            }
            if (particle.age > 0) {
                var x = particle.x,
                    y = particle.y;

                if (!field.isInBound(x, y)) {
                    particle.age = 0;
                } else {
                    uv = field.getIn(x, y);
                    nextX = x + self.WindFieldOption.speed * uv[0];
                    nextY = y + self.WindFieldOption.speed * uv[1];
                    particle.path.push(nextX, nextY);
                    particle.x = nextX;
                    particle.y = nextY;
                    instances.push(self._createLineInstance(self._map(particle.path), particle.age / particle.birthAge));
                    particle.age--;
                }
            }
        });
        if (instances.length <= 0) this.removeLines();
        self._drawLines(instances);
    };

    FlowField.prototype._parseWindJson = function () {
        var uComponent = null,
            vComponent = null,
            header = null;
        this.windData.forEach(function (record) {
            var type = record.header.parameterCategory + "," + record.header.parameterNumber;
            switch (type) {
                case "2,2":
                    uComponent = record['data'];
                    header = record['header'];
                    break;
                case "2,3":
                    vComponent = record['data'];
                    break;
            }
        });
        return {
            header: header,
            uComponent: uComponent,
            vComponent: vComponent
        };
    };

    //移除
    FlowField.prototype.removeLines = function () {
        if (this.lines) {
            this.primitives.remove(this.lines);
            this.lines.destroy();
        }
    };

    //求路径上点
    FlowField.prototype._map = function (arr) {
        var length = arr.length,
            field = this.windField,
            dx = field.dx,
            dy = field.dy,
            west = field.west,
            south = field.north,
            newArr = [];
        for (var i = 0; i <= length - 2; i += 2) {
            newArr.push(
                west + arr[i] * dx,
                south - arr[i + 1] * dy
            );
        }
        return newArr;
    };
    FlowField.prototype._createLineInstance = function (positions, ageRate) {
        var colors = [],
            length = positions.length,
            count = length / 2;
        for (var i = 0; i < length; i++) {
            colors.push(this.WindFieldOption.color === 'random' ? this._cesium.Color.fromRandom({ alpha: i / count * ageRate * this.WindFieldOption.brighten }) : this.WindFieldOption.color.withAlpha(i / count * ageRate * this.WindFieldOption.brighten));
        }
        return new this._cesium.GeometryInstance({
            geometry: new this._cesium.PolylineGeometry({
                positions: this._cesium.Cartesian3.fromDegreesArray(positions),
                colors: colors,
                width: 1.5,
                colorsPerVertex: true
            })
        });
    };

    FlowField.prototype._drawLines = function (lineInstances) {
        this.removeLines();
        var linePrimitive = new this._cesium.Primitive({
            appearance: new this._cesium.PolylineColorAppearance({
                translucent: true
            }),
            geometryInstances: lineInstances,
            asynchronous: false
        });
        this.lines = this.primitives.add(linePrimitive);
    };
    FlowField.prototype.randomParticle = function (particle) {
        var safe = 30, x, y;

        do {
            x = Math.floor(Math.random() * (this.windField.cols - 2));
            y = Math.floor(Math.random() * (this.windField.rows - 2));
        } while (this.windField.getIn(x, y)[2] <= 0 && safe++ < 30);

        particle.x = x;
        particle.y = y;
        particle.age = Math.round(Math.random() * this.WindFieldOption.maxAge);//每一次生成都不一样
        particle.birthAge = particle.age;
        particle.path = [x, y];
        return particle;
    };

    /**
     * 改变颜色
     */
    FlowField.prototype.changeColor = function (color) {
        if (color === 'random') {
            this.WindFieldOption.color = color;
        } else {
            this.WindFieldOption.color = this._cesium.Color.fromCssColorString(color);
        }
    };

    /**
     * 速度
     */
    FlowField.prototype.setSpeed = function (speed) {
        this.WindFieldOption.speed = speed;
    };

    /**
     * 最大存活时间
     */
    FlowField.prototype.setMaxAge = function (age) {
        this.WindFieldOption.maxAge = age;
    };

    /**
     * 亮度
     */
    FlowField.prototype.setBrighten = function (brighten) {
        this.WindFieldOption.brighten = brighten;
    };

    /**
     * 这个方法用于移除流场
     */
    FlowField.prototype.destroy = function () {
        this.timer && clearInterval(this.timer);
        this.timer = undefined;
        this.removeLines();
    };

    //粒子参数
    var Particle = function () {
        this.x = null;
        this.dx = null;
        this.dx = null;
        this.y = null;
        this.age = null;
        this.birthAge = null;
        this.path = null;
    };

    var WindField = function (obj) {
        this.west = null;
        this.east = null;
        this.south = null;
        this.north = null;
        this.rows = null;
        this.cols = null;
        this.dx = null;
        this.dy = null;
        this.unit = null;
        this.date = null;

        this.grid = null;
        this._init(obj);
    };

    WindField.prototype = {
        constructor: WindField,
        _init: function (obj) {
            var header = obj.header,
                uComponent = obj['uComponent'],
                vComponent = obj['vComponent'];

            this.west = +header['lo1'];
            this.east = +header['lo2'];
            this.south = +header['la2'];
            this.north = +header['la1'];
            this.rows = +header['ny'];
            this.cols = +header['nx'];
            this.dx = +header['dx'];
            this.dy = +header['dy'];
            this.unit = header['parameterUnit'];
            this.date = header['refTime'];

            this.grid = [];
            var k = 0,
                rows = null,
                uv = null;
            for (var j = 0; j < this.rows; j++) {
                rows = [];
                for (var i = 0; i < this.cols; i++, k++) {
                    uv = this._calcUV(uComponent[k], vComponent[k]);
                    rows.push(uv);
                }
                this.grid.push(rows);
            }
        },
        _calcUV: function (u, v) {
            return [+u, +v, Math.sqrt(u * u + v * v)];
        },
        _bilinearInterpolation: function (x, y, g00, g10, g01, g11) {
            var rx = (1 - x);
            var ry = (1 - y);
            var a = rx * ry, b = x * ry, c = rx * y, d = x * y;
            var u = g00[0] * a + g10[0] * b + g01[0] * c + g11[0] * d;
            var v = g00[1] * a + g10[1] * b + g01[1] * c + g11[1] * d;
            return this._calcUV(u, v);
        },
        getIn: function (x, y) {
            var x0 = Math.floor(x),
                y0 = Math.floor(y),
                x1, y1;
            if (x0 === x && y0 === y) return this.grid[y][x];

            x1 = x0 + 1;
            y1 = y0 + 1;

            var g00 = this.getIn(x0, y0),
                g10 = this.getIn(x1, y0),
                g01 = this.getIn(x0, y1),
                g11 = this.getIn(x1, y1);
            return this._bilinearInterpolation(x - x0, y - y0, g00, g10, g01, g11);
        },
        isInBound: function (x, y) {
            if ((x >= 0 && x < this.cols - 2) && (y >= 0 && y < this.rows - 2)) return true;
            return false;
        }
    };

    /**
     * 流光线图层对象
     *
     * @alias Streamerpath
     * @constructor
     *
     * @param {Viewer} Viewer 地图视图。
     * 
     * @example
     * streamerpath = new SmartEarth.Streamerpath(Viewer);
     */
    function Streamerpath(Viewer) {
        this._viewer = Viewer;
        this.PrimitiveCollection = [];
        this.lineColor = Cesium.Color.fromCssColorString('#330066').withAlpha(.8);
        this.pointColor = Cesium.Color.fromCssColorString('#CCFFFF').withAlpha(1);
    }
    /**
     * 添加流光线图层。
     * @param {Object} [option] 参数。
     * @param {String} [option.id] id（可选）。
     * @param {Array} [option.position] 单条线。
     * @param {Array} [option.positions] 多条线。
     * @param {String} [option.lineColor="#0033FF"] 线颜色。
     * @param {Number} [option.lineAlpha=1.0] 线透明度。
     * @param {Number} [option.linewidth=5.0] 线宽。
     * @param {String} [option.pointColor="#FFFFFF"] 点颜色。
     * @param {Number} [option.pointAlpha=1.0] 点透明度。
     * @param {Number} [option.near=0] 最小可视距离。
     * @param {Number} [option.far=Math.MAX_VALUE] 最大可视距离。
     * @param {Number} [option.speed=1] 点移动速度。
     *
     */
    Streamerpath.prototype.create = function (option = {}) {
        this.position = option.position || void 0;
        this.positions = option.positions || void 0;
        this.linewidth = option.linewidth || void 0;
        this.near = option.near;
        this.far = option.far;
        this._speed = option.speed;
        Cesium.defined(this._speed) || (this._speed = 1);
        this._id = option.id;
        option.lineColor && (this.lineColor = Cesium.Color.fromCssColorString(option.lineColor).withAlpha(option.lineAlpha || 1));
        option.pointColor && (this.pointColor = Cesium.Color.fromCssColorString(option.pointColor).withAlpha(option.pointAlpha || 1));
        this.getShader();
        this.collection = new Cesium.PrimitiveCollection;
        this.collection._guid = this._id;
        this._viewer.scene.primitives.add(this.collection);
        this.position ? this.getInstance() : this.positions && this.getInstances();
        this.addGroundLine();
        this.PrimitiveCollection.push(this.collection);
    };
    Streamerpath.prototype.getById = function (i) {
        for (var item = null, P2 = this._viewer.scene.primitives, o = P2.length, n = 0; n < o; n++) {
            var p_PKAmE3 = P2.get(n);
            p_PKAmE3._guid === i && (item = p_PKAmE3);
        }
        return item
    };
    Streamerpath.prototype.remove = function (i) {
        var path = this.getById(i);
        path && this._viewer.scene.primitives.remove(path);
    };
    Streamerpath.prototype.removeAll = function () {
        for (var i = 0; i < this.PrimitiveCollection.length; i++) {
            var Primitive = this.PrimitiveCollection[i];
            this._viewer.scene.primitives.remove(Primitive);
        }
        this.PrimitiveCollection = [];
    };
    Streamerpath.prototype.show = function (show) {
        for (var i = 0; i < this.PrimitiveCollection.length; i++) {
            var Primitive = this.PrimitiveCollection[i];
            Primitive.show = show;
        }
        //this.PrimitiveCollection = []
    };
    Streamerpath.prototype.getInstance = function () {
        let positions;
        if (this.position[0] instanceof Cesium.Cartesian3) {
            positions = this.position;
        } else {
            positions = Cesium.Cartesian3.fromDegreesArray(this.position);
        }
        let geometry = new Cesium.GroundPolylineGeometry({
            positions: positions,
            width: this.linewidth,
            vertexFormat: Cesium.PolylineColorAppearance.VERTEX_FORMAT
        });
        this.instances = new Cesium.GeometryInstance({
            geometry: geometry,
            attributes: {
                distanceDisplayCondition: new Cesium.DistanceDisplayConditionGeometryInstanceAttribute(this.near, this.far)
            }
        });
    };
    Streamerpath.prototype.getInstances = function () {
        this.instances = [];
        for (let i = 0; i < this.positions.length; i++) {
            let positions;
            if (this.positions[i][0] instanceof Cesium.Cartesian3) {
                positions = this.positions[i];
            } else {
                positions = Cesium.Cartesian3.fromDegreesArray(this.positions[i]);
            }
            let GeometryInstance = new Cesium.GeometryInstance({
                geometry: new Cesium.GroundPolylineGeometry({
                    positions: positions,
                    width: this.linewidth,
                    vertexFormat: Cesium.PolylineColorAppearance.VERTEX_FORMAT
                }),
                attributes: {
                    distanceDisplayCondition: new Cesium.DistanceDisplayConditionGeometryInstanceAttribute(this.near, this.far)
                }
            });
            this.instances.push(GeometryInstance);
        }
    };
    Streamerpath.prototype.addGroundLine = async function () {
        this.instances.forEach(instance => {
            let Primitive = new Cesium.GroundPolylinePrimitive({
                geometryInstances: instance,
                appearance: new Cesium.MaterialAppearance({
                    material: new Cesium.Material({
                        fabric: {
                            source: this.fs,
                            uniforms: {
                                u_moveColor: this.pointColor,
                                u_lineColor: this.lineColor
                            }
                        }
                    })
                })
            });
            this.collection.add(Primitive);
        });
    };
    Streamerpath.prototype.addLine = function () {
        var appearance = new Cesium.PolylineMaterialAppearance({
            material: new Cesium.Material({
                fabric: {
                    source: this.fs,
                    uniforms: {
                        u_moveColor: this.pointColor,
                        u_lineColor: this.lineColor
                    }
                }
            })
        });
        let Primitive = new Cesium.Primitive({
            geometryInstances: this.instances,
            appearance: appearance
        });
        this.collection.add(Primitive);
    };
    Streamerpath.prototype.getShader = function () {
        this.fs = `
        \tuniform vec4 u_moveColor;
        \tuniform vec4 u_lineColor;
        #define PI_OVER_TWO 1.5707963
        \tczm_material czm_getMaterial(czm_materialInput materialInput){
            czm_material material = czm_getDefaultMaterial(materialInput);
            float iTime = czm_frameNumber / 60.0 * ${this._speed.toFixed(1)};
            vec2 uv = materialInput.st;
            vec4 finalColor = u_lineColor;
            float dt = clamp(tan(uv.x * 5.0  - iTime * 1.0) * 0.3 - 0.1, 0.5, PI_OVER_TWO);
            finalColor = mix(finalColor, u_moveColor, dt);
            float alpha = pow(finalColor.w * (1.0 - abs(uv.y - 0.5)), 2.0);
            material.diffuse = finalColor.xyz;
            material.alpha = alpha;
            return material;
        }
    `;
    };

    /**
     * 动态墙图层对象
     *
     * @alias Streamerwall
     * @constructor
     *
     * @param {Viewer} Viewer 地图视图。
     * 
     * @example
     * streamerpath = new SmartEarth.Streamerwall(Viewer);
     */
    function Streamerwall(Viewer) {
        this._viewer = Viewer;
        this.PrimitiveCollection = [];
        this.color = Cesium.Color.BLUE;
    }
    /**
     * 添加动态墙图层。
     * @param {Object} [option] 参数。
     * @param {String} [option.id] id（可选）。
     * @param {Array} [option.position] 单条线。
     * @param {Array} [option.positions] 多条线。
     * @param {String} [option.color="#0033FF"] 颜色。
     * @param {Number} [option.height=50] 墙高。
     * @param {Number} [option.minHeight] 底部高度。
     * @param {Number} [option.near=0] 最小可视距离。
     * @param {Number} [option.far=Math.MAX_VALUE] 最大可视距离。
     * @param {Number} [option.speed=1] 流动速度。
     *
     */
    Streamerwall.prototype.create = function (option = {}) {
        this.position = option.position || void 0;
        this.positions = option.positions || void 0;
        this.height = option.height || 50;
        this.minHeight = option.minHeight;
        this.near = option.near;
        this.far = option.far;
        this._speed = option.speed || 1;
        this._id = option.id;
        option.color && (this.color = Cesium.Color.fromCssColorString(option.color));

        this.getShader();
        this.collection = new Cesium.PrimitiveCollection;
        this.collection._guid = this._id;
        this._viewer.scene.primitives.add(this.collection);
        this.position ? this.getInstance() : this.positions && this.getInstances();
        this.addWall();
        this.PrimitiveCollection.push(this.collection);
    };
    Streamerwall.prototype.getById = function (i) {
        for (var item = null, P2 = this._viewer.scene.primitives, o = P2.length, n = 0; n < o; n++) {
            var p_PKAmE3 = P2.get(n);
            p_PKAmE3._guid === i && (item = p_PKAmE3);
        }
        return item
    };
    Streamerwall.prototype.remove = function (i) {
        var s$c1 = this.getById(i);
        null != s$c1 && this._viewer.scene.primitives.remove(s$c1);
    };
    Streamerwall.prototype.removeAll = function () {
        for (var i = 0; i < this.PrimitiveCollection.length; i++) {
            var gojbCN2 = this.PrimitiveCollection[i];
            this._viewer.scene.primitives.remove(gojbCN2);
        }
        this.PrimitiveCollection = [];
    };
    Streamerwall.prototype.show = function (show) {
        for (var i = 0; i < this.PrimitiveCollection.length; i++) {
            var gojbCN2 = this.PrimitiveCollection[i];
            gojbCN2.show = show;
        }
        //this.PrimitiveCollection = []
    };
    Streamerwall.prototype.getInstance = function () {
        let positions;
        if (this.position[0] instanceof Cesium.Cartesian3) {
            positions = this.position;
        } else {
            positions = Cesium.Cartesian3.fromDegreesArray(this.position);
        }
        let maximumHeights = Array(positions.length).fill(this.height);
        let minimumHeights = Array(positions.length).fill(this.minHeight || 0);
        let geometry = new Cesium.WallGeometry({
            positions: positions,
            maximumHeights: maximumHeights,
            minimumHeights: minimumHeights
        });
        this.instances = [new Cesium.GeometryInstance({
            geometry: geometry,
            attributes: {
                distanceDisplayCondition: new Cesium.DistanceDisplayConditionGeometryInstanceAttribute(this.near, this.far)
            }
        })];
    };
    Streamerwall.prototype.getInstances = function () {
        this.instances = [];
        for (let i = 0; i < this.positions.length; i++) {
            let positions;
            if (this.positions[i][0] instanceof Cesium.Cartesian3) {
                positions = this.positions[i];
            } else {
                positions = Cesium.Cartesian3.fromDegreesArray(this.positions[i]);
            }
            let maximumHeights = Array(positions.length).fill(this.height);
            let minimumHeights = Array(positions.length).fill(this.minHeight || 0);
            let instance = new Cesium.GeometryInstance({
                geometry: new Cesium.WallGeometry({
                    positions: positions,
                    maximumHeights: maximumHeights,
                    minimumHeights: minimumHeights
                }),
                attributes: {
                    distanceDisplayCondition: new Cesium.DistanceDisplayConditionGeometryInstanceAttribute(this.near, this.far)
                }
            });
            this.instances.push(instance);
        }
    };
    Streamerwall.prototype.addWall = async function () {
        this.instances.forEach(instance => {
            let Primitive = new Cesium.Primitive({
                geometryInstances: instance,
                appearance: new Cesium.MaterialAppearance({
                    material: new Cesium.Material({
                        fabric: {
                            source: this.fs,
                            uniforms: {
                                u_wallColor: this.color.withAlpha(0.5),
                                u_moveColor: this.color
                            }
                        }
                    })
                })
            });
            this.collection.add(Primitive);
        });
    };

    Streamerwall.prototype.getShader = function () {
        this.fs = `
    \tuniform vec4 u_moveColor;
    \tuniform vec4 u_wallColor;
    \#define PI_OVER_TWO 1.5707963
    \tczm_material czm_getMaterial(czm_materialInput materialInput){
        czm_material material = czm_getDefaultMaterial(materialInput);
        float iTime = czm_frameNumber / 60.0 * ${this._speed.toFixed(1)};
        vec2 uv = materialInput.st;
        vec4 finalColor = u_wallColor;
        float dt = clamp(tan(uv.y * 5.0  - iTime) * 0.3 - 0.1, 0.5, PI_OVER_TWO);
        finalColor = mix(finalColor, u_moveColor, dt);
        float alpha = pow(finalColor.w * (1.0 - abs(uv.y - 0.5)), 2.0);
        if(uv.y < 0.5){
          alpha = 1.0; 
          finalColor = u_wallColor;
          if(uv.y > 0.4){
            alpha = (0.5 - uv.y) * 5.0 + 0.5;
          }
        }
        material.diffuse = finalColor.xyz;
        material.alpha = alpha;
        return material;
    }
`;
    };

    /**
     *
     * 向三维场景中添加流动线。
     *
     * @alias TrailLine
     * @constructor
     *
     */
    function TrailLine(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._Color = new Color(this._viewer, this._cesium);
        this._core = new Core();
        this._getPosition = new getPosition(this._viewer, this._cesium);
        this._tree = tree;
        this._points = [];
        this._polylines = [];

        this.Streamerpath = new Streamerpath(this._viewer);
        this.Streamerwall = new Streamerwall(this._viewer);
    }

    /**
     * 向三维场景中添加流光线图层。
     * @param {Object} [option] 参数。
     * @param {String} [option.id] id（可选）。
     * @param {String} [option.url] geojson路径。
     * @param {String} [option.color="#0033FF"] 线颜色。
     * @param {Number} [option.alpha=1.0] 线透明度。
     * @param {Number} [option.width=5.0] 线宽。
     * @param {String} [option.pointColor="#FFFFFF"] 点颜色。
     * @param {Number} [option.pointColor=1.0] 点透明度。
     * @param {Number} [option.near=0] 最小可视距离。
     * @param {Number} [option.far=Math.MAX_VALUE] 最大可视距离。
     * @param {Number} [option.speed=1] 点移动速度。
     * @returns {TrailLine} 返回一个TrailLine对象。
     *
     */
    TrailLine.prototype.createPathLayer = function (option = {}) {
        var options = {
            lineColor: option.color || "#0033FF", //线的颜色
            lineAlpha: option.alpha || 1.0,//线的透明度
            linewidth: option.width || 5.0,//线的宽度
            pointColor: option.pointColor || "#FFFFFF", //移动点的颜色
            pointAlpha: option.pointAlpha || 1.0,//移动点的透明度
            id: option.id || this._core.getuid(),
            near: option.near,
            far: option.far,
            speed: option.speed || 1 //移动速度
        };
        let dataSource = Cesium.GeoJsonDataSource.load(option.url);
        dataSource.then(dataSource => {
            let entities = dataSource.entities.values;
            let positions = [];
            for (let i = 0; i < entities.length; i++) {
                let entity = entities[i];
                if (entity.polyline) {
                    positions.push(entity.polyline.positions.getValue());
                } else if (entity.polygon) {
                    positions.push(entity.polygon.hierarchy.getValue().positions);
                }
            }
            this.Streamerpath.create({
                positions: positions,
                ...options
            });
        });

        var obj = {
            id: options.id,
            name: '新建流光线图层',
            pId: 0,
            type: 'TrailLineLayer',
            item: this
        };

        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };


    /**
     * 向三维场景中添加流动墙图层。
     * @param {Object} [option] 参数。
     * @param {String} [option.id] id（可选）。
     * @param {String} [option.url] geojson路径。
     * @param {String} [option.color="#0000ff"] 颜色。
     * @param {Number} [option.height=50] 墙高。
     * @param {Number} [option.minHeight] 底部高度。
     * @param {Number} [option.near=0] 最小可视距离。
     * @param {Number} [option.far=Math.MAX_VALUE] 最大可视距离。
     * @param {Number} [option.speed=1] 流动速度。
     * @returns {TrailLine} 返回一个TrailLine对象。
     *
     */
    TrailLine.prototype.createWallLayer = function (option = {}) {
        var options = {
            color: option.color || "#0000ff", //颜色
            id: option.id || this._core.getuid(),
            speed: option.speed, //流动速度
            height: option.height, //颜色
            minHeight: option.minHeight, //底部高度。
            near: option.near,
            far: option.far,
        };

        let dataSource = Cesium.GeoJsonDataSource.load(option.url);
        dataSource.then(dataSource => {
            let entities = dataSource.entities.values;
            let positions = [];
            for (let i = 0; i < entities.length; i++) {
                let entity = entities[i];
                if (entity.polyline) {
                    positions.push(entity.polyline.positions.getValue());
                } else if (entity.polygon) {
                    positions.push(entity.polygon.hierarchy.getValue().positions);
                }

            }
            this.Streamerwall.create({
                positions: positions,
                ...options
            });
        });

        var obj = {
            id: options.id,
            name: '新建流动墙图层',
            pId: 0,
            type: 'TrailLineLayer',
            item: this
        };

        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };

    TrailLine.prototype.getLinePosition = function (data) {
        let positions = [];
        data.geometries && data.geometries.forEach(item => {
            let pArr = [];
            item.coordinates.forEach(coordinate => {
                pArr.push(coordinate[0], coordinate[1]);
            });
            positions.push(pArr);
        });

        data.features && data.features.forEach(item => {
            let pArr = [];
            item.geometry.coordinates.forEach(coordinate => {
                pArr.push(coordinate[0], coordinate[1]);
            });
            positions.push(pArr);
        });

        return positions;
    };

    /**
     * 向三维场景中添加流动路径。
     * @param {Object} [center] 中心。
     * @param {Array} [positions] 周围点。
     * @param {Number} [timeOrOption] 持续时间或参数{
         time:3000,    //时间（可选）
         width: 10,     //线宽（可选）
         height: 50000,     //抛物线高度（可选）
         num: 100,     //线采样数（可选）
         color: '#ff0000',  //线颜色（可选）
         LightSpot: false,   //是否使用光点效果
         url: 'Workers/image/TrailLine.png',     //渐变图片链接（可选）
         twoColor: {color1:'#00ff00',color2:'#ff0000'},     //配置两种颜色（可选）
     * }。
     * @returns {TrailLine} 返回一个TrailLine对象。
     *
     */
    TrailLine.prototype.createPath = function (center, positions, timeOrOption) {
        var _this = this;
        !timeOrOption && (timeOrOption = {});
        if (typeof timeOrOption === 'number') {
            timeOrOption = {
                time: timeOrOption
            };
        }
        var options = {
            time: 3000,
            LineColor: this._core.defaultValue(timeOrOption.color, '#ff0000'),
            LinkImage: this._core.defaultValue(timeOrOption.url, window.SmartEarthRootUrl + configData$1.TrailLine),
            height: 50000,
            num: 100,
            width: 2,
            LightSpot: false,
            alpha: 0.3
        };
        options = this._core.extend(options, timeOrOption, true);
        var lineOption;
        if (options.twoColor) {
            lineOption = {
                color1: options.twoColor.color1,
                color2: options.twoColor.color2
            };
        }
        if (options.LightSpot) {
            lineOption = {
                LightSpot: true,
                color: options.LightSpotColor || options.LineColor
            };
        }
        var material = new PolylineTrailLinkMaterial(options.LineColor, this._core.defaultValue(lineOption, options.LinkImage), options.time);
        material.alpha = options.alpha;

        for (var j = 0; j < positions.length; j++) {
            var points = this.parabolaEquation({ pt1: center, pt2: positions[j], height: options.height, num: options.num });
            var pointArr = [];
            for (var i = 0; i < points.length; i++) {
                pointArr.push(points[i][0], points[i][1], points[i][2]);
            }
            this._polylines.push(this._viewer.entities.add({
                name: 'PolylineTrailLink' + j,
                polyline: {
                    positions: _this._cesium.Cartesian3.fromDegreesArrayHeights(pointArr),
                    width: options.width,
                    material: material,
                    distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, options.far || Infinity)
                }
            }));
        }
        // this._points.push(_this._viewer.entities.add({
        //     position: _this._cesium.Cartesian3.fromDegrees(center.lon, center.lat, center.height),
        //     point: {
        //         pixelSize: 6,
        //         color: _this._cesium.Color.BLUE
        //     }
        // }));
        // for (var i = 0; i < positions.length; i++) {
        //     this._points.push(this._viewer.entities.add({
        //         position: _this._cesium.Cartesian3.fromDegrees(positions[i].lon, positions[i].lat, positions[i].height),
        //         point: {
        //             pixelSize: 6,
        //             color: _this._cesium.Color.RED
        //         }
        //     }));
        // }
        this.pathMaterial = material;
        if (options.static) {
            this.pathMaterial.setScale(0);
        }

        var obj = {
            id: this._core.getuid(),
            name: '新建流动路径',
            pId: 0,
            type: 'TrailLine',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };

    /**
     * 向三维场景中添加垂直飞线。
     * @param {Array} [positions] 飞线点。
     * @param {Object} [option] 参数{
         time: 3000,    //时间（可选）
         width: 1,     //线宽（可选）
         color: '#ffffff',  //线颜色（可选）
         minHeight: 0,  //起始高度（可选）
     * }。
     * @returns {TrailLine} 返回一个TrailLine对象。
     *
     */
    TrailLine.prototype.createFlyingLine = function (positions, option = {}) {
        var options = {
            time: 3000,
            LineColor: this._core.defaultValue(option.color, '#ffffff'),
            LinkImage: this._core.defaultValue(option.url, window.SmartEarthRootUrl + configData$1.TrailLine),
            minHeight: 0,
            width: 1,
            alpha: 0
        };
        options = this._core.extend(options, option, true);
        var lineOption = {
            LightSpot: true,
            color: options.LightSpotColor || options.LineColor
        };
        var material = new PolylineTrailLinkMaterial(options.LineColor, this._core.defaultValue(lineOption, options.LinkImage), options.time);
        material.alpha = options.alpha;

        let position;
        positions.forEach(p => {
            position = [p.lon, p.lat, options.minHeight, p.lon, p.lat, p.height];
            this._polylines.push(this._viewer.entities.add({
                name: 'FlyingLine',
                polyline: {
                    positions: Cesium.Cartesian3.fromDegreesArrayHeights(position),
                    width: options.width,
                    material: material
                }
            }));
        });

        var obj = {
            id: this._core.getuid(),
            name: '新建垂直飞线',
            pId: 0,
            type: 'TrailLine',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };

    /**
     * 向三维场景中添加流动线。
     * @param {Array} [Geometry] 坐标。
     * @param {Number} [timeOrOption] 持续时间或参数{
         time:3000,    //时间（可选）
         width: 10,     //线宽（可选）
         color: '#ff0000',  //线颜色（可选）
         url: 'http://183.162.245.49:82/05sdkdemo/src/static/image/TrailLine.png',     //渐变图片链接（可选）
         clampToGround:true     //是否贴地（可选）
     * }。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    TrailLine.prototype.createLine = function (Geometry, timeOrOption) {
        !timeOrOption && (timeOrOption = {});
        if (typeof timeOrOption === 'number') {
            timeOrOption = {
                time: timeOrOption
            };
        }
        var options = {
            time: 3000,
            LineColor: this._core.defaultValue(timeOrOption.color, "#ff0000"),
            LinkImage: this._core.defaultValue(timeOrOption.url, window.SmartEarthRootUrl + configData$1.TrailLine),
            width: 10
        };
        options = this._core.extend(options, timeOrOption, true);
        var material = new PolylineTrailLinkMaterial(options.LineColor, options.LinkImage, options.time);
        var pArray = [];
        if (!Geometry[0].x && !Geometry[0].y) {
            if (Geometry[0].length === 2) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1]));
                }
            } else if (Geometry[0].length === 3) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1], Geometry[i][2]));
                }
            }
        } else {
            if (Geometry[0].z !== undefined) {
                if (Geometry[0].x >= -180 && Geometry[0].x <= 180) {
                    for (var i = 0; i < Geometry.length; i++) {
                        pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y, Geometry[i].z));
                    }
                } else {
                    pArray = Geometry;
                }
            } else {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y));
                }
            }
        }
        this._polylines.push(this._viewer.entities.add({
            name: 'PolylineTrail',
            polyline: {
                positions: pArray,
                width: options.width,
                material: material,
                clampToGround: options.clampToGround
            }
        }));

        var obj = {
            id: this._core.getuid(),
            name: '新建流动线',
            pId: 0,
            type: 'TrailLine',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };
    /**
     * 向三维场景中添加流动墙。
     * @param {Array} [Geometry] 坐标。
     * @param {Number} [timeOrOption] 持续时间或参数{
         time:3000,    //时间（可选）
         color: '#ff0000',  //线颜色（可选）
         url: 'http://183.162.245.49:82/05sdkdemo/src/static/image/TrailLine.png',     //渐变图片链接（可选）
         maximumHeights:[10, 10],   //顶部高度（可选）
         minimumHeights:[0, 0],   //底部高度（可选）
     * }。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    TrailLine.prototype.createWall = function (Geometry, timeOrOption) {
        !timeOrOption && (timeOrOption = {});
        if (typeof timeOrOption === 'number') {
            timeOrOption = {
                time: timeOrOption
            };
        }
        var options = {
            time: 9000,
            LineColor: this._core.defaultValue(timeOrOption.color, this._cesium.Color.ORANGE),
            LinkImage: this._core.defaultValue(timeOrOption.url, window.SmartEarthRootUrl + configData$1.colors3)
        };
        options = this._core.extend(options, timeOrOption, true);
        var material = new PolylineTrailLinkMaterial(options.LineColor, options.LinkImage, options.time || 9000);
        var pArray = [];
        if (!Geometry[0].x && !Geometry[0].y) {
            if (Geometry[0].length === 2) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1]));
                }
            } else if (Geometry[0].length === 3) {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i][0], Geometry[i][1], Geometry[i][2]));
                }
            }
        } else {
            if (Geometry[0].z !== undefined) {
                if (Geometry[0].x >= -180 && Geometry[0].x <= 180) {
                    for (var i = 0; i < Geometry.length; i++) {
                        pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y, Geometry[i].z));
                    }
                } else {
                    pArray = Geometry;
                }
            } else {
                for (var i = 0; i < Geometry.length; i++) {
                    pArray.push(this._cesium.Cartesian3.fromDegrees(Geometry[i].x, Geometry[i].y));
                }
            }
        }
        this._polylines.push(this._viewer.entities.add({
            name: 'WallTrail',
            wall: {
                positions: pArray,
                material: material,
                maximumHeights: options.maximumHeights,
                minimumHeights: options.minimumHeights
            }
        }));

        var obj = {
            id: this._core.getuid(),
            name: '新建流动墙',
            pId: 0,
            type: 'TrailLine',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };

    //求路径点
    TrailLine.prototype.parabolaEquation = function (options, resultOut) {
        //方程 y=-(4h/L^2)*x^2+h h:顶点高度 L：横纵间距较大者
        var h = this._core.defaultValue(options.height, 5000);
        var L = Math.abs(options.pt1.lon - options.pt2.lon) > Math.abs(options.pt1.lat - options.pt2.lat) ? Math.abs(options.pt1.lon - options.pt2.lon) : Math.abs(options.pt1.lat - options.pt2.lat);
        var num = options.num && options.num > 50 ? options.num : 50;
        var result = [];
        var dlt = L / num;
        var height1 = options.pt1.height || 0;
        var height2 = options.pt2.height || 0;
        if (Math.abs(options.pt1.lon - options.pt2.lon) > Math.abs(options.pt1.lat - options.pt2.lat)) {//以lon为基准
            var delLat = (options.pt2.lat - options.pt1.lat) / num;
            if (options.pt1.lon - options.pt2.lon > 0) {
                dlt = -dlt;
            }
            for (var i = 0; i <= num; i++) {
                var tempH = h - Math.pow((-0.5 * L + Math.abs(dlt) * i), 2) * 4 * h / Math.pow(L, 2) + height1 + (height2 - height1) * i / num;
                var lon = options.pt1.lon + dlt * i;
                var lat = options.pt1.lat + delLat * i;
                result.push([lon, lat, tempH]);
            }
        } else {//以lat为基准
            var delLon = (options.pt2.lon - options.pt1.lon) / num;
            if (options.pt1.lat - options.pt2.lat > 0) {
                dlt = -dlt;
            }
            for (var i = 0; i < num; i++) {
                var tempH = h - Math.pow((-0.5 * L + Math.abs(dlt) * i), 2) * 4 * h / Math.pow(L, 2) + height1 + (height2 - height1) * i / num;
                var lon = options.pt1.lon + delLon * i;
                var lat = options.pt1.lat + dlt * i;
                result.push([lon, lat, tempH]);
            }
        }
        return result;
    };

    TrailLine.prototype.setThisPosition = function (PositionArr, thisPosition) {
        if (this.pathMaterial) {
            var startP = this._cesium.Cartesian3.fromDegrees(PositionArr[0].lon, PositionArr[0].lat);
            var endP = this._cesium.Cartesian3.fromDegrees(PositionArr[1].lon, PositionArr[1].lat);
            var thisP = this._cesium.Cartesian3.fromDegrees(thisPosition.lon, thisPosition.lat);
            var length = this._core.getSpaceDistancem([startP, endP], this._cesium);
            var _lenght = this._core.getSpaceDistancem([startP, thisP], this._cesium);
            this.pathMaterial.setScale(_lenght / length);
        }
    };

    TrailLine.prototype.clear = function () {
        if (this._points.length > 0) {
            for (var i = 0; i < this._points.length; i++) {
                this._viewer.entities.remove(this._points[i]);
            }
        }
        if (this._polylines.length > 0) {
            for (var i = 0; i < this._polylines.length; i++) {
                this._viewer.entities.remove(this._polylines[i]);
            }
        }
        this._points = [];
        this._polylines = [];

        this.Streamerpath.removeAll();
        this.Streamerwall.removeAll();
    };

    //工程树添加
    TrailLine.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    /**
     * 删除
     */
    TrailLine.prototype.deleteObject = function () {
        this.clear();
    };

    /**
     * 设置polyline的显示隐藏
     * @param {boolean} [b] true|false
     */
    TrailLine.prototype.setVisibility = function (b) {
        if (this._points.length > 0) {
            for (var i = 0; i < this._points.length; i++) {
                this._points[i].show = b;
            }
        }
        if (this._polylines.length > 0) {
            for (var i = 0; i < this._polylines.length; i++) {
                this._polylines[i].show = b;
            }
        }
        this.Streamerpath.show(b);
        this.Streamerwall.show(b);
    };

    /**
     *
     * 向三维场景中道路。
     *
     * @alias Road
     * @constructor
     *
     */
    function Road(viewer) {
        this._viewer = viewer;
        this._cesium = Cesium;
        this._core = new Core();
        this._Buffer = new BufferAnalysis(viewer, Cesium);
        this._tree = tree;
    }

    /**
     * 向三维场景中添加道路
     * @param {Object} [option] 参数。
     * @param {String} [option.id] id（可选）。
     * @param {Array} option.positions 道路点
     * @param {String} [option.image] 贴图。
     * @param {Number} [option.alpha=1.0] 透明度。
     * @param {Number} [option.width=20] 道路宽。
     * @param {Number} [option.height=1] 道路高。
     * @returns {Road} 返回一个Road对象。
     *
     */
    Road.prototype.createRoad = function (option = {}) {
        var options = {
            id: option.id || this._core.getuid(),
            image: window.SmartEarthRootUrl + configData$1.road,
            height: 1,
            width: 20,
            alpha: 1
        };
        options = this._core.extend(options, option, true);

        let degreesArr = [];
        option.positions.forEach(item => {
            let degrees = this._core.toDegrees(item);
            degreesArr.push([degrees.lon, degrees.lat]);
        });
        let polylineF = Cesium.turf.lineString(degreesArr);
        let positions = this._Buffer.getBuff(polylineF, options.width, { steps: 0 });
        this.item = this._Buffer.addBufferPolyogn(positions, {
            material: new Cesium.ImageMaterialProperty({
                image: options.image,
                color: Cesium.Color.WHITE.withAlpha(options.alpha)
            }),
            height: option.height,
            perPositionHeight: false,
            stRotation: 90,
            heightReference: 0,
            outline: false,
        });

        var obj = {
            id: options.id,
            name: '新建道路图层',
            pId: 0,
            type: 'RoadLayer',
            item: this
        };

        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;
    };

    //工程树添加
    Road.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    /**
     * 删除
     */
    Road.prototype.deleteObject = function () {
        this.item && this._viewer.entities.remove(this.item);
    };

    /**
     * 设置polyline的显示隐藏
     * @param {boolean} [b] true|false
     */
    Road.prototype.setVisibility = function (b) {
        this.item && (this.item.show = b);
    };

    /**
     *
     * 体积方量测量。
     *
     * @alias VolumetricMeasure
     * @constructor
     *
     */
    function VolumetricMeasure(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._scene = viewer.scene;
        this._core = new Core();
        this._tooltip = this._core.CreateTooltip();
        this._drawColor = {
            point: cesium.Color.BLUE,
            polyline: cesium.Color.YELLOW,
            polygon: cesium.Color.YELLOW.withAlpha(0.5)
        };
        this.loadingImg = window.SmartEarthRootUrl + configData$1.loading;
    }

    VolumetricMeasure.prototype.cleanUp = function () {
        if (this._prevEntity !== undefined) {
            this._viewer.entities.remove(this._prevEntity);
            this._prevEntity = undefined;
        }

        if (this._prevEntity1 !== undefined) {
            this._viewer.entities.remove(this._prevEntity1);
            this._prevEntity1 = undefined;
        }

        if (this._volumeLabel !== undefined) {
            this._viewer.entities.remove(this._volumeLabel);
            this._volumeLabel = undefined;
        }

        if (this._volumeLabel1 !== undefined) {
            this._viewer.entities.remove(this._volumeLabel1);
            this._volumeLabel1 = undefined;
        }
        if (this.addPointHandle) {
            this.addPointHandle.destroy();
            this.addPointHandle = undefined;
        }
        this.Triangulation = [];

        this._tooltip.show(false);
    };
    VolumetricMeasure.prototype.deleteObject = VolumetricMeasure.prototype.cleanUp;

    VolumetricMeasure.prototype.startDrawing = function (option, spacing, callback) {

        var scene = this._scene;
        var tooltip = this._tooltip;

        var minPoints = 3;

        var positions = [];
        var _positions = [];
        var firstPoint;
        this._positions = _positions;
        if (option && Object.keys(option).length > 0) {
            if (option.point !== "" && option.point !== undefined) {
                this._drawColor.point = option.point;
            }
            if (option.polyline !== "" && option.polyline !== undefined) {
                this._drawColor.polyline = option.polyline;
            }
            if (option.polygon !== "" && option.polygon !== undefined) {
                this._drawColor.polygon = option.polygon;
            }
            if (option.loading !== "" && option.loading !== undefined) {
                this.loadingImg = option.loading;
            }
        }
        var _this = this;
        if (this._mouseHandler) {
            this._mouseHandler.destroy();
        }
        if (!this.loading) {
            this.addLoading();
        }

        var mouseHandler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);

        this._mouseHandler = mouseHandler;
        this.cleanUp();
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        let polyline;
        // Now wait for start
        mouseHandler.setInputAction(function (movement) {
            if (movement.position != null) {
                var ray = scene.camera.getPickRay(movement.position);
                var cartesian = scene.globe.pick(ray, scene);
                var feature = this._viewer.scene.pick(movement.position);
                if (feature) {
                    var _cartesian = this._viewer.scene.pickPosition(movement.position);
                    if (_cartesian) {
                        cartesian = _cartesian;
                    }
                }

                if (cartesian) {
                    var cartographic = Cesium.Cartographic.fromCartesian(cartesian);
                    var longitude = Cesium.Math.toDegrees(cartographic.longitude);
                    var latitude = Cesium.Math.toDegrees(cartographic.latitude);

                    // first click
                    if (positions.length === 0) {
                        positions.push(longitude, latitude);
                        _positions.push(cartesian);
                        firstPoint = cartesian;
                    }

                    if (_positions.length >= 4) {
                        var firstPointScreenPosition = Cesium.SceneTransforms.wgs84ToWindowCoordinates(
                            this._viewer.scene, firstPoint);

                        if (firstPointScreenPosition !== undefined) {
                            var dx = firstPointScreenPosition.x - movement.position.x;
                            var dy = firstPointScreenPosition.y - movement.position.y;

                            var delta = dx * dx + dy * dy;

                            if (delta < 16) {
                                positions.splice(positions.length - 2, 2);
                                _positions.pop();
                                this.stopDrawing(callback);
                                return;
                            }
                        }
                    }

                    // add new point to point array
                    // this one will move with the mouse
                    positions.push(longitude, latitude);
                    _positions.push(cartesian);
                    // add marker at the new position
                    //markers.addBillboard(cartesian);

                    if (_positions.length === 2 && !polyline) {
                        polyline = this._viewer.entities.add({
                            name: '临时线',
                            polyline: {
                                positions: new Cesium.CallbackProperty(function () {
                                    return _positions
                                }, false),
                                clampToGround: true,
                                material: _this._drawColor.polygon,
                                width: 3,
                            }
                        });
                    }
                    if (_positions.length === minPoints) {
                        polyline && this._viewer.entities.remove(polyline);
                        this._prevEntity = this._viewer.entities.add({
                            polygon: {
                                hierarchy: new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromDegreesArray(positions)),
                                material: _this._drawColor.polygon,
                                fill: true
                            }
                        });
                        this._prevEntity.polygon.hierarchy = new Cesium.CallbackProperty(getHierarchy, false);
                    }
                }
            }
        }.bind(this), Cesium.ScreenSpaceEventType.LEFT_CLICK);

        mouseHandler.setInputAction(function (movement) {
            var position = movement.endPosition;

            if (position != null) {
                if (_positions.length === 0) {
                    tooltip.showAt(position, "点击开始绘制第一个点");
                } else {
                    var ray = scene.camera.getPickRay(position);
                    var cartesian = scene.globe.pick(ray, scene);
                    var feature = this._viewer.scene.pick(position);
                    if (feature) {
                        var _cartesian = this._viewer.scene.pickPosition(position);
                        if (_cartesian) {
                            cartesian = _cartesian;
                        }
                    }
                    if (cartesian) {
                        var cartographic = Cesium.Cartographic.fromCartesian(cartesian);
                        var longitude = Cesium.Math.toDegrees(cartographic.longitude);
                        var latitude = Cesium.Math.toDegrees(cartographic.latitude);

                        positions.splice(positions.length - 2, 2);
                        _positions.pop();
                        // make sure it is slightly different
                        //cartesian.y += (1 + Math.random());
                        positions.push(longitude, latitude);
                        _positions.push(cartesian);

                        // update marker
                        //markers.getBillboard(_positions.length - 1).position = cartesian;
                        // show tooltip
                        tooltip.showAt(position, "右键结束绘制");

                        if (_positions.length >= 3) {

                            if (_positions.length >= 4) {
                                var firstPointScreenPosition = Cesium.SceneTransforms.wgs84ToWindowCoordinates(
                                    this._viewer.scene, firstPoint);

                                if (firstPointScreenPosition !== undefined) {
                                    var dx = firstPointScreenPosition.x - position.x;
                                    var dy = firstPointScreenPosition.y - position.y;

                                    var delta = dx * dx + dy * dy;

                                    if (delta < 16) {
                                        document.body.style.cursor = 'pointer';
                                    } else
                                        document.body.style.cursor = 'default';
                                }
                            }
                        }
                    }
                }
            }
        }.bind(this), Cesium.ScreenSpaceEventType.MOUSE_MOVE);

        mouseHandler.setInputAction(function (movement) {
            this.end && this.end();
        }.bind(this), Cesium.ScreenSpaceEventType.RIGHT_CLICK);

        function getHierarchy() {
            return new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromDegreesArray(positions));
        }

        this.end = (type) => {
            if (this._mouseHandler !== undefined) {
                this._mouseHandler.destroy();
                this._mouseHandler = undefined;
            }
            this._core.mouse(this._viewer.container, 0);
            this._tooltip.show(false);
            polyline && this._viewer.entities.remove(polyline);
            this.end = undefined;

            if (_positions.length < minPoints) ; else {
                this._prevEntity && (this._prevEntity.polygon.hierarchy = Cesium.Cartesian3.fromDegreesArray(positions));
                if (type === 'cancel') {
                    this._prevEntity && this._viewer.entities.remove(this._prevEntity);
                    return;
                }
                this.stopDrawing(spacing, callback);
            }
        };
        return this;
    };

    VolumetricMeasure.prototype.stopDrawing = function (spacing, callback) {
        if (this._mouseHandler !== undefined) {
            this._mouseHandler.destroy();
            this._mouseHandler = undefined;
        }

        if (this._volumeLabel !== undefined) {
            this._viewer.entities.remove(this._volumeLabel);
            this._volumeLabel = undefined;
        }

        if (this._volumeLabel1 !== undefined) {
            this._viewer.entities.remove(this._volumeLabel1);
            this._volumeLabel1 = undefined;
        }

        this.isLoading(true);

        setTimeout(() => {
            var compute = this.computeCutVolume(spacing);
            var maxHeight = compute.maxHeight;
            var minHeight = compute.minHeight;

            this._prevEntity.polygon.height = compute.minHeight;
            this._prevEntity.polygon.heightReference = 0;

            (typeof callback === "function") && callback(compute);
            var drawingPolygon = {
                polygon: {
                    hierarchy: {
                        positions: this._positions
                    },
                    height: minHeight,
                    extrudedHeight: maxHeight,
                    closeTop: false,
                    closeBottom: false,
                    material: Cesium.Color.CYAN.withAlpha(0.2),
                    outline: true,
                    outlineColor: Cesium.Color.RED,
                    outlineWidth: 2
                }
            };

            this._prevEntity1 = this._viewer.entities.add(drawingPolygon);
        }, 100);

    };

    function computeCentroidOfPolygon(positions) {
        var x = [];
        var y = [];
        var allX = 0;
        var allY = 0;

        for (var i = 0; i < positions.length; i++) {
            var cartographic = Cesium.Cartographic.fromCartesian(positions[i]);
            allX += cartographic.longitude;
            allY += cartographic.latitude;
            x.push(cartographic.longitude);
            y.push(cartographic.latitude);
        }
        var centroidx = 0.0, centroidy = 0.0;

        // for (i = 0; i < positions.length; i++) {
        //     x0 = x[i];
        //     y0 = y[i];
        //
        //     if (i == positions.length - 1) {
        //         x1 = x[0];
        //         y1 = y[0];
        //     } else {
        //         x1 = x[i + 1];
        //         y1 = y[i + 1];
        //     }
        //
        //     a = x0 * y1 - x1 * y0;
        //     signedArea += a;
        //     centroidx += (x0 + x1) * a;
        //     centroidy += (y0 + y1) * a;
        // }
        //
        // signedArea *= 0.5;
        // centroidx /= (6.0 * signedArea);
        // centroidy /= (6.0 * signedArea);
        centroidx = allX / positions.length;
        centroidy = allY / positions.length;

        return new Cesium.Cartographic(centroidx, centroidy);
    }

    function computeAreaOfTriangle(pos1, pos2, pos3) {
        var a = Cesium.Cartesian3.distance(pos1, pos2);
        var b = Cesium.Cartesian3.distance(pos2, pos3);
        var c = Cesium.Cartesian3.distance(pos3, pos1);

        var S = (a + b + c) / 2;

        return Math.sqrt(S * (S - a) * (S - b) * (S - c));
    }

    var Ea = 6378137.0;     //   赤道半径

    //通过角度和距离获取经纬度
    function GetPositionFromA_D(lon, lat, distance, angle) {
        var Ea = 6378137.0;     //   赤道半径
        var Eb = 6356725.0;     //   极半径
        var dx = distance * Math.sin(angle * Math.PI / 180.0);
        var dy = distance * Math.cos(angle * Math.PI / 180.0);

        var ec = Eb + (Ea - Eb) * (90.0 - lat) / 90.0;
        var ed = ec * Math.cos(lat * Math.PI / 180);

        var newLon = (dx / ed + lon * Math.PI / 180.0) * 180.0 / Math.PI;
        var newLat = (dy / ec + lat * Math.PI / 180.0) * 180.0 / Math.PI;

        return [newLon, newLat];
    }

    function getGranularity(position, spacing) {
        var newPosition = GetPositionFromA_D(position.lon, position.lat, spacing, 0);
        var newPosition1 = GetPositionFromA_D(position.lon, position.lat, spacing, 90);
        var a = getRad(newPosition1[0]) - getRad(position.lon);
        var b = getRad(newPosition[1]) - getRad(position.lat);
        return a > b ? a : b;
    }

    function getDistance$1(lng1, lat1, lng2, lat2) {
        var radLat1 = getRad(lat1);
        var radLat2 = getRad(lat2);
        var a = getRad(lat2) - getRad(lat1);
        var b = getRad(lng2) - getRad(lng1);

        var distance = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) + Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
        distance = distance * Ea;
        distance = Math.round(distance * 10000) / 10000.0;
        return distance;
    }

    function getRad(d) {
        return d * Math.PI / 180.0;
    }

    /**
     * 计算体方量
     * @param {Number} [spacing] 间距
     *
     */
    VolumetricMeasure.prototype.computeCutVolume = function (spacing) {
        var minHeight = 15000;
        var DegreesArr = [];
        var length = this._positions.length;

        for (var i = 0, _cartographic, lon, lat, height, _height; i < length; i++) {
            _cartographic = Cesium.Cartographic.fromCartesian(this._positions[i]);
            lon = Cesium.Math.toDegrees(_cartographic.longitude);
            lat = Cesium.Math.toDegrees(_cartographic.latitude);
            DegreesArr.push(lon, lat);
            if (i === length - 1) {
                DegreesArr.push(lon, lat);
            }

            height = this._scene.globe.getHeight(_cartographic);
            _height = this._scene.sampleHeight(_cartographic);
            if (_height !== undefined && _height > height) {
                height = _height;
            }

            if (minHeight > height)
                minHeight = height;
        }

        if (spacing === 'auto') {
            var polygonLength = 0;
            for (var i = 0; i < DegreesArr.length - 2; i += 2) {
                polygonLength += getDistance$1(DegreesArr[i], DegreesArr[i + 1], DegreesArr[i + 2], DegreesArr[i + 3]);
            }
            spacing = polygonLength * 2 / DegreesArr.length;
            spacing = spacing / 5;
        }

        var granularity = getGranularity({ lon: DegreesArr[0], lat: DegreesArr[1] }, spacing);

        var polygonGeometry = new Cesium.PolygonGeometry.fromPositions(
            {
                positions: this._positions,
                vertexFormat: Cesium.PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
                granularity: granularity
            }
        );

        //polygon subdivision

        var geom = new Cesium.PolygonGeometry.createGeometry(polygonGeometry);

        var totalCutVolume = {
            fill: 0,
            dig: 0
        };
        var unit = {
            fill: '立方米',
            dig: '立方米'
        };
        var maxHeight = 0;
        var i0, i1, i2;
        var height1, height2, height3;
        var _height1, _height2, _height3;
        var p1, p2, p3;
        var TriangulationHeight;
        var cartesian;
        var cartographic;
        var bottomArea;
        var scale = {
            fill: 1,
            dig: 1
        };
        this.Triangulation = [];

        for (var i = 0; i < geom.indices.length; i += 3) {
            i0 = geom.indices[i];
            i1 = geom.indices[i + 1];
            i2 = geom.indices[i + 2];

            cartesian = new Cesium.Cartesian3(geom.attributes.position.values[i0 * 3],
                geom.attributes.position.values[i0 * 3 + 1],
                geom.attributes.position.values[i0 * 3 + 2]);

            cartographic = Cesium.Cartographic.fromCartesian(cartesian);

            height1 = this._scene.globe.getHeight(cartographic);
            _height1 = this._scene.sampleHeight(cartographic);
            if (_height1 !== undefined && _height1 > height1) {
                height1 = _height1;
            }

            p1 = Cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, 0/*height1 + 1000*/);

            if (maxHeight < height1)
                maxHeight = height1;

            cartesian = new Cesium.Cartesian3(geom.attributes.position.values[i1 * 3],
                geom.attributes.position.values[i1 * 3 + 1],
                geom.attributes.position.values[i1 * 3 + 2]);

            cartographic = Cesium.Cartographic.fromCartesian(cartesian);

            height2 = this._scene.globe.getHeight(cartographic);
            _height2 = this._scene.sampleHeight(cartographic);
            if (_height2 !== undefined && _height2 > height2) {
                height2 = _height2;
            }

            p2 = Cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, 0 /*height2 + 1000*/);

            if (maxHeight < height2)
                maxHeight = height2;

            cartesian = new Cesium.Cartesian3(geom.attributes.position.values[i2 * 3],
                geom.attributes.position.values[i2 * 3 + 1],
                geom.attributes.position.values[i2 * 3 + 2]);

            cartographic = Cesium.Cartographic.fromCartesian(cartesian);

            height3 = this._scene.globe.getHeight(cartographic);
            _height3 = this._scene.sampleHeight(cartographic);
            if (_height3 !== undefined && _height3 > height3) {
                height3 = _height3;
            }

            p3 = Cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, 0 /*height3 + 1000*/);

            if (maxHeight < height3)
                maxHeight = height3;

            bottomArea = computeAreaOfTriangle(p1, p2, p3);

            this.Triangulation.push({
                bottomArea: bottomArea,
                height: [height1, height2, height3]
            });

            TriangulationHeight = (height1 - minHeight + height2 - minHeight + height3 - minHeight) / 3;
            if (TriangulationHeight > 0) {
                totalCutVolume.dig = totalCutVolume.dig + bottomArea * TriangulationHeight * scale.dig;
            } else {
                totalCutVolume.fill = totalCutVolume.fill - bottomArea * TriangulationHeight * scale.fill;
            }
            if (totalCutVolume.dig > 1e10 && unit.dig === '立方米') {
                totalCutVolume.dig = totalCutVolume.dig / 1e9;
                unit.dig = '立方千米';
                scale.dig = 1e-9;
            }
            if (totalCutVolume.fill > 1e10 && unit.fill === '立方米') {
                totalCutVolume.fill = totalCutVolume.fill / 1e9;
                unit.fill = '立方千米';
                scale.fill = 1e-9;
            }
        }

        var centroid = computeCentroidOfPolygon(this._positions);

        this._volumeLabel = this._viewer.entities.add({
            position: Cesium.Cartesian3.fromRadians(centroid.longitude, centroid.latitude, maxHeight),
            label: {
                text: '挖方体积：' + totalCutVolume.dig.toFixed(4) + unit.dig,
                pixelOffset: { x: 0, y: -30 },
                font: '16px 宋体',
                fillColor: Cesium.Color.GOLD,
                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                showBackground: true,
                disableDepthTestDistance: Number.POSITIVE_INFINITY,
            }
        });
        this._volumeLabel1 = this._viewer.entities.add({
            position: Cesium.Cartesian3.fromRadians(centroid.longitude, centroid.latitude, maxHeight),
            label: {
                text: '填方体积：' + totalCutVolume.fill.toFixed(4) + unit.fill,
                pixelOffset: { x: 0, y: -70 },
                font: '16px 宋体',
                fillColor: Cesium.Color.GOLD,
                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                showBackground: true,
                disableDepthTestDistance: Number.POSITIVE_INFINITY,
            }
        });
        this.isLoading(false);
        return { maxHeight: maxHeight, minHeight: minHeight, volume: totalCutVolume, unit: unit, spacing: spacing };
    };

    VolumetricMeasure.prototype.addLoading = function () {
        var loading = document.createElement('div');
        loading.id = 'cesiumLoading';
        loading.style.cssText = 'width: 100%;height: 100%;display:none;pointer-events: none;position: absolute;top: 0;left: 0;-moz-box-sizing: border-box;box-sizing: border-box;background-color: unset;z-index: 99999;';
        var img = document.createElement('img');
        img.style.cssText = 'position: relative;width: 110px;height: 110px;margin: auto;top: 50%;left: 50%;margin-top: -55px;margin-left: -55px;';
        img.src = this.loadingImg;
        loading.appendChild(img);
        this.loading = loading;
        this._viewer.container.appendChild(loading);
    };

    VolumetricMeasure.prototype.isLoading = function (loading) {
        if (loading) {
            this.loading.style.display = 'block';
        } else {
            this.loading.style.display = 'none';
        }
    };

    VolumetricMeasure.prototype.removeLoading = function () {
        this.loading && this.loading.remove();
        this.loading = undefined;
    };

    /**
     * 
     * 点选高度。
     * @param {Function} [callback] 回调
     * 
     */
    VolumetricMeasure.prototype.addPoint = function (callback) {
        if (this.addPointHandle) {
            this.addPointHandle.destroy();
            this.addPointHandle = null;
        }
        this.addPointHandle = new this._cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
        //鼠标左键单击
        this.addPointHandle.setInputAction(function (movement) {
            var cartesian;
            var ray = this._viewer.scene.camera.getPickRay(movement.position);
            if (ray) {
                cartesian = this._viewer.scene.globe.pick(ray, this._viewer.scene);
            }
            var feature = this._viewer.scene.pick(movement.position);
            if (feature) {
                var _cartesian = this._viewer.scene.pickPosition(movement.position);
                if (_cartesian) {
                    cartesian = _cartesian;
                }
            }
            if (!cartesian) {
                return;
            }
            var cartographic = this._cesium.Cartographic.fromCartesian(cartesian);
            this.addPointHandle.destroy();
            this.addPointHandle = null;
            (callback && typeof callback === 'function') && callback(cartographic.height.toFixed(1));
        }.bind(this), this._cesium.ScreenSpaceEventType.LEFT_CLICK);
    };

    /**
     * 设置基准面。
     * @param {Number} [DatumHeight] 基准面高
     * @param {Function} [callback] 回调
     *
     */
    VolumetricMeasure.prototype.setDatum = function (DatumHeight, callback) {
        if (this.Triangulation && this.Triangulation.length > 0) {
            var bottomArea, heightArr, TriangulationHeight;
            var totalCutVolume = {
                fill: 0,
                dig: 0
            };
            var unit = {
                fill: '立方米',
                dig: '立方米'
            };
            var scale = {
                fill: 1,
                dig: 1
            };
            this.Triangulation.forEach(function (item) {
                bottomArea = item.bottomArea;
                heightArr = item.height;
                TriangulationHeight = (heightArr[0] - DatumHeight + heightArr[1] - DatumHeight + heightArr[2] - DatumHeight) / 3;
                if (TriangulationHeight > 0) {
                    totalCutVolume.dig = totalCutVolume.dig + bottomArea * TriangulationHeight * scale.dig;
                } else {
                    totalCutVolume.fill = totalCutVolume.fill - bottomArea * TriangulationHeight * scale.fill;
                }
                if (totalCutVolume.dig > 1e10 && unit.dig === '立方米') {
                    totalCutVolume.dig = totalCutVolume.dig / 1e9;
                    unit.dig = '立方千米';
                    scale.dig = 1e-9;
                }
                if (totalCutVolume.fill > 1e10 && unit.fill === '立方米') {
                    totalCutVolume.fill = totalCutVolume.fill / 1e9;
                    unit.fill = '立方千米';
                    scale.fill = 1e-9;
                }
            });
            this._volumeLabel.label.text = '挖方体积：' + totalCutVolume.dig.toFixed(4) + unit.dig;
            this._volumeLabel1.label.text = '填方体积：' + totalCutVolume.fill.toFixed(4) + unit.fill;
            this._prevEntity.polygon.height = DatumHeight;
            (callback && typeof callback === 'function') && callback({ volume: totalCutVolume, unit: unit });
        }
    };

    /**
     *
     * 鹰眼
     *
     * @alias Hawkeye
     * @constructor
     *
     */
    function Hawkeye(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 创建鹰眼
     * 
     * @param {string} [name] 名称
     * @param {object} [options] 名称
     */
    Hawkeye.prototype.createHawkeye = function (options, style) {
        var div = document.createElement('div');
        div.id = "Hawkeye";
        div.style.position = "absolute";
        div.style.width = "15%";
        div.style.height = "20%";
        div.style.bottom = "0";
        div.style.right = "0";
        div.style.pointerEvents = "none";

        if (style) {
            if (style.width) {
                div.style.width = style.width;
            }
            if (style.height) {
                div.style.height = style.height;
            }
            if (style.bottom) {
                div.style.bottom = style.bottom;
            }
            if (style.right) {
                div.style.right = style.right;
            }
            if (style.top) {
                div.style.top = style.top;
                div.style.bottom = 'unset';
            }
            if (style.left) {
                div.style.left = style.left;
                div.style.right = 'unset';
            }
        }
        this._viewer.container.appendChild(div);
        let imageryProvider;
        if (options.url) {
            imageryProvider = new this._cesium.SingleTileImageryProvider({
                url: options.url
            });
        } else {
            imageryProvider = options.imageryProvider;
        }
        var viewer1 = new this._cesium.Viewer('Hawkeye', {
            imageryProvider: imageryProvider,
            baseLayerPicker: false,
            shadows: false,
            shouldAnimate: true,
            animation: true,
            scene3DOnly: true,
            fullscreenButton: false,
            geocoder: false,
            homeButton: false,
            infoBox: false,
            selectionIndicator: false,
            timeline: false,
            navigationHelpButton: false,
        });
        viewer1._cesiumWidget._creditContainer.style.display = "none";

        var that = this;
        let height = this._core.defaultValue(style && style.height, 10000);
        function updataView() {
            let position = that._viewer.camera.position;
            let Cartographic = Cesium.Cartographic.fromCartesian(position);
            Cartographic.height += height;
            viewer1.camera.setView({
                destination: Cesium.Cartographic.toCartesian(Cartographic),
                orientation: {
                    heading: that._viewer.camera.heading,
                    pitch: that._viewer.camera.pitch,
                    roll: that._viewer.camera.roll
                }
            });
        }
        that._viewer.scene.preRender.addEventListener(updataView);

        this.close = function () {
            that._viewer.scene.preRender.removeEventListener(updataView);
            viewer1.destroy();
            div.remove();
            that.close = undefined;
        };
        return this;
    };

    /**
     *
     * 军标
     *
     * @alias MilitaryStandard
     * @constructor
     *
     */
    function MilitaryStandard(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
        this._getPosition = new getPosition(this._viewer, this._cesium);
        this._popupmessage = new PopupMessage(this._viewer, this._cesium);
        this.tooltip = this._core.CreateTooltip({ id: '_jb' });
        //需要排除的对象
        this.objectsToExclude = [];
        this.MilitaryStandardObj = [];
        this.drawHandler = undefined;
        ///编辑
        this.editHandler = null;
        // 清空编辑点ID数组
        //this.pointsId = [];

        this.heightpointsId = [];
        this.state = 0; //1为新增 2为编辑 0为清除
        //
        this.isEditting = false;
        this.editProp = true;
    }

    /**
     * 创建军标(贝塞尔曲线,二维)
     * 
     * @param {Function} [callBack] 回调
     * @param {Object} [option] 参数
     */
    MilitaryStandard.prototype.createBezierline = function (option, callBack) {
        var that = this;
        var viewer = this._viewer;

        var anchorpoints = [];
        var pottingPoint = [];
        var polyline = undefined;
        var tooltip = "单击开始绘制";
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;
        var BezierlinePoints;
        this.drawHandler.setInputAction(function (event) {
            tooltip = "左键添加点 右键结束";
            var window_position = event.position;
            var GeoPoints = that._createGeoPoints(viewer, [{ x: window_position.x, y: window_position.y }]);
            if (anchorpoints.length == 0) {
                anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                pottingPoint.push(GeoPoints);
            }

            pottingPoint.push(GeoPoints);
            anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        this.drawHandler.setInputAction(function (movement) {
            that._core.CreateTooltip(tooltip, movement.endPosition, true);
            var w_p = movement.endPosition;
            if (anchorpoints.length > 0) {
                if (!that._cesium.defined(polyline)) {
                    var window_points = that._createBezierPoints(anchorpoints);
                    var GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    BezierlinePoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                    polyline = viewer.entities.add({
                        name: 'Bezierline',
                        polyline: {
                            positions: new that._cesium.CallbackProperty(function () {
                                return BezierlinePoints;
                            }, false),
                            width: that._core.defaultValue(option.width, 2),
                            material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, '#ff0000')),
                        }
                    });
                    polyline.GeoType = 'Bezierline';
                    that.MilitaryStandardObj.push(polyline.id);
                } else {
                    anchorpoints.pop();
                    pottingPoint.pop();
                    var GeoPoints = that._createGeoPoints(viewer, [{ x: w_p.x, y: w_p.y }]);
                    anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                    pottingPoint.push(GeoPoints);

                    var window_points = that._createBezierPoints(anchorpoints);
                    var GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    BezierlinePoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        this.drawHandler.setInputAction(function (event) {
            that.end && that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        this.end = (type) => {
            this.end = undefined;
            polyline && (polyline.pottingPoint = pottingPoint);
            that.drawHandler.destroy();
            that._core.CreateTooltip(tooltip, undefined, false);
            //设置鼠标样式
            that._core.mouse(that._viewer.container, 0);
            setTimeout(function () {
                tree.states = 0;
            }, 100);
            if (type === 'cancel') {
                polyline && (viewer.entities.remove(polyline),
                    that.MilitaryStandardObj.pop());
                return;
            }
            //回调
            callBack && callBack(polyline);
        };
        return this;
    };
    /**
    * 创建军标(贝塞尔箭头,二维)
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    MilitaryStandard.prototype.createBezierArrow = function (option, callBack) {
        var that = this;
        var viewer = this._viewer;
        var tooltip = "单击开始绘制";

        var anchorpoints = [];
        var pottingPoint = [];
        var polyline = undefined;
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        //设置鼠标样式
        that._core.mouse(that._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        tree.states = 1;
        var BezierArrowPoints;
        that.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        that.drawHandler.setInputAction(function (event) {
            tooltip = "左键添加点 右键结束";
            var window_position = event.position;
            var GeoPoints = that._createGeoPoints(viewer, [{ x: window_position.x, y: window_position.y }]);
            if (anchorpoints.length == 0) {
                anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                pottingPoint.push(GeoPoints);
            }
            anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
            pottingPoint.push(GeoPoints);
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        that.drawHandler.setInputAction(function (movement) {
            that._core.CreateTooltip(tooltip, movement.endPosition, true);
            var w_p = movement.endPosition;
            if (anchorpoints.length > 0) {
                if (!that._cesium.defined(polyline)) {
                    var window_points = that._createBezierPoints(anchorpoints);
                    var GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    BezierArrowPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                    polyline = viewer.entities.add({
                        name: 'BezierArrow',
                        polyline: {
                            positions: new that._cesium.CallbackProperty(function () {
                                return BezierArrowPoints;
                            }, false),
                            width: that._core.defaultValue(option.width, 5),
                            material: new that._cesium.PolylineArrowMaterialProperty(that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, '#ff0000')),)
                        }
                    });
                    polyline.GeoType = 'BezierArrow';
                    that.MilitaryStandardObj.push(polyline.id);
                } else {
                    anchorpoints.pop();
                    pottingPoint.pop();
                    var GeoPoints = that._createGeoPoints(viewer, [{ x: w_p.x, y: w_p.y }]);
                    anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                    pottingPoint.push(GeoPoints);

                    var window_points = that._createBezierPoints(anchorpoints);
                    var GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    BezierArrowPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        that.drawHandler.setInputAction(function (event) {
            that.end && that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        this.end = (type) => {
            this.end = undefined;
            polyline && (polyline.pottingPoint = pottingPoint);
            that.drawHandler.destroy();
            that._core.CreateTooltip(tooltip, undefined, false);
            //设置鼠标样式
            that._core.mouse(that._viewer.container, 0);
            setTimeout(function () {
                tree.states = 0;
            }, 100);
            if (type === 'cancel') {
                polyline && (viewer.entities.remove(polyline),
                    that.MilitaryStandardObj.pop());
                return;
            }
            //回调
            callBack && callBack(polyline);
        };
        return this;
    };
    /**
    * 创建军标(燕尾箭头,二维)
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    MilitaryStandard.prototype.createSwallowtailArrow = function (type1, option, callBack) {
        var type = type1;
        var that = this;
        var viewer = this._viewer;

        var polygon = undefined;
        var pottingPoint = [];
        var anchorpoints = [];
        var tooltip = "单击开始绘制";
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        //设置鼠标样式
        that._core.mouse(that._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        tree.states = 1;
        var SwallowtailArrowPoints;
        that.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        that.drawHandler.setInputAction(function (event) {
            var window_position = event.position;
            tooltip = "单击完成绘制";
            if (anchorpoints.length == 0) {
                var GeoPoints = that._createGeoPoints(viewer, [{ x: window_position.x, y: window_position.y }]);
                anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] }, { x: GeoPoints[0] + 0.0000001, y: GeoPoints[1] + 0.0000001, z: GeoPoints[2] });
                pottingPoint.push(GeoPoints, GeoPoints);
            } else if (anchorpoints.length == 2) {
                that.end && that.end();
            }    }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        that.drawHandler.setInputAction(function (event) {
            that._core.CreateTooltip(tooltip, event.endPosition, true);
            var w_p = event.endPosition;
            if (anchorpoints.length > 1) {
                if (!that._cesium.defined(polygon)) {
                    polygon = that.plotingSwallowtailArrow(viewer, anchorpoints, type, option);
                    var control_w_p = that._computeSwallowtailArrow(anchorpoints);
                    var GeoPoints = [];
                    control_w_p.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    SwallowtailArrowPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                    polygon.polygon.hierarchy = new that._cesium.CallbackProperty(function () {
                        return new that._cesium.PolygonHierarchy(SwallowtailArrowPoints)
                    }, false);
                    polygon.GeoType = 'SwallowtailArrow';
                    that.MilitaryStandardObj.push(polygon.id);
                } else {
                    anchorpoints.pop();
                    pottingPoint.pop();
                    var GeoPoints = that._createGeoPoints(viewer, [{ x: w_p.x, y: w_p.y }]);
                    anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                    pottingPoint.push(GeoPoints);

                    var control_w_p = that._computeSwallowtailArrow(anchorpoints);
                    var GeoPoints = [];
                    control_w_p.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    SwallowtailArrowPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                }
            } else {
                return;
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        that.drawHandler.setInputAction(function (event) {
            that.end && that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        this.end = (type) => {
            this.end = undefined;
            polygon && (polygon.pottingPoint = pottingPoint);
            that._core.CreateTooltip(tooltip, undefined, false);
            that.drawHandler.destroy();
            //设置鼠标样式
            that._core.mouse(that._viewer.container, 0);

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            if (type === 'cancel') {
                polygon && (viewer.entities.remove(polygon),
                    that.MilitaryStandardObj.pop());
                return;
            }
            //回调
            callBack && callBack(polygon);
        };
        return this;
    };
    /**
    * 创建军标(粗直箭头,二维)
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    MilitaryStandard.prototype.createStraightArrow = function (type1, option, callBack) {
        var type = type1;
        var that = this;
        var viewer = this._viewer;

        var anchorpoints = [];
        var polygon = undefined;
        var pottingPoint = [];
        var tooltip = "单击开始绘制";
        tree.states = 1;
        var StraightArrowPoints;
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        //设置鼠标样式
        that._core.mouse(that._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        that.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        that.drawHandler.setInputAction(function (event) {
            var window_position = event.position;
            tooltip = "单击完成绘制";
            if (anchorpoints.length == 0) {
                var GeoPoints = that._createGeoPoints(viewer, [{ x: window_position.x, y: window_position.y }]);
                anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] }, { x: GeoPoints[0] + 0.0000001, y: GeoPoints[1] + 0.0000001, z: GeoPoints[2] });
                pottingPoint.push(GeoPoints, GeoPoints);
            } else if (anchorpoints.length == 2) {
                that.end && that.end();
            }    }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        that.drawHandler.setInputAction(function (event) {
            var w_p = event.endPosition;
            that._core.CreateTooltip(tooltip, w_p, true);
            if (anchorpoints.length > 1) {
                if (!that._cesium.defined(polygon)) {
                    var control_w_p = that.calculateMorePoints(anchorpoints);
                    var GeoPoints = [];
                    control_w_p.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    StraightArrowPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                    if (type == "polygon") {
                        polygon = viewer.entities.add({
                            name: 'StraightArrow',
                            polygon: {
                                hierarchy: StraightArrowPoints,
                                material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                            }
                        });
                    } else if (type == 'box') {
                        polygon = viewer.entities.add({
                            name: 'StraightArrow',
                            polygon: {
                                hierarchy: StraightArrowPoints,
                                material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                                extrudedHeight: GeoPoints[2] + that._core.defaultValue(option.extrudedHeight, 200),
                                height: GeoPoints[2],
                                outline: that._core.defaultValue(option.outline, true),
                                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),
                            }
                        });

                    }
                    polygon.polygon.hierarchy = new that._cesium.CallbackProperty(function () {
                        return new that._cesium.PolygonHierarchy(StraightArrowPoints)
                    }, false);
                    polygon.GeoType = 'StraightArrow';
                    that.MilitaryStandardObj.push(polygon.id);
                } else {
                    anchorpoints.pop();
                    pottingPoint.pop();
                    var GeoPoints = that._createGeoPoints(viewer, [{ x: w_p.x, y: w_p.y }]);
                    anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                    pottingPoint.push(GeoPoints);

                    var control_w_p = that.calculateMorePoints(anchorpoints);
                    var GeoPoints = [];
                    control_w_p.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    StraightArrowPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                }
            }
            else {
                return;
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        that.drawHandler.setInputAction(function (event) {
            that.end && that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        this.end = (type) => {
            this.end = undefined;
            polygon && (polygon.pottingPoint = pottingPoint);
            that._core.CreateTooltip(tooltip, undefined, false);
            that.drawHandler.destroy();
            //设置鼠标样式
            that._core.mouse(that._viewer.container, 0);

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            if (type === 'cancel') {
                polygon && (viewer.entities.remove(polygon),
                    that.MilitaryStandardObj.pop());
                return;
            }
            //回调
            callBack && callBack(polygon);
        };
        return this;
    };
    /**
    * 创建军标(圆角矩形,二维)
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    MilitaryStandard.prototype.createRoundedRectangle = function (type1, option, callBack) {
        var type = type1;
        var tooltip = "单击开始绘制";
        var that = this;
        var viewer = this._viewer;

        var anchorpoints = [];
        var pottingPoint = [];
        var polygon = undefined;
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        //设置鼠标样式
        that._core.mouse(that._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        tree.states = 1;
        var RoundedRectanglePoints;
        that.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        that.drawHandler.setInputAction(function (event) {
            var window_position = event.position;
            tooltip = "单击完成绘制";
            if (anchorpoints.length == 0) {
                var GeoPoints = that._createGeoPoints(viewer, [{ x: window_position.x, y: window_position.y }]);
                anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] }, { x: GeoPoints[0] + 0.0000001, y: GeoPoints[1] + 0.0000001, z: GeoPoints[2] });
                pottingPoint.push(GeoPoints, GeoPoints);
            } else if (anchorpoints.length == 2) {
                that.end && that.end();
            }    }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        that.drawHandler.setInputAction(function (movement) {
            that._core.CreateTooltip(tooltip, movement.endPosition, true);
            var w_p = movement.endPosition;
            if (anchorpoints.length > 1) {
                if (!Cesium.defined(polygon)) {
                    var window_points = that._computeRoundedRectanglePoints(anchorpoints);
                    var GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    RoundedRectanglePoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);

                    if (type == "polygon") {
                        polygon = viewer.entities.add({
                            name: 'RoundedRectangle',
                            polygon: {
                                hierarchy: RoundedRectanglePoints,
                                material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                                outline: that._core.defaultValue(option.outline, true),
                                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)'))
                            }
                        });
                    } else if (type == 'box') {
                        polygon = viewer.entities.add({
                            name: 'RoundedRectangle',
                            polygon: {
                                hierarchy: RoundedRectanglePoints,
                                material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                                outline: that._core.defaultValue(option.outline, true),
                                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),
                                extrudedHeight: GeoPoints[2] + that._core.defaultValue(option.extrudedHeight, 200),
                                height: GeoPoints[2]
                            }
                        });
                    }
                    polygon.polygon.hierarchy = new that._cesium.CallbackProperty(function () {
                        return new that._cesium.PolygonHierarchy(RoundedRectanglePoints);
                    }, false);
                    polygon.GeoType = 'RoundedRectangle';
                    that.MilitaryStandardObj.push(polygon.id);
                } else {
                    anchorpoints.pop();
                    pottingPoint.pop();
                    var GeoPoints = that._createGeoPoints(viewer, [{ x: w_p.x, y: w_p.y }]);
                    anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                    pottingPoint.push(GeoPoints);

                    var window_points = that._computeRoundedRectanglePoints(anchorpoints);
                    var GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    RoundedRectanglePoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        that.drawHandler.setInputAction(function (event) {
            that.end && that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        this.end = (type) => {
            this.end = undefined;
            polygon && (polygon.pottingPoint = pottingPoint);
            that._core.CreateTooltip(tooltip, undefined, false);
            that.drawHandler.destroy();
            //设置鼠标样式
            that._core.mouse(that._viewer.container, 0);

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            if (type === 'cancel') {
                polygon && (viewer.entities.remove(polygon),
                    that.MilitaryStandardObj.pop());
                return;
            }
            //回调
            callBack && callBack(polygon);
        };
        return this;
    };
    /**
    * 创建军标(扇形,二维)
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    MilitaryStandard.prototype.createSector = function (type1, option, callBack) {
        var type = type1;
        var tooltip = "单击开始绘制";
        var viewer = this._viewer;
        var that = this;

        var anchorpoints = [];
        var pottingPoint = [];
        var polygon, polyline;
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        //设置鼠标样式
        that._core.mouse(that._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        tree.states = 1;
        var SectorPoints;
        that.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        that.drawHandler.setInputAction(function (event) {
            tooltip = "单击添加点";
            var window_position = event.position;
            var GeoPoints = that._createGeoPoints(viewer, [{ x: window_position.x, y: window_position.y }]);
            if (anchorpoints.length == 0) {
                anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] }, { x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                pottingPoint.push(GeoPoints, GeoPoints);
            } else if (anchorpoints.length == 2) {
                anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                pottingPoint.push(GeoPoints);
            } else if (anchorpoints.length == 3) {
                that.end && that.end();
            }        if (pottingPoint.length === 2 && !polyline) {
                polyline = viewer.entities.add({
                    name: '临时线',
                    polyline: {
                        positions: new Cesium.CallbackProperty(function () {
                            return [Cesium.Cartesian3.fromDegrees(pottingPoint[0][0], pottingPoint[0][1]), Cesium.Cartesian3.fromDegrees(pottingPoint[1][0], pottingPoint[1][1])]
                        }, false),
                        clampToGround: true,
                        material: Cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                        width: 3,
                    }
                });
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        that.drawHandler.setInputAction(function (movement) {
            that._core.CreateTooltip(tooltip, movement.endPosition, true);
            var w_p = movement.endPosition;
            if (anchorpoints.length === 2) {
                anchorpoints.pop();
                pottingPoint.pop();
                var GeoPoints = that._createGeoPoints(viewer, [{ x: w_p.x, y: w_p.y }]);
                anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                pottingPoint.push(GeoPoints);
            }
            if (anchorpoints.length > 2) {
                polyline && viewer.entities.remove(polyline);
                if (!that._cesium.defined(polygon)) {
                    var window_points = that._computeSectorPoints(anchorpoints);
                    var GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    SectorPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);

                    if (type == "polygon") {
                        polygon = viewer.entities.add({
                            name: 'Sector',
                            polygon: {
                                hierarchy: SectorPoints,
                                material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                                outline: that._core.defaultValue(option.outline, true),
                                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),
                            }
                        });
                    } else if (type == 'box') {
                        polygon = viewer.entities.add({
                            name: 'Sector',
                            polygon: {
                                hierarchy: SectorPoints,
                                material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                                outline: that._core.defaultValue(option.outline, true),
                                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),
                                extrudedHeight: GeoPoints[2] + that._core.defaultValue(option.extrudedHeight, 200),
                                height: GeoPoints[2],
                            }
                        });
                    }
                    polygon.polygon.hierarchy = new that._cesium.CallbackProperty(function () {
                        return new that._cesium.PolygonHierarchy(SectorPoints);
                    }, false);
                    polygon.GeoType = 'Sector';
                    that.MilitaryStandardObj.push(polygon.id);
                } else {
                    anchorpoints.pop();
                    pottingPoint.pop();
                    var GeoPoints = that._createGeoPoints(viewer, [{ x: w_p.x, y: w_p.y }]);
                    anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                    pottingPoint.push(GeoPoints);

                    var window_points = that._computeSectorPoints(anchorpoints);
                    var GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    SectorPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        that.drawHandler.setInputAction(function (event) {
            that.end && that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        this.end = (type) => {
            this.end = undefined;
            polygon && (polygon.pottingPoint = pottingPoint);
            that._core.CreateTooltip(tooltip, undefined, false);
            that.drawHandler.destroy();
            //设置鼠标样式
            that._core.mouse(that._viewer.container, 0);
            polyline && viewer.entities.remove(polyline);

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            if (type === 'cancel') {
                polygon && (viewer.entities.remove(polygon),
                    that.MilitaryStandardObj.pop());
                return;
            }
            //回调
            callBack && callBack(polygon);
        };
        return this;
    };
    /**
    * 创建军标(弓形,二维)
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    MilitaryStandard.prototype.createBow = function (type1, option, callBack) {
        var type = type1;
        var that = this;
        var viewer = this._viewer;
        var tooltip = "单击开始绘制";

        var anchorpoints = [];
        var pottingPoint = [];
        var polygon = undefined;
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        //设置鼠标样式
        that._core.mouse(that._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        tree.states = 1;
        var BowPoints;
        that.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        that.drawHandler.setInputAction(function (event) {
            tooltip = "单击添加点";
            var window_position = event.position;
            var GeoPoints = that._createGeoPoints(viewer, [{ x: window_position.x, y: window_position.y }]);
            if (anchorpoints.length == 0) {
                anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                pottingPoint.push(GeoPoints);
            } else if (anchorpoints.length == 1) {
                anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] }, { x: GeoPoints[0] + 0.0000001, y: GeoPoints[1] + 0.0000001, z: GeoPoints[2] });
                pottingPoint.push(GeoPoints, GeoPoints);
            } else if (anchorpoints.length == 3) {
                that.end && that.end();
            }    }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        that.drawHandler.setInputAction(function (movement) {
            var w_p = movement.endPosition;
            that._core.CreateTooltip(tooltip, movement.endPosition, true);
            if (anchorpoints.length > 2) {
                if (!Cesium.defined(polygon)) {
                    var window_points = that._computeBowPoints(anchorpoints);
                    var GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    BowPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);

                    if (type == "polygon") {
                        polygon = viewer.entities.add({
                            name: 'Bow',
                            polygon: {
                                hierarchy: BowPoints,
                                material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                                outline: that._core.defaultValue(option.outline, true),
                                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),
                            }
                        });
                    } else if (type == 'box') {
                        polygon = viewer.entities.add({
                            name: 'Bow',
                            polygon: {
                                hierarchy: BowPoints,
                                material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                                outline: that._core.defaultValue(option.outline, true),
                                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),
                                extrudedHeight: GeoPoints[2] + that._core.defaultValue(option.extrudedHeight, 200),
                                height: GeoPoints[2]
                            }
                        });
                    }
                    polygon.polygon.hierarchy = new that._cesium.CallbackProperty(function () {
                        return new that._cesium.PolygonHierarchy(BowPoints);
                    }, false);
                    polygon.GeoType = 'Bow';
                    that.MilitaryStandardObj.push(polygon.id);
                } else {
                    anchorpoints.pop();
                    pottingPoint.pop();
                    var GeoPoints = that._createGeoPoints(viewer, [{ x: w_p.x, y: w_p.y }]);
                    anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                    pottingPoint.push(GeoPoints);

                    var window_points = that._computeBowPoints(anchorpoints);
                    var GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    BowPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        that.drawHandler.setInputAction(function (event) {
            that.end && that.end();
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);

        this.end = (type) => {
            this.end = undefined;
            polygon && (polygon.pottingPoint = pottingPoint);
            that._core.CreateTooltip(tooltip, undefined, false);
            that.drawHandler.destroy();
            //设置鼠标样式
            that._core.mouse(that._viewer.container, 0);

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            if (type === 'cancel') {
                polygon && (viewer.entities.remove(polygon),
                    that.MilitaryStandardObj.pop());
                return;
            }
            //回调
            callBack && callBack(polygon);
        };
        return this;
    };
    /**
    * 创建军标(钳击箭头,二维)
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    MilitaryStandard.prototype.createPincerArrow = function (type1, option, callBack) {
        var type = type1;
        var that = this;
        var viewer = this._viewer;

        var anchorpoints = [];
        var pottingPoint = [];
        var arrowEntity = undefined;
        var tooltip = "单击开始绘制";
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        //设置鼠标样式
        that._core.mouse(that._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        tree.states = 1;
        that.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);

        that.drawHandler.setInputAction(function (event) {
            var cartesian;
            var window_position = event.position;
            tooltip = "单击增加点";
            cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;
            if (anchorpoints.length > 4) { //结束绘制
                that._core.CreateTooltip(tooltip, event.position, false);
                arrowEntity.pottingPoint = pottingPoint;
                that.drawHandler.destroy();
                //设置鼠标样式
                that._core.mouse(that._viewer.container, 0);

                setTimeout(function () {
                    tree.states = 0;
                }, 100);
                callBack && callBack(arrowEntity);
                return;
            } else {
                anchorpoints.push(cartesian);
                var GeoPoints = that._createGeoPoints(viewer, [{ x: window_position.x, y: window_position.y }]);
                pottingPoint.push(GeoPoints);
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        that.drawHandler.setInputAction(function (evt) { //移动时绘制面
            if (anchorpoints.length < 2) return;
            that._core.CreateTooltip(tooltip, evt.endPosition, true);

            var cartesian;
            cartesian = that._getPosition.getMousePosition(evt);
            if (!cartesian) return;
            if (anchorpoints.length >= 2) {
                if (!that._cesium.defined(arrowEntity)) {
                    anchorpoints.push(cartesian);
                    var GeoPoints = that._createGeoPoints(viewer, [evt.endPosition]);
                    pottingPoint.push(GeoPoints);

                    arrowEntity = that.showArrowOnMap(anchorpoints, type, option);
                    arrowEntity.GeoType = 'PincerArrow';
                    that.MilitaryStandardObj.push(arrowEntity.id);
                } else {
                    anchorpoints.pop();
                    pottingPoint.pop();
                    anchorpoints.push(cartesian);
                    var GeoPoints = that._createGeoPoints(viewer, [evt.endPosition]);
                    pottingPoint.push(GeoPoints);
                }
            }

        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
    };
    /**
    * 创建军标(攻击箭头,二维)
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    MilitaryStandard.prototype.createAttackArrow = function (type1, option, callBack) {
        var type = type1;
        var that = this;
        var viewer = this._viewer;

        var anchorpoints = [];
        var pottingPoint = [];
        var arrowEntity = undefined;
        var tooltip = "单击开始绘制";
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        //设置鼠标样式
        that._core.mouse(that._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        tree.states = 1;
        that.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);

        that.drawHandler.setInputAction(function (event) {
            var cartesian;
            tooltip = "单击增加点";
            cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;
            anchorpoints.push(cartesian);
            var GeoPoints = that._createGeoPoints(viewer, [event.position]);
            pottingPoint.push(GeoPoints);
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        that.drawHandler.setInputAction(function (event) {
            if (anchorpoints.length > 1) {
                anchorpoints.pop();
                pottingPoint.pop();
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
        that.drawHandler.setInputAction(function (evt) { //移动时绘制面
            if (anchorpoints.length < 2) return;
            that._core.CreateTooltip(tooltip, evt.endPosition, true);
            var cartesian;
            cartesian = that._getPosition.getMousePosition(evt);
            if (!cartesian) return;
            if (anchorpoints.length >= 2) {
                if (!that._cesium.defined(arrowEntity)) {
                    anchorpoints.push(cartesian);
                    var GeoPoints = that._createGeoPoints(viewer, [evt.endPosition]);
                    pottingPoint.push(GeoPoints);

                    arrowEntity = that.showAttackArrowOnMap(anchorpoints, type, option);
                    arrowEntity.GeoType = 'AttackArrow';
                    that.MilitaryStandardObj.push(arrowEntity.id);
                } else {
                    anchorpoints.pop();
                    pottingPoint.pop();
                    anchorpoints.push(cartesian);
                    var GeoPoints = that._createGeoPoints(viewer, [evt.endPosition]);
                    pottingPoint.push(GeoPoints);
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        that.drawHandler.setInputAction(function (evt) {
            that._core.CreateTooltip(tooltip, evt.position, false);
            arrowEntity.pottingPoint = pottingPoint;

            that.drawHandler.destroy();
            //设置鼠标样式
            that._core.mouse(that._viewer.container, 0);

            setTimeout(function () {
                tree.states = 0;
            }, 100);
            callBack && callBack(arrowEntity);
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);
    };
    /**
    * 创建军标(集结地,二维)
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    MilitaryStandard.prototype.createHandlerPolygon = function (type1, option, callBack) {
        var type = type1;

        var tooltip = "单击开始绘制";
        var that = this;
        var viewer = this._viewer;

        var anchorpoints = [];
        var pottingPoint = [];
        var polygon = undefined;
        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        //设置鼠标样式
        that._core.mouse(that._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        tree.states = 1;
        var jjdPoints;
        that.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        that.drawHandler.setInputAction(function (event) {
            var window_position = event.position;
            tooltip = "单击完成绘制";
            if (anchorpoints.length == 0) {
                var GeoPoints = that._createGeoPoints(viewer, [{ x: window_position.x, y: window_position.y }]);
                anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] }, { x: GeoPoints[0] + 0.0000001, y: GeoPoints[1] + 0.0000001, z: GeoPoints[2] });
                pottingPoint.push(GeoPoints, GeoPoints);
            } else if (anchorpoints.length == 2) {
                that._core.CreateTooltip(tooltip, window_position, false);
                polygon.pottingPoint = pottingPoint;
                setTimeout(function () {
                    tree.states = 0;
                }, 100);
                that.drawHandler.destroy();
                //设置鼠标样式
                that._core.mouse(that._viewer.container, 0);

                callBack && callBack(polygon);
            }    }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
        that.drawHandler.setInputAction(function (event) {
            var w_p = event.endPosition;
            that._core.CreateTooltip(tooltip, event.endPosition, true);
            if (anchorpoints.length > 1) {
                var window_points, GeoPoints, GatheringPlacePoints, CardinalPoints;

                if (!Cesium.defined(polygon)) {
                    GatheringPlacePoints = that._computeGatheringPlacePoints(anchorpoints);
                    CardinalPoints = that.createCloseCardinal(GatheringPlacePoints);
                    window_points = that.calculatePointsFBZ3(CardinalPoints, 100);
                    GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    jjdPoints = GeoPoints;
                    ///type判断二维三维
                    polygon = that.plotingGatheringPlace(viewer, anchorpoints, type, option);
                    polygon.polygon.hierarchy = new that._cesium.CallbackProperty(function () {
                        return new that._cesium.PolygonHierarchy(that._cesium.Cartesian3.fromDegreesArrayHeights(jjdPoints))
                    }, false);
                    polygon.GeoType = 'GatheringPlace';
                    that.MilitaryStandardObj.push(polygon.id);
                }
                else {
                    anchorpoints.pop();
                    pottingPoint.pop();
                    var GeoPoints = that._createGeoPoints(viewer, [{ x: w_p.x, y: w_p.y }]);
                    anchorpoints.push({ x: GeoPoints[0], y: GeoPoints[1], z: GeoPoints[2] });
                    pottingPoint.push(GeoPoints);

                    GatheringPlacePoints = that._computeGatheringPlacePoints(anchorpoints);
                    CardinalPoints = that.createCloseCardinal(GatheringPlacePoints);
                    window_points = that.calculatePointsFBZ3(CardinalPoints, 100);
                    var GeoPoints = [];
                    window_points.forEach(item => {
                        GeoPoints.push(item.x, item.y, anchorpoints[0].z);
                    });
                    jjdPoints = GeoPoints;
                }
            }
        }, that._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return anchorpoints;
    };
    /**
    * 绘制聚集区
    * @param viewer
    * @param anchorpoints
    */
    MilitaryStandard.prototype.plotingGatheringPlace = function (viewer, anchorpoints, type, option) {
        var GatheringPlacePoints = this._computeGatheringPlacePoints(anchorpoints);
        var CardinalPoints = this.createCloseCardinal(GatheringPlacePoints);
        var window_points = this.calculatePointsFBZ3(CardinalPoints, 100);
        var GeoPoints = this._createGeoPoints(viewer, window_points);
        var polygon;

        if (type == "polygon") {
            polygon = viewer.entities.add({
                name: 'GatheringPlace',
                polygon: {
                    hierarchy: this._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints),
                    material: this._cesium.Color.fromCssColorString(this._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                    outline: this._core.defaultValue(option.outline, true),
                    outlineColor: this._cesium.Color.fromCssColorString(this._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),

                }
            });
        } else {
            polygon = viewer.entities.add({
                name: 'GatheringPlace',
                polygon: {
                    hierarchy: this._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints),
                    extrudedHeight: this._core.defaultValue(option.extrudedHeight, 200) + GeoPoints[2],
                    height: GeoPoints[2],
                    material: this._cesium.Color.fromCssColorString(this._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                    outline: this._core.defaultValue(option.outline, true),
                    outlineColor: this._cesium.Color.fromCssColorString(this._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),
                }
            });
        }
        return polygon
    };
    //打开
    MilitaryStandard.prototype.open = function (file) {
        var that = this;
        var viewer = this._viewer;
        var reader = new FileReader();//读取操作就是由它完成的。
        reader.readAsText(file);//读取文件的内容
        var collection = new that._cesium.EntityCollection();
        reader.onload = function () {
            //当读取完成之后会回调这个函数，然后此时文件的内容存储到了result中。直接操作即可。
            let data = JSON.parse(this.result);
            let features = data.features;
            let control_w_p;
            let ArrowPoint;
            features.forEach(item => {
                ArrowPoint = item.geometry.coordinates;
                let points = [];
                if (item.type == 'PincerArrow') {
                    let res = JBAlgorithm.algorithm.doubleArrow(ArrowPoint);
                    let returnData = [];
                    let index = JSON.stringify(res.polygonalPoint).indexOf("null");
                    if (index == -1) returnData = res.polygonalPoint;
                    control_w_p = returnData;
                } else if (item.type == 'AttackArrow') {
                    let res = JBAlgorithm.algorithm.tailedAttackArrow(ArrowPoint);
                    let index = JSON.stringify(res.polygonalPoint).indexOf("null");
                    let returnData = [];
                    if (index == -1) returnData = res.polygonalPoint;
                    control_w_p = returnData;
                } else {
                    ArrowPoint.forEach(point => {
                        points.push({
                            x: point[0],
                            y: point[1],
                            z: point[2]
                        });
                    });
                    if (item.type == "StraightArrow") {///粗直箭头
                        control_w_p = that.calculateMorePoints(points);
                    } else if (item.type == "RoundedRectangle") {///圆角矩形
                        control_w_p = that._computeRoundedRectanglePoints(points);
                    } else if (item.type == "Sector") {///扇形
                        control_w_p = that._computeSectorPoints(points);
                    } else if (item.type == "Bow") {///弓形
                        control_w_p = that._computeBowPoints(points);
                    } else if (item.type == "GatheringPlace") {///聚集区
                        let GatheringPlacePoints = that._computeGatheringPlacePoints(points);
                        let CardinalPoints = that.createCloseCardinal(GatheringPlacePoints);
                        control_w_p = that.calculatePointsFBZ3(CardinalPoints, 100);
                    } else if (item.type == "SwallowtailArrow") {///燕尾箭头
                        control_w_p = that._computeSwallowtailArrow(points);
                    } else if (item.type == "Bezierline") {///贝塞尔曲线
                        control_w_p = that._createBezierPoints(points);
                    } else if (item.type == "BezierArrow") {///贝塞尔箭头
                        control_w_p = that._createBezierPoints(points);
                    }
                }

                let GeoPoints;
                if (item.type !== 'AttackArrow' && item.type !== 'PincerArrow') {
                    GeoPoints = [];
                    control_w_p.forEach(item => {
                        GeoPoints.push(item.x, item.y, points[0].z);
                    });
                    GeoPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                } else {
                    GeoPoints = control_w_p;
                }

                let entity;
                if (item.type.indexOf("Bezier") >= 0) {
                    entity = viewer.entities.add({
                        name: item.name,
                        polyline: {
                            positions: new that._cesium.CallbackProperty(function () {
                                return GeoPoints;
                            }, false),
                            width: item.style.width,
                            material: item.type === 'BezierArrow' ?
                                new that._cesium.PolylineArrowMaterialProperty(
                                    new that._cesium.Color.fromCssColorString(item.style.fillColor.color).withAlpha(item.style.fillColor.alpha)
                                ) :
                                new that._cesium.Color.fromCssColorString(item.style.fillColor.color).withAlpha(item.style.fillColor.alpha)
                        }
                    });
                } else {
                    entity = viewer.entities.add({
                        name: item.name,
                        polygon: {
                            hierarchy: new that._cesium.CallbackProperty(function () {
                                return new that._cesium.PolygonHierarchy(GeoPoints)
                            }, false),
                            fill: true,
                            extrudedHeight: item.style.extrudedHeight !== undefined ? item.style.extrudedHeight + item.style.height : undefined,
                            height: item.style.height,
                            material: new that._cesium.Color.fromCssColorString(item.style.fillColor.color).withAlpha(item.style.fillColor.alpha),
                            outline: item.style.outline,
                            outlineColor: item.style.outlineColor ? new that._cesium.Color.fromCssColorString(item.style.outlineColor.color).withAlpha(item.style.outlineColor.alpha) : undefined,
                        }
                    });
                }
                entity.GeoType = item.type;
                entity.pottingPoint = ArrowPoint;
                that.MilitaryStandardObj.push(entity.id);
                collection.add(entity);
            });
            viewer.flyTo(collection);
            //启用编辑
            if (that.MilitaryStandardObj.length && !that.editHandler) {
                that.edit(that.openEdit, that.editOption);
            }
        };
    };
    //清空
    MilitaryStandard.prototype.clear = function () {
        var viewer = this._viewer;
        this.MilitaryStandardObj.forEach(id => {
            viewer.entities.removeById(id);
        });
        this.MilitaryStandardObj = [];
        window.layuiLayer.close(this.layerIndex);
        if (!this.MilitaryStandardObj.length && this.editHandler) {
            this.edit(false);
        }
    };
    //保存
    MilitaryStandard.prototype.save = function () {
        var viewer = this._viewer;
        var data = {
            "type": "FeatureCollection",
            "features": []
        };
        var feature;
        var that = this;
        function getColor(rgba) {
            return {
                color: that.colorHex('rgb(' + rgba.red * 255 + ',' + rgba.green * 255 + ',' + rgba.blue * 255 + ')'),
                alpha: rgba.alpha
            }
        }

        this.MilitaryStandardObj.forEach(id => {
            let item = viewer.entities.getById(id);
            if (item) {
                feature = {
                    type: item.GeoType,
                    name: item.name,
                    editType: ''
                };
                let pottingPoints = item.pottingPoint;
                if (item.polyline) {
                    feature.editType = 'GroundPolyline';
                    feature.geometry = {
                        "type": "polyline",
                        "coordinates": pottingPoints
                    };
                    feature.style = {
                        "fillColor": getColor(item.polyline.material.color._value),
                        "width": item.polyline.width.getValue()
                    };
                } else {
                    feature.editType = 'GroundPolygon';
                    feature.geometry = {
                        "type": "polygon",
                        "coordinates": pottingPoints
                    };
                    feature.style = {
                        "fillColor": getColor(item.polygon.material.color._value)
                    };
                    if (item.polygon.extrudedHeight) {
                        feature.editType = 'ExtrudedPolygon';
                        feature.style.height = item.polygon.height.getValue();
                        feature.style.extrudedHeight = item.polygon.extrudedHeight.getValue() - item.polygon.height.getValue();
                        item.polygon.outline && (feature.style.outline = item.polygon.outline.getValue());
                        item.polygon.outlineColor && (feature.style.outlineColor = getColor(item.polygon.outlineColor._value));
                    }
                }
            }
            data.features.push(feature);
        });
        var content = JSON.stringify(data);
        var blob = new Blob([content], { type: "text/plain;charset=utf-8" });
        this._core.saveAs(blob, "军标.json");
    };
    //rgb转hex
    MilitaryStandard.prototype.colorHex = function (rgb) {
        var _this = rgb;
        var reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;
        if (/^(rgb|RGB)/.test(_this)) {
            var str = _this.replace(/(rgb|RGB)*/g, "");
            str = str.replace("(", "").replace(")", "");
            var aColor = str.split(",");
            var strHex = "#";
            for (var i = 0; i < aColor.length; i++) {
                var hex = Number(aColor[i]).toString(16);
                hex = hex.length === 1 ? 0 + '' + hex : hex;// 保证每个rgb的值为2位
                if (hex === "0") {
                    hex += hex;
                }
                strHex += hex;
            }
            if (strHex.length !== 7) {
                strHex = _this;
            }
            return strHex;
        } else if (reg.test(_this)) {
            var aNum = _this.replace(/#/, "").split("");
            if (aNum.length === 6) {
                return _this;
            } else if (aNum.length === 3) {
                var numHex = "#";
                for (var i = 0; i < aNum.length; i += 1) {
                    numHex += (aNum[i] + aNum[i]);
                }
                return numHex;
            }
        } else {
            return _this;
        }
    };
    //复制军标在线
    MilitaryStandard.prototype.copyJb = function (obj) {
        var entity;
        if (obj.type == "StraightArrow" || obj.type == "SwallowtailArrow" || obj.type == "PincerArrow") {
            var hierarchy = { holes: [], positions: this.szposis(obj.pos) };
            entity = this._viewer.entities.add({
                name: 'StraightArrow',
                polygon: {
                    hierarchy: hierarchy,
                    material: this._cesium.Color.RED.withAlpha(0.5)
                }
            });
        } else if (obj.type == "BezierArrow") {
            entity = this._viewer.entities.add({
                name: 'BezierArrow',
                polyline: {
                    positions: this.szposis(obj.pos),
                    width: 5,
                    material: new this._cesium.PolylineArrowMaterialProperty(this._cesium.Color.RED)
                }
            });
        } else if (obj.img) {
            entity = this._viewer.entities.add({
                //中心的位置（长、宽、高）
                position: this.zfsz(obj.pos),
                billboard: {
                    image: obj.img,
                    show: true,
                }
            });
        } else if (obj.text) {
            entity = this._viewer.entities.add({
                position: this.zfsz(obj.pos),
                label: {
                    text: obj.text, //文本
                    horizontalOrigin: this._cesium.HorizontalOrigin.CENTER,
                    verticalOrigin: this._cesium.VerticalOrigin.CENTER,
                    show: true,
                    showBackground: false,
                }
            });
        }
        entity._id = obj.id;
        that.objectsToExclude.push(entity);
        return entity;
    };
    //根据id查询对象
    MilitaryStandard.prototype.getEntityById = function (id) {
        var entity = this._viewer.entities.getById(id);
        var objs;
        if (entity.polyline != undefined && entity.polyline) {
            objs = {
                obj: entity.polyline,
                type: entity.name,
                posion: entity.polyline.positions.getValue()
            };
        } else if (entity.polygon != undefined && entity.polygon) {
            objs = {
                obj: entity.polygon,
                type: entity.name,
                posion: entity.polygon.hierarchy.getValue().positions
            };
        } else if (entity.label != undefined && entity.label) {
            objs = {
                obj: entity.label,
                type: "lable",
                text: entity.label.text.getValue(),
                posion: entity.position.getValue()
            };
        } else if (entity.billboard != undefined && entity.billboard) {
            objs = {
                obj: entity.billboard,
                type: "img",
                img: entity.billboard.image.getValue(),
                posion: entity.position.getValue()
            };
        }
        return objs;
    };
    //数组
    MilitaryStandard.prototype.szposis = function (obj) {
        var pos = [];
        var array = obj.split(",(");
        for (var i = 0; i < array.length; i++) {
            var op = this.zfsz(array[i]);
            pos.push(op);
        }
        return pos;
    };
    //提取坐标
    MilitaryStandard.prototype.zfsz = function (obj) {
        var posion;
        var array = obj.split(",");
        for (var i = 0; i < array.length; i++) {
            if (array[i].indexOf("(") != -1) {
                array[i] = array[i].replace("(", "");
            } else if (array[i].indexOf(")") != -1) {
                array[i] = array[i].replace("(", "");
            }
        }
        posion = {
            x: parseFloat(array[0]),
            y: parseFloat(array[1]),
            z: parseFloat(array[2])
        };
        return posion
    };
    ///绘制箭头，钳击箭头
    MilitaryStandard.prototype.showArrowOnMap = function (positions, type, option) {
        var that = this;
        var latlng = that._viewer.scene.globe.ellipsoid.cartesianToCartographic(positions[0]);
        var height = latlng.height;
        var update = function () {
            //计算面
            if (positions.length < 3) {
                return null;
            }
            var lnglatArr = [];

            for (var i = 0; i < positions.length; i++) {
                // var lnglat = $this.cartesianToLatlng(positions[i]);
                var latlng = that._viewer.scene.globe.ellipsoid.cartesianToCartographic(positions[i]);
                var lat = that._cesium.Math.toDegrees(latlng.latitude);
                var lng = that._cesium.Math.toDegrees(latlng.longitude);
                lnglatArr.push([lng, lat]);
            }
            var res = JBAlgorithm.algorithm.doubleArrow(lnglatArr);
            var returnData = [];
            var index = JSON.stringify(res.polygonalPoint).indexOf("null");
            if (index == -1) returnData = res.polygonalPoint;
            return new that._cesium.PolygonHierarchy(returnData);
        };
        var entiy;

        if (type == 'polygon') {
            entiy = that._viewer.entities.add({
                name: 'PincerArrow',
                polygon: new that._cesium.PolygonGraphics({
                    hierarchy: new that._cesium.CallbackProperty(update, false),
                    show: true,
                    fill: true,
                    material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                    outline: that._core.defaultValue(option.outline, true),
                    outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),
                })
            });
        } else if (type == 'box') {
            entiy = that._viewer.entities.add({
                name: 'PincerArrow',
                polygon: new that._cesium.PolygonGraphics({
                    hierarchy: new that._cesium.CallbackProperty(update, false),
                    show: true,
                    fill: true,
                    material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                    outline: that._core.defaultValue(option.outline, true),
                    outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),
                    extrudedHeight: height + that._core.defaultValue(option.extrudedHeight, 200),
                    height: height,
                })
            });

        }
        return entiy
    };
    ///绘制箭头，攻击箭头
    MilitaryStandard.prototype.showAttackArrowOnMap = function (positions, type, option) {
        var that = this;
        var latlng = that._viewer.scene.globe.ellipsoid.cartesianToCartographic(positions[0]);
        var height = latlng.height;

        var update = function () {
            //计算面
            if (positions.length < 3) {
                return null;
            }
            var lnglatArr = [];
            for (var i = 0; i < positions.length; i++) {
                var lnglat = that.cartesianToLatlng(positions[i]);
                lnglatArr.push(lnglat);
            }
            var res = JBAlgorithm.algorithm.tailedAttackArrow(lnglatArr);
            var index = JSON.stringify(res.polygonalPoint).indexOf("null");
            var returnData = [];
            if (index == -1) returnData = res.polygonalPoint;
            return new that._cesium.PolygonHierarchy(returnData);
        };

        return this._viewer.entities.add({
            name: 'AttackArrow',
            polygon: new that._cesium.PolygonGraphics({
                hierarchy: new that._cesium.CallbackProperty(update, false),
                show: true,
                fill: true,
                classificationType: that._cesium.ClassificationType.TERRAIN,
                extrudedHeight: type === 'box' ? that._core.defaultValue(option.extrudedHeight, 200) + height : undefined,
                height: type === 'box' ? height : undefined,
                material: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                outline: that._core.defaultValue(option.outline, true),
                outlineColor: that._cesium.Color.fromCssColorString(that._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),
            })
        });
    };
    MilitaryStandard.prototype.cartesianToLatlng = function (cartesian) {
        var latlng = this._viewer.scene.globe.ellipsoid.cartesianToCartographic(cartesian);
        var lat = this._cesium.Math.toDegrees(latlng.latitude);
        var lng = this._cesium.Math.toDegrees(latlng.longitude);
        return [lng, lat];
    };
    //钳击箭头坐标转化
    MilitaryStandard.prototype.getCatesian3FromPX = function (px, viewer) {
        var picks = this._viewer.scene.drillPick(px);
        this._viewer.render();
        var cartesian;
        var isOn3dtiles = true;

        for (var i = 0; i < picks.length; i++) {
            if ((picks[i] && picks[i].primitive) || picks[i] instanceof this._cesium.Cesium3DTileFeature) { //模型上拾取
                isOn3dtiles = true;
            }
        }
        if (isOn3dtiles) {
            cartesian = this._viewer.scene.pickPosition(px);
        } else {
            var ray = this._viewer.camera.getPickRay(px);
            if (!ray) return null;
            cartesian = this._viewer.scene.globe.pick(ray, this._viewer.scene);
        }
        return cartesian;
    };
    /**
    *根据特征点屏幕坐标计算地理坐标
    * @param viewer
    * @param window_points 屏幕坐标
    * @returns {Array} 地理坐标（经纬度）
    * @private
    */
    MilitaryStandard.prototype._createGeoPoints = function (viewer, window_points) {
        var points = [];
        var ray, cartesian, cartographic, lng, lat, height;
        for (var i = 0; i < window_points.length; i++) {
            ray = viewer.camera.getPickRay(window_points[i]);
            ray && (cartesian = viewer.scene.globe.pick(ray, viewer.scene));

            // feature = viewer.scene.pick(window_points[i]);
            // if (feature && (feature.id instanceof this._cesium.Entity || feature.id instanceof this._cesium.EntityCollection)) {
            //     feature = undefined;
            // }
            // if (feature) {
            //     _cartesian = viewer.scene.pickPosition(window_points[i]);
            //     if (_cartesian) {
            //         cartesian = _cartesian;
            //     }
            // }

            if (cartesian) {
                cartographic = this._cesium.Cartographic.fromCartesian(cartesian);
                lng = this._cesium.Math.toDegrees(cartographic.longitude);
                lat = this._cesium.Math.toDegrees(cartographic.latitude);
                height = cartographic.height;
                points.push(lng, lat, height);
            }

        }
        return points;
    };
    /**
    *根据特征点地理坐标计算屏幕坐标
    * @param viewer
    * @param geo_points 地理坐标（经纬度）
    * @returns {Array} 屏幕坐标
    * @private
    */
    MilitaryStandard.prototype._createScreenPoints = function (viewer, geo_points) {
        var points = [];
        var pointposition;
        for (var i = 0; i < geo_points.length; i++) {
            pointposition = viewer.scene.cartesianToCanvasCoordinates(geo_points[i]);
            points.push(pointposition);
        }
        return points;
    };
    //
    MilitaryStandard.prototype._createBezierPoints = function (anchorpoints) {
        var numpoints = 100;
        var points = [];
        for (var i = 0; i <= numpoints; i++) {
            var point = this._computeBezierPoints(anchorpoints, i / numpoints);
            points.push(point);
        }
        return points;
    };
    /**
    * 计算贝塞尔曲线特征点
    * @param anchorpoints
    * @param t
    * @returns {{x: number, y: number}}
    * @private
    */
    MilitaryStandard.prototype._computeBezierPoints = function (anchorpoints, t) {
        var x = 0, y = 0;
        var Binomial_coefficient = this._computeBinomial(anchorpoints);
        for (var j = 0; j < anchorpoints.length; j++) {
            var tempPoint = anchorpoints[j];
            x += tempPoint.x * Math.pow((1 - t), (anchorpoints.length - 1 - j)) * Math.pow(t, j) * Binomial_coefficient[j];
            y += tempPoint.y * Math.pow((1 - t), (anchorpoints.length - 1 - j)) * Math.pow(t, j) * Binomial_coefficient[j];
        }
        return { x: x, y: y }
    };
    /**
    * 计算二项式系数
    * @param anchorpoints
    * @returns {Array}
    * @private
    */
    MilitaryStandard.prototype._computeBinomial = function (anchorpoints) {
        var lens = anchorpoints.length;
        var Binomial_coefficient = [];
        Binomial_coefficient.push(1);
        for (var k = 1; k < lens - 1; k++) {
            var cs = 1, bcs = 1;
            for (var m = 0; m < k; m++) {
                cs = cs * (lens - 1 - m);
                bcs = bcs * (k - m);
            }
            Binomial_coefficient.push(cs / bcs);
        }
        Binomial_coefficient.push(1);
        return Binomial_coefficient;
    };
    /**
    * 计算聚集区特征点
    * @param anchorpoints
    * @returns {Array}
    * @private
    */
    MilitaryStandard.prototype._computeGatheringPlacePoints = function (anchorpoints) {
        var points = [];
        if (anchorpoints.length == 2) {
            var originP = anchorpoints[0];
            var lastP = anchorpoints[anchorpoints.length - 1];
            var vectorOL = { x: lastP.x - originP.x, y: lastP.y - originP.y };
            var dOL = Math.sqrt(vectorOL.x * vectorOL.x + vectorOL.y * vectorOL.y);
            var v_O_P1_lr = this.calculateVector(vectorOL, Math.PI / 3, Math.sqrt(3) / 12 * dOL);
            var originP_P1 = v_O_P1_lr[1];
            var p1 = { x: originP.x + originP_P1.x, y: originP.y + originP_P1.y };
            var p2 = { x: (originP.x + lastP.x) / 2, y: (originP.y + lastP.y) / 2 };
            var v_L_P3_lr = this.calculateVector(vectorOL, Math.PI * 2 / 3, Math.sqrt(3) / 12 * dOL);
            var lastP_P3 = v_L_P3_lr[1];
            var p3 = { x: lastP.x + lastP_P3.x, y: lastP.y + lastP_P3.y };
            var v_O_P5_lr = this.calculateVector(vectorOL, Math.PI / 2, 1 / 2 * dOL);
            var v_O_P5 = v_O_P5_lr[0];
            var p5 = { x: v_O_P5.x + p2.x, y: v_O_P5.y + p2.y };
            var p0 = originP;
            var p4 = lastP;
            points.push(p0, p1, p2, p3, p4, p5);
        }
        return points;
    };
    /**
    * 生成闭合的样条点
    * @param points
    * @returns {*}
    */
    MilitaryStandard.prototype.createCloseCardinal = function (points) {
        if (points == null || points.length < 3) {
            return points;
        }
        //获取起点，作为终点，以闭合曲线。
        var lastP = points[0];
        points.push(lastP);
        //定义传入的点数组，将在点数组中央（每两个点）插入两个控制点
        var cPoints = points;
        //包含输入点和控制点的数组
        var cardinalPoints = [];
        //至少三个点以上
        //这些都是相关资料测出的经验数值
        //定义张力系数，取值在0<t<0.5
        var t = 0.4;
        //误差控制，是一个大于等于0的数，用于三点非常趋近与一条直线时，减少计算量
        var e = 0.005;
        //传入的点数量，至少有三个，n至少为2
        var n = cPoints.length - 1;
        //从开始遍历到倒数第二个，其中倒数第二个用于计算起点（终点）的插值控制点
        for (var k = 0; k <= n - 1; k++) {
            //计算起点（终点）的左右控制点
            if (k == n - 1) {
                //三个基础输入点
                var p0 = cPoints[n - 1];
                var p1 = cPoints[0];
                var p2 = cPoints[1];
            }
            else {
                var p0 = cPoints[k];
                var p1 = cPoints[k + 1];
                var p2 = cPoints[k + 2];
            }
            //定义p1的左控制点和右控制点
            var p1l = { x: undefined, y: undefined };
            var p1r = { x: undefined, y: undefined };
            //通过p0、p1、p2计算p1点的做控制点p1l和又控制点p1r
            //计算向量p0_p1和p1_p2
            var p0_p1 = { x: p1.x - p0.x, y: p1.y - p0.y };
            var p1_p2 = { x: p2.x - p1.x, y: p2.y - p1.y };
            //并计算模
            var d01 = Math.sqrt(p0_p1.x * p0_p1.x + p0_p1.y * p0_p1.y);
            var d12 = Math.sqrt(p1_p2.x * p1_p2.x + p1_p2.y * p1_p2.y);
            //向量单位化
            var p0_p1_1 = { x: p0_p1.x / d01, y: p0_p1.y / d01 };
            var p1_p2_1 = { x: p1_p2.x / d12, y: p1_p2.y / d12 };
            //计算向量p0_p1和p1_p2的夹角平分线向量
            var p0_p1_p2 = { x: p0_p1_1.x + p1_p2_1.x, y: p0_p1_1.y + p1_p2_1.y };
            //计算向量 p0_p1_p2 的模
            var d012 = Math.sqrt(p0_p1_p2.x * p0_p1_p2.x + p0_p1_p2.y * p0_p1_p2.y);
            //单位化向量p0_p1_p2
            var p0_p1_p2_1 = { x: p0_p1_p2.x / d012, y: p0_p1_p2.y / d012 };
            //判断p0、p1、p2是否共线，这里判定向量p0_p1和p1_p2的夹角的余弦和1的差值小于e就认为三点共线
            var cosE_p0p1p2 = (p0_p1_1.x * p1_p2_1.x + p0_p1_1.y * p1_p2_1.y) / 1;
            //共线
            if (Math.abs(1 - cosE_p0p1p2) < e) {
                //计算p1l的坐标
                p1l.x = p1.x - p1_p2_1.x * d01 * t;
                p1l.y = p1.y - p1_p2_1.y * d01 * t;
                //计算p1r的坐标
                p1r.x = p1.x + p0_p1_1.x * d12 * t;
                p1r.y = p1.y + p0_p1_1.y * d12 * t;
            }
            //非共线
            else {
                //计算p1l的坐标
                p1l.x = p1.x - p0_p1_p2_1.x * d01 * t;
                p1l.y = p1.y - p0_p1_p2_1.y * d01 * t;
                //计算p1r的坐标
                p1r.x = p1.x + p0_p1_p2_1.x * d12 * t;
                p1r.y = p1.y + p0_p1_p2_1.y * d12 * t;
            }
            //记录起点（终点）的左右插值控制点及倒数第二个控制点
            if (k == n - 1) {
                cardinalPoints[0] = p1;
                cardinalPoints[1] = p1r;
                cardinalPoints[(n - 2) * 3 + 2 + 3] = p1l;
                cardinalPoints[(n - 2) * 3 + 2 + 4] = cPoints[n];
            }
            else {
                //记录下这三个控制点
                cardinalPoints[k * 3 + 2 + 0] = p1l;
                cardinalPoints[k * 3 + 2 + 1] = p1;
                cardinalPoints[k * 3 + 2 + 2] = p1r;
            }
        }
        return cardinalPoints
    };
    /**
    * 计算三阶贝塞尔点
    * @param points
    * @param part
    * @returns {Array}
    */
    MilitaryStandard.prototype.calculatePointsFBZ3 = function (points, part) {
        if (!part) part = 20;
        //获取待拆分的点
        var bezierPts = [];
        var scale = 0.05;
        if (part > 0) {
            scale = 1 / part;
        }
        for (var i = 0; i < points.length - 3;) {
            //起始点
            var pointS = points[i];
            //第一个控制点
            var pointC1 = points[i + 1];
            //第二个控制点
            var pointC2 = points[i + 2];
            //结束点
            var pointE = points[i + 3];
            bezierPts.push(pointS);
            for (var t = 0; t < 1;) {
                //三次贝塞尔曲线公式
                var x = (1 - t) * (1 - t) * (1 - t) * pointS.x + 3 * t * (1 - t) * (1 - t) * pointC1.x + 3 * t * t * (1 - t) * pointC2.x + t * t * t * pointE.x;
                var y = (1 - t) * (1 - t) * (1 - t) * pointS.y + 3 * t * (1 - t) * (1 - t) * pointC1.y + 3 * t * t * (1 - t) * pointC2.y + t * t * t * pointE.y;
                var point = { x: x, y: y };
                bezierPts.push(point);
                t += scale;
            }
            i += 3;
            if (i >= points.length) {
                bezierPts.push(pointS);
            }
        }
        //需要判定一下最后一个点是否存在
        bezierPts[bezierPts.length - 1];
        points[points.length - 1];
        /*if (!poRE.equals(popE)) {
            bezierPts.push(popE.clone());
        }*/
        return bezierPts;
    };
    /**
    * 根据基准向量、夹角、长度计算指定向量
    * @param v
    * @param theta
    * @param d
    * @returns {Array}
    */
    MilitaryStandard.prototype.calculateVector = function (v, theta, d) {
        if (!theta) theta = Math.PI / 2;
        if (!d) d = 1;
        var x_1;
        var x_2;
        var y_1;
        var y_2;
        var v_l;
        var v_r;
        var d_v = Math.sqrt(v.x * v.x + v.y * v.y);
        if (v.y == 0) {
            x_1 = x_2 = d_v * d * Math.cos(theta) / v.x;
            if (v.x > 0) {
                y_1 = Math.sqrt(d * d - x_1 * x_1);
                y_2 = -y_1;
            }
            else if (v.x < 0) {
                y_2 = Math.sqrt(d * d - x_1 * x_1);
                y_1 = -y_2;
            }
            v_l = { x: x_1, y: y_1 };
            v_r = { x: x_2, y: y_2 };
        }
        else {
            var n = -v.x / v.y;
            var m = d * d_v * Math.cos(theta) / v.y;
            var a = 1 + n * n;
            var b = 2 * n * m;
            var c = m * m - d * d;
            x_1 = (-b - Math.sqrt(b * b - 4 * a * c)) / (2 * a);
            x_2 = (-b + Math.sqrt(b * b - 4 * a * c)) / (2 * a);
            y_1 = n * x_1 + m;
            y_2 = n * x_2 + m;
            if (v.y >= 0) {
                v_l = { x: x_1, y: y_1 };
                v_r = { x: x_2, y: y_2 };
            }
            else if (v.y < 0) {
                v_l = { x: x_2, y: y_2 };
                v_r = { x: x_1, y: y_1 };
            }
        }
        return [v_l, v_r];
    };
    /**
    * 绘制燕尾箭头
    * @param viewer
    * @param anchorpoints
    */
    MilitaryStandard.prototype.plotingSwallowtailArrow = function (viewer, anchorpoints, type, option) {
        var window_points = this._computeSwallowtailArrow(anchorpoints);
        var GeoPoints = [];
        window_points.forEach(item => {
            GeoPoints.push(item.x, item.y, anchorpoints[0].z);
        });
        var polygon;
        if (type == "polygon") {
            polygon = viewer.entities.add({
                name: 'SwallowtailArrow',
                polygon: {
                    hierarchy: this._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints),
                    material: this._cesium.Color.fromCssColorString(this._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                },

            });
        } else if (type == "box") {
            polygon = viewer.entities.add({
                name: 'SwallowtailArrow',
                polygon: {
                    hierarchy: this._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints),
                    material: this._cesium.Color.fromCssColorString(this._core.defaultValue(option.color, 'rgba(255,0,0,0.6)')),
                    extrudedHeight: GeoPoints[2] + this._core.defaultValue(option.extrudedHeight, 200),
                    height: GeoPoints[2],
                    outline: this._core.defaultValue(option.outline, true),
                    outlineColor: this._cesium.Color.fromCssColorString(this._core.defaultValue(option.outlineColor, 'rgba(255,0,0,0.6)')),
                },
            });
        }
        return polygon
    };
    /**
     * 计算燕尾箭头特征点屏幕坐标
     * @param anchorpoints
     * @returns {any[]}
     * @private
     */
    MilitaryStandard.prototype._computeSwallowtailArrow = function (anchorpoints) {
        var x0 = anchorpoints[0].x;
        var y0 = anchorpoints[0].y;
        var x1 = anchorpoints[1].x;
        var y1 = anchorpoints[1].y;
        var xt = (15.8 * x1 + 3.2 * x0) / 19;
        var yt = (15.8 * y1 + 3.2 * y0) / 19;
        var ap = new Array(7);
        ap[0] = { x: x1, y: y1 };
        ap[1] = { x: xt + 0.85 / 3.2 * (y1 - yt), y: yt - 0.85 / 3.2 * (x1 - xt) };
        ap[2] = { x: xt + 0.25 / 3.2 * (y1 - yt), y: yt - 0.25 / 3.2 * (x1 - xt) };
        ap[3] = { x: x0 + 1.6 / 19 * (y1 - y0), y: y0 - 1.6 / 19 * (x1 - x0) };
        ap[4] = { x: (3.2 * x1 + 15.8 * x0) / 19, y: (3.2 * y1 + 15.8 * y0) / 19 };
        ap[5] = { x: x0 - 1.6 / 19 * (y1 - y0), y: y0 + 1.6 / 19 * (x1 - x0) };
        ap[6] = { x: xt - 0.25 / 3.2 * (y1 - yt), y: yt + 0.25 / 3.2 * (x1 - xt) };
        ap[7] = { x: xt - 0.85 / 3.2 * (y1 - yt), y: yt + 0.85 / 3.2 * (x1 - xt) };
        return ap;
    };
    //修改
    MilitaryStandard.prototype.calculateMorePoints = function (anchorpoints) {
        var ratio = 6;
        var pointsR;
        if (anchorpoints.length > 2) {
            var l = 0, w, pointS, pointE;
            for (var i = 0; i < anchorpoints.length - 1; i++) {
                //取出首尾两个点
                pointS = anchorpoints[i];
                pointE = anchorpoints[i + 1];
                l += Math.sqrt((pointE.y - pointS.y) * (pointE.y - pointS.y) + (pointE.x - pointS.x) * (pointE.x - pointS.x));
            }
            w = l / ratio;
            //定义左右控制点集合
            var points_C_l = [];
            var points_C_r = [];
            //定义尾部左右的起始点
            var point_t_l = { x: undefined, y: undefined };
            var point_t_r = { x: undefined, y: undefined };
            //计算中间的所有交点
            for (var j = 0; j < anchorpoints.length - 2; j++) {
                var pointU_1 = anchorpoints[j];//第一个用户传入的点
                var pointU_2 = anchorpoints[j + 1];//第二个用户传入的点
                var pointU_3 = anchorpoints[j + 2];//第三个用户传入的点
                //计算向量
                var v_U_1_2 = { x: pointU_2.x - pointU_1.x, y: pointU_2.y - pointU_1.y };
                var v_U_2_3 = { x: pointU_3.x - pointU_2.x, y: pointU_3.y - pointU_2.y };
                var v_lr_1_2 = this.calculateVector(v_U_1_2, Math.PI / 2, w / 2);
                var v_l_1_2 = v_lr_1_2[0];
                var v_r_1_2 = v_lr_1_2[1];
                var v_lr_2_3 = this.calculateVector(v_U_2_3, Math.PI / 2, w / 2);
                var v_l_2_3 = v_lr_2_3[0];
                var v_r_2_3 = v_lr_2_3[1];
                //获取左右
                var point_l_1 = { x: pointU_1.x + v_l_1_2.x, y: pointU_1.y + v_l_1_2.y };
                var point_r_1 = { x: pointU_1.x + v_r_1_2.x, y: pointU_1.y + v_r_1_2.y };
                var point_l_2 = { x: pointU_2.x + v_l_2_3.x, y: pointU_2.y + v_l_2_3.y };
                var point_r_2 = { x: pointU_2.x + v_r_2_3.x, y: pointU_2.y + v_r_2_3.y };
                //向量v_U_1_2和向量v-point_l_1和point_r_1是平行的
                //如果向量a=(x1，y1)，b=(x2，y2)，则a//b等价于x1y2－x2y1=0
                //得到(x-point_l_1.x)*v_U_1_2.y=v_U_1_2.x*(y-point_l_1.y)
                //得到(point_l_2.x-x)*v_U_2_3.y=v_U_2_3.x*(point_l_2.y-y)
                //可以求出坐边的交点(x,y)，即控制点
                var point_C_l = this.calculateIntersection(v_U_1_2, v_U_2_3, point_l_1, point_l_2);
                var point_C_r = this.calculateIntersection(v_U_1_2, v_U_2_3, point_r_1, point_r_2);
                //定义中间的控制点
                var point_C_l_c;
                var point_C_r_c;
                if (j == 0) {
                    //记录下箭头尾部的左右两个端点
                    point_t_l = point_l_1;
                    point_t_r = point_r_1;
                    //计算第一个曲线控制点
                    point_C_l_c = { x: (point_t_l.x + point_C_l.x) / 2, y: (point_t_l.y + point_C_l.y) / 2 };
                    point_C_r_c = { x: (point_t_r.x + point_C_r.x) / 2, y: (point_t_r.y + point_C_r.y) / 2 };
                    //添加两个拐角控制点中间的中间控制点
                    points_C_l.push(point_C_l_c);
                    points_C_r.push(point_C_r_c);
                }
                else {
                    //获取前一个拐角控制点
                    var point_C_l_q = points_C_l[points_C_l.length - 1];
                    var point_C_r_q = points_C_r[points_C_r.length - 1];
                    //计算两个拐角之间的中心控制点
                    point_C_l_c = { x: (point_C_l_q.x + point_C_l.x) / 2, y: (point_C_l_q.y + point_C_l.y) / 2 };
                    point_C_r_c = { x: (point_C_r_q.x + point_C_r.x) / 2, y: (point_C_r_q.y + point_C_r.y) / 2 };
                    //添加两个拐角控制点中间的中间控制点
                    points_C_l.push(point_C_l_c);
                    points_C_r.push(point_C_r_c);
                }
                //添加后面的拐角控制点
                points_C_l.push(point_C_l);
                points_C_r.push(point_C_r);
            }
            //计算
            //进入计算头部
            //计算一下头部的长度
            var pointU_E2 = anchorpoints[anchorpoints.length - 2];//倒数第二个用户点
            var pointU_E1 = anchorpoints[anchorpoints.length - 1];//最后一个用户点
            var v_U_E2_E1 = { x: pointU_E1.x - pointU_E2.x, y: pointU_E1.y - pointU_E2.y };
            var head_d = Math.sqrt(v_U_E2_E1.x * v_U_E2_E1.x + v_U_E2_E1.y * v_U_E2_E1.y);
            //定义头部的左右两结束点
            var point_h_l;
            var point_h_r;
            //头部左右两向量数组
            var v_lr_h = [];
            var v_l_h = { x: undefined, y: undefined };
            var v_r_h = { x: undefined, y: undefined };
            //定义曲线最后一个控制点，也就是头部结束点和最后一个拐角点的中点
            var point_C_l_e = { x: undefined, y: undefined };
            var point_C_r_e = { x: undefined, y: undefined };
            //定义三角形的左右两个点
            var point_triangle_l = { x: undefined, y: undefined };
            var point_triangle_r = { x: undefined, y: undefined };
            //获取当前的最后的控制点，也就是之前计算的拐角点
            var point_C_l_eq = points_C_l[points_C_l.length - 1];
            var point_C_r_eq = points_C_r[points_C_r.length - 1];
            //三角的高度都不够
            if (head_d <= w) {
                v_lr_h = this.calculateVector(v_U_E2_E1, Math.PI / 2, w / 2);
                v_l_h = v_lr_h[0];
                v_r_h = v_lr_h[1];
                //获取头部的左右两结束点
                point_h_l = { x: pointU_E2.x + v_l_h.x, y: pointU_E2.y + v_l_h.y };
                point_h_r = { x: pointU_E2.x + v_r_h.x, y: pointU_E2.y + v_r_h.y };
                //计算最后的控制点
                point_C_l_e = { x: (point_C_l_eq.x + point_h_l.x) / 2, y: (point_C_l_eq.y + point_h_l.y) / 2 };
                point_C_r_e = { x: (point_C_r_eq.x + point_h_r.x) / 2, y: (point_C_r_eq.y + point_h_r.y) / 2 };
                //添加最后的控制点（中心点）
                points_C_l.push(point_C_l_e);
                points_C_r.push(point_C_r_e);
                //计算三角形的左右两点
                point_triangle_l = { x: 2 * point_h_l.x - pointU_E2.x, y: 2 * point_h_l.y - pointU_E2.y };
                point_triangle_r = { x: 2 * point_h_r.x - pointU_E2.x, y: 2 * point_h_r.y - pointU_E2.y };
            }
            //足够三角的高度
            else {
                //由于够了三角的高度，所以首先去掉三角的高度
                //计算向量
                var v_E2_E1 = { x: pointU_E1.x - pointU_E2.x, y: pointU_E1.y - pointU_E2.y };
                //取模
                var v_E2_E1_d = Math.sqrt(v_E2_E1.x * v_E2_E1.x + v_E2_E1.y * v_E2_E1.y);
                //首先需要计算三角形的底部中心点
                var point_c = { x: pointU_E1.x - v_E2_E1.x * w / v_E2_E1_d, y: pointU_E1.y - v_E2_E1.y * w / v_E2_E1_d };
                //计算出在三角形上底边上头部结束点
                v_lr_h = this.calculateVector(v_U_E2_E1, Math.PI / 2, w / 2);
                v_l_h = v_lr_h[0];
                v_r_h = v_lr_h[1];
                //获取头部的左右两结束点
                point_h_l = { x: point_c.x + v_l_h.x, y: point_c.y + v_l_h.y };
                point_h_r = { x: point_c.x + v_r_h.x, y: point_c.y + v_r_h.y };
                //计算最后的控制点
                point_C_l_e = { x: (point_C_l_eq.x + point_h_l.x) / 2, y: (point_C_l_eq.y + point_h_l.y) / 2 };
                point_C_r_e = { x: (point_C_r_eq.x + point_h_r.x) / 2, y: (point_C_r_eq.y + point_h_r.y) / 2 };
                //添加最后的控制点（中心点）
                points_C_l.push(point_C_l_e);
                points_C_r.push(point_C_r_e);
                //计算三角形的左右点
                point_triangle_l = { x: 2 * point_h_l.x - point_c.x, y: 2 * point_h_l.y - point_c.y };
                point_triangle_r = { x: 2 * point_h_r.x - point_c.x, y: 2 * point_h_r.y - point_c.y };
            }
            //使用控制点计算差值
            //计算贝塞尔的控制点
            var points_BC_l = [], points_BC_r = [];
            for (var i = 0; i < points_C_l.length - 2; i++) {
                var temp_l = [];
                var temp_r = [];
                var temp1_l = points_C_l[i];
                var temp2_l = points_C_l[i + 1];
                var temp3_l = points_C_l[i + 2];
                var temp1_r = points_C_r[i];
                var temp2_r = points_C_r[i + 1];
                var temp3_r = points_C_r[i + 2];
                temp_l.push(temp1_l, temp2_l, temp3_l);
                temp_r.push(temp1_r, temp2_r, temp3_r);
                var points_temp_l = this._createBezierPoints(temp_l);
                var points_temp_r = this._createBezierPoints(temp_r);
                points_BC_l = points_BC_l.concat(points_temp_l);
                points_BC_r = points_BC_r.concat(points_temp_r);
            }
            //组合左右点集和三角形三个点
            pointsR = [point_t_l];
            //首先连接左边的差值曲线
            pointsR = pointsR.concat(points_BC_l);
            //添加左边头部结束点
            pointsR.push(point_h_l);
            //添加三角形左边点
            pointsR.push(point_triangle_l);
            //添加三角形顶点
            pointsR.push(pointU_E1);
            //添加三角形右边点
            pointsR.push(point_triangle_r);
            //添加右边头部结束点
            pointsR.push(point_h_r);
            //合并右边的所有点（先把右边的点倒序）
            pointsR = pointsR.concat(points_BC_r.reverse());

            //添加右边尾部起始点
            pointsR.push(point_t_r);
        }
        else {
            pointsR = this.calculateTwoPoints(anchorpoints);
        }
        return pointsR;
    };
    //修改
    MilitaryStandard.prototype.calculateIntersection = function (v_1, v_2, point1, point2) {
        var x;
        var y;
        if (v_1.y * v_2.x - v_1.x * v_2.y == 0) {
            if (v_1.x * v_2.x > 0 || v_1.y * v_2.y > 0) {
                x = (point1.x + point2.x) / 2;
                y = (point1.y + point2.y) / 2;
            }
            else {
                x = point2.x;
                y = point2.y;
            }
        }
        else {
            //
            x = (v_1.x * v_2.x * (point2.y - point1.y) + point1.x * v_1.y * v_2.x - point2.x * v_2.y * v_1.x) / (v_1.y * v_2.x - v_1.x * v_2.y);
            if (v_1.x != 0) {
                y = (x - point1.x) * v_1.y / v_1.x + point1.y;
            }
            else {
                y = (x - point2.x) * v_2.y / v_2.x + point2.y;
            }
        }
        return { x: x, y: y };

    };

    //粗直箭头
    MilitaryStandard.prototype.calculateTwoPoints = function (anchorpoints) {
        var ratio = 6;
        var pointS = anchorpoints[0];//箭头起点
        var pointE = anchorpoints[1];//箭头终点
        var controlPois = [];
        var v_based = { x: pointE.x - pointS.x, y: pointE.y - pointS.y };//计算基准向量
        var l = Math.sqrt((pointE.x - pointS.x) * (pointE.x - pointS.x) + (pointE.y - pointS.y) * (pointE.y - pointS.y));//计算箭头长度
        var w = l / ratio;//箭头宽度
        var x_ = pointS.x + 5 * (pointE.x - pointS.x) / ratio;//箭头前端三角形中点坐标x
        var y_ = pointS.y + 5 * (pointE.y - pointS.y) / ratio;//箭头前端三角形中点坐标y
        var v_lr = this.calculateVector(v_based, Math.PI / 2, w / 2);
        var v_l = v_lr[0];
        var v_r = v_lr[1];
        var point1 = { x: pointS.x + v_l.x, y: pointS.y + v_l.y };
        var point2 = { x: x_ + v_l.x, y: y_ + v_l.y };
        var point3 = { x: x_ + 2 * v_l.x, y: y_ + 2 * v_l.y };
        var point4 = { x: pointE.x, y: pointE.y };
        var point5 = { x: x_ + 2 * v_r.x, y: y_ + 2 * v_r.y };
        var point6 = { x: x_ + v_r.x, y: y_ + v_r.y };
        var point7 = { x: pointS.x + v_r.x, y: pointS.y + v_r.y };
        controlPois.push(point1, point2, point3, point4, point5, point6, point7);
        return controlPois;
    };

    /**
    * 计算圆角矩形特征点
    * @param anchor
    * @returns {Array}
    * @private
    */
    MilitaryStandard.prototype._computeRoundedRectanglePoints = function (anchor) {
        var o_x = (anchor[0].x + anchor[1].x) / 2;
        var o_y = (anchor[0].y + anchor[1].y) / 2;
        //a为矩形的长边，b为矩形的短边
        var a = Math.abs(anchor[0].x - anchor[1].x);
        var b = Math.abs(anchor[0].y - anchor[1].y);
        var r = 1 / 10 * Math.min(a, b);
        //从左上点开始，顺时针求四个圆弧的圆心
        var o1_x = o_x - a / 2 + r;
        var o1_y = o_y - b / 2 + r;
        var o1 = { x: o1_x, y: o1_y };
        var o2 = { x: o_x + a / 2 - r, y: o_y - b / 2 + r };
        var o3 = { x: o_x + a / 2 - r, y: o_y + b / 2 - r };
        var o4 = { x: o_x - a / 2 + r, y: o_y + b / 2 - r };
        //从左上角开始画圆弧
        var step = Math.PI / 180;
        var points1 = [];
        var theta1 = Math.PI;
        var theta2 = 3 / 2 * Math.PI;
        var radius1 = theta1;
        for (var i = 0; i < Math.abs(theta1 - theta2); i += step) {
            var X = o1.x + r * Math.cos(radius1);
            var Y = o1.y + r * Math.sin(radius1);
            radius1 = radius1 + step;
            radius1 = radius1 < 0 ? 2 * Math.PI + radius1 : radius1;
            radius1 = radius1 > 2 * Math.PI ? 2 * Math.PI - radius1 : radius1;
            points1.push({ x: X, y: Y });
        }
        var points2 = points1;
        var theta3 = Math.PI * 3 / 2;
        var theta4 = 2 * Math.PI;
        var radius2 = theta3;
        for (var i = 0; i < Math.abs(theta3 - theta4); i += step) {
            var X = o2.x + r * Math.cos(radius2);
            var Y = o2.y + r * Math.sin(radius2);
            radius2 = radius2 + step;
            radius2 = radius2 < 0 ? 2 * Math.PI + radius2 : radius2;
            radius2 = radius2 > 2 * Math.PI ? 2 * Math.PI - radius2 : radius2;
            points2.push({ x: X, y: Y });
        }
        var points3 = points2;
        var theta5 = 0;
        var theta6 = 1 / 2 * Math.PI;
        var radius3 = theta5;
        for (var i = 0; i < Math.abs(theta5 - theta6); i += step) {
            var X = o3.x + r * Math.cos(radius3);
            var Y = o3.y + r * Math.sin(radius3);
            radius3 = radius3 + step;
            radius3 = radius3 < 0 ? 2 * Math.PI + radius3 : radius3;
            radius3 = radius3 > 2 * Math.PI ? 2 * Math.PI - radius3 : radius3;
            points3.push({ x: X, y: Y });
        }
        var points = points3;
        var theta7 = 1 / 2 * Math.PI;
        var theta8 = Math.PI;
        var radius4 = theta7;
        for (var i = 0; i < Math.abs(theta7 - theta8); i += step) {
            var X = o4.x + r * Math.cos(radius4);
            var Y = o4.y + r * Math.sin(radius4);
            radius4 = radius4 + step;
            radius4 = radius4 < 0 ? 2 * Math.PI + radius4 : radius4;
            radius4 = radius4 > 2 * Math.PI ? 2 * Math.PI - radius4 : radius4;
            points.push({ x: X, y: Y });
        }
        return points;
    };
    /**
    *计算扇形特征点
    * @param anchor
    * @returns {Array}
    * @private
    */
    MilitaryStandard.prototype._computeSectorPoints = function (anchor) {
        var theta1 = this.calculateAngle(anchor[0], anchor[1]);
        var theta2 = this.calculateAngle(anchor[0], anchor[2]);
        if (theta1 > theta2) {
            theta2 = 2 * Math.PI + theta2;
        }
        var step = Math.PI / 180;
        var radius = theta1;
        var points = [anchor[0]];
        var r = Math.sqrt((anchor[1].x - anchor[0].x) * (anchor[1].x - anchor[0].x) + (anchor[1].y - anchor[0].y) * (anchor[1].y - anchor[0].y));
        for (var i = 0; i < Math.abs(theta1 - theta2); i += step) {
            var X = anchor[0].x + r * Math.cos(radius);
            var Y = anchor[0].y + r * Math.sin(radius);
            radius = radius + step;
            radius = radius < 0 ? 2 * Math.PI + radius : radius;
            radius = radius > 2 * Math.PI ? radius - 2 * Math.PI : radius;
            points.push({ x: X, y: Y });
        }
        return points;
    };
    /**
    * 根据输入的两点计算向量的角度
    * @param a1
    * @param a2
    * @returns {*}
    */
    MilitaryStandard.prototype.calculateAngle = function (a1, a2) {
        var a = { x: a2.x - a1.x, y: a2.y - a1.y };
        var theta = Math.atan2(a.y, a.x);
        if (theta < 0) {
            theta = theta + 2 * Math.PI;
        }
        return theta;
    };
    /**
    * 计算弓形特征点
    * @param anchorpoints
    * @returns {Array}
    * @private
    */
    MilitaryStandard.prototype._computeBowPoints = function (anchor) {
        //根据三个点到圆心的距离相等
        var A1 = 2 * (anchor[1].x - anchor[0].x);
        var B1 = 2 * (anchor[1].y - anchor[0].y);
        var C1 = anchor[1].x * anchor[1].x + anchor[1].y * anchor[1].y - anchor[0].x * anchor[0].x - anchor[0].y * anchor[0].y;
        var A2 = 2 * (anchor[2].x - anchor[1].x);
        var B2 = 2 * (anchor[2].y - anchor[1].y);
        var C2 = anchor[2].x * anchor[2].x + anchor[2].y * anchor[2].y - anchor[1].x * anchor[1].x - anchor[1].y * anchor[1].y;
        var o_x = (C1 * B2 - C2 * B1) / (A1 * B2 - A2 * B1);
        var o_y = (A1 * C2 - A2 * C1) / (A1 * B2 - A2 * B1);
        var o = { x: o_x, y: o_y };
        var r = Math.sqrt((anchor[0].x - o_x) * (anchor[0].x - o_x) + (anchor[0].y - o_y) * (anchor[0].y - o_y));
        var theta1 = this.calculateAngle(o, anchor[0]);
        var theta2 = this.calculateAngle(o, anchor[1]);
        var theta3 = this.calculateAngle(o, anchor[2]);
        var step = Math.PI / 180;
        var radius = undefined;
        var points = [];
        if ((theta1 < theta3 && theta3 < theta2) || (theta2 < theta3 && theta3 < theta1)) {
            radius = theta1 < theta2 ? theta1 : theta2;
            for (var i = 0; i < Math.abs(theta1 - theta2); i += step) {
                var X = o_x + r * Math.cos(radius);
                var Y = o_y + r * Math.sin(radius);
                radius = radius + step;
                radius = radius < 0 ? 2 * Math.PI + radius : radius;
                radius = radius > 2 * Math.PI ? 2 * Math.PI - radius : radius;
                points.push({ x: X, y: Y });
            }
        }
        else {
            radius = theta1 > theta2 ? theta1 : theta2;
            for (var i = 0; i < (2 * Math.PI - Math.abs(theta1 - theta2)); i += step) {
                var X = o_x + r * Math.cos(radius);
                var Y = o_y + r * Math.sin(radius);
                radius = radius + step;
                radius = radius < 0 ? 2 * Math.PI + radius : radius;
                radius = radius > 2 * Math.PI ? radius - 2 * Math.PI : radius;
                points.push({ x: X, y: Y });
            }
        }
        return points;
    };
    /**
    * 测试距离
    * @param anchorpoints
    * @returns {Array}
    * @private
    */
    MilitaryStandard.prototype.Cdcl = function (lat1, lng1, lat2, lng2) {
        var cdcl = 0.0;
        var EARTH_RADIUS = 6378137.0;    //单位M
        var PI = Math.PI;

        function getRad(d) {
            return d * PI / 180.0;
        }
        var f = getRad((lat1 + lat2) / 2);
        var g = getRad((lat1 - lat2) / 2);
        var l = getRad((lng1 - lng2) / 2);

        var sg = Math.sin(g);
        var sl = Math.sin(l);
        var sf = Math.sin(f);

        var s, c, w, r, d, h1, h2;
        var a = EARTH_RADIUS;
        var fl = 1 / 298.257;

        sg = sg * sg;
        sl = sl * sl;
        sf = sf * sf;

        s = sg * (1 - sl) + (1 - sf) * sl;
        c = (1 - sg) * (1 - sl) + sf * sl;

        w = Math.atan(Math.sqrt(s / c));
        r = Math.sqrt(s * c) / w;
        d = 2 * w * a;
        h1 = (3 * r - 1) / 2 / c;
        h2 = (3 * r + 1) / 2 / s;
        cdcl = d * (1 + fl * (h1 * sf * (1 - sg) - h2 * (1 - sf) * sg));
        return cdcl;
    };
    /**
     * 编辑
     * @param anchorpoints
     * @returns {Array}
     * @private
     */
    MilitaryStandard.prototype.createPoint = function (position, show) {
        if (!position) return;
        return this._viewer.entities.add({
            position: position,
            point: {
                pixelSize: 10,
                color: this._cesium.Color.ROYALBLUE,
                outlineWidth: 2,
                outlineColor: this._cesium.Color.WHITE,
                heightReference: this._cesium.HeightReference.CLAMP_TO_GROUND,
                disableDepthTestDistance: Number.POSITIVE_INFINITY
            },
            show: show
        });
    };
    /**
    * 设置编辑状态编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    MilitaryStandard.prototype.setEdit = function (open, option) {
        open === undefined && (open = true);
        !option && (option = {});
        this.editOption = option;
        this.openEdit = open;
    };
    /**
    * 编辑
    * 
    * @param {Boolean} [open] 是否开启编辑
    * @param {Object} [option] 参数
    */
    MilitaryStandard.prototype.edit = function (open, option) {
        var that = this;
        var viewer = this._viewer;
        !option && (option = {});
        //是否开启属性弹框
        option.editProp !== undefined && (this.editProp = option.editProp);

        if (this.editHandler) {
            this.editHandler.destroy();
            this.editHandler = undefined;
            // 移除编辑点，清空编辑点数组
            for (var i in tree.pointsId) {
                this._viewer.entities.removeById(tree.pointsId[i]);
            }
            tree.pointsId = [];
        }
        open === undefined && (open = true);
        if (!open) {
            endThisEdit();
            return;
        }

        // 创建监听的handler
        this.editHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        // 用于保存实体的对象
        var gon = undefined;
        // 判断是否处于编辑状态
        this.isEditting = false;
        // 设置当前的编辑点
        var currentPoint = undefined;
        var types;
        var currentPointpos = undefined;
        var movePoint;
        // 对鼠标按下事件的监听
        this.editHandler.setInputAction((event) => {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            if (tree.editVector) return;
            // 获取屏幕坐标
            var windowPosition = event.position;
            // 通过屏幕坐标获取当前位置的实体信息
            var pickedObject = viewer.scene.pick(windowPosition);
            // 如果实体信息存在则说明该位置存在实体
            if (pickedObject && pickedObject.id instanceof Cesium.Entity) {
                // 获取当前点的实体
                var entity = pickedObject.id;
                // 如果实体为面同时没有处于编辑状态，那么保存面的实体 
                // if (entity.name === "" && !isEditting) {
                //that.objectsToExclude.push(entity);
                if (!that.isEditting && tree.states == 0) {
                    if (that.MilitaryStandardObj.indexOf(entity.id) === -1) {
                        return;
                    }
                    gon = entity;
                    // 生成编辑点
                    /// var gonposition = gon.polygon.hierarchy.getValue().positions
                    var pottingPoint = gon.pottingPoint;
                    if (!pottingPoint) return;
                    //var pottingPoints = pottingPoint[pottingPoint.length - 1];
                    //var control_w_p = calculateMorePoints(pottingPoint);
                    // 设置编辑状态为true 
                    that.isEditting = true;
                    var points = pottingPoint;
                    var centerPoint = {
                        x: 0, y: 0, z: 0
                    };
                    for (var i in points) {
                        var cartesian = points[i];
                        centerPoint.x += cartesian[0];
                        centerPoint.y += cartesian[1];
                        centerPoint.z += cartesian[2];
                        var position = that._cesium.Cartesian3.fromDegreesArrayHeights(cartesian);
                        var point = viewer.entities.add({
                            name: "polygon_point",
                            position: position[0],
                            point: {
                                pixelSize: 10,
                                color: Cesium.Color.ROYALBLUE,
                                outlineWidth: 2,
                                outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                                heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
                                disableDepthTestDistance: Number.POSITIVE_INFINITY

                            }
                        });
                        point.pottingPoint = cartesian;
                        // 保存点的ID以便删除
                        //that.pointsId.push(point.id);
                        tree.pointsId.push(point.id);
                        that.objectsToExclude.push(point);
                        var heightpoint;
                        if (gon.polygon && gon.polygon.extrudedHeight) {
                            if (!position.x) {
                                var cartographic = that._cesium.Cartographic.fromCartesian(position[0]);
                            } else {
                                var cartographic = that._cesium.Cartographic.fromCartesian(position);
                            }
                            var lon = that._cesium.Math.toDegrees(cartographic.longitude);
                            var lat = that._cesium.Math.toDegrees(cartographic.latitude);
                            var height = gon.polygon.extrudedHeight.getValue();
                            var pos = that._cesium.Cartesian3.fromDegrees(lon, lat, height);
                            heightpoint = viewer.entities.add({
                                name: "box_point",
                                position: pos,
                                point: {
                                    color: Cesium.Color.YELLOW,
                                    pixelSize: 12,
                                    outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                                    outlineWidth: 2,
                                    heightReference: that._cesium.HeightReference.NONE,
                                    disableDepthTestDistance: Number.POSITIVE_INFINITY,
                                }
                            });
                            heightpoint.pottingPoint = cartesian;
                            heightpoint.pointid = point.id;
                            that.objectsToExclude.push(heightpoint);
                            that.heightpoints.push(heightpoint);
                            that.heightpointsId.push(heightpoint.id);
                        }                }
                    centerPoint.x /= points.length;
                    centerPoint.y /= points.length;
                    centerPoint.z /= points.length;
                    movePoint = viewer.entities.add({
                        name: "move_point",
                        position: that._cesium.Cartesian3.fromDegrees(centerPoint.x, centerPoint.y, centerPoint.z),
                        point: {
                            color: Cesium.Color.PURPLE,
                            pixelSize: 10,
                            outlineColor: Cesium.Color.WHITE.withAlpha(0.6),
                            outlineWidth: 2,
                            heightReference: that._cesium.HeightReference.NONE,
                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
                        }
                    });
                    SmartEarthPopupData.editGraphic = {
                        entity: gon,
                        graphic: gon.polygon || gon.polyline,
                        heightpoints: that.heightpoints
                    };
                    if (this.editProp) {
                        !option.editPropData && (option.editPropData = {});
                        that._popupmessage.createPopupProp('属性编辑', {
                            width: option.editPropData.width || 360,
                            height: option.editPropData.height || '90%',
                            url: 'Workers/prop/jb_prop.html',
                            shade: option.editPropData.shade,
                            offset: option.editPropData.offset,
                            type: gon.polyline ? 'GroundPolyline' : that.heightpoints.length > 0 ? 'ExtrudedPolygon' : 'GroundPolygon',
                            fn: {
                                success: function (layero, index) {
                                    option.editPropData.success && option.editPropData.success(layero, index);
                                    that.layerIndex = index;
                                    SmartEarthPopupData.window = layero.find('iframe')[0].contentWindow;
                                },
                                end: function () {
                                    option.editPropData.end && option.editPropData.end();
                                    endThisEdit();
                                    that.layerIndex = undefined;
                                    SmartEarthPopupData.window = undefined;
                                }
                            }
                        });
                    }
                } else if (entity.name == "box_point" || entity.name == "polygon_point" || entity.name == "move_point") {
                    // 禁止地球旋转和缩放，地球的旋转会对鼠标移动监听有影响，所以需要禁止
                    that.defaultEvent(false);
                    if (entity.name == "box_point") {
                        currentPointpos = entity.position.getValue();
                        let cartographic = that._cesium.Cartographic.fromCartesian(currentPointpos);
                        currentPointpos = {
                            lon: that._cesium.Math.toDegrees(cartographic.longitude),
                            lat: that._cesium.Math.toDegrees(cartographic.latitude),
                            height: cartographic.height
                        };
                        types = "box_point";
                    } else if (entity.name == "move_point") {
                        types = "move_point";
                    } else {
                        types = "polygon_point";
                    }
                    // 如果实体为编辑点，那么设置当前编辑点为该点
                    currentPoint = entity;
                } else {
                    if (gon && entity.id === gon.id) {
                        return;
                    }
                    endThisEdit();
                }
            } else {
                endThisEdit();
            }
        }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);
        //// 对鼠标移动事件的监听
        this.editHandler.setInputAction(function (event) {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            if (tree.editVector) return;
            let pickedObject = viewer.scene.pick(event.endPosition);
            if (that._cesium.defined(pickedObject)) {
                if (that.isEditting && !currentPoint) {
                    //兼容地下模式
                    if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                        that.isEditting && (endThisEdit(), that.defaultEvent(false));
                        return;
                    }
                    if (pickedObject.id && (pickedObject.id.name === "move_point" || pickedObject.id.name === "polygon_point")) {
                        that.tooltip.showAt(event.endPosition, '拖拽修改位置');
                    } else if (pickedObject.id && pickedObject.id.name === "box_point") {
                        that.tooltip.showAt(event.endPosition, '拖拽修改高度');
                    } else if (pickedObject.id == gon) {
                        that.tooltip.show(false);
                    }
                } else if (!that.isEditting && tree.states === 0) {
                    if (pickedObject.id && that.MilitaryStandardObj.indexOf(pickedObject.id.id) > -1) {
                        that.tooltip.showAt(event.endPosition, '点击激活编辑，右键删除');
                    } else {
                        that.tooltip.show(false);
                    }
                }
            } else if (tree.states == 0 && !currentPoint) {
                that.tooltip.show(false);
            }

            // 如果处于编辑状态且编辑点已定义，那么开始拖拽编辑
            if (that.isEditting && currentPoint) {
                that.tooltip.showAt(event.endPosition, '释放后完成修改');
                // 获取屏幕坐标，移动监听与点击有所不同，所以有起始位置和终点位置
                var windowPosition = event.startPosition;
                var cartesian;
                // 将屏幕坐标转为笛卡尔坐标
                var ray = viewer.camera.getPickRay(windowPosition);
                ray && (cartesian = viewer.scene.globe.pick(ray, viewer.scene));
                // 如果点击到地球外，那么返回 
                if (!cartesian) {
                    return;
                }            var exheight = undefined;
                ///地面上点
                if (types == "polygon_point") {
                    // 更新编辑点的位置
                    currentPoint.position = cartesian;
                    for (var i in tree.pointsId) {
                        if (tree.pointsId[i] == currentPoint.id) {
                            var expiont = viewer.entities.getById(that.heightpointsId[i]);
                            if (!expiont) break
                            var cartographic = that._cesium.Cartographic.fromCartesian(cartesian);
                            var lon = that._cesium.Math.toDegrees(cartographic.longitude);
                            var lat = that._cesium.Math.toDegrees(cartographic.latitude);
                            var expiontcart = that._cesium.Cartographic.fromCartesian(expiont.position._value);
                            var height = cartographic.height + expiontcart.height;
                            expiont.position = that._cesium.Cartesian3.fromDegrees(lon, lat, height);
                        }
                    }
                    var points = [];
                    var ArrowPoint = [];
                    var _center = new that._cesium.Cartesian3();
                    for (var i in tree.pointsId) {
                        let p = viewer.entities.getById(tree.pointsId[i]).position._value;
                        let cartographic = that._cesium.Cartographic.fromCartesian(p);
                        let degrees = {
                            x: that._cesium.Math.toDegrees(cartographic.longitude),
                            y: that._cesium.Math.toDegrees(cartographic.latitude),
                            z: cartographic.height
                        };
                        points.push(degrees);
                        ArrowPoint.push([degrees.x, degrees.y, degrees.z]);
                        _center.x += p.x;
                        _center.y += p.y;
                        _center.z += p.z;
                    }
                    _center.x /= points.length;
                    _center.y /= points.length;
                    _center.z /= points.length;
                    movePoint && (movePoint.position = _center);

                    var control_w_p;
                    if (gon.GeoType == "StraightArrow") {///粗直箭头
                        control_w_p = that.calculateMorePoints(points);
                    } else if (gon.GeoType == "RoundedRectangle") {///圆角矩形
                        control_w_p = that._computeRoundedRectanglePoints(points);
                    } else if (gon.GeoType == "Sector") {///扇形
                        control_w_p = that._computeSectorPoints(points);
                    } else if (gon.GeoType == "Bow") {///弓形
                        control_w_p = that._computeBowPoints(points);
                    } else if (gon.GeoType == "GatheringPlace") {///聚集区
                        let GatheringPlacePoints = that._computeGatheringPlacePoints(points);
                        let CardinalPoints = that.createCloseCardinal(GatheringPlacePoints);
                        control_w_p = that.calculatePointsFBZ3(CardinalPoints, 100);
                    } else if (gon.GeoType == "SwallowtailArrow") {///燕尾箭头
                        control_w_p = that._computeSwallowtailArrow(points);
                    } else if (gon.GeoType == "Bezierline") {///贝塞尔曲线
                        control_w_p = that._createBezierPoints(points);
                    } else if (gon.GeoType == "BezierArrow") {///贝塞尔箭头
                        control_w_p = that._createBezierPoints(points);
                    } else if (gon.GeoType == 'PincerArrow') {
                        let res = JBAlgorithm.algorithm.doubleArrow(ArrowPoint);
                        let returnData = [];
                        let index = JSON.stringify(res.polygonalPoint).indexOf("null");
                        if (index == -1) returnData = res.polygonalPoint;
                        control_w_p = returnData;
                    } else if (gon.GeoType == 'AttackArrow') {
                        let res = JBAlgorithm.algorithm.tailedAttackArrow(ArrowPoint);
                        let index = JSON.stringify(res.polygonalPoint).indexOf("null");
                        let returnData = [];
                        if (index == -1) returnData = res.polygonalPoint;
                        control_w_p = returnData;
                    }

                    let GeoPoints;
                    if (gon.GeoType !== 'AttackArrow' && gon.GeoType !== 'PincerArrow') {
                        GeoPoints = [];
                        control_w_p.forEach(item => {
                            GeoPoints.push(item.x, item.y, points[0].z);
                        });
                        GeoPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                    } else {
                        GeoPoints = control_w_p;
                    }
                    gon.pottingPoint = ArrowPoint;

                    if (gon.GeoType.indexOf("Bezier") >= 0) {
                        gon.polyline.positions = new that._cesium.CallbackProperty(function () {
                            return GeoPoints;
                        }, false);
                    } else {
                        gon.polygon.hierarchy = new that._cesium.CallbackProperty(function () {
                            return new that._cesium.PolygonHierarchy(GeoPoints)
                        }, false);
                    }
                } else if (types == "box_point") {////拉伸高度点
                    ///移动后高度变化
                    var ray = viewer.camera.getPickRay(event.endPosition);
                    var cartesian = viewer.scene.globe.pick(ray, viewer.scene);
                    var moveend = that._cesium.Cartographic.fromCartesian(cartesian);
                    var lon1 = that._cesium.Math.toDegrees(moveend.longitude);
                    var lat1 = that._cesium.Math.toDegrees(moveend.latitude);
                    //   var height = cartographic.height;
                    ///移动前经纬度
                    var lon2 = currentPointpos.lon;
                    var lat2 = currentPointpos.lat;
                    var height = that.Cdcl(lat1, lon1, lat2, lon2);
                    exheight = height;
                    for (let i in that.heightpointsId) {
                        var enty = viewer.entities.getById(that.heightpointsId[i]);
                        var entypos = enty.position._value;
                        var entycartographic = that._cesium.Cartographic.fromCartesian(entypos);
                        var lng3 = that._cesium.Math.toDegrees(entycartographic.longitude);
                        var lat3 = that._cesium.Math.toDegrees(entycartographic.latitude);
                        var pos = that._cesium.Cartesian3.fromDegrees(lng3, lat3, exheight);
                        enty.position = pos;
                    }

                    gon.polygon.extrudedHeight = new that._cesium.CallbackProperty(function () {
                        return exheight
                    }, false);
                    SmartEarthPopupData.window && SmartEarthPopupData.window.document.querySelector('.ExtrudedPolygon input[name="height"]') && (SmartEarthPopupData.window.document.querySelector('.ExtrudedPolygon input[name="height"]').value = parseInt(exheight));
                } else {
                    ///移动后变化
                    var moveend = that._cesium.Cartographic.fromCartesian(cartesian);
                    var lon1 = that._cesium.Math.toDegrees(moveend.longitude);
                    var lat1 = that._cesium.Math.toDegrees(moveend.latitude);
                    ///移动前经纬度
                    currentPointpos = currentPoint.position.getValue();
                    let cartographic = that._cesium.Cartographic.fromCartesian(currentPointpos);
                    currentPointpos = {
                        lon: that._cesium.Math.toDegrees(cartographic.longitude),
                        lat: that._cesium.Math.toDegrees(cartographic.latitude),
                        height: cartographic.height
                    };
                    var lon2 = currentPointpos.lon;
                    var lat2 = currentPointpos.lat;
                    var _x = lon1 - lon2, _y = lat1 - lat2;

                    currentPoint.position = cartesian;
                    var points = [];
                    var ArrowPoint = [];
                    for (var i in tree.pointsId) {
                        let oldPosition, oldCartographic;
                        let polygonPoint = viewer.entities.getById(tree.pointsId[i]);
                        if (polygonPoint) {
                            oldPosition = polygonPoint.position.getValue();
                            oldCartographic = that._cesium.Cartographic.fromCartesian(oldPosition);
                            oldPosition = {
                                lon: that._cesium.Math.toDegrees(oldCartographic.longitude),
                                lat: that._cesium.Math.toDegrees(oldCartographic.latitude),
                                height: oldCartographic.height
                            };
                            polygonPoint.position = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height);
                            points.push({
                                x: oldPosition.lon + _x,
                                y: oldPosition.lat + _y,
                                z: oldPosition.height
                            });
                            ArrowPoint.push([oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height]);
                        }

                        let expiont = viewer.entities.getById(that.heightpointsId[i]);
                        if (expiont) {
                            oldPosition = expiont.position.getValue();
                            oldCartographic = that._cesium.Cartographic.fromCartesian(oldPosition);
                            oldPosition = {
                                lon: that._cesium.Math.toDegrees(oldCartographic.longitude),
                                lat: that._cesium.Math.toDegrees(oldCartographic.latitude),
                                height: oldCartographic.height
                            };
                            expiont.position = that._cesium.Cartesian3.fromDegrees(oldPosition.lon + _x, oldPosition.lat + _y, oldPosition.height);
                        }
                    }
                    var control_w_p;
                    if (gon.GeoType == "StraightArrow") {///粗直箭头
                        control_w_p = that.calculateMorePoints(points);
                    } else if (gon.GeoType == "RoundedRectangle") {///圆角矩形
                        control_w_p = that._computeRoundedRectanglePoints(points);
                    } else if (gon.GeoType == "Sector") {///扇形
                        control_w_p = that._computeSectorPoints(points);
                    } else if (gon.GeoType == "Bow") {///弓形
                        control_w_p = that._computeBowPoints(points);
                    } else if (gon.GeoType == "GatheringPlace") {///聚集区
                        let GatheringPlacePoints = that._computeGatheringPlacePoints(points);
                        let CardinalPoints = that.createCloseCardinal(GatheringPlacePoints);
                        control_w_p = that.calculatePointsFBZ3(CardinalPoints, 100);
                    } else if (gon.GeoType == "SwallowtailArrow") {///燕尾箭头
                        control_w_p = that._computeSwallowtailArrow(points);
                    } else if (gon.GeoType == "Bezierline") {///贝塞尔曲线
                        control_w_p = that._createBezierPoints(points);
                    } else if (gon.GeoType == "BezierArrow") {///贝塞尔箭头
                        control_w_p = that._createBezierPoints(points);
                    } else if (gon.GeoType == 'PincerArrow') {
                        let res = JBAlgorithm.algorithm.doubleArrow(ArrowPoint);
                        let returnData = [];
                        let index = JSON.stringify(res.polygonalPoint).indexOf("null");
                        if (index == -1) returnData = res.polygonalPoint;
                        control_w_p = returnData;
                    } else if (gon.GeoType == 'AttackArrow') {
                        let res = JBAlgorithm.algorithm.tailedAttackArrow(ArrowPoint);
                        let index = JSON.stringify(res.polygonalPoint).indexOf("null");
                        let returnData = [];
                        if (index == -1) returnData = res.polygonalPoint;
                        control_w_p = returnData;
                    }
                    let GeoPoints;
                    if (gon.GeoType !== 'AttackArrow' && gon.GeoType !== 'PincerArrow') {
                        GeoPoints = [];
                        control_w_p.forEach(item => {
                            GeoPoints.push(item.x, item.y, points[0].z);
                        });
                        GeoPoints = that._cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
                    } else {
                        GeoPoints = control_w_p;
                    }
                    gon.pottingPoint = ArrowPoint;

                    if (gon.GeoType.indexOf("Bezier") >= 0) {
                        gon.polyline.positions = new that._cesium.CallbackProperty(function () {
                            return GeoPoints;
                        }, false);
                    } else {
                        gon.polygon.hierarchy = new that._cesium.CallbackProperty(function () {
                            return new that._cesium.PolygonHierarchy(GeoPoints)
                        }, false);
                    }
                }
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        //// 对鼠标抬起事件的监听
        this.editHandler.setInputAction(function (event) {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            if (tree.editVector) return;
            // 移除当前编辑点
            currentPoint = undefined;
            // 恢复地球的旋转和缩放
            that.defaultEvent(true);
        }, this._cesium.ScreenSpaceEventType.LEFT_UP);
        this.editHandler.setInputAction(function (event) {
            //兼容地下模式
            if (Cesium.ExpandBySmartEarth && (Cesium.ExpandBySmartEarth.underEarth.enable || Cesium.ExpandBySmartEarth.isStreetView)) {
                that.isEditting && (endThisEdit(), that.defaultEvent(false));
                return;
            }
            if (tree.editVector) return;
            // 通过屏幕坐标获取当前位置的实体信息
            var pickedObject = viewer.scene.pick(event.position);
            // 如果实体信息存在则说明该位置存在实体
            if (that._cesium.defined(pickedObject) && tree.states == 0) {
                // 获取当前点的实体
                var entity = pickedObject.id;
                if (that.MilitaryStandardObj.indexOf(entity.id) === -1) {
                    return;
                }
                that.delButton(true, event.position, function () {
                    viewer.entities.removeById(entity.id);
                    let index = that.MilitaryStandardObj.indexOf(entity.id);
                    that.MilitaryStandardObj.splice(index, 1);
                    that.delButton(false);
                    that.tooltip.show(false);
                    endThisEdit();
                    if (!that.MilitaryStandardObj.length && that.editHandler) {
                        that.edit(false);
                    }
                });
            }
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);
        // 恢复地球的旋转和缩放
        that.defaultEvent(true);
        // 移除编辑点，清空编辑点数组
        for (var i in tree.pointsId) {
            viewer.entities.removeById(tree.pointsId[i]);
        }  // 移除编辑点，清空编辑点数组
        for (var i in that.heightpointsId) {
            viewer.entities.removeById(that.heightpointsId[i]);
        }
        that.heightpointsId = [];
        that.heightpoints = [];
        //that.pointsId = [];
        tree.pointsId = [];
        function endThisEdit() {
            // 恢复地球的旋转和缩放
            that.defaultEvent(true);
            // 移除编辑点，清空编辑点数组
            for (var i in tree.pointsId) {
                viewer.entities.removeById(tree.pointsId[i]);
            }
            for (var i in that.heightpointsId) {
                viewer.entities.removeById(that.heightpointsId[i]);
            }
            movePoint && viewer.entities.remove(movePoint);
            movePoint = undefined;
            gon = undefined;
            window.layuiLayer.close(that.layerIndex);
            that.isEditting = false;
            //that.pointsId = [];
            tree.pointsId = [];
            that.heightpointsId = [];
            that.heightpoints = [];
            that.delButton(false);
        }
    };
    //分割数组
    MilitaryStandard.prototype.spArray = function (N, Q) {
        var R = [], F;
        for (F = 0; F < Q.length;) {
            R.push(Q.slice(F, F += N));
        }
        return R
    };
    //删除按钮
    MilitaryStandard.prototype.delButton = function (show, position, even) {
        if (show) {
            let del = document.getElementById('DeleteMilitaryStandardDelete');
            if (!del) {
                del = document.createElement('button');
                del.id = 'DeleteMilitaryStandardDelete';
                del.innerText = '删除对象';
                del.style.cssText = `height: 38px;
                                    line-height: 38px;
                                    padding: 0 18px;
                                    background-color: #052355;
                                    color: #fff;
                                    white-space: nowrap;
                                    text-align: center;
                                    font-size: 14px;
                                    border: none;
                                    border-radius: 2px;
                                    cursor: pointer;
                                    position: absolute;`;
                this._viewer.container.appendChild(del);
            }
            del.style.display = 'block';
            del.style.top = position.y + 'px';
            del.style.left = position.x + 'px';
            del.onclick = even;
        } else {
            let del = document.getElementById('DeleteMilitaryStandardDelete');
            if (del) {
                del.style.display = 'none';
                del.onclick = null;
            }

        }
    };
    //默认鼠标事件
    MilitaryStandard.prototype.defaultEvent = function (isOpen) {
        var scene = this._viewer.scene;
        scene.screenSpaceCameraController.enableRotate = isOpen;
        scene.screenSpaceCameraController.enableTranslate = isOpen;
        scene.screenSpaceCameraController.enableZoom = isOpen;
        scene.screenSpaceCameraController.enableTilt = isOpen;
        scene.screenSpaceCameraController.enableLook = isOpen;
    };

    /**
     *
     * 创建KML图层。
     *
     * @alias KmlLayer
     * @constructor
     *
     * @param {Viewer} viewer Cesium的viewer对象。
     *
     */
    function KmlLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this._Provider = undefined;
    }

    /**
     * 加载kml服务
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    KmlLayer.prototype.createKmlLayer = function (url, modelurl, lex) {
        var options = {
            camera: this._viewer.scene.camera,
            canvas: this._viewer.scene.canvas
        };
        var uri = modelurl;
        ({
            uri: uri,
            heightReference: this._cesium.HeightReference.CLAMP_TO_GROUND,
            minimumPixelSize: 128,
            maximumScale: 20,
            scale: 1.0,
            runAnimations: false
        });
        var billboard = {
            show: true,
            position: this._cesium.Cartesian3.ZERO,
            pixelOffset: this._cesium.Cartesian2.ZERO,
            eyeOffset: this._cesium.Cartesian3.ZERO,
            heightReference: this._cesium.HeightReference.NONE,
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER,
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,
            scale: 1.0,
            image: uri,
            imageSubRegion: undefined,
            color: this._cesium.Color.WHITE,
            id: undefined,
            rotation: 0.0,
            alignedAxis: this._cesium.Cartesian3.ZERO,
            width: undefined,
            height: undefined,
            scaleByDistance: undefined,
            translucencyByDistance: undefined,
            pixelOffsetScaleByDistance: undefined,
            sizeInMeters: false,
            distanceDisplayCondition: undefined
        };
        var that = this;
        this._cesium.KmlDataSource.load(url, options).then(function (dataSource) {
            dataSource.entities;
            if (lex == "model") {
                for (var i = 0; i < dataSource.entities.values.length; i++) {
                    var entity = dataSource.entities.values[i];
                    that._viewer.entities.add({
                        name: '',
                        position: entity.position,
                        model: {
                            uri: uri,
                            heightReference: that._cesium.HeightReference.CLAMP_TO_GROUND,
                            minimumPixelSize: 128,
                            maximumScale: 20,
                            scale: 1.0,
                            runAnimations: false
                        }
                    });
                }
            } else if (lex == "billboard") {
                var options = that._core.extend(billboard, option, true);
                for (var i = 0; i < dataSource.entities.values.length; i++) {
                    var entity = dataSource.entities.values[i];
                    options.position = entity.position._value;
                    billboardCollections.add(options);
                }
                that._viewer.scene.primitives.add(billboardCollections);
            }
        });
    };

    /**
     * 加载kml服务
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [url] geojosn对象或者地址
     */
    KmlLayer.prototype.addKmlLayer = function (name, url, checked, callback) {
        var options = {
            camera: this._viewer.scene.camera,
            canvas: this._viewer.scene.canvas
        };
        var that = this;
        let urls = url;
        let id;
        if (urls.id) {
            id = urls.id;
            urls = urls.url;
        }
        var data = this._cesium.KmlDataSource.load(urls, options);
        this._viewer.dataSources.add(data);
        data.then(function (dataSource) {
            that.item = dataSource;
            if (!checked) {
                that.setVisibility(false);
            }
            callback && typeof callback === 'function' && callback(dataSource);
        });

        var obj = {
            id: id || this._core.getuid(),
            name: name,
            pId: 0,
            type: 'KML',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);
        return this;
    };
    /**
     * 导出工程数据
     */
    KmlLayer.prototype.export = function () {
        //导出工程数据修改
        var show = this.item.show == undefined ? undefined : this.item.show;
        var url = this.treeobj.url;
        return {
            type: this.treeobj.type,
            treeobj: {
                name: this.treeobj.name,
                pId: this.treeobj.pId,
            },
            style: {
                show: show,
                url: url
            }
        };
    };
    /**
     * 删除图层
     */
    KmlLayer.prototype.deleteObject = function () {
        this._viewer.dataSources.remove(this.item);
    };

    //工程树添加
    KmlLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    /**
     * 设置显示隐藏
     * @param {boolean} [b] true|false
     */
    KmlLayer.prototype.setVisibility = function (b) {
        if (this.item != undefined) {
            this.item.show = b;
        }
    };

    /**
     *
     * 模型压平
     *
     * @alias ModifyMesh
     * @constructor
     *
     */
    function ModifyMesh(yViewer) {
        this._viewer = yViewer;
        this._cesium = Cesium;
        this._core = new Core();
        this._tree = tree;
        this.texturePixel = 1024;
    }

    /**
     * 创建模型压平
     *
     * @param {string} [name] 名称
     * @param {object} [options] 名称
     */
    ModifyMesh.prototype.createModifyMesh = function (description, polygon, altitude, meshObject, options) {
        var len = polygon.length;

        var heights = new Array(len);
        heights.fill(altitude);
        var guid = meshObject.id || Cesium.createGuid();
        var nowTime = Date.now();
        var polygonRect = Cesium.Rectangle.fromCartesianArray(polygon);
        if (meshObject.modifyMeshObject === undefined) {
            meshObject.modifyMeshObject = [];
        }
        var modifyMeshObject = {
            id: guid,
            show: true,
            name: description,
            rectangle: polygonRect,
            vertices: polygon,
            polygon: polygon,
            heights: heights,
            meshObject: meshObject,
            timeStamp: nowTime,
            polygonGeometry:new Cesium.PolygonGeometry({
                polygonHierarchy: new Cesium.PolygonHierarchy(polygon),
            }),
            image: this.createTexture(polygon),
            texture: null,
        };
        meshObject.modifyMeshObject = modifyMeshObject;
        this.item = meshObject;
        return this;
    };
    ModifyMesh.prototype.createTexture = function (polygon) {
        var rect = Cesium.Rectangle.fromCartesianArray(polygon);
        var west = (rect.west * 180) / Math.PI;
        var south = (rect.south * 180) / Math.PI;
        var east = (rect.east * 180) / Math.PI;
        var north = (rect.north * 180) / Math.PI;
        var nowRect = new Cesium.Rectangle(west, south, east, north);
        var canvasPolygon = [];
        var that = this;
        polygon.forEach(function (position) {
            var point = position.longitude ? position : Cesium.Ellipsoid.WGS84.cartesianToCartographic(position);
            point = that.getPointRelativePosition(point, nowRect, that.texturePixel, that.texturePixel);
            canvasPolygon.push([point.normalizedLongitude, point.normalizedLatitude]);
        });
        var canvas = this.createCanvas(canvasPolygon, "#FF0000", that.texturePixel, that.texturePixel);
        var image = new Image();
        image.width = that.texturePixel;
        image.height = that.texturePixel;
        image.src = canvas.toDataURL("image/png");
        return image;
    };
    ModifyMesh.prototype.getPointRelativePosition = function (point, rect, pixelX, pixelY) {
        var lonDelta = rect.east - rect.west;
        var latDelta = rect.north - rect.south;
        var radianLon = (point.longitude * 180) / Math.PI;
        var radianLat = (point.latitude * 180) / Math.PI;
        point.normalizedLongitude = ((radianLon - rect.west) / lonDelta) * pixelX;
        point.normalizedLatitude = ((radianLat - rect.south) / latDelta) * pixelY;
        return point;
    };
    ModifyMesh.prototype.createCanvas = function (canvasPolygon, color, pixelX, pixelY) {
        var canvas = document.createElement("canvas");
        canvas.width = pixelX;
        canvas.height = pixelY;
        var ctx = canvas.getContext("2d");
        ctx.fillStyle = "#000";
        ctx.fillRect(0, 0, pixelX, pixelX);
        if (canvasPolygon.length <= 0) return;
        ctx.moveTo(canvasPolygon[0][0], canvasPolygon[0][1]);
        for (var i = 0; i < canvasPolygon.length; i++) {
            ctx.lineTo(canvasPolygon[i][0], canvasPolygon[i][1]);
        }
        ctx.fillStyle = color;
        ctx.fill();
        return canvas;
    };

    ModifyMesh.prototype.remove = function () {
        this.item.modifyMeshObject = undefined;
    };

    /**
     *
     * 模型裁剪
     *
     * @alias ModelClipping
     * @constructor
     *
     */
    function ModelClipping(Viewer) {
        this._viewer = Viewer;
        this._core = new Core();
    }

    /**
     * 创建模型压平
     *
     */
    ModelClipping.prototype.addClipping = function (tileset, option = {}) {
        this.remove();
        if (option.type === 'polygon') {
            let positions = option.positions;
            let degreesArray = [];
            positions.forEach(p => {
                degreesArray.push(this._core.toDegrees(p));
            });
            degreesArray.push(degreesArray[0]);
            let isReverse;
            if (option.isInner) {
                isReverse = this.isClockWise(degreesArray);
            } else {
                isReverse = !this.isClockWise(degreesArray);
            }
            isReverse && degreesArray.reverse();
            let planes = [];
            let Transform = this.getInverseTransform(tileset);
            for (let i = 0; i < degreesArray.length - 1; i++) {
                let plan = this.createPlane(degreesArray[i], degreesArray[i + 1], Transform);
                planes.push(plan);
            }
            tileset.clippingPlanes = new Cesium.ClippingPlaneCollection({
                planes: planes,
                unionClippingRegions: !option.isInner,
            });
        }

        this.item = tileset;
        return this;
    };

    ModelClipping.prototype.getInverseTransform = function (tileSet) {
        let transform;
        let tmp = tileSet.root.transform;
        if ((tmp && tmp.equals(Cesium.Matrix4.IDENTITY)) || !tmp) {
            // 如果root.transform不存在，则3DTiles的原点变成了boundingSphere.center
            transform = Cesium.Transforms.eastNorthUpToFixedFrame(tileSet.boundingSphere.center);
        } else {
            transform = Cesium.Matrix4.fromArray(tileSet.root.transform);
        }
        return Cesium.Matrix4.inverseTransformation(transform, new Cesium.Matrix4())
    };

    ModelClipping.prototype.getOriginCoordinateSystemPoint = function (point, inverseTransform) {
        let val = Cesium.Cartesian3.fromDegrees(point.lon, point.lat);
        return Cesium.Matrix4.multiplyByPoint(
            inverseTransform, val, new Cesium.Cartesian3(0, 0, 0))
    };

    ModelClipping.prototype.createPlane = function (p1, p2, inverseTransform) {
        // 将仅包含经纬度信息的p1,p2，转换为相应坐标系的cartesian3对象
        let p1C3 = this.getOriginCoordinateSystemPoint(p1, inverseTransform);
        let p2C3 = this.getOriginCoordinateSystemPoint(p2, inverseTransform);

        // 定义一个垂直向上的向量up
        let up = new Cesium.Cartesian3(0, 0, 1);
        //  right 实际上就是由p1指向p2的向量
        let right = Cesium.Cartesian3.subtract(p2C3, p1C3, new Cesium.Cartesian3());

        // 计算normal， right叉乘up，得到平面法向量，这个法向量指向right的右侧
        let normal = Cesium.Cartesian3.cross(right, up, new Cesium.Cartesian3());
        normal = Cesium.Cartesian3.normalize(normal, normal);

        //由于已经获得了法向量和过平面的一点，因此可以直接构造Plane,并进一步构造ClippingPlane
        let planeTmp = Cesium.Plane.fromPointNormal(p1C3, normal);
        return Cesium.ClippingPlane.fromPlane(planeTmp)
    };

    ModelClipping.prototype.isClockWise = function (latLngArr) {
        if (latLngArr.length < 3) {
            return null
        }
        if (latLngArr[0] === latLngArr[latLngArr.length - 1]) {
            latLngArr = latLngArr.slice(0, latLngArr.length - 1);
        }
        let latMin = { i: -1, val: 90 };
        for (let i = 0; i < latLngArr.length; i++) {
            let { lat } = latLngArr[i];
            if (lat < latMin.val) {
                latMin.val = lat;
                latMin.i = i;
            }
        }
        let i1 = (latMin.i + latLngArr.length - 1) % latLngArr.length;
        let i2 = latMin.i;
        let i3 = (latMin.i + 1) % latLngArr.length;

        let v2_1 = {
            lat: latLngArr[i2].lat - latLngArr[i1].lat,
            lon: latLngArr[i2].lon - latLngArr[i1].lon
        };
        let v3_2 = {
            lat: latLngArr[i3].lat - latLngArr[i2].lat,
            lon: latLngArr[i3].lon - latLngArr[i2].lon
        };
        let result = v3_2.lon * v2_1.lat - v2_1.lon * v3_2.lat;
        // result>0 3-2在2-1的顺时针方向 result<0 3-2在2-1的逆时针方向 result==0 3-2和2-1共线，可能同向也可能反向
        return result === 0 ? (latLngArr[i3].lon < latLngArr[i1].lon) : (result > 0)
    };

    ModelClipping.prototype.remove = function () {
        this.item && this.item.clippingPlanes && this.item.clippingPlanes.removeAll();
        this.item && (this.item.clippingPlanes = undefined);
    };

    /**
     *
     * CZML
     *
     * @alias CZML
     * @constructor
     *
     */
    function CZML(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 向三维场景中添加CZML。
     * @param {Object} [czml] czml数据。
     * @param {Object} [option] 参数。{
            linkColor: '#0000ff',     //链路线颜色（可选）
            linkPointColor: '#ffffff',  //链路点颜色（可选）
            linkTime: 3000,         //链路时间（可选）
            coneRadarColor: '#0000ff', //卫星雷达颜色（可选）
            multiCircleColor: '#ff0000',    //扩散圆颜色[多环]（可选）
            multiCircleTime: 3000,    //扩散圆时间[多环]（可选）
            sectorScanColor: '#ff0000',    //扇形扩散颜色（可选）
            sectorScanAngle: 45,    //扇形扩散角度（可选）
            circleScanColor: '#ff0000',    //扩散圆颜色（可选）
            circleScanTime: 3000,    //扩散圆时间（可选）
            radarScanColor: '#ff0000',    //雷达扫描颜色（可选）
            radarScanTime: 3000,    //雷达扫描时间（可选）
     * }
     * @param {Function} [callback] 回调函数。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    CZML.prototype.addCZML = function (czml, option, callback) {
        var _this = this;
        !option && (option = {});
        var dataSource = new this._cesium.CzmlDataSource();
        this._viewer.dataSources.add(dataSource);
        this.item = dataSource;
        this._option = option;
        this.item.process(czml).then(function (dataSources) {
            _this.Pretreatment(dataSources, option);
            callback && typeof callback == 'function' && callback(dataSources);
        });

        var obj = {
            id: this._core.getuid(),
            name: '新建CZML',
            pId: 0,
            type: 'CZML',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);
        return this;
    };

    //加载进程
    CZML.prototype.process = function (czml, callback) {
        let _this = this;
        this.item && this.item.process(czml).then(function (dataSources) {
            _this.Pretreatment(dataSources, _this._option);
            callback && typeof callback == 'function' && callback(dataSources);
        });
    };

    //预处理
    CZML.prototype.Pretreatment = function (dataSources, option) {
        let _this = this;
        let entities = dataSources.entities.values;
        entities.forEach(entity => {
            if (entity.id.indexOf('Link_') === 0) {
                entity.polyline.material = _this._core.getLinkMaterial(option.linkColor, option.linkPointColor, option.linkTime);
            } else if (entity.id.indexOf('ConeRadar_') === 0) {
                entity.cylinder.material = _this._core.getConeRadarMaterial(option.coneRadarColor);
            } else if (entity.id.indexOf('MultiCircleScan_') === 0) {
                entity.ellipse.material = _this._core.getMultiCircleScanMaterial(option.multiCircleColor, option.multiCircleTime);
            } else if (entity.id.indexOf('SectorScan_') === 0) {
                let angle = _this._core.defaultValue(option.sectorScanAngle, 45);
                entity.ellipse.material = _this._core.getSectorScanMaterial(option.sectorScanColor, angle);
                entity.ellipse.stRotation = new _this._cesium.CallbackProperty(function (time, result) {
                    let Quaternion = entity.orientation.getValue(time, result);

                    let headingpitchroll = _this._cesium.HeadingPitchRoll.fromQuaternion(Quaternion);
                    return headingpitchroll.heading - Math.PI / 2;
                }, false);
            } else if (entity.id.indexOf('CircleScan_') === 0) {
                entity.ellipse.material = _this._core.getCircleScanMaterial(option.circleScanColor, option.circleScanTime);
            } else if (entity.id.indexOf('RadarScan_') === 0) {
                entity.ellipse.material = _this._core.getRadarScanMaterial(option.radarScanColor, option.radarScanTime);
            }
        });
    };

    /**
     * 删除图层
     */
    CZML.prototype.deleteObject = function () {
        this._viewer.dataSources.remove(this.item);
    };

    //工程树添加
    CZML.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    /**
     * 设置显示隐藏
     * @param {boolean} [b] true|false
     */
    CZML.prototype.setVisibility = function (b) {
        if (this.item != undefined) {
            this.item.show = b;
        }
    };

    /**
     *
     * Heatmap
     *
     * @alias Heatmap
     * @constructor
     *
     * @param {Viewer} Viewer 地图视图。
     *
     */
    function Heatmap(Viewer) {
        this._viewer = Viewer;
        this._cesium = Cesium;
        this._core = new Core();
        this._tree = tree;
        if (!window.h337) {
            let SkipTool = new Skip(false);
            SkipTool.addJs(document.body, window.SmartEarthRootUrl + 'Workers/heatmap/heatmap.min.js');
            SkipTool.addJs(document.body, window.SmartEarthRootUrl + 'Workers/heatmap/webgl-heatmap.js');
        }
    }

    /**
     * 向三维场景中添加热力图。
     * @param {String} [name] 名称。
     * @param {Object} [option] 参数。
     * @param {String} [option.type='Heatmap'] 热力图类型[Heatmap/Heatmap3D/HeatmapGL]（可选）。
     * @param {Object} [option.sourceData] 热力图点数据（可选）。
     * @param {Boolean} [option.flyTo=true] 加载数据后定位。
     * @param {Number} [option.radius=50] 半径。
     * @param {Number} [option.alpha=1] 矩形面透明度。
     * @param {Number} [option.height] 矩形面高度，未设置高度则贴地。
     * @param {Boolean} [option.dynamic=false] 动态半径，半径随高度变化而变化，点数多时慎用。
     * @param {Number} [option.minRadius=1] 最小半径，dynamic为true生效。
     * @param {Number} [option.maxRadius=50] 最大半径，dynamic为true生效。
     * @param {Number} [option.minOpacity=0.1] 最小透明度，HeatmapGL无效。
     * @param {Number} [option.maxOpacity=0.8] 最大透明度，HeatmapGL无效。
     * @param {Number} [option.blur=0.85] 模糊系数，模糊系数越高，渐变就越平滑，HeatmapGL无效。
     * @param {Object} [option.gradient={'.3': 'blue','.5': 'green','.7': 'yellow','.95': 'red'}] 渐变色，HeatmapGL无效。
     * @param {Boolean} [option.tooltip=false] 是否显示tooltip，HeatmapGL无效。
     * @returns {Heatmap} 返回一个Heatmap的对象。
     *
     */
    Heatmap.prototype.addHeatMap = function (name, option = {}) {
        if (option.type === 'HeatmapGL') {
            this.item = new CesiumHeatmapGL(this._viewer, option);
        } else {
            this.item = new CesiumHeatmap(this._viewer, option);
        }
        if (option.sourceData) {
            this.item.create(option.sourceData);
        }

        var obj = {
            id: this._core.getuid(),
            name: name,
            pId: 0,
            type: 'Heatmap',
            item: this
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);
        return this;
    };

    /**
     * 从热图实例中删除所有先前存在的点并重新初始化。
     * 
     * @param {Object[]} [data] 热力值数据。
     * 
     */
    Heatmap.prototype.setData = function (data) {
        this.item && this.item.setData(data);
    };

    /**
     * 定位数据范围
     * 
     */
    Heatmap.prototype.flyToBounding = function () {
        this.item && this.item.flyToBounding();
    };

    /**
     * 删除图层
     */
    Heatmap.prototype.deleteObject = function () {
        this.item && this.item.destroy();
    };

    // 工程树添加
    Heatmap.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    /**
     * 设置显示隐藏
     * @param {Boolean} [show] true|false
     */
    Heatmap.prototype.setVisibility = function (show) {
        if (this.item != undefined) {
            this.item.show(show);
        }
    };

    /**
    *
    * 卫星轨迹
    *
    * @alias SatelliteTrail
    * @constructor
    *
    */
    function SatelliteTrail(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this.TrailEntitys = [];
    }
    /**
    * 创建卫星轨迹
    * @param {Object} [option] 参数。{
        start: new Cesium.JulianDate(),     //起始时间（可选）
        stop: new Cesium.JulianDate(),     //结束时间（可选）
        speed: 2,     //倍速（可选）
        path: [],    //路径数据（可选）
        radarColor: "#00ff00",   //雷达颜色（可选）
        height: 700000,   //卫星高度（可选）
        width: 5,        //轨迹宽度（可选）  
        model: 'a.gltf',  //卫星模型（可选）
        img:'a.png',   //卫星图标（可选）
        scale: 1,    //卫星比例
    * }
    */
    SatelliteTrail.prototype.createSatelliteTrail = function (option) {
        !option && (option = {});
        let viewer = this._viewer;
        //开始时间
        let start = new Cesium.JulianDate.fromDate(new Date());
        // 结束时间(默认一小时)
        let stop = Cesium.JulianDate.addSeconds(start, 3600, new Cesium.JulianDate());

        //设置系统时间
        viewer.clock.startTime = option.start || start.clone();
        viewer.clock.stopTime = option.stop || stop.clone();
        viewer.clock.currentTime = option.start || start.clone();
        viewer.clock.clockRange = Cesium.ClockRange.LOOP_STOP; //循环结束时
        //时间变化来控制速度
        viewer.clock.multiplier = option.speed || 2;

        //卫星高度
        this.flyHeight = option.height || 700000;

        //给时间线设置边界
        //viewer.timeline.zoomTo(start, stop);
        //随机获得位置
        let arrStates = [];
        if (option.path) {
            arrStates = option.path;
        } else {
            this.getRandState(arrStates, 2);
        }

        //生成轨迹
        arrStates.forEach(item => {
            this.getStatePath(item, option);
        });
        return this;
    };

    //获取轨迹
    SatelliteTrail.prototype.getStatePath = function (_SatePosition, option) {
        let viewer = this._viewer;
        let start = viewer.clock.startTime.clone();
        let stop = viewer.clock.stopTime.clone();

        //创建雷达
        let entity_ty1p = this.computeCirclularFlight(_SatePosition, 2);
        let entity_ty1 = viewer.entities.add({
            availability: new Cesium.TimeIntervalCollection([new Cesium.TimeInterval({
                start: start,
                stop: stop
            })]),
            position: entity_ty1p,
            orientation: new Cesium.VelocityOrientationProperty(entity_ty1p),
            cylinder: {
                HeightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
                length: this.flyHeight,
                topRadius: 0,
                bottomRadius: this.flyHeight / 2,
                material: this._core.getConeRadarMaterial(option.radarColor || '#00ff00'),
                outline: false,
                numberOfVerticalLines: 0
            },
        });

        //插值计算
        entity_ty1.position.setInterpolationOptions({
            interpolationDegree: 5,
            interpolationAlgorithm: Cesium.LagrangePolynomialApproximation
        });
        this.TrailEntitys.push(entity_ty1);

        //创建卫星模型/图标
        let entity1p = this.computeCirclularFlight(_SatePosition, 1);
        let data = {
            // 将实体availability设置为与模拟时间相同的时间间隔。
            availability: new Cesium.TimeIntervalCollection([new Cesium.TimeInterval({
                start: start,
                stop: stop
            })]),
            position: entity1p,
            orientation: new Cesium.VelocityOrientationProperty(entity1p),
            //轨迹
            path: {
                resolution: 1,
                material: new Cesium.PolylineGlowMaterialProperty({
                    color: Cesium.Color.DEEPSKYBLUE
                }),
                width: option.width || 5
            }
        };
        //卫星模型/图标参数
        if (option.img) {
            if (typeof option.img === 'object') {
                data.billboard = option.img;
            } else if (typeof option.img === 'string') {
                data.billboard = {
                    image: option.img,
                    scale: option.scale
                };
            }
        } else {
            data.model = {
                uri: option.model || window.SmartEarthRootUrl + configData$1.flyModel,
                minimumPixelSize: 32,
                scale: option.scale
            };
        }

        let entity1 = viewer.entities.add(data);

        //插值计算
        entity1.position.setInterpolationOptions({
            interpolationDegree: 5,
            interpolationAlgorithm: Cesium.LagrangePolynomialApproximation
        });
        this.TrailEntitys.push(entity1);
    };

    /**
     * 清除
     */
    SatelliteTrail.prototype.clear = function () {
        this.TrailEntitys.forEach(item => {
            this._viewer.entities.remove(item);
        });
        this.TrailEntitys = [];
    };

    /**
     * 加速
     */
    SatelliteTrail.prototype.faster = function () {
        this._viewer.animation.viewModel.faster();
    };

    /**
     * 减速
     */
    SatelliteTrail.prototype.slower = function () {
        // 倍率减
        this._viewer.animation.viewModel.slower();
    };

    /**
     * 设置速度
     */
    SatelliteTrail.prototype.setSpeed = function (speed) {
        this._viewer.clock.multiplier = parseFloat(speed);
    };

    /**
     * 是否暂停
     */
    SatelliteTrail.prototype.isPause = function (isPause) {
        var clockViewModel = this._viewer.clockViewModel;
        clockViewModel.shouldAnimate = !isPause;
    };

    SatelliteTrail.prototype.computeCirclularFlight = function (source, type) {
        let start = this._viewer.clock.startTime.clone();
        let property = new Cesium.SampledPositionProperty();
        if (type == 1) {         //卫星位置
            for (let i = 0; i < source.length; i++) {
                let time = Cesium.JulianDate.addSeconds(start, source[i].time, new Cesium.JulianDate);
                let position = Cesium.Cartesian3.fromDegrees(source[i].lon, source[i].lat, source[i].hei);
                // 添加位置，和时间对应
                property.addSample(time, position);
            }
        } else if (type == 2) {//轨道位置
            for (let i = 0; i < source.length; i++) {
                let time = Cesium.JulianDate.addSeconds(start, source[i].time, new Cesium.JulianDate);
                let position = Cesium.Cartesian3.fromDegrees(source[i].lon, source[i].lat, source[i].phei);
                // 添加位置，和时间对应
                property.addSample(time, position);
            }
        }
        return property;
    };

    function SatePosition(height) {
        this.lon = 0;
        this.lat = 0;
        this.hei = height;          //卫星高度
        this.phei = height / 2;     //轨道高度
        this.time = 0;
    }
    //获取随机轨迹数据
    SatelliteTrail.prototype.getRandState = function (brr, count) {
        let height = this.flyHeight;
        for (let m = 0; m < count; m++) {
            let arr = [];
            let t = Math.floor(Math.random() * 180);
            for (let i = 0; i <= 360; i += 30) {
                let _SatePosition = new SatePosition(height);
                if (i <= 180) {
                    _SatePosition.lon = t;
                    _SatePosition.lat = i - 90;
                    _SatePosition.time = i * 10;
                    arr.push(_SatePosition);
                } else {
                    _SatePosition.lon = t - 180;
                    _SatePosition.lat = 270 - i;
                    _SatePosition.time = i * 10;
                    arr.push(_SatePosition);
                }
            }
            brr.push(arr);
        }
        for (let m = 0; m < count; m++) {
            let arr = [];
            let t = Math.floor(Math.random() * 180) - 90;
            for (let i = -180; i <= 180; i += 30) {
                let _SatePosition = new SatePosition(height);
                _SatePosition.lon = i;
                _SatePosition.lat = t;
                _SatePosition.time = (i + 180) * 10;
                arr.push(_SatePosition);
            }
            brr.push(arr);
        }
    };

    /**
     *
     * 视锥
     *
     * @alias ViewCone
     * @constructor
     *
     */
    function ViewCone(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._tree = tree;
        this._getPosition = new getPosition(this._viewer, this._cesium);
        this.tooltip = this._core.CreateTooltip();
    }

    /**
     * 创建视锥
     * 
     * @param {Object} [option] 参数
     * @param {Function} [callBack] 回调
     */
    ViewCone.prototype.createViewCone = function (option, callBack) {
        let defaultOption = {
            roll: 0,
            fov: 60,
            near: 1.0,
            fillColor: 'rgba(0,255,0,0.1)',
            outlineColor: 'rgba(0,255,0,1)'
        };

        !option && (option = {});

        option = this._core.extend(defaultOption, option, true);

        this._option = option;

        //设置鼠标样式
        this._core.mouse(this._viewer.container, 1, window.SmartEarthRootUrl + configData$1.draw);

        let that = this;
        let viewer = this._viewer;

        if (this.drawHandler) {
            this.drawHandler.destroy();
            this.drawHandler = undefined;
        }
        this.drawHandler = new this._cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
        tree.states = 1;

        let positions = [];
        this.drawHandler.setInputAction(event => {
            let cartesian = that._getPosition.getMousePosition(event);
            if (!cartesian) return;

            if (positions.length === 0) {
                positions.push(cartesian, cartesian);
            } else {
                that.drawHandler.destroy();
                that.drawHandler = undefined;
                that.tooltip.show(false);
                setTimeout(function () {
                    tree.states = 0;
                }, 100);
                //恢复鼠标样式
                that._core.mouse(that._viewer.container, 0, "0");

                //回调
                callBack && typeof callBack === 'function' && callBack(that.item);
            }

            if (!that.item) {
                that.viewConeCamera = new Cesium.Camera(viewer.scene);

                let direction = Cesium.Cartesian3.normalize(Cesium.Cartesian3.subtract(positions[1], positions[0], new Cesium.Cartesian3()), new Cesium.Cartesian3());
                that.viewConeCamera.position = positions[0];   //位置
                that.viewConeCamera.direction = direction;   //相机面向的方向
                that.viewConeCamera.frustum.fov = Cesium.Math.toRadians(option.fov);
                that.viewConeCamera.frustum.near = option.near;
                that.viewConeCamera.frustum.far = 1;

                let scratchRight = new Cesium.Cartesian3();
                let scratchRotation = new Cesium.Matrix3();
                let scratchOrientation = new Cesium.Quaternion();

                let position = that.viewConeCamera.positionWC;
                let up = that.viewConeCamera.upWC;
                let right = that.viewConeCamera.rightWC;
                right = Cesium.Cartesian3.negate(right, scratchRight);

                let rotation = scratchRotation;
                Cesium.Matrix3.setColumn(rotation, 0, right, rotation);
                Cesium.Matrix3.setColumn(rotation, 1, up, rotation);
                Cesium.Matrix3.setColumn(rotation, 2, direction, rotation);

                //计算视锥姿态
                let orientation = Cesium.Quaternion.fromRotationMatrix(rotation, scratchOrientation);

                option.fill && (that._planesPrimitive = new Cesium.Primitive({
                    geometryInstances: new Cesium.GeometryInstance({
                        geometry: new Cesium.FrustumGeometry({
                            origin: position,
                            orientation: orientation,
                            frustum: that.viewConeCamera.frustum
                        }),
                        attributes: {
                            color: Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.fromCssColorString(option.fillColor))
                        },
                        id: option.id
                    }),
                    appearance: new Cesium.PerInstanceColorAppearance({
                        translucent: true,
                        flat: true
                    }),
                    asynchronous: false,
                    allowPicking: false
                }));

                that._outlinePrimitive = new Cesium.Primitive({
                    geometryInstances: new Cesium.GeometryInstance({
                        geometry: new Cesium.FrustumOutlineGeometry({
                            origin: position,
                            orientation: orientation,
                            frustum: that.viewConeCamera.frustum
                        }),
                        attributes: {
                            color: Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.fromCssColorString(option.outlineColor))
                        },
                        id: option.id
                    }),
                    appearance: new Cesium.PerInstanceColorAppearance({
                        translucent: false,
                        flat: true
                    }),
                    asynchronous: false,
                    allowPicking: false
                });

                that.item = new Cesium.PrimitiveCollection();
                that._viewer.scene.primitives.add(that.item);

                that._outlinePrimitive && that.item.add(that._outlinePrimitive);
                that._planesPrimitive && that.item.add(that._planesPrimitive);

            }
        }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);

        this.drawHandler.setInputAction(event => {
            if (positions.length > 0) {
                that.tooltip.showAt(event.endPosition, "再次点击结束绘制");
                let cartesian = that._getPosition.getMousePosition(event);
                if (cartesian) {
                    positions[1] = cartesian;
                    that.viewConeCamera.direction = Cesium.Cartesian3.normalize(Cesium.Cartesian3.subtract(positions[1], positions[0], new Cesium.Cartesian3()), new Cesium.Cartesian3());
                    that.updata({
                        heading: Cesium.Math.toDegrees(that.viewConeCamera.heading),
                        pitch: Cesium.Math.toDegrees(that.viewConeCamera.pitch),
                        far: that._core.getSpaceDistancem(positions, Cesium)
                    });
                }
            } else {
                that.tooltip.showAt(event.endPosition, "点击开始绘制");
            }
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);

        return this;
    };


    /**
     * 添加视锥
     * 
     * @param {Object} [option] 参数
     */
    ViewCone.prototype.addViewCone = function (option) {
        let defaultOption = {
            position: this._viewer.camera.position.clone(),
            heading: 0,
            pitch: 0,
            roll: 0,
            fov: 60,
            near: 1.0,
            far: 60,
            fillColor: 'rgba(0,255,0,0.1)',
            outlineColor: 'rgba(0,255,0,1)',
        };

        !option && (option = {});
        if (option.position && option.position.lon) {
            option.position = Cesium.Cartesian3.fromDegrees(option.position.lon, option.position.lat, option.position.height);
        }

        option = this._core.extend(defaultOption, option, true);

        this.viewConeCamera = new Cesium.Camera(this._viewer.scene);
        //设置方向角
        this.viewConeCamera.setView({
            destination: option.position, // 设置位置
            orientation: {
                heading: Cesium.Math.toRadians(option.heading), // 方向角
                pitch: Cesium.Math.toRadians(option.pitch),// 俯仰角
                roll: Cesium.Math.toRadians(option.roll)   //翻滚角
            }
        });
        this.viewConeCamera.frustum.fov = Cesium.Math.toRadians(option.fov);
        this.viewConeCamera.frustum.near = option.near;
        this.viewConeCamera.frustum.far = option.far;

        let scratchRight = new Cesium.Cartesian3();
        let scratchRotation = new Cesium.Matrix3();
        let scratchOrientation = new Cesium.Quaternion();

        let position = this.viewConeCamera.positionWC;
        let direction = this.viewConeCamera.directionWC;
        let up = this.viewConeCamera.upWC;
        let right = this.viewConeCamera.rightWC;
        right = Cesium.Cartesian3.negate(right, scratchRight);

        let rotation = scratchRotation;
        Cesium.Matrix3.setColumn(rotation, 0, right, rotation);
        Cesium.Matrix3.setColumn(rotation, 1, up, rotation);
        Cesium.Matrix3.setColumn(rotation, 2, direction, rotation);

        //计算视锥姿态
        let orientation = Cesium.Quaternion.fromRotationMatrix(rotation, scratchOrientation);

        option.fill && (this._planesPrimitive = new Cesium.Primitive({
            geometryInstances: new Cesium.GeometryInstance({
                geometry: new Cesium.FrustumGeometry({
                    origin: position,
                    orientation: orientation,
                    frustum: this.viewConeCamera.frustum
                }),
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.fromCssColorString(option.fillColor))
                },
                id: option.id
            }),
            appearance: new Cesium.PerInstanceColorAppearance({
                translucent: true,
                flat: true
            }),
            asynchronous: false,
            allowPicking: false
        }));

        this._outlinePrimitive = new Cesium.Primitive({
            geometryInstances: new Cesium.GeometryInstance({
                geometry: new Cesium.FrustumOutlineGeometry({
                    origin: position,
                    orientation: orientation,
                    frustum: this.viewConeCamera.frustum
                }),
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.fromCssColorString(option.outlineColor))
                },
                id: option.id
            }),
            appearance: new Cesium.PerInstanceColorAppearance({
                translucent: false,
                flat: true
            }),
            asynchronous: false,
            allowPicking: false
        });

        this._option = option;

        this.item = new Cesium.PrimitiveCollection();
        this._viewer.scene.primitives.add(this.item);

        this._outlinePrimitive && this.item.add(this._outlinePrimitive);
        this._planesPrimitive && this.item.add(this._planesPrimitive);

        return this;
    };

    /**
     * 更新参数
     * 
     * @param {Object} [option] 参数
     */
    ViewCone.prototype.updata = function (option) {
        !option && (option = {});
        if (option.position && option.position.lon) {
            option.position = Cesium.Cartesian3.fromDegrees(option.position.lon, option.position.lat, option.position.height);
        }

        option = this._core.extend(this._option, option, true);

        this._outlinePrimitive && this._outlinePrimitive.destroy();
        this._planesPrimitive && this._planesPrimitive.destroy();
        this.item.removeAll();

        //设置方向角
        this.viewConeCamera.setView({
            destination: option.position, // 设置位置
            orientation: {
                heading: Cesium.Math.toRadians(option.heading), // 方向角
                pitch: Cesium.Math.toRadians(option.pitch),// 俯仰角
                roll: Cesium.Math.toRadians(option.roll)   //翻滚角
            }
        });
        this.viewConeCamera.frustum.fov = Cesium.Math.toRadians(option.fov);
        this.viewConeCamera.frustum.near = option.near;
        this.viewConeCamera.frustum.far = option.far;

        let scratchRight = new Cesium.Cartesian3();
        let scratchRotation = new Cesium.Matrix3();
        let scratchOrientation = new Cesium.Quaternion();

        let position = this.viewConeCamera.positionWC;
        let direction = this.viewConeCamera.directionWC;
        let up = this.viewConeCamera.upWC;
        let right = this.viewConeCamera.rightWC;
        right = Cesium.Cartesian3.negate(right, scratchRight);

        let rotation = scratchRotation;
        Cesium.Matrix3.setColumn(rotation, 0, right, rotation);
        Cesium.Matrix3.setColumn(rotation, 1, up, rotation);
        Cesium.Matrix3.setColumn(rotation, 2, direction, rotation);

        //计算视锥姿态
        let orientation = Cesium.Quaternion.fromRotationMatrix(rotation, scratchOrientation);

        option.fill && (this._planesPrimitive = new Cesium.Primitive({
            geometryInstances: new Cesium.GeometryInstance({
                geometry: new Cesium.FrustumGeometry({
                    origin: position,
                    orientation: orientation,
                    frustum: this.viewConeCamera.frustum
                }),
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.fromCssColorString(option.fillColor))
                },
                id: option.id
            }),
            appearance: new Cesium.PerInstanceColorAppearance({
                translucent: true,
                flat: true
            }),
            asynchronous: false,
            allowPicking: false
        }));

        this._outlinePrimitive = new Cesium.Primitive({
            geometryInstances: new Cesium.GeometryInstance({
                geometry: new Cesium.FrustumOutlineGeometry({
                    origin: position,
                    orientation: orientation,
                    frustum: this.viewConeCamera.frustum
                }),
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.fromCssColorString(option.outlineColor))
                },
                id: option.id
            }),
            appearance: new Cesium.PerInstanceColorAppearance({
                translucent: false,
                flat: true
            }),
            asynchronous: false,
            allowPicking: false
        });

        this._option = option;

        this.item.add(this._outlinePrimitive);
        this._planesPrimitive && this.item.add(this._planesPrimitive);
    };

    ViewCone.prototype.destroy = function () {
        this._outlinePrimitive && this._outlinePrimitive.destroy();
        this._planesPrimitive && this._planesPrimitive.destroy();
        this.item && this._viewer.scene.primitives.removeAndDestroy(this.item);
        return Cesium.destroyObject(this);
    };

    let ContentState = {
        UNLOADED: 0,
        LOADING: 1,
        PARSING: 2,
        READY: 3,
        FAILED: 4
    };

    var ContentState$1 = Object.freeze(ContentState);

    let S3MPixelFormat = {
        LUMINANCE_8: 1,
        LUMINANCE_16: 2,
        ALPHA: 3,
        ALPHA_4_LUMINANCE_4: 4,
        LUMINANCE_ALPHA: 5,
        RGB_565: 6,
        BGR565: 7,
        RGB: 10,
        BGR: 11,
        ARGB: 12,
        ABGR: 13,
        BGRA: 14,
        WEBP: 25,
        RGBA: 28,
        DXT1: 17,
        DXT2: 18,
        DXT3: 19,
        DXT4: 20,
        DXT5: 21
    };
    var S3MPixelFormat$1 = Object.freeze(S3MPixelFormat);

    let S3MCompressType = {
        encNONE: 0,
        enrS3TCDXTN: 14,
        enrPVRTPF_PVRTC2: 19,
        enrPVRTPF_PVRTC: 20,
        enrPVRTPF_PVRTC_4bpp: 21,
        enrPVRTPF_ETC1: 22
    };
    var S3MCompressType$1 = Object.freeze(S3MCompressType);

    let VertexCompressOptions = {
        SVC_Vertex: 1,
        SVC_Normal: 2,
        SVC_VertexColor: 4,
        SVC_SecondColor: 8,
        SVC_TexutreCoord: 16,
        SVC_TexutreCoordIsW: 32
    };
    var VertexCompressOption = Object.freeze(VertexCompressOptions);

    /* pako 1.0.4 nodeca/pako */
    var pako = (
        function e(t, n, r) {
            function s(o, u) {
                if (!n[o]) { if (!t[o]) { var a = typeof require == "function" && require; if (!u && a) return a(o, !0); if (i) return i(o, !0); var f = new Error("Cannot find module '" + o + "'"); throw f.code = "MODULE_NOT_FOUND", f } var l = n[o] = { exports: {} }; t[o][0].call(l.exports, function (e) { var n = t[o][1][e]; return s(n ? n : e) }, l, l.exports, e, t, n, r); } return n[o].exports
            } var i = typeof require == "function" && require; for (var o = 0; o < r.length; o++)s(r[o]); return s
        })({
            1: [function (require, module, exports) {


                var TYPED_OK = (typeof Uint8Array !== 'undefined') &&
                    (typeof Uint16Array !== 'undefined') &&
                    (typeof Int32Array !== 'undefined');


                exports.assign = function (obj /*from1, from2, from3, ...*/) {
                    var sources = Array.prototype.slice.call(arguments, 1);
                    while (sources.length) {
                        var source = sources.shift();
                        if (!source) { continue; }

                        if (typeof source !== 'object') {
                            throw new TypeError(source + 'must be non-object');
                        }

                        for (var p in source) {
                            if (source.hasOwnProperty(p)) {
                                obj[p] = source[p];
                            }
                        }
                    }

                    return obj;
                };


                // reduce buffer size, avoiding mem copy
                exports.shrinkBuf = function (buf, size) {
                    if (buf.length === size) { return buf; }
                    if (buf.subarray) { return buf.subarray(0, size); }
                    buf.length = size;
                    return buf;
                };


                var fnTyped = {
                    arraySet: function (dest, src, src_offs, len, dest_offs) {
                        if (src.subarray && dest.subarray) {
                            dest.set(src.subarray(src_offs, src_offs + len), dest_offs);
                            return;
                        }
                        // Fallback to ordinary array
                        for (var i = 0; i < len; i++) {
                            dest[dest_offs + i] = src[src_offs + i];
                        }
                    },
                    // Join array of chunks to single array.
                    flattenChunks: function (chunks) {
                        var i, l, len, pos, chunk, result;

                        // calculate data length
                        len = 0;
                        for (i = 0, l = chunks.length; i < l; i++) {
                            len += chunks[i].length;
                        }

                        // join chunks
                        result = new Uint8Array(len);
                        pos = 0;
                        for (i = 0, l = chunks.length; i < l; i++) {
                            chunk = chunks[i];
                            result.set(chunk, pos);
                            pos += chunk.length;
                        }

                        return result;
                    }
                };

                var fnUntyped = {
                    arraySet: function (dest, src, src_offs, len, dest_offs) {
                        for (var i = 0; i < len; i++) {
                            dest[dest_offs + i] = src[src_offs + i];
                        }
                    },
                    // Join array of chunks to single array.
                    flattenChunks: function (chunks) {
                        return [].concat.apply([], chunks);
                    }
                };


                // Enable/Disable typed arrays use, for testing
                //
                exports.setTyped = function (on) {
                    if (on) {
                        exports.Buf8 = Uint8Array;
                        exports.Buf16 = Uint16Array;
                        exports.Buf32 = Int32Array;
                        exports.assign(exports, fnTyped);
                    } else {
                        exports.Buf8 = Array;
                        exports.Buf16 = Array;
                        exports.Buf32 = Array;
                        exports.assign(exports, fnUntyped);
                    }
                };

                exports.setTyped(TYPED_OK);

            }, {}], 2: [function (require, module, exports) {


                var utils = require('./common');


                // Quick check if we can use fast array to bin string conversion
                //
                // - apply(Array) can fail on Android 2.2
                // - apply(Uint8Array) can fail on iOS 5.1 Safary
                //
                var STR_APPLY_OK = true;
                var STR_APPLY_UIA_OK = true;

                try { String.fromCharCode.apply(null, [0]); } catch (__) { STR_APPLY_OK = false; }
                try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }


                // Table with utf8 lengths (calculated by first byte of sequence)
                // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
                // because max possible codepoint is 0x10ffff
                var _utf8len = new utils.Buf8(256);
                for (var q = 0; q < 256; q++) {
                    _utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);
                }
                _utf8len[254] = _utf8len[254] = 1; // Invalid sequence start


                // convert string to array (typed, when possible)
                exports.string2buf = function (str) {
                    var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;

                    // count binary size
                    for (m_pos = 0; m_pos < str_len; m_pos++) {
                        c = str.charCodeAt(m_pos);
                        if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
                            c2 = str.charCodeAt(m_pos + 1);
                            if ((c2 & 0xfc00) === 0xdc00) {
                                c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
                                m_pos++;
                            }
                        }
                        buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
                    }

                    // allocate buffer
                    buf = new utils.Buf8(buf_len);

                    // convert
                    for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
                        c = str.charCodeAt(m_pos);
                        if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
                            c2 = str.charCodeAt(m_pos + 1);
                            if ((c2 & 0xfc00) === 0xdc00) {
                                c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
                                m_pos++;
                            }
                        }
                        if (c < 0x80) {
                            /* one byte */
                            buf[i++] = c;
                        } else if (c < 0x800) {
                            /* two bytes */
                            buf[i++] = 0xC0 | (c >>> 6);
                            buf[i++] = 0x80 | (c & 0x3f);
                        } else if (c < 0x10000) {
                            /* three bytes */
                            buf[i++] = 0xE0 | (c >>> 12);
                            buf[i++] = 0x80 | (c >>> 6 & 0x3f);
                            buf[i++] = 0x80 | (c & 0x3f);
                        } else {
                            /* four bytes */
                            buf[i++] = 0xf0 | (c >>> 18);
                            buf[i++] = 0x80 | (c >>> 12 & 0x3f);
                            buf[i++] = 0x80 | (c >>> 6 & 0x3f);
                            buf[i++] = 0x80 | (c & 0x3f);
                        }
                    }

                    return buf;
                };

                // Helper (used in 2 places)
                function buf2binstring(buf, len) {
                    // use fallback for big arrays to avoid stack overflow
                    if (len < 65537) {
                        if ((buf.subarray && STR_APPLY_UIA_OK) || (!buf.subarray && STR_APPLY_OK)) {
                            return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len));
                        }
                    }

                    var result = '';
                    for (var i = 0; i < len; i++) {
                        result += String.fromCharCode(buf[i]);
                    }
                    return result;
                }


                // Convert byte array to binary string
                exports.buf2binstring = function (buf) {
                    return buf2binstring(buf, buf.length);
                };


                // Convert binary string (typed, when possible)
                exports.binstring2buf = function (str) {
                    var buf = new utils.Buf8(str.length);
                    for (var i = 0, len = buf.length; i < len; i++) {
                        buf[i] = str.charCodeAt(i);
                    }
                    return buf;
                };


                // convert array to string
                exports.buf2string = function (buf, max) {
                    var i, out, c, c_len;
                    var len = max || buf.length;

                    // Reserve max possible length (2 words per char)
                    // NB: by unknown reasons, Array is significantly faster for
                    //     String.fromCharCode.apply than Uint16Array.
                    var utf16buf = new Array(len * 2);

                    for (out = 0, i = 0; i < len;) {
                        c = buf[i++];
                        // quick process ascii
                        if (c < 0x80) { utf16buf[out++] = c; continue; }

                        c_len = _utf8len[c];
                        // skip 5 & 6 byte codes
                        if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }

                        // apply mask on first byte
                        c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
                        // join the rest
                        while (c_len > 1 && i < len) {
                            c = (c << 6) | (buf[i++] & 0x3f);
                            c_len--;
                        }

                        // terminated by end of string?
                        if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }

                        if (c < 0x10000) {
                            utf16buf[out++] = c;
                        } else {
                            c -= 0x10000;
                            utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
                            utf16buf[out++] = 0xdc00 | (c & 0x3ff);
                        }
                    }

                    return buf2binstring(utf16buf, out);
                };


                // Calculate max possible position in utf8 buffer,
                // that will not break sequence. If that's not possible
                // - (very small limits) return max size as is.
                //
                // buf[] - utf8 bytes array
                // max   - length limit (mandatory);
                exports.utf8border = function (buf, max) {
                    var pos;

                    max = max || buf.length;
                    if (max > buf.length) { max = buf.length; }

                    // go back from last position, until start of sequence found
                    pos = max - 1;
                    while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }

                    // Fuckup - very small and broken sequence,
                    // return max, because we should return something anyway.
                    if (pos < 0) { return max; }

                    // If we came to start of buffer - that means vuffer is too small,
                    // return max too.
                    if (pos === 0) { return max; }

                    return (pos + _utf8len[buf[pos]] > max) ? pos : max;
                };

            }, { "./common": 1 }], 3: [function (require, module, exports) {

                // Note: adler32 takes 12% for level 0 and 2% for level 6.
                // It doesn't worth to make additional optimizationa as in original.
                // Small size is preferable.

                function adler32(adler, buf, len, pos) {
                    var s1 = (adler & 0xffff) | 0,
                        s2 = ((adler >>> 16) & 0xffff) | 0,
                        n = 0;

                    while (len !== 0) {
                        // Set limit ~ twice less than 5552, to keep
                        // s2 in 31-bits, because we force signed ints.
                        // in other case %= will fail.
                        n = len > 2000 ? 2000 : len;
                        len -= n;

                        do {
                            s1 = (s1 + buf[pos++]) | 0;
                            s2 = (s2 + s1) | 0;
                        } while (--n);

                        s1 %= 65521;
                        s2 %= 65521;
                    }

                    return (s1 | (s2 << 16)) | 0;
                }


                module.exports = adler32;

            }, {}], 4: [function (require, module, exports) {


                module.exports = {

                    /* Allowed flush values; see deflate() and inflate() below for details */
                    Z_NO_FLUSH: 0,
                    Z_PARTIAL_FLUSH: 1,
                    Z_SYNC_FLUSH: 2,
                    Z_FULL_FLUSH: 3,
                    Z_FINISH: 4,
                    Z_BLOCK: 5,
                    Z_TREES: 6,

                    /* Return codes for the compression/decompression functions. Negative values
                     * are errors, positive values are used for special but normal events.
                     */
                    Z_OK: 0,
                    Z_STREAM_END: 1,
                    Z_NEED_DICT: 2,
                    Z_ERRNO: -1,
                    Z_STREAM_ERROR: -2,
                    Z_DATA_ERROR: -3,
                    //Z_MEM_ERROR:     -4,
                    Z_BUF_ERROR: -5,
                    //Z_VERSION_ERROR: -6,

                    /* compression levels */
                    Z_NO_COMPRESSION: 0,
                    Z_BEST_SPEED: 1,
                    Z_BEST_COMPRESSION: 9,
                    Z_DEFAULT_COMPRESSION: -1,


                    Z_FILTERED: 1,
                    Z_HUFFMAN_ONLY: 2,
                    Z_RLE: 3,
                    Z_FIXED: 4,
                    Z_DEFAULT_STRATEGY: 0,

                    /* Possible values of the data_type field (though see inflate()) */
                    Z_BINARY: 0,
                    Z_TEXT: 1,
                    //Z_ASCII:                1, // = Z_TEXT (deprecated)
                    Z_UNKNOWN: 2,

                    /* The deflate compression method */
                    Z_DEFLATED: 8
                    //Z_NULL:                 null // Use -1 or null inline, depending on var type
                };

            }, {}], 5: [function (require, module, exports) {

                // Note: we can't get significant speed boost here.
                // So write code to minimize size - no pregenerated tables
                // and array tools dependencies.


                // Use ordinary array, since untyped makes no boost here
                function makeTable() {
                    var c, table = [];

                    for (var n = 0; n < 256; n++) {
                        c = n;
                        for (var k = 0; k < 8; k++) {
                            c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
                        }
                        table[n] = c;
                    }

                    return table;
                }

                // Create table on load. Just 255 signed longs. Not a problem.
                var crcTable = makeTable();


                function crc32(crc, buf, len, pos) {
                    var t = crcTable,
                        end = pos + len;

                    crc ^= -1;

                    for (var i = pos; i < end; i++) {
                        crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
                    }

                    return (crc ^ (-1)); // >>> 0;
                }


                module.exports = crc32;

            }, {}], 6: [function (require, module, exports) {


                function GZheader() {
                    /* true if compressed data believed to be text */
                    this.text = 0;
                    /* modification time */
                    this.time = 0;
                    /* extra flags (not used when writing a gzip file) */
                    this.xflags = 0;
                    /* operating system */
                    this.os = 0;
                    /* pointer to extra field or Z_NULL if none */
                    this.extra = null;
                    /* extra field length (valid if extra != Z_NULL) */
                    this.extra_len = 0; // Actually, we don't need it in JS,
                    // but leave for few code modifications

                    //
                    // Setup limits is not necessary because in js we should not preallocate memory
                    // for inflate use constant limit in 65536 bytes
                    //

                    /* space at extra (only when reading header) */
                    // this.extra_max  = 0;
                    /* pointer to zero-terminated file name or Z_NULL */
                    this.name = '';
                    /* space at name (only when reading header) */
                    // this.name_max   = 0;
                    /* pointer to zero-terminated comment or Z_NULL */
                    this.comment = '';
                    /* space at comment (only when reading header) */
                    // this.comm_max   = 0;
                    /* true if there was or will be a header crc */
                    this.hcrc = 0;
                    /* true when done reading gzip header (not used when writing a gzip file) */
                    this.done = false;
                }

                module.exports = GZheader;

            }, {}], 7: [function (require, module, exports) {

                // See state defs from inflate.js
                var BAD = 30;       /* got a data error -- remain here until reset */
                var TYPE = 12;      /* i: waiting for type bits, including last-flag bit */

                /*
                 Decode literal, length, and distance codes and write out the resulting
                 literal and match bytes until either not enough input or output is
                 available, an end-of-block is encountered, or a data error is encountered.
                 When large enough input and output buffers are supplied to inflate(), for
                 example, a 16K input buffer and a 64K output buffer, more than 95% of the
                 inflate execution time is spent in this routine.
            
                 Entry assumptions:
            
                 state.mode === LEN
                 strm.avail_in >= 6
                 strm.avail_out >= 258
                 start >= strm.avail_out
                 state.bits < 8
            
                 On return, state.mode is one of:
            
                 LEN -- ran out of enough output space or enough available input
                 TYPE -- reached end of block code, inflate() to interpret next block
                 BAD -- error in block data
            
                 Notes:
            
                 - The maximum input bits used by a length/distance pair is 15 bits for the
                 length code, 5 bits for the length extra, 15 bits for the distance code,
                 and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
                 Therefore if strm.avail_in >= 6, then there is enough input to avoid
                 checking for available input while decoding.
            
                 - The maximum bytes that a single length/distance pair can output is 258
                 bytes, which is the maximum length that can be coded.  inflate_fast()
                 requires strm.avail_out >= 258 for each loop to avoid checking for
                 output space.
                 */
                module.exports = function inflate_fast(strm, start) {
                    var state;
                    var _in;                    /* local strm.input */
                    var last;                   /* have enough input while in < last */
                    var _out;                   /* local strm.output */
                    var beg;                    /* inflate()'s initial strm.output */
                    var end;                    /* while out < end, enough space available */
                    //#ifdef INFLATE_STRICT
                    var dmax;                   /* maximum distance from zlib header */
                    //#endif
                    var wsize;                  /* window size or zero if not using window */
                    var whave;                  /* valid bytes in the window */
                    var wnext;                  /* window write index */
                    // Use `s_window` instead `window`, avoid conflict with instrumentation tools
                    var s_window;               /* allocated sliding window, if wsize != 0 */
                    var hold;                   /* local strm.hold */
                    var bits;                   /* local strm.bits */
                    var lcode;                  /* local strm.lencode */
                    var dcode;                  /* local strm.distcode */
                    var lmask;                  /* mask for first level of length codes */
                    var dmask;                  /* mask for first level of distance codes */
                    var here;                   /* retrieved table entry */
                    var op;                     /* code bits, operation, extra bits, or */
                    /*  window position, window bytes to copy */
                    var len;                    /* match length, unused bytes */
                    var dist;                   /* match distance */
                    var from;                   /* where to copy match from */
                    var from_source;


                    var input, output; // JS specific, because we have no pointers

                    /* copy state to local variables */
                    state = strm.state;
                    //here = state.here;
                    _in = strm.next_in;
                    input = strm.input;
                    last = _in + (strm.avail_in - 5);
                    _out = strm.next_out;
                    output = strm.output;
                    beg = _out - (start - strm.avail_out);
                    end = _out + (strm.avail_out - 257);
                    //#ifdef INFLATE_STRICT
                    dmax = state.dmax;
                    //#endif
                    wsize = state.wsize;
                    whave = state.whave;
                    wnext = state.wnext;
                    s_window = state.window;
                    hold = state.hold;
                    bits = state.bits;
                    lcode = state.lencode;
                    dcode = state.distcode;
                    lmask = (1 << state.lenbits) - 1;
                    dmask = (1 << state.distbits) - 1;


                    /* decode literals and length/distances until end-of-block or not enough
                     input data or output space */

                    top:
                    do {
                        if (bits < 15) {
                            hold += input[_in++] << bits;
                            bits += 8;
                            hold += input[_in++] << bits;
                            bits += 8;
                        }

                        here = lcode[hold & lmask];

                        dolen:
                        for (; ;) { // Goto emulation
                            op = here >>> 24/*here.bits*/;
                            hold >>>= op;
                            bits -= op;
                            op = (here >>> 16) & 0xff/*here.op*/;
                            if (op === 0) {                          /* literal */
                                //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
                                //        "inflate:         literal '%c'\n" :
                                //        "inflate:         literal 0x%02x\n", here.val));
                                output[_out++] = here & 0xffff/*here.val*/;
                            }
                            else if (op & 16) {                     /* length base */
                                len = here & 0xffff/*here.val*/;
                                op &= 15;                           /* number of extra bits */
                                if (op) {
                                    if (bits < op) {
                                        hold += input[_in++] << bits;
                                        bits += 8;
                                    }
                                    len += hold & ((1 << op) - 1);
                                    hold >>>= op;
                                    bits -= op;
                                }
                                //Tracevv((stderr, "inflate:         length %u\n", len));
                                if (bits < 15) {
                                    hold += input[_in++] << bits;
                                    bits += 8;
                                    hold += input[_in++] << bits;
                                    bits += 8;
                                }
                                here = dcode[hold & dmask];

                                dodist:
                                for (; ;) { // goto emulation
                                    op = here >>> 24/*here.bits*/;
                                    hold >>>= op;
                                    bits -= op;
                                    op = (here >>> 16) & 0xff/*here.op*/;

                                    if (op & 16) {                      /* distance base */
                                        dist = here & 0xffff/*here.val*/;
                                        op &= 15;                       /* number of extra bits */
                                        if (bits < op) {
                                            hold += input[_in++] << bits;
                                            bits += 8;
                                            if (bits < op) {
                                                hold += input[_in++] << bits;
                                                bits += 8;
                                            }
                                        }
                                        dist += hold & ((1 << op) - 1);
                                        //#ifdef INFLATE_STRICT
                                        if (dist > dmax) {
                                            strm.msg = 'invalid distance too far back';
                                            state.mode = BAD;
                                            break top;
                                        }
                                        //#endif
                                        hold >>>= op;
                                        bits -= op;
                                        //Tracevv((stderr, "inflate:         distance %u\n", dist));
                                        op = _out - beg;                /* max distance in output */
                                        if (dist > op) {                /* see if copy from window */
                                            op = dist - op;               /* distance back in window */
                                            if (op > whave) {
                                                if (state.sane) {
                                                    strm.msg = 'invalid distance too far back';
                                                    state.mode = BAD;
                                                    break top;
                                                }

                                                // (!) This block is disabled in zlib defailts,
                                                // don't enable it for binary compatibility
                                                //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
                                                //                if (len <= op - whave) {
                                                //                  do {
                                                //                    output[_out++] = 0;
                                                //                  } while (--len);
                                                //                  continue top;
                                                //                }
                                                //                len -= op - whave;
                                                //                do {
                                                //                  output[_out++] = 0;
                                                //                } while (--op > whave);
                                                //                if (op === 0) {
                                                //                  from = _out - dist;
                                                //                  do {
                                                //                    output[_out++] = output[from++];
                                                //                  } while (--len);
                                                //                  continue top;
                                                //                }
                                                //#endif
                                            }
                                            from = 0; // window index
                                            from_source = s_window;
                                            if (wnext === 0) {           /* very common case */
                                                from += wsize - op;
                                                if (op < len) {         /* some from window */
                                                    len -= op;
                                                    do {
                                                        output[_out++] = s_window[from++];
                                                    } while (--op);
                                                    from = _out - dist;  /* rest from output */
                                                    from_source = output;
                                                }
                                            }
                                            else if (wnext < op) {      /* wrap around window */
                                                from += wsize + wnext - op;
                                                op -= wnext;
                                                if (op < len) {         /* some from end of window */
                                                    len -= op;
                                                    do {
                                                        output[_out++] = s_window[from++];
                                                    } while (--op);
                                                    from = 0;
                                                    if (wnext < len) {  /* some from start of window */
                                                        op = wnext;
                                                        len -= op;
                                                        do {
                                                            output[_out++] = s_window[from++];
                                                        } while (--op);
                                                        from = _out - dist;      /* rest from output */
                                                        from_source = output;
                                                    }
                                                }
                                            }
                                            else {                      /* contiguous in window */
                                                from += wnext - op;
                                                if (op < len) {         /* some from window */
                                                    len -= op;
                                                    do {
                                                        output[_out++] = s_window[from++];
                                                    } while (--op);
                                                    from = _out - dist;  /* rest from output */
                                                    from_source = output;
                                                }
                                            }
                                            while (len > 2) {
                                                output[_out++] = from_source[from++];
                                                output[_out++] = from_source[from++];
                                                output[_out++] = from_source[from++];
                                                len -= 3;
                                            }
                                            if (len) {
                                                output[_out++] = from_source[from++];
                                                if (len > 1) {
                                                    output[_out++] = from_source[from++];
                                                }
                                            }
                                        }
                                        else {
                                            from = _out - dist;          /* copy direct from output */
                                            do {                        /* minimum length is three */
                                                output[_out++] = output[from++];
                                                output[_out++] = output[from++];
                                                output[_out++] = output[from++];
                                                len -= 3;
                                            } while (len > 2);
                                            if (len) {
                                                output[_out++] = output[from++];
                                                if (len > 1) {
                                                    output[_out++] = output[from++];
                                                }
                                            }
                                        }
                                    }
                                    else if ((op & 64) === 0) {          /* 2nd level distance code */
                                        here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
                                        continue dodist;
                                    }
                                    else {
                                        strm.msg = 'invalid distance code';
                                        state.mode = BAD;
                                        break top;
                                    }

                                    break; // need to emulate goto via "continue"
                                }
                            }
                            else if ((op & 64) === 0) {              /* 2nd level length code */
                                here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
                                continue dolen;
                            }
                            else if (op & 32) {                     /* end-of-block */
                                //Tracevv((stderr, "inflate:         end of block\n"));
                                state.mode = TYPE;
                                break top;
                            }
                            else {
                                strm.msg = 'invalid literal/length code';
                                state.mode = BAD;
                                break top;
                            }

                            break; // need to emulate goto via "continue"
                        }
                    } while (_in < last && _out < end);

                    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
                    len = bits >> 3;
                    _in -= len;
                    bits -= len << 3;
                    hold &= (1 << bits) - 1;

                    /* update state and return */
                    strm.next_in = _in;
                    strm.next_out = _out;
                    strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));
                    strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));
                    state.hold = hold;
                    state.bits = bits;
                    return;
                };

            }, {}], 8: [function (require, module, exports) {


                var utils = require('../utils/common');
                var adler32 = require('./adler32');
                var crc32 = require('./crc32');
                var inflate_fast = require('./inffast');
                var inflate_table = require('./inftrees');

                var CODES = 0;
                var LENS = 1;
                var DISTS = 2;

                /* Public constants ==========================================================*/
                /* ===========================================================================*/


                /* Allowed flush values; see deflate() and inflate() below for details */
                //var Z_NO_FLUSH      = 0;
                //var Z_PARTIAL_FLUSH = 1;
                //var Z_SYNC_FLUSH    = 2;
                //var Z_FULL_FLUSH    = 3;
                var Z_FINISH = 4;
                var Z_BLOCK = 5;
                var Z_TREES = 6;


                /* Return codes for the compression/decompression functions. Negative values
                 * are errors, positive values are used for special but normal events.
                 */
                var Z_OK = 0;
                var Z_STREAM_END = 1;
                var Z_NEED_DICT = 2;
                //var Z_ERRNO         = -1;
                var Z_STREAM_ERROR = -2;
                var Z_DATA_ERROR = -3;
                var Z_MEM_ERROR = -4;
                var Z_BUF_ERROR = -5;
                //var Z_VERSION_ERROR = -6;

                /* The deflate compression method */
                var Z_DEFLATED = 8;


                /* STATES ====================================================================*/
                /* ===========================================================================*/


                var HEAD = 1;       /* i: waiting for magic header */
                var FLAGS = 2;      /* i: waiting for method and flags (gzip) */
                var TIME = 3;       /* i: waiting for modification time (gzip) */
                var OS = 4;         /* i: waiting for extra flags and operating system (gzip) */
                var EXLEN = 5;      /* i: waiting for extra length (gzip) */
                var EXTRA = 6;      /* i: waiting for extra bytes (gzip) */
                var NAME = 7;       /* i: waiting for end of file name (gzip) */
                var COMMENT = 8;    /* i: waiting for end of comment (gzip) */
                var HCRC = 9;       /* i: waiting for header crc (gzip) */
                var DICTID = 10;    /* i: waiting for dictionary check value */
                var DICT = 11;      /* waiting for inflateSetDictionary() call */
                var TYPE = 12;      /* i: waiting for type bits, including last-flag bit */
                var TYPEDO = 13;    /* i: same, but skip check to exit inflate on new block */
                var STORED = 14;    /* i: waiting for stored size (length and complement) */
                var COPY_ = 15;     /* i/o: same as COPY below, but only first time in */
                var COPY = 16;      /* i/o: waiting for input or output to copy stored block */
                var TABLE = 17;     /* i: waiting for dynamic block table lengths */
                var LENLENS = 18;   /* i: waiting for code length code lengths */
                var CODELENS = 19;  /* i: waiting for length/lit and distance code lengths */
                var LEN_ = 20;      /* i: same as LEN below, but only first time in */
                var LEN = 21;       /* i: waiting for length/lit/eob code */
                var LENEXT = 22;    /* i: waiting for length extra bits */
                var DIST = 23;      /* i: waiting for distance code */
                var DISTEXT = 24;   /* i: waiting for distance extra bits */
                var MATCH = 25;     /* o: waiting for output space to copy string */
                var LIT = 26;       /* o: waiting for output space to write literal */
                var CHECK = 27;     /* i: waiting for 32-bit check value */
                var LENGTH = 28;    /* i: waiting for 32-bit length (gzip) */
                var DONE = 29;      /* finished check, done -- remain here until reset */
                var BAD = 30;       /* got a data error -- remain here until reset */
                var MEM = 31;       /* got an inflate() memory error -- remain here until reset */
                var SYNC = 32;      /* looking for synchronization bytes to restart inflate() */

                /* ===========================================================================*/



                var ENOUGH_LENS = 852;
                var ENOUGH_DISTS = 592;
                //var ENOUGH =  (ENOUGH_LENS+ENOUGH_DISTS);

                var MAX_WBITS = 15;
                /* 32K LZ77 window */
                var DEF_WBITS = MAX_WBITS;


                function zswap32(q) {
                    return (((q >>> 24) & 0xff) +
                        ((q >>> 8) & 0xff00) +
                        ((q & 0xff00) << 8) +
                        ((q & 0xff) << 24));
                }


                function InflateState() {
                    this.mode = 0;             /* current inflate mode */
                    this.last = false;          /* true if processing last block */
                    this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */
                    this.havedict = false;      /* true if dictionary provided */
                    this.flags = 0;             /* gzip header method and flags (0 if zlib) */
                    this.dmax = 0;              /* zlib header max distance (INFLATE_STRICT) */
                    this.check = 0;             /* protected copy of check value */
                    this.total = 0;             /* protected copy of output count */
                    // TODO: may be {}
                    this.head = null;           /* where to save gzip header information */

                    /* sliding window */
                    this.wbits = 0;             /* log base 2 of requested window size */
                    this.wsize = 0;             /* window size or zero if not using window */
                    this.whave = 0;             /* valid bytes in the window */
                    this.wnext = 0;             /* window write index */
                    this.window = null;         /* allocated sliding window, if needed */

                    /* bit accumulator */
                    this.hold = 0;              /* input bit accumulator */
                    this.bits = 0;              /* number of bits in "in" */

                    /* for string and stored block copying */
                    this.length = 0;            /* literal or length of data to copy */
                    this.offset = 0;            /* distance back to copy string from */

                    /* for table and code decoding */
                    this.extra = 0;             /* extra bits needed */

                    /* fixed and dynamic code tables */
                    this.lencode = null;          /* starting table for length/literal codes */
                    this.distcode = null;         /* starting table for distance codes */
                    this.lenbits = 0;           /* index bits for lencode */
                    this.distbits = 0;          /* index bits for distcode */

                    /* dynamic table building */
                    this.ncode = 0;             /* number of code length code lengths */
                    this.nlen = 0;              /* number of length code lengths */
                    this.ndist = 0;             /* number of distance code lengths */
                    this.have = 0;              /* number of code lengths in lens[] */
                    this.next = null;              /* next available space in codes[] */

                    this.lens = new utils.Buf16(320); /* temporary storage for code lengths */
                    this.work = new utils.Buf16(288); /* work area for code table building */

                    /*
                     because we don't have pointers in js, we use lencode and distcode directly
                     as buffers so we don't need codes
                     */
                    //this.codes = new utils.Buf32(ENOUGH);       /* space for code tables */
                    this.lendyn = null;              /* dynamic table for length/literal codes (JS specific) */
                    this.distdyn = null;             /* dynamic table for distance codes (JS specific) */
                    this.sane = 0;                   /* if false, allow invalid distance too far */
                    this.back = 0;                   /* bits back of last unprocessed length/lit */
                    this.was = 0;                    /* initial length of match */
                }

                function inflateResetKeep(strm) {
                    var state;

                    if (!strm || !strm.state) { return Z_STREAM_ERROR; }
                    state = strm.state;
                    strm.total_in = strm.total_out = state.total = 0;
                    strm.msg = ''; /*Z_NULL*/
                    if (state.wrap) {       /* to support ill-conceived Java test suite */
                        strm.adler = state.wrap & 1;
                    }
                    state.mode = HEAD;
                    state.last = 0;
                    state.havedict = 0;
                    state.dmax = 32768;
                    state.head = null/*Z_NULL*/;
                    state.hold = 0;
                    state.bits = 0;
                    //state.lencode = state.distcode = state.next = state.codes;
                    state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);
                    state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);

                    state.sane = 1;
                    state.back = -1;
                    //Tracev((stderr, "inflate: reset\n"));
                    return Z_OK;
                }

                function inflateReset(strm) {
                    var state;

                    if (!strm || !strm.state) { return Z_STREAM_ERROR; }
                    state = strm.state;
                    state.wsize = 0;
                    state.whave = 0;
                    state.wnext = 0;
                    return inflateResetKeep(strm);

                }

                function inflateReset2(strm, windowBits) {
                    var wrap;
                    var state;

                    /* get the state */
                    if (!strm || !strm.state) { return Z_STREAM_ERROR; }
                    state = strm.state;

                    /* extract wrap request from windowBits parameter */
                    if (windowBits < 0) {
                        wrap = 0;
                        windowBits = -windowBits;
                    }
                    else {
                        wrap = (windowBits >> 4) + 1;
                        if (windowBits < 48) {
                            windowBits &= 15;
                        }
                    }

                    /* set number of window bits, free window if different */
                    if (windowBits && (windowBits < 8 || windowBits > 15)) {
                        return Z_STREAM_ERROR;
                    }
                    if (state.window !== null && state.wbits !== windowBits) {
                        state.window = null;
                    }

                    /* update state and reset the rest of it */
                    state.wrap = wrap;
                    state.wbits = windowBits;
                    return inflateReset(strm);
                }

                function inflateInit2(strm, windowBits) {
                    var ret;
                    var state;

                    if (!strm) { return Z_STREAM_ERROR; }
                    //strm.msg = Z_NULL;                 /* in case we return an error */

                    state = new InflateState();

                    //if (state === Z_NULL) return Z_MEM_ERROR;
                    //Tracev((stderr, "inflate: allocated\n"));
                    strm.state = state;
                    state.window = null/*Z_NULL*/;
                    ret = inflateReset2(strm, windowBits);
                    if (ret !== Z_OK) {
                        strm.state = null/*Z_NULL*/;
                    }
                    return ret;
                }

                function inflateInit(strm) {
                    return inflateInit2(strm, DEF_WBITS);
                }


                /*
                 Return state with length and distance decoding tables and index sizes set to
                 fixed code decoding.  Normally this returns fixed tables from inffixed.h.
                 If BUILDFIXED is defined, then instead this routine builds the tables the
                 first time it's called, and returns those tables the first time and
                 thereafter.  This reduces the size of the code by about 2K bytes, in
                 exchange for a little execution time.  However, BUILDFIXED should not be
                 used for threaded applications, since the rewriting of the tables and virgin
                 may not be thread-safe.
                 */
                var virgin = true;

                var lenfix, distfix; // We have no pointers in JS, so keep tables separate

                function fixedtables(state) {
                    /* build fixed huffman tables if first call (may not be thread safe) */
                    if (virgin) {
                        var sym;

                        lenfix = new utils.Buf32(512);
                        distfix = new utils.Buf32(32);

                        /* literal/length table */
                        sym = 0;
                        while (sym < 144) { state.lens[sym++] = 8; }
                        while (sym < 256) { state.lens[sym++] = 9; }
                        while (sym < 280) { state.lens[sym++] = 7; }
                        while (sym < 288) { state.lens[sym++] = 8; }

                        inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });

                        /* distance table */
                        sym = 0;
                        while (sym < 32) { state.lens[sym++] = 5; }

                        inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });

                        /* do this just once */
                        virgin = false;
                    }

                    state.lencode = lenfix;
                    state.lenbits = 9;
                    state.distcode = distfix;
                    state.distbits = 5;
                }


                /*
                 Update the window with the last wsize (normally 32K) bytes written before
                 returning.  If window does not exist yet, create it.  This is only called
                 when a window is already in use, or when output has been written during this
                 inflate call, but the end of the deflate stream has not been reached yet.
                 It is also called to create a window for dictionary data when a dictionary
                 is loaded.
            
                 Providing output buffers larger than 32K to inflate() should provide a speed
                 advantage, since only the last 32K of output is copied to the sliding window
                 upon return from inflate(), and since all distances after the first 32K of
                 output will fall in the output data, making match copies simpler and faster.
                 The advantage may be dependent on the size of the processor's data caches.
                 */
                function updatewindow(strm, src, end, copy) {
                    var dist;
                    var state = strm.state;

                    /* if it hasn't been done already, allocate space for the window */
                    if (state.window === null) {
                        state.wsize = 1 << state.wbits;
                        state.wnext = 0;
                        state.whave = 0;

                        state.window = new utils.Buf8(state.wsize);
                    }

                    /* copy state->wsize or less output bytes into the circular window */
                    if (copy >= state.wsize) {
                        utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0);
                        state.wnext = 0;
                        state.whave = state.wsize;
                    }
                    else {
                        dist = state.wsize - state.wnext;
                        if (dist > copy) {
                            dist = copy;
                        }
                        //zmemcpy(state->window + state->wnext, end - copy, dist);
                        utils.arraySet(state.window, src, end - copy, dist, state.wnext);
                        copy -= dist;
                        if (copy) {
                            //zmemcpy(state->window, end - copy, copy);
                            utils.arraySet(state.window, src, end - copy, copy, 0);
                            state.wnext = copy;
                            state.whave = state.wsize;
                        }
                        else {
                            state.wnext += dist;
                            if (state.wnext === state.wsize) { state.wnext = 0; }
                            if (state.whave < state.wsize) { state.whave += dist; }
                        }
                    }
                    return 0;
                }

                function inflate(strm, flush) {
                    var state;
                    var input, output;          // input/output buffers
                    var next;                   /* next input INDEX */
                    var put;                    /* next output INDEX */
                    var have, left;             /* available input and output */
                    var hold;                   /* bit buffer */
                    var bits;                   /* bits in bit buffer */
                    var _in, _out;              /* save starting available input and output */
                    var copy;                   /* number of stored or match bytes to copy */
                    var from;                   /* where to copy match bytes from */
                    var from_source;
                    var here = 0;               /* current decoding table entry */
                    var here_bits, here_op, here_val; // paked "here" denormalized (JS specific)
                    //var last;                   /* parent table entry */
                    var last_bits, last_op, last_val; // paked "last" denormalized (JS specific)
                    var len;                    /* length to copy for repeats, bits to drop */
                    var ret;                    /* return code */
                    var hbuf = new utils.Buf8(4);    /* buffer for gzip header crc calculation */
                    var opts;

                    var n; // temporary var for NEED_BITS

                    var order = /* permutation of code lengths */
                        [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];


                    if (!strm || !strm.state || !strm.output ||
                        (!strm.input && strm.avail_in !== 0)) {
                        return Z_STREAM_ERROR;
                    }

                    state = strm.state;
                    if (state.mode === TYPE) { state.mode = TYPEDO; }    /* skip check */


                    //--- LOAD() ---
                    put = strm.next_out;
                    output = strm.output;
                    left = strm.avail_out;
                    next = strm.next_in;
                    input = strm.input;
                    have = strm.avail_in;
                    hold = state.hold;
                    bits = state.bits;
                    //---

                    _in = have;
                    _out = left;
                    ret = Z_OK;

                    inf_leave: // goto emulation
                    for (; ;) {
                        switch (state.mode) {
                            case HEAD:
                                if (state.wrap === 0) {
                                    state.mode = TYPEDO;
                                    break;
                                }
                                //=== NEEDBITS(16);
                                while (bits < 16) {
                                    if (have === 0) { break inf_leave; }
                                    have--;
                                    hold += input[next++] << bits;
                                    bits += 8;
                                }
                                //===//
                                if ((state.wrap & 2) && hold === 0x8b1f) {  /* gzip header */
                                    state.check = 0/*crc32(0L, Z_NULL, 0)*/;
                                    //=== CRC2(state.check, hold);
                                    hbuf[0] = hold & 0xff;
                                    hbuf[1] = (hold >>> 8) & 0xff;
                                    state.check = crc32(state.check, hbuf, 2, 0);
                                    //===//

                                    //=== INITBITS();
                                    hold = 0;
                                    bits = 0;
                                    //===//
                                    state.mode = FLAGS;
                                    break;
                                }
                                state.flags = 0;           /* expect zlib header */
                                if (state.head) {
                                    state.head.done = false;
                                }
                                if (!(state.wrap & 1) ||   /* check if zlib header allowed */
                                    (((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) {
                                    strm.msg = 'incorrect header check';
                                    state.mode = BAD;
                                    break;
                                }
                                if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) {
                                    strm.msg = 'unknown compression method';
                                    state.mode = BAD;
                                    break;
                                }
                                //--- DROPBITS(4) ---//
                                hold >>>= 4;
                                bits -= 4;
                                //---//
                                len = (hold & 0x0f)/*BITS(4)*/ + 8;
                                if (state.wbits === 0) {
                                    state.wbits = len;
                                }
                                else if (len > state.wbits) {
                                    strm.msg = 'invalid window size';
                                    state.mode = BAD;
                                    break;
                                }
                                state.dmax = 1 << len;
                                //Tracev((stderr, "inflate:   zlib header ok\n"));
                                strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
                                state.mode = hold & 0x200 ? DICTID : TYPE;
                                //=== INITBITS();
                                hold = 0;
                                bits = 0;
                                //===//
                                break;
                            case FLAGS:
                                //=== NEEDBITS(16); */
                                while (bits < 16) {
                                    if (have === 0) { break inf_leave; }
                                    have--;
                                    hold += input[next++] << bits;
                                    bits += 8;
                                }
                                //===//
                                state.flags = hold;
                                if ((state.flags & 0xff) !== Z_DEFLATED) {
                                    strm.msg = 'unknown compression method';
                                    state.mode = BAD;
                                    break;
                                }
                                if (state.flags & 0xe000) {
                                    strm.msg = 'unknown header flags set';
                                    state.mode = BAD;
                                    break;
                                }
                                if (state.head) {
                                    state.head.text = ((hold >> 8) & 1);
                                }
                                if (state.flags & 0x0200) {
                                    //=== CRC2(state.check, hold);
                                    hbuf[0] = hold & 0xff;
                                    hbuf[1] = (hold >>> 8) & 0xff;
                                    state.check = crc32(state.check, hbuf, 2, 0);
                                    //===//
                                }
                                //=== INITBITS();
                                hold = 0;
                                bits = 0;
                                //===//
                                state.mode = TIME;
                            /* falls through */
                            case TIME:
                                //=== NEEDBITS(32); */
                                while (bits < 32) {
                                    if (have === 0) { break inf_leave; }
                                    have--;
                                    hold += input[next++] << bits;
                                    bits += 8;
                                }
                                //===//
                                if (state.head) {
                                    state.head.time = hold;
                                }
                                if (state.flags & 0x0200) {
                                    //=== CRC4(state.check, hold)
                                    hbuf[0] = hold & 0xff;
                                    hbuf[1] = (hold >>> 8) & 0xff;
                                    hbuf[2] = (hold >>> 16) & 0xff;
                                    hbuf[3] = (hold >>> 24) & 0xff;
                                    state.check = crc32(state.check, hbuf, 4, 0);
                                    //===
                                }
                                //=== INITBITS();
                                hold = 0;
                                bits = 0;
                                //===//
                                state.mode = OS;
                            /* falls through */
                            case OS:
                                //=== NEEDBITS(16); */
                                while (bits < 16) {
                                    if (have === 0) { break inf_leave; }
                                    have--;
                                    hold += input[next++] << bits;
                                    bits += 8;
                                }
                                //===//
                                if (state.head) {
                                    state.head.xflags = (hold & 0xff);
                                    state.head.os = (hold >> 8);
                                }
                                if (state.flags & 0x0200) {
                                    //=== CRC2(state.check, hold);
                                    hbuf[0] = hold & 0xff;
                                    hbuf[1] = (hold >>> 8) & 0xff;
                                    state.check = crc32(state.check, hbuf, 2, 0);
                                    //===//
                                }
                                //=== INITBITS();
                                hold = 0;
                                bits = 0;
                                //===//
                                state.mode = EXLEN;
                            /* falls through */
                            case EXLEN:
                                if (state.flags & 0x0400) {
                                    //=== NEEDBITS(16); */
                                    while (bits < 16) {
                                        if (have === 0) { break inf_leave; }
                                        have--;
                                        hold += input[next++] << bits;
                                        bits += 8;
                                    }
                                    //===//
                                    state.length = hold;
                                    if (state.head) {
                                        state.head.extra_len = hold;
                                    }
                                    if (state.flags & 0x0200) {
                                        //=== CRC2(state.check, hold);
                                        hbuf[0] = hold & 0xff;
                                        hbuf[1] = (hold >>> 8) & 0xff;
                                        state.check = crc32(state.check, hbuf, 2, 0);
                                        //===//
                                    }
                                    //=== INITBITS();
                                    hold = 0;
                                    bits = 0;
                                    //===//
                                }
                                else if (state.head) {
                                    state.head.extra = null/*Z_NULL*/;
                                }
                                state.mode = EXTRA;
                            /* falls through */
                            case EXTRA:
                                if (state.flags & 0x0400) {
                                    copy = state.length;
                                    if (copy > have) { copy = have; }
                                    if (copy) {
                                        if (state.head) {
                                            len = state.head.extra_len - state.length;
                                            if (!state.head.extra) {
                                                // Use untyped array for more conveniend processing later
                                                state.head.extra = new Array(state.head.extra_len);
                                            }
                                            utils.arraySet(
                                                state.head.extra,
                                                input,
                                                next,
                                                // extra field is limited to 65536 bytes
                                                // - no need for additional size check
                                                copy,
                                                /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
                                                len
                                            );
                                            //zmemcpy(state.head.extra + len, next,
                                            //        len + copy > state.head.extra_max ?
                                            //        state.head.extra_max - len : copy);
                                        }
                                        if (state.flags & 0x0200) {
                                            state.check = crc32(state.check, input, copy, next);
                                        }
                                        have -= copy;
                                        next += copy;
                                        state.length -= copy;
                                    }
                                    if (state.length) { break inf_leave; }
                                }
                                state.length = 0;
                                state.mode = NAME;
                            /* falls through */
                            case NAME:
                                if (state.flags & 0x0800) {
                                    if (have === 0) { break inf_leave; }
                                    copy = 0;
                                    do {
                                        // TODO: 2 or 1 bytes?
                                        len = input[next + copy++];
                                        /* use constant limit because in js we should not preallocate memory */
                                        if (state.head && len &&
                                            (state.length < 65536 /*state.head.name_max*/)) {
                                            state.head.name += String.fromCharCode(len);
                                        }
                                    } while (len && copy < have);

                                    if (state.flags & 0x0200) {
                                        state.check = crc32(state.check, input, copy, next);
                                    }
                                    have -= copy;
                                    next += copy;
                                    if (len) { break inf_leave; }
                                }
                                else if (state.head) {
                                    state.head.name = null;
                                }
                                state.length = 0;
                                state.mode = COMMENT;
                            /* falls through */
                            case COMMENT:
                                if (state.flags & 0x1000) {
                                    if (have === 0) { break inf_leave; }
                                    copy = 0;
                                    do {
                                        len = input[next + copy++];
                                        /* use constant limit because in js we should not preallocate memory */
                                        if (state.head && len &&
                                            (state.length < 65536 /*state.head.comm_max*/)) {
                                            state.head.comment += String.fromCharCode(len);
                                        }
                                    } while (len && copy < have);
                                    if (state.flags & 0x0200) {
                                        state.check = crc32(state.check, input, copy, next);
                                    }
                                    have -= copy;
                                    next += copy;
                                    if (len) { break inf_leave; }
                                }
                                else if (state.head) {
                                    state.head.comment = null;
                                }
                                state.mode = HCRC;
                            /* falls through */
                            case HCRC:
                                if (state.flags & 0x0200) {
                                    //=== NEEDBITS(16); */
                                    while (bits < 16) {
                                        if (have === 0) { break inf_leave; }
                                        have--;
                                        hold += input[next++] << bits;
                                        bits += 8;
                                    }
                                    //===//
                                    if (hold !== (state.check & 0xffff)) {
                                        strm.msg = 'header crc mismatch';
                                        state.mode = BAD;
                                        break;
                                    }
                                    //=== INITBITS();
                                    hold = 0;
                                    bits = 0;
                                    //===//
                                }
                                if (state.head) {
                                    state.head.hcrc = ((state.flags >> 9) & 1);
                                    state.head.done = true;
                                }
                                strm.adler = state.check = 0;
                                state.mode = TYPE;
                                break;
                            case DICTID:
                                //=== NEEDBITS(32); */
                                while (bits < 32) {
                                    if (have === 0) { break inf_leave; }
                                    have--;
                                    hold += input[next++] << bits;
                                    bits += 8;
                                }
                                //===//
                                strm.adler = state.check = zswap32(hold);
                                //=== INITBITS();
                                hold = 0;
                                bits = 0;
                                //===//
                                state.mode = DICT;
                            /* falls through */
                            case DICT:
                                if (state.havedict === 0) {
                                    //--- RESTORE() ---
                                    strm.next_out = put;
                                    strm.avail_out = left;
                                    strm.next_in = next;
                                    strm.avail_in = have;
                                    state.hold = hold;
                                    state.bits = bits;
                                    //---
                                    return Z_NEED_DICT;
                                }
                                strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
                                state.mode = TYPE;
                            /* falls through */
                            case TYPE:
                                if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; }
                            /* falls through */
                            case TYPEDO:
                                if (state.last) {
                                    //--- BYTEBITS() ---//
                                    hold >>>= bits & 7;
                                    bits -= bits & 7;
                                    //---//
                                    state.mode = CHECK;
                                    break;
                                }
                                //=== NEEDBITS(3); */
                                while (bits < 3) {
                                    if (have === 0) { break inf_leave; }
                                    have--;
                                    hold += input[next++] << bits;
                                    bits += 8;
                                }
                                //===//
                                state.last = (hold & 0x01)/*BITS(1)*/;
                                //--- DROPBITS(1) ---//
                                hold >>>= 1;
                                bits -= 1;
                                //---//

                                switch ((hold & 0x03)/*BITS(2)*/) {
                                    case 0:                             /* stored block */
                                        //Tracev((stderr, "inflate:     stored block%s\n",
                                        //        state.last ? " (last)" : ""));
                                        state.mode = STORED;
                                        break;
                                    case 1:                             /* fixed block */
                                        fixedtables(state);
                                        //Tracev((stderr, "inflate:     fixed codes block%s\n",
                                        //        state.last ? " (last)" : ""));
                                        state.mode = LEN_;             /* decode codes */
                                        if (flush === Z_TREES) {
                                            //--- DROPBITS(2) ---//
                                            hold >>>= 2;
                                            bits -= 2;
                                            //---//
                                            break inf_leave;
                                        }
                                        break;
                                    case 2:                             /* dynamic block */
                                        //Tracev((stderr, "inflate:     dynamic codes block%s\n",
                                        //        state.last ? " (last)" : ""));
                                        state.mode = TABLE;
                                        break;
                                    case 3:
                                        strm.msg = 'invalid block type';
                                        state.mode = BAD;
                                }
                                //--- DROPBITS(2) ---//
                                hold >>>= 2;
                                bits -= 2;
                                //---//
                                break;
                            case STORED:
                                //--- BYTEBITS() ---// /* go to byte boundary */
                                hold >>>= bits & 7;
                                bits -= bits & 7;
                                //---//
                                //=== NEEDBITS(32); */
                                while (bits < 32) {
                                    if (have === 0) { break inf_leave; }
                                    have--;
                                    hold += input[next++] << bits;
                                    bits += 8;
                                }
                                //===//
                                if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {
                                    strm.msg = 'invalid stored block lengths';
                                    state.mode = BAD;
                                    break;
                                }
                                state.length = hold & 0xffff;
                                //Tracev((stderr, "inflate:       stored length %u\n",
                                //        state.length));
                                //=== INITBITS();
                                hold = 0;
                                bits = 0;
                                //===//
                                state.mode = COPY_;
                                if (flush === Z_TREES) { break inf_leave; }
                            /* falls through */
                            case COPY_:
                                state.mode = COPY;
                            /* falls through */
                            case COPY:
                                copy = state.length;
                                if (copy) {
                                    if (copy > have) { copy = have; }
                                    if (copy > left) { copy = left; }
                                    if (copy === 0) { break inf_leave; }
                                    //--- zmemcpy(put, next, copy); ---
                                    utils.arraySet(output, input, next, copy, put);
                                    //---//
                                    have -= copy;
                                    next += copy;
                                    left -= copy;
                                    put += copy;
                                    state.length -= copy;
                                    break;
                                }
                                //Tracev((stderr, "inflate:       stored end\n"));
                                state.mode = TYPE;
                                break;
                            case TABLE:
                                //=== NEEDBITS(14); */
                                while (bits < 14) {
                                    if (have === 0) { break inf_leave; }
                                    have--;
                                    hold += input[next++] << bits;
                                    bits += 8;
                                }
                                //===//
                                state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257;
                                //--- DROPBITS(5) ---//
                                hold >>>= 5;
                                bits -= 5;
                                //---//
                                state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1;
                                //--- DROPBITS(5) ---//
                                hold >>>= 5;
                                bits -= 5;
                                //---//
                                state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4;
                                //--- DROPBITS(4) ---//
                                hold >>>= 4;
                                bits -= 4;
                                //---//
                                //#ifndef PKZIP_BUG_WORKAROUND
                                if (state.nlen > 286 || state.ndist > 30) {
                                    strm.msg = 'too many length or distance symbols';
                                    state.mode = BAD;
                                    break;
                                }
                                //#endif
                                //Tracev((stderr, "inflate:       table sizes ok\n"));
                                state.have = 0;
                                state.mode = LENLENS;
                            /* falls through */
                            case LENLENS:
                                while (state.have < state.ncode) {
                                    //=== NEEDBITS(3);
                                    while (bits < 3) {
                                        if (have === 0) { break inf_leave; }
                                        have--;
                                        hold += input[next++] << bits;
                                        bits += 8;
                                    }
                                    //===//
                                    state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);
                                    //--- DROPBITS(3) ---//
                                    hold >>>= 3;
                                    bits -= 3;
                                    //---//
                                }
                                while (state.have < 19) {
                                    state.lens[order[state.have++]] = 0;
                                }
                                // We have separate tables & no pointers. 2 commented lines below not needed.
                                //state.next = state.codes;
                                //state.lencode = state.next;
                                // Switch to use dynamic table
                                state.lencode = state.lendyn;
                                state.lenbits = 7;

                                opts = { bits: state.lenbits };
                                ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
                                state.lenbits = opts.bits;

                                if (ret) {
                                    strm.msg = 'invalid code lengths set';
                                    state.mode = BAD;
                                    break;
                                }
                                //Tracev((stderr, "inflate:       code lengths ok\n"));
                                state.have = 0;
                                state.mode = CODELENS;
                            /* falls through */
                            case CODELENS:
                                while (state.have < state.nlen + state.ndist) {
                                    for (; ;) {
                                        here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/
                                        here_bits = here >>> 24;
                                        here_op = (here >>> 16) & 0xff;
                                        here_val = here & 0xffff;

                                        if ((here_bits) <= bits) { break; }
                                        //--- PULLBYTE() ---//
                                        if (have === 0) { break inf_leave; }
                                        have--;
                                        hold += input[next++] << bits;
                                        bits += 8;
                                        //---//
                                    }
                                    if (here_val < 16) {
                                        //--- DROPBITS(here.bits) ---//
                                        hold >>>= here_bits;
                                        bits -= here_bits;
                                        //---//
                                        state.lens[state.have++] = here_val;
                                    }
                                    else {
                                        if (here_val === 16) {
                                            //=== NEEDBITS(here.bits + 2);
                                            n = here_bits + 2;
                                            while (bits < n) {
                                                if (have === 0) { break inf_leave; }
                                                have--;
                                                hold += input[next++] << bits;
                                                bits += 8;
                                            }
                                            //===//
                                            //--- DROPBITS(here.bits) ---//
                                            hold >>>= here_bits;
                                            bits -= here_bits;
                                            //---//
                                            if (state.have === 0) {
                                                strm.msg = 'invalid bit length repeat';
                                                state.mode = BAD;
                                                break;
                                            }
                                            len = state.lens[state.have - 1];
                                            copy = 3 + (hold & 0x03);//BITS(2);
                                            //--- DROPBITS(2) ---//
                                            hold >>>= 2;
                                            bits -= 2;
                                            //---//
                                        }
                                        else if (here_val === 17) {
                                            //=== NEEDBITS(here.bits + 3);
                                            n = here_bits + 3;
                                            while (bits < n) {
                                                if (have === 0) { break inf_leave; }
                                                have--;
                                                hold += input[next++] << bits;
                                                bits += 8;
                                            }
                                            //===//
                                            //--- DROPBITS(here.bits) ---//
                                            hold >>>= here_bits;
                                            bits -= here_bits;
                                            //---//
                                            len = 0;
                                            copy = 3 + (hold & 0x07);//BITS(3);
                                            //--- DROPBITS(3) ---//
                                            hold >>>= 3;
                                            bits -= 3;
                                            //---//
                                        }
                                        else {
                                            //=== NEEDBITS(here.bits + 7);
                                            n = here_bits + 7;
                                            while (bits < n) {
                                                if (have === 0) { break inf_leave; }
                                                have--;
                                                hold += input[next++] << bits;
                                                bits += 8;
                                            }
                                            //===//
                                            //--- DROPBITS(here.bits) ---//
                                            hold >>>= here_bits;
                                            bits -= here_bits;
                                            //---//
                                            len = 0;
                                            copy = 11 + (hold & 0x7f);//BITS(7);
                                            //--- DROPBITS(7) ---//
                                            hold >>>= 7;
                                            bits -= 7;
                                            //---//
                                        }
                                        if (state.have + copy > state.nlen + state.ndist) {
                                            strm.msg = 'invalid bit length repeat';
                                            state.mode = BAD;
                                            break;
                                        }
                                        while (copy--) {
                                            state.lens[state.have++] = len;
                                        }
                                    }
                                }

                                /* handle error breaks in while */
                                if (state.mode === BAD) { break; }

                                /* check for end-of-block code (better have one) */
                                if (state.lens[256] === 0) {
                                    strm.msg = 'invalid code -- missing end-of-block';
                                    state.mode = BAD;
                                    break;
                                }

                                /* build code tables -- note: do not change the lenbits or distbits
                                 values here (9 and 6) without reading the comments in inftrees.h
                                 concerning the ENOUGH constants, which depend on those values */
                                state.lenbits = 9;

                                opts = { bits: state.lenbits };
                                ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
                                // We have separate tables & no pointers. 2 commented lines below not needed.
                                // state.next_index = opts.table_index;
                                state.lenbits = opts.bits;
                                // state.lencode = state.next;

                                if (ret) {
                                    strm.msg = 'invalid literal/lengths set';
                                    state.mode = BAD;
                                    break;
                                }

                                state.distbits = 6;
                                //state.distcode.copy(state.codes);
                                // Switch to use dynamic table
                                state.distcode = state.distdyn;
                                opts = { bits: state.distbits };
                                ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
                                // We have separate tables & no pointers. 2 commented lines below not needed.
                                // state.next_index = opts.table_index;
                                state.distbits = opts.bits;
                                // state.distcode = state.next;

                                if (ret) {
                                    strm.msg = 'invalid distances set';
                                    state.mode = BAD;
                                    break;
                                }
                                //Tracev((stderr, 'inflate:       codes ok\n'));
                                state.mode = LEN_;
                                if (flush === Z_TREES) { break inf_leave; }
                            /* falls through */
                            case LEN_:
                                state.mode = LEN;
                            /* falls through */
                            case LEN:
                                if (have >= 6 && left >= 258) {
                                    //--- RESTORE() ---
                                    strm.next_out = put;
                                    strm.avail_out = left;
                                    strm.next_in = next;
                                    strm.avail_in = have;
                                    state.hold = hold;
                                    state.bits = bits;
                                    //---
                                    inflate_fast(strm, _out);
                                    //--- LOAD() ---
                                    put = strm.next_out;
                                    output = strm.output;
                                    left = strm.avail_out;
                                    next = strm.next_in;
                                    input = strm.input;
                                    have = strm.avail_in;
                                    hold = state.hold;
                                    bits = state.bits;
                                    //---

                                    if (state.mode === TYPE) {
                                        state.back = -1;
                                    }
                                    break;
                                }
                                state.back = 0;
                                for (; ;) {
                                    here = state.lencode[hold & ((1 << state.lenbits) - 1)];  /*BITS(state.lenbits)*/
                                    here_bits = here >>> 24;
                                    here_op = (here >>> 16) & 0xff;
                                    here_val = here & 0xffff;

                                    if (here_bits <= bits) { break; }
                                    //--- PULLBYTE() ---//
                                    if (have === 0) { break inf_leave; }
                                    have--;
                                    hold += input[next++] << bits;
                                    bits += 8;
                                    //---//
                                }
                                if (here_op && (here_op & 0xf0) === 0) {
                                    last_bits = here_bits;
                                    last_op = here_op;
                                    last_val = here_val;
                                    for (; ;) {
                                        here = state.lencode[last_val +
                                            ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
                                        here_bits = here >>> 24;
                                        here_op = (here >>> 16) & 0xff;
                                        here_val = here & 0xffff;

                                        if ((last_bits + here_bits) <= bits) { break; }
                                        //--- PULLBYTE() ---//
                                        if (have === 0) { break inf_leave; }
                                        have--;
                                        hold += input[next++] << bits;
                                        bits += 8;
                                        //---//
                                    }
                                    //--- DROPBITS(last.bits) ---//
                                    hold >>>= last_bits;
                                    bits -= last_bits;
                                    //---//
                                    state.back += last_bits;
                                }
                                //--- DROPBITS(here.bits) ---//
                                hold >>>= here_bits;
                                bits -= here_bits;
                                //---//
                                state.back += here_bits;
                                state.length = here_val;
                                if (here_op === 0) {
                                    //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
                                    //        "inflate:         literal '%c'\n" :
                                    //        "inflate:         literal 0x%02x\n", here.val));
                                    state.mode = LIT;
                                    break;
                                }
                                if (here_op & 32) {
                                    //Tracevv((stderr, "inflate:         end of block\n"));
                                    state.back = -1;
                                    state.mode = TYPE;
                                    break;
                                }
                                if (here_op & 64) {
                                    strm.msg = 'invalid literal/length code';
                                    state.mode = BAD;
                                    break;
                                }
                                state.extra = here_op & 15;
                                state.mode = LENEXT;
                            /* falls through */
                            case LENEXT:
                                if (state.extra) {
                                    //=== NEEDBITS(state.extra);
                                    n = state.extra;
                                    while (bits < n) {
                                        if (have === 0) { break inf_leave; }
                                        have--;
                                        hold += input[next++] << bits;
                                        bits += 8;
                                    }
                                    //===//
                                    state.length += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
                                    //--- DROPBITS(state.extra) ---//
                                    hold >>>= state.extra;
                                    bits -= state.extra;
                                    //---//
                                    state.back += state.extra;
                                }
                                //Tracevv((stderr, "inflate:         length %u\n", state.length));
                                state.was = state.length;
                                state.mode = DIST;
                            /* falls through */
                            case DIST:
                                for (; ;) {
                                    here = state.distcode[hold & ((1 << state.distbits) - 1)];/*BITS(state.distbits)*/
                                    here_bits = here >>> 24;
                                    here_op = (here >>> 16) & 0xff;
                                    here_val = here & 0xffff;

                                    if ((here_bits) <= bits) { break; }
                                    //--- PULLBYTE() ---//
                                    if (have === 0) { break inf_leave; }
                                    have--;
                                    hold += input[next++] << bits;
                                    bits += 8;
                                    //---//
                                }
                                if ((here_op & 0xf0) === 0) {
                                    last_bits = here_bits;
                                    last_op = here_op;
                                    last_val = here_val;
                                    for (; ;) {
                                        here = state.distcode[last_val +
                                            ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
                                        here_bits = here >>> 24;
                                        here_op = (here >>> 16) & 0xff;
                                        here_val = here & 0xffff;

                                        if ((last_bits + here_bits) <= bits) { break; }
                                        //--- PULLBYTE() ---//
                                        if (have === 0) { break inf_leave; }
                                        have--;
                                        hold += input[next++] << bits;
                                        bits += 8;
                                        //---//
                                    }
                                    //--- DROPBITS(last.bits) ---//
                                    hold >>>= last_bits;
                                    bits -= last_bits;
                                    //---//
                                    state.back += last_bits;
                                }
                                //--- DROPBITS(here.bits) ---//
                                hold >>>= here_bits;
                                bits -= here_bits;
                                //---//
                                state.back += here_bits;
                                if (here_op & 64) {
                                    strm.msg = 'invalid distance code';
                                    state.mode = BAD;
                                    break;
                                }
                                state.offset = here_val;
                                state.extra = (here_op) & 15;
                                state.mode = DISTEXT;
                            /* falls through */
                            case DISTEXT:
                                if (state.extra) {
                                    //=== NEEDBITS(state.extra);
                                    n = state.extra;
                                    while (bits < n) {
                                        if (have === 0) { break inf_leave; }
                                        have--;
                                        hold += input[next++] << bits;
                                        bits += 8;
                                    }
                                    //===//
                                    state.offset += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
                                    //--- DROPBITS(state.extra) ---//
                                    hold >>>= state.extra;
                                    bits -= state.extra;
                                    //---//
                                    state.back += state.extra;
                                }
                                //#ifdef INFLATE_STRICT
                                if (state.offset > state.dmax) {
                                    strm.msg = 'invalid distance too far back';
                                    state.mode = BAD;
                                    break;
                                }
                                //#endif
                                //Tracevv((stderr, "inflate:         distance %u\n", state.offset));
                                state.mode = MATCH;
                            /* falls through */
                            case MATCH:
                                if (left === 0) { break inf_leave; }
                                copy = _out - left;
                                if (state.offset > copy) {         /* copy from window */
                                    copy = state.offset - copy;
                                    if (copy > state.whave) {
                                        if (state.sane) {
                                            strm.msg = 'invalid distance too far back';
                                            state.mode = BAD;
                                            break;
                                        }
                                        // (!) This block is disabled in zlib defailts,
                                        // don't enable it for binary compatibility
                                        //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
                                        //          Trace((stderr, "inflate.c too far\n"));
                                        //          copy -= state.whave;
                                        //          if (copy > state.length) { copy = state.length; }
                                        //          if (copy > left) { copy = left; }
                                        //          left -= copy;
                                        //          state.length -= copy;
                                        //          do {
                                        //            output[put++] = 0;
                                        //          } while (--copy);
                                        //          if (state.length === 0) { state.mode = LEN; }
                                        //          break;
                                        //#endif
                                    }
                                    if (copy > state.wnext) {
                                        copy -= state.wnext;
                                        from = state.wsize - copy;
                                    }
                                    else {
                                        from = state.wnext - copy;
                                    }
                                    if (copy > state.length) { copy = state.length; }
                                    from_source = state.window;
                                }
                                else {                              /* copy from output */
                                    from_source = output;
                                    from = put - state.offset;
                                    copy = state.length;
                                }
                                if (copy > left) { copy = left; }
                                left -= copy;
                                state.length -= copy;
                                do {
                                    output[put++] = from_source[from++];
                                } while (--copy);
                                if (state.length === 0) { state.mode = LEN; }
                                break;
                            case LIT:
                                if (left === 0) { break inf_leave; }
                                output[put++] = state.length;
                                left--;
                                state.mode = LEN;
                                break;
                            case CHECK:
                                if (state.wrap) {
                                    //=== NEEDBITS(32);
                                    while (bits < 32) {
                                        if (have === 0) { break inf_leave; }
                                        have--;
                                        // Use '|' insdead of '+' to make sure that result is signed
                                        hold |= input[next++] << bits;
                                        bits += 8;
                                    }
                                    //===//
                                    _out -= left;
                                    strm.total_out += _out;
                                    state.total += _out;
                                    if (_out) {
                                        strm.adler = state.check =
                                            /*UPDATE(state.check, put - _out, _out);*/
                                            (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));

                                    }
                                    _out = left;
                                    // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
                                    if ((state.flags ? hold : zswap32(hold)) !== state.check) {
                                        strm.msg = 'incorrect data check';
                                        state.mode = BAD;
                                        break;
                                    }
                                    //=== INITBITS();
                                    hold = 0;
                                    bits = 0;
                                    //===//
                                    //Tracev((stderr, "inflate:   check matches trailer\n"));
                                }
                                state.mode = LENGTH;
                            /* falls through */
                            case LENGTH:
                                if (state.wrap && state.flags) {
                                    //=== NEEDBITS(32);
                                    while (bits < 32) {
                                        if (have === 0) { break inf_leave; }
                                        have--;
                                        hold += input[next++] << bits;
                                        bits += 8;
                                    }
                                    //===//
                                    if (hold !== (state.total & 0xffffffff)) {
                                        strm.msg = 'incorrect length check';
                                        state.mode = BAD;
                                        break;
                                    }
                                    //=== INITBITS();
                                    hold = 0;
                                    bits = 0;
                                    //===//
                                    //Tracev((stderr, "inflate:   length matches trailer\n"));
                                }
                                state.mode = DONE;
                            /* falls through */
                            case DONE:
                                ret = Z_STREAM_END;
                                break inf_leave;
                            case BAD:
                                ret = Z_DATA_ERROR;
                                break inf_leave;
                            case MEM:
                                return Z_MEM_ERROR;
                            case SYNC:
                            /* falls through */
                            default:
                                return Z_STREAM_ERROR;
                        }
                    }

                    // inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave"

                    /*
                     Return from inflate(), updating the total counts and the check value.
                     If there was no progress during the inflate() call, return a buffer
                     error.  Call updatewindow() to create and/or update the window state.
                     Note: a memory error from inflate() is non-recoverable.
                     */

                    //--- RESTORE() ---
                    strm.next_out = put;
                    strm.avail_out = left;
                    strm.next_in = next;
                    strm.avail_in = have;
                    state.hold = hold;
                    state.bits = bits;
                    //---

                    if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
                        (state.mode < CHECK || flush !== Z_FINISH))) {
                        if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) ;
                    }
                    _in -= strm.avail_in;
                    _out -= strm.avail_out;
                    strm.total_in += _in;
                    strm.total_out += _out;
                    state.total += _out;
                    if (state.wrap && _out) {
                        strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
                            (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));
                    }
                    strm.data_type = state.bits + (state.last ? 64 : 0) +
                        (state.mode === TYPE ? 128 : 0) +
                        (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
                    if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) {
                        ret = Z_BUF_ERROR;
                    }
                    return ret;
                }

                function inflateEnd(strm) {

                    if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {
                        return Z_STREAM_ERROR;
                    }

                    var state = strm.state;
                    if (state.window) {
                        state.window = null;
                    }
                    strm.state = null;
                    return Z_OK;
                }

                function inflateGetHeader(strm, head) {
                    var state;

                    /* check state */
                    if (!strm || !strm.state) { return Z_STREAM_ERROR; }
                    state = strm.state;
                    if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }

                    /* save header structure */
                    state.head = head;
                    head.done = false;
                    return Z_OK;
                }

                function inflateSetDictionary(strm, dictionary) {
                    var dictLength = dictionary.length;

                    var state;
                    var dictid;
                    var ret;

                    /* check state */
                    if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR; }
                    state = strm.state;

                    if (state.wrap !== 0 && state.mode !== DICT) {
                        return Z_STREAM_ERROR;
                    }

                    /* check for correct dictionary identifier */
                    if (state.mode === DICT) {
                        dictid = 1; /* adler32(0, null, 0)*/
                        /* dictid = adler32(dictid, dictionary, dictLength); */
                        dictid = adler32(dictid, dictionary, dictLength, 0);
                        if (dictid !== state.check) {
                            return Z_DATA_ERROR;
                        }
                    }
                    /* copy dictionary to window using updatewindow(), which will amend the
                     existing dictionary if appropriate */
                    ret = updatewindow(strm, dictionary, dictLength, dictLength);
                    if (ret) {
                        state.mode = MEM;
                        return Z_MEM_ERROR;
                    }
                    state.havedict = 1;
                    // Tracev((stderr, "inflate:   dictionary set\n"));
                    return Z_OK;
                }

                exports.inflateReset = inflateReset;
                exports.inflateReset2 = inflateReset2;
                exports.inflateResetKeep = inflateResetKeep;
                exports.inflateInit = inflateInit;
                exports.inflateInit2 = inflateInit2;
                exports.inflate = inflate;
                exports.inflateEnd = inflateEnd;
                exports.inflateGetHeader = inflateGetHeader;
                exports.inflateSetDictionary = inflateSetDictionary;
                exports.inflateInfo = 'pako inflate (from Nodeca project)';

                /* Not implemented
                 exports.inflateCopy = inflateCopy;
                 exports.inflateGetDictionary = inflateGetDictionary;
                 exports.inflateMark = inflateMark;
                 exports.inflatePrime = inflatePrime;
                 exports.inflateSync = inflateSync;
                 exports.inflateSyncPoint = inflateSyncPoint;
                 exports.inflateUndermine = inflateUndermine;
                 */

            }, { "../utils/common": 1, "./adler32": 3, "./crc32": 5, "./inffast": 7, "./inftrees": 9 }], 9: [function (require, module, exports) {


                var utils = require('../utils/common');

                var MAXBITS = 15;
                var ENOUGH_LENS = 852;
                var ENOUGH_DISTS = 592;
                //var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);

                var CODES = 0;
                var LENS = 1;
                var DISTS = 2;

                var lbase = [ /* Length codes 257..285 base */
                    3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
                    35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
                ];

                var lext = [ /* Length codes 257..285 extra */
                    16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
                    19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78
                ];

                var dbase = [ /* Distance codes 0..29 base */
                    1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
                    257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
                    8193, 12289, 16385, 24577, 0, 0
                ];

                var dext = [ /* Distance codes 0..29 extra */
                    16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
                    23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
                    28, 28, 29, 29, 64, 64
                ];

                module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) {
                    var bits = opts.bits;
                    //here = opts.here; /* table entry for duplication */

                    var len = 0;               /* a code's length in bits */
                    var sym = 0;               /* index of code symbols */
                    var min = 0, max = 0;          /* minimum and maximum code lengths */
                    var root = 0;              /* number of index bits for root table */
                    var curr = 0;              /* number of index bits for current table */
                    var drop = 0;              /* code bits to drop for sub-table */
                    var left = 0;                   /* number of prefix codes available */
                    var used = 0;              /* code entries in table used */
                    var huff = 0;              /* Huffman code */
                    var incr;              /* for incrementing code, index */
                    var fill;              /* index for replicating entries */
                    var low;               /* low bits for current root entry */
                    var mask;              /* mask for low root bits */
                    var next;             /* next available space in table */
                    var base = null;     /* base value table to use */
                    var base_index = 0;
                    //  var shoextra;    /* extra bits table to use */
                    var end;                    /* use base and extra for symbol > end */
                    var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1];    /* number of codes of each length */
                    var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1];     /* offsets in table for each length */
                    var extra = null;
                    var extra_index = 0;

                    var here_bits, here_op, here_val;

                    /*
                     Process a set of code lengths to create a canonical Huffman code.  The
                     code lengths are lens[0..codes-1].  Each length corresponds to the
                     symbols 0..codes-1.  The Huffman code is generated by first sorting the
                     symbols by length from short to long, and retaining the symbol order
                     for codes with equal lengths.  Then the code starts with all zero bits
                     for the first code of the shortest length, and the codes are integer
                     increments for the same length, and zeros are appended as the length
                     increases.  For the deflate format, these bits are stored backwards
                     from their more natural integer increment ordering, and so when the
                     decoding tables are built in the large loop below, the integer codes
                     are incremented backwards.
            
                     This routine assumes, but does not check, that all of the entries in
                     lens[] are in the range 0..MAXBITS.  The caller must assure this.
                     1..MAXBITS is interpreted as that code length.  zero means that that
                     symbol does not occur in this code.
            
                     The codes are sorted by computing a count of codes for each length,
                     creating from that a table of starting indices for each length in the
                     sorted table, and then entering the symbols in order in the sorted
                     table.  The sorted table is work[], with that space being provided by
                     the caller.
            
                     The length counts are used for other purposes as well, i.e. finding
                     the minimum and maximum length codes, determining if there are any
                     codes at all, checking for a valid set of lengths, and looking ahead
                     at length counts to determine sub-table sizes when building the
                     decoding tables.
                     */

                    /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
                    for (len = 0; len <= MAXBITS; len++) {
                        count[len] = 0;
                    }
                    for (sym = 0; sym < codes; sym++) {
                        count[lens[lens_index + sym]]++;
                    }

                    /* bound code lengths, force root to be within code lengths */
                    root = bits;
                    for (max = MAXBITS; max >= 1; max--) {
                        if (count[max] !== 0) { break; }
                    }
                    if (root > max) {
                        root = max;
                    }
                    if (max === 0) {                     /* no symbols to code at all */
                        //table.op[opts.table_index] = 64;  //here.op = (var char)64;    /* invalid code marker */
                        //table.bits[opts.table_index] = 1;   //here.bits = (var char)1;
                        //table.val[opts.table_index++] = 0;   //here.val = (var short)0;
                        table[table_index++] = (1 << 24) | (64 << 16) | 0;


                        //table.op[opts.table_index] = 64;
                        //table.bits[opts.table_index] = 1;
                        //table.val[opts.table_index++] = 0;
                        table[table_index++] = (1 << 24) | (64 << 16) | 0;

                        opts.bits = 1;
                        return 0;     /* no symbols, but wait for decoding to report error */
                    }
                    for (min = 1; min < max; min++) {
                        if (count[min] !== 0) { break; }
                    }
                    if (root < min) {
                        root = min;
                    }

                    /* check for an over-subscribed or incomplete set of lengths */
                    left = 1;
                    for (len = 1; len <= MAXBITS; len++) {
                        left <<= 1;
                        left -= count[len];
                        if (left < 0) {
                            return -1;
                        }        /* over-subscribed */
                    }
                    if (left > 0 && (type === CODES || max !== 1)) {
                        return -1;                      /* incomplete set */
                    }

                    /* generate offsets into symbol table for each length for sorting */
                    offs[1] = 0;
                    for (len = 1; len < MAXBITS; len++) {
                        offs[len + 1] = offs[len] + count[len];
                    }

                    /* sort symbols by length, by symbol order within each length */
                    for (sym = 0; sym < codes; sym++) {
                        if (lens[lens_index + sym] !== 0) {
                            work[offs[lens[lens_index + sym]]++] = sym;
                        }
                    }

                    /*
                     Create and fill in decoding tables.  In this loop, the table being
                     filled is at next and has curr index bits.  The code being used is huff
                     with length len.  That code is converted to an index by dropping drop
                     bits off of the bottom.  For codes where len is less than drop + curr,
                     those top drop + curr - len bits are incremented through all values to
                     fill the table with replicated entries.
            
                     root is the number of index bits for the root table.  When len exceeds
                     root, sub-tables are created pointed to by the root entry with an index
                     of the low root bits of huff.  This is saved in low to check for when a
                     new sub-table should be started.  drop is zero when the root table is
                     being filled, and drop is root when sub-tables are being filled.
            
                     When a new sub-table is needed, it is necessary to look ahead in the
                     code lengths to determine what size sub-table is needed.  The length
                     counts are used for this, and so count[] is decremented as codes are
                     entered in the tables.
            
                     used keeps track of how many table entries have been allocated from the
                     provided *table space.  It is checked for LENS and DIST tables against
                     the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
                     the initial root table size constants.  See the comments in inftrees.h
                     for more information.
            
                     sym increments through all symbols, and the loop terminates when
                     all codes of length max, i.e. all codes, have been processed.  This
                     routine permits incomplete codes, so another loop after this one fills
                     in the rest of the decoding tables with invalid code markers.
                     */

                    /* set up for code type */
                    // poor man optimization - use if-else instead of switch,
                    // to avoid deopts in old v8
                    if (type === CODES) {
                        base = extra = work;    /* dummy value--not used */
                        end = 19;

                    } else if (type === LENS) {
                        base = lbase;
                        base_index -= 257;
                        extra = lext;
                        extra_index -= 257;
                        end = 256;

                    } else {                    /* DISTS */
                        base = dbase;
                        extra = dext;
                        end = -1;
                    }

                    /* initialize opts for loop */
                    huff = 0;                   /* starting code */
                    sym = 0;                    /* starting code symbol */
                    len = min;                  /* starting code length */
                    next = table_index;              /* current table to fill in */
                    curr = root;                /* current table index bits */
                    drop = 0;                   /* current bits to drop from code for index */
                    low = -1;                   /* trigger new sub-table when len > root */
                    used = 1 << root;          /* use root table entries */
                    mask = used - 1;            /* mask for comparing low */

                    /* check available table space */
                    if ((type === LENS && used > ENOUGH_LENS) ||
                        (type === DISTS && used > ENOUGH_DISTS)) {
                        return 1;
                    }

                    /* process all codes and make table entries */
                    for (; ;) {
                        /* create table entry */
                        here_bits = len - drop;
                        if (work[sym] < end) {
                            here_op = 0;
                            here_val = work[sym];
                        }
                        else if (work[sym] > end) {
                            here_op = extra[extra_index + work[sym]];
                            here_val = base[base_index + work[sym]];
                        }
                        else {
                            here_op = 32 + 64;         /* end of block */
                            here_val = 0;
                        }

                        /* replicate for those indices with low len bits equal to huff */
                        incr = 1 << (len - drop);
                        fill = 1 << curr;
                        min = fill;                 /* save offset to next table */
                        do {
                            fill -= incr;
                            table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val | 0;
                        } while (fill !== 0);

                        /* backwards increment the len-bit code huff */
                        incr = 1 << (len - 1);
                        while (huff & incr) {
                            incr >>= 1;
                        }
                        if (incr !== 0) {
                            huff &= incr - 1;
                            huff += incr;
                        } else {
                            huff = 0;
                        }

                        /* go to next symbol, update count, len */
                        sym++;
                        if (--count[len] === 0) {
                            if (len === max) { break; }
                            len = lens[lens_index + work[sym]];
                        }

                        /* create new sub-table if needed */
                        if (len > root && (huff & mask) !== low) {
                            /* if first time, transition to sub-tables */
                            if (drop === 0) {
                                drop = root;
                            }

                            /* increment past last table */
                            next += min;            /* here min is 1 << curr */

                            /* determine length of next table */
                            curr = len - drop;
                            left = 1 << curr;
                            while (curr + drop < max) {
                                left -= count[curr + drop];
                                if (left <= 0) { break; }
                                curr++;
                                left <<= 1;
                            }

                            /* check for enough space */
                            used += 1 << curr;
                            if ((type === LENS && used > ENOUGH_LENS) ||
                                (type === DISTS && used > ENOUGH_DISTS)) {
                                return 1;
                            }

                            /* point entry in root table to sub-table */
                            low = huff & mask;
                            /*table.op[low] = curr;
                             table.bits[low] = root;
                             table.val[low] = next - opts.table_index;*/
                            table[low] = (root << 24) | (curr << 16) | (next - table_index) | 0;
                        }
                    }

                    /* fill in remaining table entry if code is incomplete (guaranteed to have
                     at most one remaining entry, since if the code is incomplete, the
                     maximum code length that was allowed to get this far is one bit) */
                    if (huff !== 0) {
                        //table.op[next + huff] = 64;            /* invalid code marker */
                        //table.bits[next + huff] = len - drop;
                        //table.val[next + huff] = 0;
                        table[next + huff] = ((len - drop) << 24) | (64 << 16) | 0;
                    }

                    /* set return parameters */
                    //opts.table_index += used;
                    opts.bits = root;
                    return 0;
                };

            }, { "../utils/common": 1 }], 10: [function (require, module, exports) {

                module.exports = {
                    2: 'need dictionary',     /* Z_NEED_DICT       2  */
                    1: 'stream end',          /* Z_STREAM_END      1  */
                    0: '',                    /* Z_OK              0  */
                    '-1': 'file error',          /* Z_ERRNO         (-1) */
                    '-2': 'stream error',        /* Z_STREAM_ERROR  (-2) */
                    '-3': 'data error',          /* Z_DATA_ERROR    (-3) */
                    '-4': 'insufficient memory', /* Z_MEM_ERROR     (-4) */
                    '-5': 'buffer error',        /* Z_BUF_ERROR     (-5) */
                    '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */
                };

            }, {}], 11: [function (require, module, exports) {


                function ZStream() {
                    /* next input byte */
                    this.input = null; // JS specific, because we have no pointers
                    this.next_in = 0;
                    /* number of bytes available at input */
                    this.avail_in = 0;
                    /* total number of input bytes read so far */
                    this.total_in = 0;
                    /* next output byte should be put there */
                    this.output = null; // JS specific, because we have no pointers
                    this.next_out = 0;
                    /* remaining free space at output */
                    this.avail_out = 0;
                    /* total number of bytes output so far */
                    this.total_out = 0;
                    /* last error message, NULL if no error */
                    this.msg = ''/*Z_NULL*/;
                    /* not visible by applications */
                    this.state = null;
                    /* best guess about the data type: binary or text */
                    this.data_type = 2/*Z_UNKNOWN*/;
                    /* adler32 value of the uncompressed data */
                    this.adler = 0;
                }

                module.exports = ZStream;

            }, {}], "/lib/inflate.js": [function (require, module, exports) {


                var zlib_inflate = require('./zlib/inflate');
                var utils = require('./utils/common');
                var strings = require('./utils/strings');
                var c = require('./zlib/constants');
                var msg = require('./zlib/messages');
                var ZStream = require('./zlib/zstream');
                var GZheader = require('./zlib/gzheader');

                var toString = Object.prototype.toString;

                /**
                 * class Inflate
                 *
                 * Generic JS-style wrapper for zlib calls. If you don't need
                 * streaming behaviour - use more simple functions: [[inflate]]
                 * and [[inflateRaw]].
                 **/

                /* internal
                 * inflate.chunks -> Array
                 *
                 * Chunks of output data, if [[Inflate#onData]] not overriden.
                 **/

                /**
                 * Inflate.result -> Uint8Array|Array|String
                 *
                 * Uncompressed result, generated by default [[Inflate#onData]]
                 * and [[Inflate#onEnd]] handlers. Filled after you push last chunk
                 * (call [[Inflate#push]] with `Z_FINISH` / `true` param) or if you
                 * push a chunk with explicit flush (call [[Inflate#push]] with
                 * `Z_SYNC_FLUSH` param).
                 **/

                /**
                 * Inflate.err -> Number
                 *
                 * Error code after inflate finished. 0 (Z_OK) on success.
                 * Should be checked if broken data possible.
                 **/

                /**
                 * Inflate.msg -> String
                 *
                 * Error message, if [[Inflate.err]] != 0
                 **/


                /**
                 * new Inflate(options)
                 * - options (Object): zlib inflate options.
                 *
                 * Creates new inflator instance with specified params. Throws exception
                 * on bad params. Supported options:
                 *
                 * - `windowBits`
                 * - `dictionary`
                 *
                 * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
                 * for more information on these.
                 *
                 * Additional options, for internal needs:
                 *
                 * - `chunkSize` - size of generated data chunks (16K by default)
                 * - `raw` (Boolean) - do raw inflate
                 * - `to` (String) - if equal to 'string', then result will be converted
                 *   from utf8 to utf16 (javascript) string. When string output requested,
                 *   chunk length can differ from `chunkSize`, depending on content.
                 *
                 * By default, when no options set, autodetect deflate/gzip data format via
                 * wrapper header.
                 *
                 * ##### Example:
                 *
                 * ```javascript
                 * var pako = require('pako')
                 *   , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
                 *   , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
                 *
                 * var inflate = new pako.Inflate({ level: 3});
                 *
                 * inflate.push(chunk1, false);
                 * inflate.push(chunk2, true);  // true -> last chunk
                 *
                 * if (inflate.err) { throw new Error(inflate.err); }
                 *
                 * console.log(inflate.result);
                 * ```
                 **/
                function Inflate(options) {
                    if (!(this instanceof Inflate)) return new Inflate(options);

                    this.options = utils.assign({
                        chunkSize: 16384,
                        windowBits: 0,
                        to: ''
                    }, options || {});

                    var opt = this.options;

                    // Force window size for `raw` data, if not set directly,
                    // because we have no header for autodetect.
                    if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {
                        opt.windowBits = -opt.windowBits;
                        if (opt.windowBits === 0) { opt.windowBits = -15; }
                    }

                    // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate
                    if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&
                        !(options && options.windowBits)) {
                        opt.windowBits += 32;
                    }

                    // Gzip header has no info about windows size, we can do autodetect only
                    // for deflate. So, if window size not set, force it to max when gzip possible
                    if ((opt.windowBits > 15) && (opt.windowBits < 48)) {
                        // bit 3 (16) -> gzipped data
                        // bit 4 (32) -> autodetect gzip/deflate
                        if ((opt.windowBits & 15) === 0) {
                            opt.windowBits |= 15;
                        }
                    }

                    this.err = 0;      // error code, if happens (0 = Z_OK)
                    this.msg = '';     // error message
                    this.ended = false;  // used to avoid multiple onEnd() calls
                    this.chunks = [];     // chunks of compressed data

                    this.strm = new ZStream();
                    this.strm.avail_out = 0;

                    var status = zlib_inflate.inflateInit2(
                        this.strm,
                        opt.windowBits
                    );

                    if (status !== c.Z_OK) {
                        throw new Error(msg[status]);
                    }

                    this.header = new GZheader();

                    zlib_inflate.inflateGetHeader(this.strm, this.header);
                }

                /**
                 * Inflate#push(data[, mode]) -> Boolean
                 * - data (Uint8Array|Array|ArrayBuffer|String): input data
                 * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
                 *   See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.
                 *
                 * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
                 * new output chunks. Returns `true` on success. The last data block must have
                 * mode Z_FINISH (or `true`). That will flush internal pending buffers and call
                 * [[Inflate#onEnd]]. For interim explicit flushes (without ending the stream) you
                 * can use mode Z_SYNC_FLUSH, keeping the decompression context.
                 *
                 * On fail call [[Inflate#onEnd]] with error code and return false.
                 *
                 * We strongly recommend to use `Uint8Array` on input for best speed (output
                 * format is detected automatically). Also, don't skip last param and always
                 * use the same type in your code (boolean or number). That will improve JS speed.
                 *
                 * For regular `Array`-s make sure all elements are [0..255].
                 *
                 * ##### Example
                 *
                 * ```javascript
                 * push(chunk, false); // push one of data chunks
                 * ...
                 * push(chunk, true);  // push last chunk
                 * ```
                 **/
                Inflate.prototype.push = function (data, mode) {
                    var strm = this.strm;
                    var chunkSize = this.options.chunkSize;
                    var dictionary = this.options.dictionary;
                    var status, _mode;
                    var next_out_utf8, tail, utf8str;
                    var dict;

                    // Flag to properly process Z_BUF_ERROR on testing inflate call
                    // when we check that all output data was flushed.
                    var allowBufError = false;

                    if (this.ended) { return false; }
                    _mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH);

                    // Convert data if needed
                    if (typeof data === 'string') {
                        // Only binary strings can be decompressed on practice
                        strm.input = strings.binstring2buf(data);
                    } else if (toString.call(data) === '[object ArrayBuffer]') {
                        strm.input = new Uint8Array(data);
                    } else {
                        strm.input = data;
                    }

                    strm.next_in = 0;
                    strm.avail_in = strm.input.length;

                    do {
                        if (strm.avail_out === 0) {
                            strm.output = new utils.Buf8(chunkSize);
                            strm.next_out = 0;
                            strm.avail_out = chunkSize;
                        }

                        status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH);    /* no bad return value */

                        if (status === c.Z_NEED_DICT && dictionary) {
                            // Convert data if needed
                            if (typeof dictionary === 'string') {
                                dict = strings.string2buf(dictionary);
                            } else if (toString.call(dictionary) === '[object ArrayBuffer]') {
                                dict = new Uint8Array(dictionary);
                            } else {
                                dict = dictionary;
                            }

                            status = zlib_inflate.inflateSetDictionary(this.strm, dict);

                        }

                        if (status === c.Z_BUF_ERROR && allowBufError === true) {
                            status = c.Z_OK;
                            allowBufError = false;
                        }

                        if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
                            this.onEnd(status);
                            this.ended = true;
                            return false;
                        }

                        if (strm.next_out) {
                            if (strm.avail_out === 0 || status === c.Z_STREAM_END || (strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH))) {

                                if (this.options.to === 'string') {

                                    next_out_utf8 = strings.utf8border(strm.output, strm.next_out);

                                    tail = strm.next_out - next_out_utf8;
                                    utf8str = strings.buf2string(strm.output, next_out_utf8);

                                    // move tail
                                    strm.next_out = tail;
                                    strm.avail_out = chunkSize - tail;
                                    if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); }

                                    this.onData(utf8str);

                                } else {
                                    this.onData(utils.shrinkBuf(strm.output, strm.next_out));
                                }
                            }
                        }

                        // When no more input data, we should check that internal inflate buffers
                        // are flushed. The only way to do it when avail_out = 0 - run one more
                        // inflate pass. But if output data not exists, inflate return Z_BUF_ERROR.
                        // Here we set flag to process this error properly.
                        //
                        // NOTE. Deflate does not return error in this case and does not needs such
                        // logic.
                        if (strm.avail_in === 0 && strm.avail_out === 0) {
                            allowBufError = true;
                        }

                    } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END);

                    if (status === c.Z_STREAM_END) {
                        _mode = c.Z_FINISH;
                    }

                    // Finalize on the last chunk.
                    if (_mode === c.Z_FINISH) {
                        status = zlib_inflate.inflateEnd(this.strm);
                        this.onEnd(status);
                        this.ended = true;
                        return status === c.Z_OK;
                    }

                    // callback interim results if Z_SYNC_FLUSH.
                    if (_mode === c.Z_SYNC_FLUSH) {
                        this.onEnd(c.Z_OK);
                        strm.avail_out = 0;
                        return true;
                    }

                    return true;
                };


                /**
                 * Inflate#onData(chunk) -> Void
                 * - chunk (Uint8Array|Array|String): ouput data. Type of array depends
                 *   on js engine support. When string output requested, each chunk
                 *   will be string.
                 *
                 * By default, stores data blocks in `chunks[]` property and glue
                 * those in `onEnd`. Override this handler, if you need another behaviour.
                 **/
                Inflate.prototype.onData = function (chunk) {
                    this.chunks.push(chunk);
                };


                /**
                 * Inflate#onEnd(status) -> Void
                 * - status (Number): inflate status. 0 (Z_OK) on success,
                 *   other if not.
                 *
                 * Called either after you tell inflate that the input stream is
                 * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)
                 * or if an error happened. By default - join collected chunks,
                 * free memory and fill `results` / `err` properties.
                 **/
                Inflate.prototype.onEnd = function (status) {
                    // On success - join
                    if (status === c.Z_OK) {
                        if (this.options.to === 'string') {
                            // Glue & convert here, until we teach pako to send
                            // utf8 alligned strings to onData
                            this.result = this.chunks.join('');
                        } else {
                            this.result = utils.flattenChunks(this.chunks);
                        }
                    }
                    this.chunks = [];
                    this.err = status;
                    this.msg = this.strm.msg;
                };


                /**
                 * inflate(data[, options]) -> Uint8Array|Array|String
                 * - data (Uint8Array|Array|String): input data to decompress.
                 * - options (Object): zlib inflate options.
                 *
                 * Decompress `data` with inflate/ungzip and `options`. Autodetect
                 * format via wrapper header by default. That's why we don't provide
                 * separate `ungzip` method.
                 *
                 * Supported options are:
                 *
                 * - windowBits
                 *
                 * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
                 * for more information.
                 *
                 * Sugar (options):
                 *
                 * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
                 *   negative windowBits implicitly.
                 * - `to` (String) - if equal to 'string', then result will be converted
                 *   from utf8 to utf16 (javascript) string. When string output requested,
                 *   chunk length can differ from `chunkSize`, depending on content.
                 *
                 *
                 * ##### Example:
                 *
                 * ```javascript
                 * var pako = require('pako')
                 *   , input = pako.deflate([1,2,3,4,5,6,7,8,9])
                 *   , output;
                 *
                 * try {
             *   output = pako.inflate(input);
             * } catch (err)
                 *   console.log(err);
                 * }
                 * ```
                 **/
                function inflate(input, options) {
                    var inflator = new Inflate(options);

                    inflator.push(input, true);

                    // That will never happens, if you don't cheat with options :)
                    if (inflator.err) { throw inflator.msg || msg[inflator.err]; }

                    return inflator.result;
                }


                /**
                 * inflateRaw(data[, options]) -> Uint8Array|Array|String
                 * - data (Uint8Array|Array|String): input data to decompress.
                 * - options (Object): zlib inflate options.
                 *
                 * The same as [[inflate]], but creates raw data, without wrapper
                 * (header and adler32 crc).
                 **/
                function inflateRaw(input, options) {
                    options = options || {};
                    options.raw = true;
                    return inflate(input, options);
                }


                /**
                 * ungzip(data[, options]) -> Uint8Array|Array|String
                 * - data (Uint8Array|Array|String): input data to decompress.
                 * - options (Object): zlib inflate options.
                 *
                 * Just shortcut to [[inflate]], because it autodetects format
                 * by header.content. Done for convenience.
                 **/


                exports.Inflate = Inflate;
                exports.inflate = inflate;
                exports.inflateRaw = inflateRaw;
                exports.ungzip = inflate;

            }, { "./utils/common": 1, "./utils/strings": 2, "./zlib/constants": 4, "./zlib/gzheader": 6, "./zlib/inflate": 8, "./zlib/messages": 10, "./zlib/zstream": 11 }]
        }, {}, [])("/lib/inflate.js");

    function S3ModelParser() {

    }

    let S3MBVertexTag = {
        SV_Unkown: 0,
        SV_Standard: 1,
        SV_Compressed: 2
    };

    function unZip(buffer, bytesOffset) {
        let dataZip = new Uint8Array(buffer, bytesOffset);
        return pako.inflate(dataZip).buffer;
    }

    function parseString(buffer, view, bytesOffset) {
        let length = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        let stringBufferView = new Uint8Array(buffer, bytesOffset, length);
        let string = Cesium.getStringFromTypedArray(stringBufferView);
        bytesOffset += length;

        return {
            string: string,
            bytesOffset: bytesOffset
        }
    }

    function parseGeode(buffer, view, bytesOffset, geodes) {
        let geode = {};
        let skeletonNames = [];
        let geoMatrix = new Array(16);
        for (let i = 0; i < 16; i++) {
            geoMatrix[i] = view.getFloat64(bytesOffset, true);
            bytesOffset += Float64Array.BYTES_PER_ELEMENT;
        }

        geode.matrix = geoMatrix;
        geode.skeletonNames = skeletonNames;
        let skeletonCount = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        for (let i = 0; i < skeletonCount; i++) {
            let res = parseString(buffer, view, bytesOffset);
            skeletonNames.push(res.string);
            bytesOffset = res.bytesOffset;
        }

        geodes.push(geode);

        return bytesOffset;
    }

    function parsePageLOD(buffer, view, bytesOffset, pageLods) {
        let pageLOD = {};
        pageLOD.rangeList = view.getFloat32(bytesOffset, true);
        bytesOffset += Float32Array.BYTES_PER_ELEMENT;
        pageLOD.rangeMode = view.getUint16(bytesOffset, true);
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        let center = {};
        center.x = view.getFloat64(bytesOffset, true);
        bytesOffset += Float64Array.BYTES_PER_ELEMENT;
        center.y = view.getFloat64(bytesOffset, true);
        bytesOffset += Float64Array.BYTES_PER_ELEMENT;
        center.z = view.getFloat64(bytesOffset, true);
        bytesOffset += Float64Array.BYTES_PER_ELEMENT;
        let radius = view.getFloat64(bytesOffset, true);
        bytesOffset += Float64Array.BYTES_PER_ELEMENT;
        pageLOD.boundingSphere = {
            center: center,
            radius: radius
        };

        let res = parseString(buffer, view, bytesOffset);
        let strChildTile = res.string;
        bytesOffset = res.bytesOffset;
        let index = strChildTile.indexOf('Geometry');
        if (index !== -1) {
            let ignoreString = strChildTile.substring(index);
            strChildTile = strChildTile.replace(ignoreString, '');
        }

        pageLOD.childTile = strChildTile;
        pageLOD.geodes = [];
        let geodeCount = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        for (let i = 0; i < geodeCount; i++) {
            bytesOffset = parseGeode(buffer, view, bytesOffset, pageLOD.geodes);
        }

        pageLods.push(pageLOD);

        return bytesOffset;
    }

    function parseGroupNode(buffer, view, bytesOffset, result) {
        let groupNode = {};
        let pageLods = [];
        view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        let count = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        for (let i = 0; i < count; i++) {
            bytesOffset = parsePageLOD(buffer, view, bytesOffset, pageLods);
        }
        groupNode.pageLods = pageLods;
        let align = bytesOffset % 4;
        if (align !== 0) {
            bytesOffset += (4 - align);
        }

        result.groupNode = groupNode;

        return bytesOffset;
    }

    function parseVertex(buffer, view, bytesOffset, vertexPackage) {
        let verticesCount = view.getUint32(bytesOffset, true);
        vertexPackage.verticesCount = verticesCount;
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        if (bytesOffset <= 0) {
            return bytesOffset;
        }

        let vertexDimension = view.getUint16(bytesOffset, true);
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        let vertexStride = view.getUint16(bytesOffset, true);
        vertexStride = vertexDimension * Float32Array.BYTES_PER_ELEMENT;
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        let byteLength = verticesCount * vertexDimension * Float32Array.BYTES_PER_ELEMENT;
        let vertexBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
        bytesOffset += byteLength;
        let attributes = vertexPackage.vertexAttributes;
        let attrLocation = vertexPackage.attrLocation;
        attrLocation['aPosition'] = attributes.length;
        attributes.push({
            index: attrLocation['aPosition'],
            typedArray: vertexBuffer,
            componentsPerAttribute: vertexDimension,
            componentDatatype: Cesium.ComponentDatatype.FLOAT,
            offsetInBytes: 0,
            strideInBytes: vertexStride,
            normalize: false
        });

        return bytesOffset;
    }

    function parseNormal(buffer, view, bytesOffset, vertexPackage) {
        let normalCount = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        if (normalCount <= 0) {
            return bytesOffset;
        }

        let normalDimension = view.getUint16(bytesOffset, true);
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        let normalStride = view.getUint16(bytesOffset, true);
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        let byteLength = normalCount * normalDimension * Float32Array.BYTES_PER_ELEMENT;
        let normalBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
        bytesOffset += byteLength;
        let attributes = vertexPackage.vertexAttributes;
        let attrLocation = vertexPackage.attrLocation;
        attrLocation['aNormal'] = attributes.length;
        attributes.push({
            index: attrLocation['aNormal'],
            typedArray: normalBuffer,
            componentsPerAttribute: normalDimension,
            componentDatatype: Cesium.ComponentDatatype.FLOAT,
            offsetInBytes: 0,
            strideInBytes: normalStride,
            normalize: false
        });

        return bytesOffset;
    }

    function parseVertexColor(buffer, view, bytesOffset, vertexPackage) {
        let colorCount = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        let verticesCount = vertexPackage.verticesCount;
        let vertexColor;
        if (colorCount > 0) {
            view.getUint16(bytesOffset, true);
            bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
            bytesOffset += Uint8Array.BYTES_PER_ELEMENT * 2;
            let byteLength = colorCount * Uint8Array.BYTES_PER_ELEMENT * 4;
            let typedArray = new Uint8Array(buffer, bytesOffset, byteLength);
            vertexColor = typedArray.slice(0, byteLength);
            bytesOffset += byteLength;
        }
        else {
            vertexColor = new Uint8Array(4 * verticesCount);
            for (let m = 0; m < verticesCount; m++) {
                vertexColor[m * 4] = 255;
                vertexColor[m * 4 + 1] = 255;
                vertexColor[m * 4 + 2] = 255;
                vertexColor[m * 4 + 3] = 255;
            }
        }

        let attributes = vertexPackage.vertexAttributes;
        let attrLocation = vertexPackage.attrLocation;
        attrLocation['aColor'] = attributes.length;
        attributes.push({
            index: attrLocation['aColor'],
            typedArray: vertexColor,
            componentsPerAttribute: 4,
            componentDatatype: Cesium.ComponentDatatype.UNSIGNED_BYTE,
            offsetInBytes: 0,
            strideInBytes: 4,
            normalize: true
        });

        vertexPackage.vertexColor = vertexColor;

        return bytesOffset;
    }

    function parseSecondColor(buffer, view, bytesOffset, vertexPackage) {
        let secondColorCount = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        if (secondColorCount <= 0) {
            return bytesOffset;
        }

        view.getUint16(bytesOffset, true);
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        bytesOffset += Uint8Array.BYTES_PER_ELEMENT * 2;
        let byteLength = secondColorCount * Uint8Array.BYTES_PER_ELEMENT * 4;
        let secColorBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
        bytesOffset += byteLength;

        let attributes = vertexPackage.vertexAttributes;
        let attrLocation = vertexPackage.attrLocation;
        attrLocation['aSecondColor'] = attributes.length;
        attributes.push({
            index: attrLocation['aSecondColor'],
            typedArray: secColorBuffer,
            componentsPerAttribute: 4,
            componentDatatype: Cesium.ComponentDatatype.UNSIGNED_BYTE,
            offsetInBytes: 0,
            strideInBytes: 4,
            normalize: true
        });

        return bytesOffset;
    }

    function parseTexCoord(buffer, view, bytesOffset, vertexPackage) {
        let count = view.getUint16(bytesOffset, true);
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;

        for (let i = 0; i < count; i++) {
            let texCoordCount = view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            let dimension = view.getUint16(bytesOffset, true);
            bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
            view.getUint16(bytesOffset, true);
            bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
            let byteLength = texCoordCount * dimension * Float32Array.BYTES_PER_ELEMENT;
            let texCoordBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
            bytesOffset += byteLength;
            let str = 'aTexCoord' + i;
            let attributes = vertexPackage.vertexAttributes;
            let attrLocation = vertexPackage.attrLocation;
            attrLocation[str] = attributes.length;
            attributes.push({
                index: attrLocation[str],
                typedArray: texCoordBuffer,
                componentsPerAttribute: dimension,
                componentDatatype: Cesium.ComponentDatatype.FLOAT,
                offsetInBytes: 0,
                strideInBytes: dimension * Float32Array.BYTES_PER_ELEMENT,
                normalize: false
            });
        }

        return bytesOffset;
    }

    function parseInstanceInfo(buffer, view, bytesOffset, vertexPackage) {
        let count = view.getUint16(bytesOffset, true);
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        let attributes = vertexPackage.vertexAttributes;
        let attrLocation = vertexPackage.attrLocation;

        for (let i = 0; i < count; i++) {
            let texCoordCount = view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            let texDimensions = view.getUint16(bytesOffset, true);
            bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
            view.getUint16(bytesOffset, true);
            bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
            let byteLength = texCoordCount * texDimensions * Float32Array.BYTES_PER_ELEMENT;
            if (texDimensions === 17 || texDimensions === 29) {
                let instanceBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
                vertexPackage.instanceCount = texCoordCount;
                vertexPackage.instanceMode = texDimensions;
                vertexPackage.instanceBuffer = instanceBuffer;
                vertexPackage.instanceIndex = 1;
                let len = texDimensions * texCoordCount * 4;
                let vertexColorInstance = instanceBuffer.slice(0, len);
                vertexPackage.vertexColorInstance = vertexColorInstance;
                let byteStride;
                if (texDimensions === 17) {
                    byteStride = Float32Array.BYTES_PER_ELEMENT * 17;
                    attrLocation['uv2'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv2'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        normalize: false,
                        offsetInBytes: 0,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });

                    attrLocation['uv3'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv3'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        normalize: false,
                        offsetInBytes: 4 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });

                    attrLocation['uv4'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv4'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        normalize: false,
                        offsetInBytes: 8 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });

                    attrLocation['uv5'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv5'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        normalize: false,
                        offsetInBytes: 12 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });

                    attrLocation['uv6'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv6'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.UNSIGNED_BYTE,
                        normalize: true,
                        offsetInBytes: 16 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });
                }
                else if (texDimensions === 29) {
                    byteStride = Float32Array.BYTES_PER_ELEMENT * 29;
                    attrLocation['uv1'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv1'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        normalize: false,
                        offsetInBytes: 0,
                        strideInBytes: byteStride,
                        instanceDivisor: 1,
                        byteLength: byteLength
                    });

                    attrLocation['uv2'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv2'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        normalize: false,
                        offsetInBytes: 4 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });

                    attrLocation['uv3'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv3'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        normalize: false,
                        offsetInBytes: 8 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });

                    attrLocation['uv4'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv4'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        normalize: false,
                        offsetInBytes: 12 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });

                    attrLocation['uv5'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv5'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        normalize: false,
                        offsetInBytes: 16 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });

                    attrLocation['uv6'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv6'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        normalize: false,
                        offsetInBytes: 20 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });

                    attrLocation['uv7'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv7'],
                        componentsPerAttribute: 3,
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        normalize: false,
                        offsetInBytes: 24 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });
                    attrLocation['uv8'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv8'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.UNSIGNED_BYTE,
                        normalize: true,
                        offsetInBytes: 27 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });
                    attrLocation['uv9'] = attributes.length;
                    attributes.push({
                        index: attrLocation['uv9'],
                        componentsPerAttribute: 4,
                        componentDatatype: Cesium.ComponentDatatype.UNSIGNED_BYTE,
                        normalize: true,
                        offsetInBytes: 28 * Float32Array.BYTES_PER_ELEMENT,
                        strideInBytes: byteStride,
                        instanceDivisor: 1
                    });
                }
            }
            else {
                let len = texCoordCount * texDimensions;
                vertexPackage.instanceBounds = new Float32Array(len);
                for (let k = 0; k < len; k++) {
                    vertexPackage.instanceBounds[k] = view.getFloat32(bytesOffset, true);
                }
            }

            bytesOffset += byteLength;
        }

        return bytesOffset;
    }

    function parseCompressVertex(buffer, view, bytesOffset, vertexPackage) {
        let verticesCount = view.getUint32(bytesOffset, true);
        vertexPackage.verticesCount = verticesCount;
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        if (bytesOffset <= 0) {
            return bytesOffset;
        }

        let vertexDimension = view.getUint16(bytesOffset, true);
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        let vertexStride = view.getUint16(bytesOffset, true);
        vertexStride = vertexDimension * Int16Array.BYTES_PER_ELEMENT;
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;

        let vertCompressConstant = view.getFloat32(bytesOffset, true);
        bytesOffset += Float32Array.BYTES_PER_ELEMENT;
        let minVerticesValue = {};
        minVerticesValue.x = view.getFloat32(bytesOffset, true);
        bytesOffset += Float32Array.BYTES_PER_ELEMENT;
        minVerticesValue.y = view.getFloat32(bytesOffset, true);
        bytesOffset += Float32Array.BYTES_PER_ELEMENT;
        minVerticesValue.z = view.getFloat32(bytesOffset, true);
        bytesOffset += Float32Array.BYTES_PER_ELEMENT;
        minVerticesValue.w = view.getFloat32(bytesOffset, true);
        bytesOffset += Float32Array.BYTES_PER_ELEMENT;

        vertexPackage.vertCompressConstant = vertCompressConstant;
        vertexPackage.minVerticesValue = minVerticesValue;

        let byteLength = verticesCount * vertexDimension * Int16Array.BYTES_PER_ELEMENT;
        let vertexBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
        bytesOffset += byteLength;

        let attributes = vertexPackage.vertexAttributes;
        let attrLocation = vertexPackage.attrLocation;
        attrLocation['aPosition'] = attributes.length;
        attributes.push({
            index: attrLocation['aPosition'],
            typedArray: vertexBuffer,
            componentsPerAttribute: vertexDimension,
            componentDatatype: Cesium.ComponentDatatype.SHORT,
            offsetInBytes: 0,
            strideInBytes: vertexStride,
            normalize: false
        });

        return bytesOffset;
    }

    function parseCompressNormal(buffer, view, bytesOffset, vertexPackage) {
        let normalCount = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        if (normalCount <= 0) {
            return bytesOffset;
        }

        view.getUint16(bytesOffset, true);
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        let normalStride = view.getUint16(bytesOffset, true);
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        let byteLength = normalCount * 2 * Int16Array.BYTES_PER_ELEMENT;
        let normalBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
        bytesOffset += byteLength;
        let attributes = vertexPackage.vertexAttributes;
        let attrLocation = vertexPackage.attrLocation;
        attrLocation['aNormal'] = attributes.length;
        attributes.push({
            index: attrLocation['aNormal'],
            typedArray: normalBuffer,
            componentsPerAttribute: 2,
            componentDatatype: Cesium.ComponentDatatype.SHORT,
            offsetInBytes: 0,
            strideInBytes: normalStride,
            normalize: false
        });

        return bytesOffset;
    }

    function parseCompressTexCoord(buffer, view, bytesOffset, vertexPackage) {
        vertexPackage.texCoordCompressConstant = [];
        vertexPackage.minTexCoordValue = [];
        let count = view.getUint16(bytesOffset, true);
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
        for (let i = 0; i < count; i++) {
            let bNeedTexCoordZ = view.getUint8(bytesOffset, true);
            bytesOffset += Uint8Array.BYTES_PER_ELEMENT;
            bytesOffset += Uint8Array.BYTES_PER_ELEMENT * 3;
            let texCoordCount = view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            let dimension = view.getUint16(bytesOffset, true);
            bytesOffset += Uint16Array.BYTES_PER_ELEMENT;
            view.getUint16(bytesOffset, true);
            bytesOffset += Uint16Array.BYTES_PER_ELEMENT;

            let texCoordCompressConstant = view.getFloat32(bytesOffset, true);
            bytesOffset += Float32Array.BYTES_PER_ELEMENT;
            vertexPackage.texCoordCompressConstant.push(texCoordCompressConstant);

            let minTexCoordValue = {};
            minTexCoordValue.x = view.getFloat32(bytesOffset, true);
            bytesOffset += Float32Array.BYTES_PER_ELEMENT;
            minTexCoordValue.y = view.getFloat32(bytesOffset, true);
            bytesOffset += Float32Array.BYTES_PER_ELEMENT;
            minTexCoordValue.z = view.getFloat32(bytesOffset, true);
            bytesOffset += Float32Array.BYTES_PER_ELEMENT;
            minTexCoordValue.w = view.getFloat32(bytesOffset, true);
            bytesOffset += Float32Array.BYTES_PER_ELEMENT;
            vertexPackage.minTexCoordValue.push(minTexCoordValue);

            let byteLength = texCoordCount * dimension * Int16Array.BYTES_PER_ELEMENT;
            let texCoordBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
            bytesOffset += byteLength;
            let align = bytesOffset % 4;
            if (align !== 0) {
                bytesOffset += (4 - align);
            }

            let str = 'aTexCoord' + i;
            let attributes = vertexPackage.vertexAttributes;
            let attrLocation = vertexPackage.attrLocation;
            attrLocation[str] = attributes.length;
            attributes.push({
                index: attrLocation[str],
                typedArray: texCoordBuffer,
                componentsPerAttribute: dimension,
                componentDatatype: Cesium.ComponentDatatype.SHORT,
                offsetInBytes: 0,
                strideInBytes: dimension * Int16Array.BYTES_PER_ELEMENT,
                normalize: false
            });

            if (bNeedTexCoordZ) {
                byteLength = texCoordCount * Float32Array.BYTES_PER_ELEMENT;
                let texCoordZBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
                bytesOffset += byteLength;
                vertexPackage.texCoordZMatrix = true;
                str = 'aTexCoordZ' + i;
                attrLocation[str] = attributes.length;
                attributes.push({
                    index: attrLocation[str],
                    typedArray: texCoordZBuffer,
                    componentsPerAttribute: 1,
                    componentDatatype: Cesium.ComponentDatatype.FLOAT,
                    offsetInBytes: 0,
                    strideInBytes: Float32Array.BYTES_PER_ELEMENT,
                    normalize: false
                });
            }
        }
        return bytesOffset;
    }

    function parseStandardSkeleton(buffer, view, bytesOffset, vertexPackage) {
        bytesOffset = parseVertex(buffer, view, bytesOffset, vertexPackage);

        bytesOffset = parseNormal(buffer, view, bytesOffset, vertexPackage);

        bytesOffset = parseVertexColor(buffer, view, bytesOffset, vertexPackage);

        bytesOffset = parseSecondColor(buffer, view, bytesOffset, vertexPackage);

        bytesOffset = parseTexCoord(buffer, view, bytesOffset, vertexPackage);

        bytesOffset = parseInstanceInfo(buffer, view, bytesOffset, vertexPackage);

        return bytesOffset;
    }

    function parseCompressSkeleton(buffer, view, bytesOffset, vertexPackage) {
        let compressOptions = view.getUint32(bytesOffset, true);
        vertexPackage.compressOptions = compressOptions;
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        if ((compressOptions & VertexCompressOption.SVC_Vertex) === VertexCompressOption.SVC_Vertex) {
            bytesOffset = parseCompressVertex(buffer, view, bytesOffset, vertexPackage);
        }
        else {
            bytesOffset = parseVertex(buffer, view, bytesOffset, vertexPackage);
        }

        if ((compressOptions & VertexCompressOption.SVC_Normal) === VertexCompressOption.SVC_Normal) {
            bytesOffset = parseCompressNormal(buffer, view, bytesOffset, vertexPackage);
        }
        else {
            bytesOffset = parseNormal(buffer, view, bytesOffset, vertexPackage);
        }

        bytesOffset = parseVertexColor(buffer, view, bytesOffset, vertexPackage);

        bytesOffset = parseSecondColor(buffer, view, bytesOffset, vertexPackage);

        if ((compressOptions & VertexCompressOption.SVC_TexutreCoord) === VertexCompressOption.SVC_TexutreCoord) {
            bytesOffset = parseCompressTexCoord(buffer, view, bytesOffset, vertexPackage);
        }
        else {
            bytesOffset = parseTexCoord(buffer, view, bytesOffset, vertexPackage);
        }

        if ((compressOptions & VertexCompressOption.SVC_TexutreCoordIsW) === VertexCompressOption.SVC_TexutreCoordIsW) {
            vertexPackage.textureCoordIsW = true;
        }

        bytesOffset = parseInstanceInfo(buffer, view, bytesOffset, vertexPackage);

        return bytesOffset;
    }

    function parseIndexPackage(buffer, view, bytesOffset, arrIndexPackage) {
        let count = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        for (let i = 0; i < count; i++) {
            let indexPackage = {};
            let indexCount = view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            let indexType = view.getUint8(bytesOffset, true);
            bytesOffset += Uint8Array.BYTES_PER_ELEMENT;
            view.getUint8(bytesOffset, true);
            bytesOffset += Uint8Array.BYTES_PER_ELEMENT;
            let primitiveType = view.getUint8(bytesOffset, true);
            bytesOffset += Uint8Array.BYTES_PER_ELEMENT;
            bytesOffset += Uint8Array.BYTES_PER_ELEMENT;

            if (indexCount > 0) {
                let indexBuffer = null;
                let byteLength;
                if (indexType === 1 || indexType === 3) {
                    byteLength = indexCount * Uint32Array.BYTES_PER_ELEMENT;
                    indexBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
                }
                else {
                    byteLength = indexCount * Uint16Array.BYTES_PER_ELEMENT;
                    indexBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
                    if (indexCount % 2 !== 0) {
                        byteLength += 2;
                    }
                }

                indexPackage.indicesTypedArray = indexBuffer;
                bytesOffset += byteLength;
            }

            indexPackage.indicesCount = indexCount;
            indexPackage.indexType = indexType;
            indexPackage.primitiveType = primitiveType;
            let passNameCount = view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            for (let j = 0; j < passNameCount; j++) {
                let res = parseString(buffer, view, bytesOffset);
                let passName = res.string;
                bytesOffset = res.bytesOffset;
                indexPackage.materialCode = passName;
            }

            let align = bytesOffset % 4;
            if (align !== 0) {
                let nReserved = 4 - bytesOffset % 4;
                bytesOffset += nReserved;
            }

            arrIndexPackage.push(indexPackage);
        }

        return bytesOffset;
    }

    function parseSkeleton(buffer, view, bytesOffset, geoPackage) {
        view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        let count = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        for (let i = 0; i < count; i++) {
            let res = parseString(buffer, view, bytesOffset);
            let geometryName = res.string;
            bytesOffset = res.bytesOffset;
            let align = bytesOffset % 4;
            if (align !== 0) {
                bytesOffset += (4 - align);
            }

            let tag = view.getUint32(bytesOffset, true);
            bytesOffset += Int32Array.BYTES_PER_ELEMENT;

            let vertexPackage = {
                vertexAttributes: [],
                attrLocation: {},
                instanceCount: 0,
                instanceMode: 0,
                instanceIndex: -1
            };

            if (tag === S3MBVertexTag.SV_Standard) {
                bytesOffset = parseStandardSkeleton(buffer, view, bytesOffset, vertexPackage);
            }
            else if (tag === S3MBVertexTag.SV_Compressed) {
                bytesOffset = parseCompressSkeleton(buffer, view, bytesOffset, vertexPackage);
            }

            let arrIndexPackage = [];
            bytesOffset = parseIndexPackage(buffer, view, bytesOffset, arrIndexPackage);

            geoPackage[geometryName] = {
                vertexPackage: vertexPackage,
                arrIndexPackage: arrIndexPackage
            };
        }

        let secColorSize = view.getUint32(bytesOffset, true);
        bytesOffset += secColorSize;
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;

        return bytesOffset;
    }

    function parseTexturePackage(buffer, view, bytesOffset, texturePackage) {
        view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        let count = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        for (let i = 0; i < count; i++) {
            let res = parseString(buffer, view, bytesOffset);
            let textureCode = res.string;
            bytesOffset = res.bytesOffset;
            let align = bytesOffset % 4;
            if (align !== 0) {
                bytesOffset += (4 - align);
            }

            view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            let width = view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            let height = view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            let compressType = view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            let size = view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            let pixelFormat = view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            let textureData = new Uint8Array(buffer, bytesOffset, size);
            bytesOffset += size;

            texturePackage[textureCode] = {
                id: textureCode,
                width: width,
                height: height,
                compressType: compressType,
                nFormat: pixelFormat,
                internalFormat: Cesium.PixelFormat.RGBA_DXT5,
                imageBuffer: textureData
            };
        }

        return bytesOffset;
    }

    function parseMaterial$1(buffer, view, bytesOffset, result) {
        let byteLength = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        let materialBuffer = new Uint8Array(buffer, bytesOffset, byteLength);
        let strMaterials = Cesium.getStringFromTypedArray(materialBuffer);
        bytesOffset += byteLength;
        result.materials = JSON.parse(strMaterials);

        return bytesOffset;
    }

    function parsePickInfo(buffer, view, bytesOffset, nOptions, geoPackage) {
        if ((nOptions & 1) === 1) {
            view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            let count = view.getUint32(bytesOffset, true);
            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
            for (let i = 0; i < count; i++) {
                let res = parseString(buffer, view, bytesOffset);
                let geometryName = res.string;
                bytesOffset = res.bytesOffset;
                let selectInfoCount = view.getUint32(bytesOffset, true);
                bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
                let pickInfo = {};
                geoPackage[geometryName].pickInfo = pickInfo;
                let bInstanced = geoPackage[geometryName].vertexPackage.instanceIndex;
                for (let j = 0; j < selectInfoCount; j++) {
                    let nDictID = view.getUint32(bytesOffset, true);
                    bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
                    let nSize = view.getUint32(bytesOffset, true);
                    bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
                    let infos = [];
                    for (let k = 0; k < nSize; k++) {
                        let vertexColorOffset = view.getUint32(bytesOffset, true);
                        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
                        let vertexCount = 1;
                        if (bInstanced === -1) {
                            vertexCount = view.getUint32(bytesOffset, true);
                            bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
                        }

                        infos.push({
                            vertexColorOffset: vertexColorOffset,
                            vertexColorCount: vertexCount
                        });
                    }

                    pickInfo[nDictID] = infos;
                }
            }
        }

        return bytesOffset;
    }

    S3ModelParser.parseBuffer = function (buffer) {
        let bytesOffset = 0;
        let result = {
            version: undefined,
            groupNode: undefined,
            geoPackage: {},
            matrials: undefined,
            texturePackage: {}
        };

        let view = new DataView(buffer);
        result.version = view.getFloat32(bytesOffset, true);
        bytesOffset += Float32Array.BYTES_PER_ELEMENT;
        view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;
        let unzipBuffer = unZip(buffer, bytesOffset);
        view = new DataView(unzipBuffer);
        bytesOffset = 0;
        let nOptions = view.getUint32(bytesOffset, true);
        bytesOffset += Uint32Array.BYTES_PER_ELEMENT;

        bytesOffset = parseGroupNode(unzipBuffer, view, bytesOffset, result);

        bytesOffset = parseSkeleton(unzipBuffer, view, bytesOffset, result.geoPackage);

        bytesOffset = parseTexturePackage(unzipBuffer, view, bytesOffset, result.texturePackage);

        bytesOffset = parseMaterial$1(unzipBuffer, view, bytesOffset, result);

        parsePickInfo(unzipBuffer, view, bytesOffset, nOptions, result.geoPackage);

        return result;
    };

    function DDSTexture(context, id, source) {
        let gl = context._gl;
        this.id = id;
        this._size = source.imageBuffer.length;
        this._context = context;
        this._width = source.width;
        this._height = source.height;
        this._texture = null;
        this._internalFormat = source.internalFormat;
        this._wrapS = Cesium.defaultValue(source.wrapS, Cesium.TextureWrap.CLAMP_TO_EDGE);
        this._wrapT = Cesium.defaultValue(source.wrapT, Cesium.TextureWrap.CLAMP_TO_EDGE);
        this.id = id;
        this._target = gl.TEXTURE_2D;
        this._texture = gl.createTexture();
        gl.bindTexture(gl.TEXTURE_2D, this._texture);

        let offset = 0;
        let i = 0;
        let bMipMap = validateMipmap(source.imageBuffer, this._internalFormat, this._width, this._height);
        let texWidth = this._width;
        let texHeight = this._height;
        do {
            let levelSize = Cesium.PixelFormat.compressedTextureSizeInBytes(this._internalFormat, texWidth, texHeight);
            let subArrayBuffer = new Uint8Array(source.imageBuffer.buffer, source.imageBuffer.byteOffset + offset, levelSize);
            gl.compressedTexImage2D(gl.TEXTURE_2D, i++, this._internalFormat, texWidth, texHeight, 0, subArrayBuffer);
            texWidth = Math.max(texWidth >> 1, 1);
            texHeight = Math.max(texHeight >> 1, 1);
            offset += levelSize;
        }
        while (offset < source.imageBuffer.length && bMipMap);

        if (i > 1) {
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
        }
        else {
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
        }

        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, this._wrapS);
        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, this._wrapT);
        gl.bindTexture(gl.TEXTURE_2D, null);
    }

    function validateMipmap(buffer, pixelFormat, width, height) {
        let len = buffer.length;
        let w = width, h = height;
        let totalBytes = 0;
        while (1) {
            let sizeInBytes = Cesium.PixelFormat.compressedTextureSizeInBytes(pixelFormat, w, h);
            totalBytes += sizeInBytes;
            w = w >> 1;
            h = h >> 1;
            if (w == 0 && h == 0) {
                break;
            }

            w = Math.max(w, 1);
            h = Math.max(h, 1);
        }

        return totalBytes === len;
    }

    DDSTexture.prototype.enable = function () {
        let gl = this._context._gl;
        gl.activeTexture(this._gl.TEXTURE0);
        gl.bindTexture(this._target, this._texture);
    };

    DDSTexture.prototype.disable = function () {
        let gl = this._context._gl;
        gl.bindTexture(this._target, null);
    };

    DDSTexture.prototype.isDestroyed = function () {
        return false;
    };

    DDSTexture.prototype.destroy = function () {
        let gl = this._context._gl;
        gl.deleteTexture(this._texture);
        this._texture = null;
        this.id = 0;
        Cesium.destroyObject(this);
    };

    function MaterialPass() {
        this.ambientColor = new Cesium.Color();
        this.diffuseColor = new Cesium.Color();
        this.specularColor = new Cesium.Color(0.0, 0.0, 0.0, 0.0);
        this.shininess = 50.0;
        this.bTransparentSorting = false;
        this.textures = [];
    }

    MaterialPass.prototype.isDestroyed = function () {
        return false;
    };

    MaterialPass.prototype.destroy = function () {
        return destroyObject(this);
    };

    var S3MTilesVS = `
        attribute vec4 aPosition;
        attribute vec4 aTexCoord0;
    #ifdef TexCoord2
        attribute vec4 aTexCoord1;
    #endif
        varying vec4 vTexCoord;
        attribute vec4 aColor;
        varying vec4 vColor;
        void main()
        {
            vTexCoord.xy = aTexCoord0.xy;
        #ifdef TexCoord2
            vTexCoord.zw = aTexCoord1.xy;
        #endif
            vColor = aColor;
            gl_Position = czm_modelViewProjection * vec4(aPosition.xyz, 1.0);
        }
    `;

    var S3MTilesFS = `
        uniform sampler2D uTexture;
    #ifdef TexCoord2
        uniform sampler2D uTexture2;
    #endif
        uniform vec4 uDiffuseColor;
        uniform vec4 uAmbientColor;
        varying vec4 vColor;
        varying vec4 vTexCoord;
        void main()
        {
            vec4 color = vColor * texture2D(uTexture, vTexCoord.xy);
        #ifdef TexCoord2
            color *= texture2D(uTexture2, vTexCoord.zw);
        #endif
            gl_FragColor = czm_gammaCorrect(color);
        }
    `;

    function S3MCreateVertexJob() {
        this.context = undefined;
        this.model = undefined;
        this.index = undefined;
    }

    S3MCreateVertexJob.prototype.set = function (context, model, index) {
        this.context = context;
        this.model = model;
        this.index = index;
    };

    S3MCreateVertexJob.prototype.execute = function () {
        let context = this.context;
        let index = this.index;
        let vertexPackage = this.model.vertexPackage;
        let attr = vertexPackage.vertexAttributes[index];
        if (!Cesium.defined(attr)) {
            throw new Cesium.DeveloperError('attribute is null');
        }

        if (vertexPackage.instanceIndex !== -1 && !Cesium.defined(this.model._instanceBuffer)) {
            if (!Cesium.defined(vertexPackage.instanceBuffer)) {
                throw new Cesium.DeveloperError('instance buffer is null');
            }

            this.model.instanceBuffer = Cesium.Buffer.createVertexBuffer({
                context: context,
                typedArray: vertexPackage.instanceBuffer,
                usage: Cesium.BufferUsage.STATIC_DRAW
            });
        }

        if (attr.instanceDivisor === 1) {
            attr.vertexBuffer = this.model.instanceBuffer;
            return;
        }

        if (!Cesium.defined(attr.vertexBuffer)) {
            attr.vertexBuffer = Cesium.Buffer.createVertexBuffer({
                context: context,
                typedArray: attr.typedArray,
                usage: Cesium.BufferUsage.STATIC_DRAW
            });

            attr.typedArray = null;
            delete attr.typedArray;
        }
    };

    function S3MCreateIndexBufferJob() {
        this.model = undefined;
        this.context = undefined;
        this.index = 0;
    }

    S3MCreateIndexBufferJob.prototype.set = function (context, model, index) {
        this.model = model;
        this.context = context;
        this.index = index;
    };

    S3MCreateIndexBufferJob.prototype.execute = function () {
        let context = this.context;
        let indexPackage = this.model.arrIndexPackage[this.index];
        let verticesCount = this.model.vertexPackage.verticesCount;
        if (!Cesium.defined(indexPackage)) {
            throw new Cesium.DeveloperError('index package is null');
        }

        if (Cesium.defined(indexPackage.indexBuffer)) {
            return;
        }

        if (!Cesium.defined(indexPackage.indicesTypedArray)) {
            throw new Cesium.DeveloperError('index buffer is null');
        }

        let indexDataType = Cesium.IndexDatatype.UNSIGNED_SHORT;
        if ((indexPackage.indexType === 1 || verticesCount >= Cesium.Math.SIXTY_FOUR_KILOBYTES) && context.elementIndexUint) {
            indexDataType = Cesium.IndexDatatype.UNSIGNED_INT;
        }

        indexPackage.indexBuffer = Cesium.Buffer.createIndexBuffer({
            context: context,
            typedArray: indexPackage.indicesTypedArray,
            usage: Cesium.BufferUsage.STATIC_DRAW,
            indexDatatype: indexDataType
        });

        indexPackage.indicesTypedArray = null;
        delete indexPackage.indicesTypedArray;
    };

    function RenderEntity(options) {
        this.layer = options.layer;
        this.vertexPackage = options.vertexPackage;
        this.arrIndexPackage = options.arrIndexPackage;
        this.vertexBufferToCreate = new Cesium.Queue();
        this.indexBufferToCreate = new Cesium.Queue();
        let i, j;
        for (i = 0, j = this.vertexPackage.vertexAttributes.length; i < j; i++) {
            this.vertexBufferToCreate.enqueue(i);
        }

        for (i = 0, j = this.arrIndexPackage.length; i < j; i++) {
            this.indexBufferToCreate.enqueue(i);
        }

        this.boundingVolume = options.boundingVolume;
        this.material = options.material;
        this.modelMatrix = options.modelMatrix;
        this.shaderProgram = undefined;
        this.vertexArray = undefined;
        this.colorCommand = undefined;
        this.ready = false;
    }


    let _vertexBufferJob = new S3MCreateVertexJob();
    let _indexBufferJob = new S3MCreateIndexBufferJob();

    function createVertexBuffers(renderEntity, frameState) {
        let context = renderEntity.layer.context;
        let queue = renderEntity.vertexBufferToCreate;
        while (queue.length) {
            let index = queue.peek();
            _vertexBufferJob.set(context, renderEntity, index);
            if (!frameState.jobScheduler.execute(_vertexBufferJob, Cesium.JobType.BUFFER)) {
                break;
            }

            queue.dequeue();
        }
    }

    function createIndexBuffers(renderEntity, frameState) {
        let context = renderEntity.layer.context;
        let queue = renderEntity.indexBufferToCreate;
        while (queue.length) {
            let index = queue.peek();
            _indexBufferJob.set(context, renderEntity, index);
            if (!frameState.jobScheduler.execute(_indexBufferJob, Cesium.JobType.BUFFER)) {
                break;
            }

            queue.dequeue();
        }
    }

    RenderEntity.prototype.createBuffers = function (frameState) {
        createVertexBuffers(this, frameState);
        createIndexBuffers(this, frameState);
    };

    RenderEntity.prototype.createCommand = Cesium.DeveloperError.throwInstantiationError;

    RenderEntity.prototype.update = Cesium.DeveloperError.throwInstantiationError;

    RenderEntity.prototype.isDestroyed = Cesium.DeveloperError.throwInstantiationError;

    RenderEntity.prototype.destroy = Cesium.DeveloperError.throwInstantiationError;

    function S3MCacheFileRenderEntity(options) {
        RenderEntity.call(this, options);
    }

    S3MCacheFileRenderEntity.prototype = Object.create(RenderEntity.prototype);

    S3MCacheFileRenderEntity.prototype.constructor = RenderEntity;

    function createShaderProgram(context, attributeLocations, material) {
        let vp = new Cesium.ShaderSource({
            sources: [S3MTilesVS]
        });

        let fp = new Cesium.ShaderSource({
            sources: [S3MTilesFS]
        });

        if (Cesium.defined(attributeLocations['aNormal'])) {
            vp.defines.push('VertexNormal');
            fp.defines.push('VertexNormal');
        }

        if (material.textures.length > 0) {
            vp.defines.push('TexCoord');
            fp.defines.push('TexCoord');
        }

        if (material.textures.length == 2) {
            vp.defines.push('TexCoord2');
            fp.defines.push('TexCoord2');
        }

        return Cesium.ShaderProgram.fromCache({
            context: context,
            vertexShaderSource: vp,
            fragmentShaderSource: fp,
            attributeLocations: attributeLocations
        });

    }

    function getOpaqueRenderState() {
        return Cesium.RenderState.fromCache({
            cull: {
                enabled: true
            },
            depthTest: {
                enabled: true,
                func: Cesium.DepthFunction.LESS_OR_EQUAL
            }
        });
    }

    function getTransparentRenderState() {
        return Cesium.RenderState.fromCache({
            cull: {
                enabled: true
            },
            depthTest: {
                enabled: true,
                func: Cesium.DepthFunction.LESS_OR_EQUAL
            },
            blending: Cesium.BlendingState.ALPHA_BLEND
        });
    }

    function getUniformMap(material) {
        return {
            uTexture: function () {
                return material.textures[0];
            },
            uTextureWidth: function () {
                return material.textures[0]._width;
            },
            uTexture2: function () {
                return material.textures[1];
            },
            uTexture2Width: function () {
                return material.textures[1]._width;
            },
            uDiffuseColor: function () {
                return material.diffuseColor;
            },
            uAmbientColor: function () {
                return material.ambientColor;
            }
        };
    }

    S3MCacheFileRenderEntity.prototype.createCommand = function () {
        if (Cesium.defined(this.colorCommand)) {
            return;
        }

        let layer = this.layer;
        let context = layer.context;
        let vertexPackage = this.vertexPackage;
        let arrIndexPackage = this.arrIndexPackage;
        let attributes = vertexPackage.vertexAttributes;
        let attributeLocations = vertexPackage.attrLocation;
        if (arrIndexPackage.length < 1) {
            return;
        }

        let indexPackage = arrIndexPackage[0];
        let material = this.material;

        this.shaderProgram = createShaderProgram(context, attributeLocations, material);

        this.vertexArray = new Cesium.VertexArray({
            context: context,
            attributes: attributes,
            indexBuffer: indexPackage.indexBuffer
        });

        this.colorCommand = new Cesium.DrawCommand({
            primitiveType: indexPackage.primitiveType,
            modelMatrix: this.modelMatrix,
            boundingVolume: Cesium.BoundingSphere.clone(this.boundingVolume),
            pickId: 'vSecondColor',
            vertexArray: this.vertexArray,
            shaderProgram: this.shaderProgram,
            pass: material.bTransparentSorting ? Cesium.Pass.TRANSLUCENT : Cesium.Pass.CESIUM_3D_TILE,
            renderState: material.bTransparentSorting ? getTransparentRenderState() : getOpaqueRenderState()
        });

        this.colorCommand.uniformMap = getUniformMap(material);
        this.vertexPackage = null;
        this.arrIndexPackage = null;
        this.ready = true;
    };

    S3MCacheFileRenderEntity.prototype.update = function (frameState) {
        if (!this.ready) {
            this.createBuffers(frameState);
            this.createCommand(frameState);
            return;
        }

        frameState.commandList.push(this.colorCommand);
    };

    S3MCacheFileRenderEntity.prototype.isDestroyed = function () {
        return false;
    };

    S3MCacheFileRenderEntity.prototype.destroy = function () {
        this.shaderProgram = this.shaderProgram && !this.shaderProgram.isDestroyed() && this.shaderProgram.destroy();
        this.vertexArray = this.vertexArray && !this.vertexArray.isDestroyed() && this.vertexArray.destroy();
        this.colorCommand = undefined;
        this.vertexPackage = null;
        this.arrIndexPackage = null;
        return Cesium.destroyObject(this);
    };

    let S3MContentFactory = {
        'OSGBFile': function (options) {
            return new S3MCacheFileRenderEntity(options);
        },
        'OSGBCacheFile': function (options) {
            return new S3MCacheFileRenderEntity(options);
        }
    };

    function S3MContentParser() {

    }

    function parseMaterial(context, content) {
        let materialTable = {};
        let materials = content.materials.material;
        for (let i = 0, j = materials.length; i < j; i++) {
            let material = materials[i].material;
            let materialCode = material.id;
            let materialPass = new MaterialPass();
            materialTable[materialCode] = materialPass;
            let ambient = material.ambient;
            materialPass.ambientColor = new Cesium.Color(ambient.r, ambient.g, ambient.b, ambient.a);
            let diffuse = material.diffuse;
            materialPass.diffuseColor = new Cesium.Color(diffuse.r, diffuse.g, diffuse.b, diffuse.a);
            let specular = material.specular;
            materialPass.specularColor = new Cesium.Color(specular.r, specular.g, specular.b, specular.a);
            materialPass.shininess = material.shininess;
            materialPass.bTransparentSorting = material.transparentsorting;
            let textureStates = material.textureunitstates;
            let len = textureStates.length;
            for (let k = 0; k < len; k++) {
                let textureState = textureStates[k].textureunitstate;
                let textureCode = textureState.id;
                let wrapS = textureState.addressmode.u === 0 ? Cesium.TextureWrap.REPEAT : Cesium.TextureWrap.CLAMP_TO_EDGE;
                let wrapT = textureState.addressmode.v === 0 ? Cesium.TextureWrap.REPEAT : Cesium.TextureWrap.CLAMP_TO_EDGE;
                materialPass.texMatrix = Cesium.Matrix4.unpack(textureState.texmodmatrix);
                let textureInfo = content.texturePackage[textureCode];
                if (Cesium.defined(textureInfo) && textureInfo.imageBuffer.byteLength > 0) {
                    textureInfo.wrapS = wrapS;
                    textureInfo.wrapT = wrapT;
                    let texture = new DDSTexture(context, textureCode, textureInfo);
                    materialPass.textures.push(texture);
                }
            }
        }

        return materialTable;
    }

    function calcBoundingVolume(vertexPackage, transform) {
        let boundingSphere = new Cesium.BoundingSphere();
        let v1 = new Cesium.Cartesian3();
        let positionAttr = vertexPackage.vertexAttributes[0];
        let dim = positionAttr.componentsPerAttribute;
        let isCompress = Cesium.defined(vertexPackage.nCompressOptions) && (vertexPackage.nCompressOptions & VertexCompressOption.SVC_Vertex) === VertexCompressOption.SVC_Vertex;
        let normConstant = 1.0;
        let minVertex;
        let vertexTypedArray;
        if (isCompress) {
            normConstant = vertexPackage.vertCompressConstant;
            minVertex = new Cesium.Cartesian3(vertexPackage.minVerticesValue.x, vertexPackage.minVerticesValue.y, vertexPackage.minVerticesValue.z);
            vertexTypedArray = new Uint16Array(positionAttr.typedArray.buffer, positionAttr.typedArray.byteOffset, positionAttr.typedArray.byteLength / 2);
        }
        else {
            vertexTypedArray = new Float32Array(positionAttr.typedArray.buffer, positionAttr.typedArray.byteOffset, positionAttr.typedArray.byteLength / 4);
        }

        let vertexArray = [];
        for (let t = 0; t < vertexPackage.verticesCount; t++) {
            Cesium.Cartesian3.fromArray(vertexTypedArray, dim * t, v1);
            if (isCompress) {
                v1 = Cesium.Cartesian3.multiplyByScalar(v1, normConstant, v1);
                v1 = Cesium.Cartesian3.add(v1, minVertex, v1);
            }
            vertexArray.push(Cesium.Cartesian3.clone(v1));
        }

        Cesium.BoundingSphere.fromPoints(vertexArray, boundingSphere);
        Cesium.BoundingSphere.transform(boundingSphere, transform, boundingSphere);
        vertexArray.length = 0;
        return boundingSphere;
    }

    function parseGeodes(layer, content, materialTable, pagelodNode, pagelod) {
        let geoMap = {};
        let geodeList = pagelodNode.geodes;
        for (let i = 0, j = geodeList.length; i < j; i++) {
            let geodeNode = geodeList[i];
            let geoMatrix = geodeNode.matrix;
            let modelMatrix = Cesium.Matrix4.multiply(layer.modelMatrix, geoMatrix, new Cesium.Matrix4());
            let boundingSphere;
            if (Cesium.defined(pagelod.boundingVolume)) {
                boundingSphere = new Cesium.BoundingSphere(pagelod.boundingVolume.sphere.center, pagelod.boundingVolume.sphere.radius);
                Cesium.BoundingSphere.transform(boundingSphere, layer.modelMatrix, boundingSphere);
            }

            let skeletonNames = geodeNode.skeletonNames;
            for (let m = 0, n = skeletonNames.length; m < n; m++) {
                let geoName = skeletonNames[m];
                let geoPackage = content.geoPackage[geoName];
                let vertexPackage = geoPackage.vertexPackage;
                let arrIndexPackage = geoPackage.arrIndexPackage;
                let pickInfo = geoPackage.pickInfo;
                let material;
                if (arrIndexPackage.length > 0) {
                    material = materialTable[arrIndexPackage[0].materialCode];
                }

                let geodeBoundingVolume = Cesium.defined(boundingSphere) ? boundingSphere : calcBoundingVolume(vertexPackage, modelMatrix);

                geoMap[geoName] = S3MContentFactory[layer.fileType]({
                    layer: layer,
                    vertexPackage: vertexPackage,
                    arrIndexPackage: arrIndexPackage,
                    pickInfo: pickInfo,
                    modelMatrix: modelMatrix,
                    boundingVolume: geodeBoundingVolume,
                    material: material
                });
            }
        }

        if (!Cesium.defined(pagelod.boundingVolume)) {
            let arr = [];
            for (let key in geoMap) {
                if (geoMap.hasOwnProperty(key)) {
                    arr.push(geoMap[key].boundingVolume);
                }
            }

            pagelod.boundingVolume = Cesium.BoundingSphere.fromBoundingSpheres(arr);
        }

        pagelod.geoMap = geoMap;
    }

    function parsePagelods(layer, content, materialTable) {
        let groupNode = content.groupNode;
        let pagelods = [];
        for (let i = 0, j = groupNode.pageLods.length; i < j; i++) {
            let pagelod = {};
            let pagelodNode = groupNode.pageLods[i];
            pagelod.rangeMode = pagelodNode.rangeMode;
            pagelod.rangeDataList = pagelodNode.childTile;
            pagelod.rangeList = pagelodNode.rangeList;
            let center = pagelodNode.boundingSphere.center;
            let radius = pagelodNode.boundingSphere.radius;
            if (pagelod.rangeDataList !== '') {
                pagelod.boundingVolume = {
                    sphere: {
                        center: new Cesium.Cartesian3(center.x, center.y, center.z),
                        radius: radius
                    }
                };
            }
            else {
                pagelod.isLeafTile = true;
            }

            parseGeodes(layer, content, materialTable, pagelodNode, pagelod);
            pagelods.push(pagelod);
        }

        return pagelods;
    }

    S3MContentParser.parse = function (layer, content) {
        if (!Cesium.defined(content)) {
            return;
        }

        let materialTable = parseMaterial(layer.context, content);
        let pagelods = parsePagelods(layer, content, materialTable);

        return pagelods;
    };

    function S3MTile(layer, parent, boundingVolume, fileName, rangeData, renderEntityMap, isLeafTile) {
        this.layer = layer;
        this.parent = parent;
        this.fileName = fileName;
        this.isLeafTile = Cesium.defaultValue(isLeafTile, false);
        this.boundingVolume = this.createBoundingVolume(boundingVolume, layer.modelMatrix);
        let baseResource = Cesium.Resource.createIfNeeded(layer._baseResource);
        if (Cesium.defined(parent)) {
            this.baseUri = parent.baseUri;
        }
        else {
            let resource = new Cesium.Resource(fileName);
            this.baseUri = resource.getBaseUri();
        }

        this.contentResource = baseResource.getDerivedResource({
            url: fileName
        });

        this.serverKey = Cesium.RequestScheduler.getServerKey(this.contentResource.getUrlComponent());
        this.request = undefined;
        this.cacheNode = undefined;
        this.distanceToCamera = 0;
        this.pixel = 0;
        this.visibilityPlaneMask = 0;
        this.visible = false;
        this.children = [];
        this.lodRangeData = rangeData;
        this.renderEntityMap = renderEntityMap;
        this.contentState = ContentState$1.UNLOADED;
        this.readerable = false;
        this.touchedFrame = 0;
        this.requestedFrame = 0;
        this.selectedFrame = 0;
        this.priority = 0;
    }

    Object.defineProperties(S3MTile.prototype, {
        renderable: {
            get: function () {
                return Cesium.defined(this.renderEntityMap);
            }
        }
    });

    let scratchScale = new Cesium.Cartesian3();

    function createSphere(sphere, transform) {
        let center = Cesium.Cartesian3.clone(sphere.center);
        let radius = sphere.radius;
        center = Cesium.Matrix4.multiplyByPoint(transform, center, center);
        let scale = Cesium.Matrix4.getScale(transform, scratchScale);
        let maxScale = Cesium.Cartesian3.maximumComponent(scale);
        radius *= maxScale;
        return new Cesium.TileBoundingSphere(center, radius);
    }

    function createBoundingBox(box, transform) {
        let min = new Cesium.Cartesian3(box.min.x, box.min.y, box.min.z);
        Cesium.Matrix4.multiplyByPoint(transform, min, min);
        let max = new Cesium.Cartesian3(box.max.x, box.max.y, box.max.z);
        Cesium.Matrix4.multiplyByPoint(transform, max, max);
        let sphere = Cesium.BoundingSphere.fromCornerPoints(min, max, new Cesium.BoundingSphere());
        let center = sphere.center;
        let radius = sphere.radius;
        let scale = Cesium.Matrix4.getScale(transform, scratchScale);
        let maxScale = Cesium.Cartesian3.maximumComponent(scale);
        radius *= maxScale;
        return new Cesium.TileBoundingSphere(center, radius);
    }

    S3MTile.prototype.createBoundingVolume = function (parameter, transform) {
        if (this.isLeafTile) {
            return new Cesium.TileBoundingSphere(parameter.center, parameter.radius);
        }

        if (Cesium.defined(parameter.sphere)) {
            return createSphere(parameter.sphere, transform);
        }
        else if (Cesium.defined(parameter.box)) {
            return createBoundingBox(parameter.box, transform);
        }

        return undefined;
    };

    S3MTile.prototype.canTraverse = function () {
        if (this.children.length === 0 || this.isLeafTile) {
            return false;
        }

        if (!Cesium.defined(this.lodRangeData)) {
            return true;
        }

        return this.pixel > this.lodRangeData;
    };

    function getBoundingVolume(tile, frameState) {
        return tile.boundingVolume;
    }

    S3MTile.prototype.getPixel = function (frameState) {
        let boundingVolume = this.boundingVolume;
        let radius = boundingVolume.radius;
        let center = boundingVolume.center;
        let distance = Cesium.Cartesian3.distance(frameState.camera.positionWC, center);
        let height = frameState.context.drawingBufferHeight;
        let theta = frameState.camera.frustum._fovy * 0.5;
        let screenYPix = height * 0.5;
        let lamat = screenYPix / Math.tan(theta);
        return lamat * radius / distance;
    };

    S3MTile.prototype.distanceToTile = function (frameState) {
        let boundingVolume = getBoundingVolume(this);
        return boundingVolume.distanceToCamera(frameState);
    };

    S3MTile.prototype.visibility = function (frameState, parentVisibilityPlaneMask) {
        let boundingVolume = getBoundingVolume(this);
        return frameState.cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);
    };

    S3MTile.prototype.updateVisibility = function (frameState) {
        let parent = this.parent;
        let parentVisibilityPlaneMask = Cesium.defined(parent) ? parent.visibilityPlaneMask : Cesium.CullingVolume.MASK_INDETERMINATE;
        this.distanceToCamera = this.distanceToTile(frameState);
        this.pixel = this.getPixel(frameState);
        this.visibilityPlaneMask = this.visibility(frameState, parentVisibilityPlaneMask);
        this.visible = this.visibilityPlaneMask !== Cesium.CullingVolume.MASK_OUTSIDE;
    };

    function createPriorityFunction(tile) {
        return function () {
            return tile.priority;
        };
    }

    function getContentFailedFunction(tile) {
        return function (error) {
            tile.contentState = ContentState$1.FAILED;
            tile.contentReadyPromise.reject(error);
        };
    }

    function createChildren(parent, datas) {
        let layer = parent.layer;
        let length = datas.length;
        for (let i = 0; i < length; i++) {
            let data = datas[i];
            let boundingVolume = data.boundingVolume;
            let fileName = data.rangeDataList;
            fileName = parent.baseUri + fileName;
            let rangeData = data.rangeList;
            let renderEntitieMap = data.geoMap;
            let tile = new S3MTile(layer, parent, boundingVolume, fileName, rangeData, renderEntitieMap, data.isLeafTile);
            parent.children.push(tile);
            parent.layer._cache.add(tile);
        }
    }

    S3MTile.prototype.requestContent = function () {
        let that = this;
        this.layer;
        let resource = this.contentResource.clone();

        let request = new Cesium.Request({
            throttle: true,
            throttleByServer: true,
            type: Cesium.RequestType.TILES3D,
            priorityFunction: createPriorityFunction(this),
            serverKey: this.serverKey
        });

        this.request = request;
        resource.request = request;

        let promise = resource.fetchArrayBuffer();

        if (!Cesium.defined(promise)) {
            return false;
        }

        this.contentState = ContentState$1.LOADING;
        this.contentReadyPromise = Cesium.when.defer();
        let contentFailedFunction = getContentFailedFunction(this);

        promise.then(function (arrayBuffer) {
            if (that.isDestroyed()) {
                contentFailedFunction();
                return;
            }

            let content = S3ModelParser.parseBuffer(arrayBuffer);
            let data = S3MContentParser.parse(that.layer, content);
            createChildren(that, data);
            that.selectedFrame = 0;
            that.contentState = ContentState$1.READY;
            //that.renderable = true;
            that.contentReadyPromise.resolve(content);
        }).otherwise(function (error) {
            if (request.state === Cesium.RequestState.CANCELLED) {
                that.contentState = ContentState$1.UNLOADED;
                return;
            }

            contentFailedFunction(error);
        });

        return true;
    };

    S3MTile.prototype.update = function (frameState) {
        let renderEntityMap = this.renderEntityMap;

        for (let key in renderEntityMap) {
            if (renderEntityMap.hasOwnProperty(key)) {
                renderEntityMap[key].update(frameState);
            }
        }
    };

    S3MTile.prototype.free = function () {
        for (let i = 0, j = this.children.length; i < j; i++) {
            let child = this.children[i];
            child.destroy();
        }

        this.children.length = 0;
        this.contentState = ContentState$1.UNLOADED;
    };

    S3MTile.prototype.isDestroyed = function () {
        return false;
    };

    S3MTile.prototype.destroy = function () {
        for (let key in this.renderEntityMap) {
            if (this.renderEntityMap.hasOwnProperty(key)) {
                this.renderEntityMap[key].destroy();
            }
        }

        this.renderEntityMap = undefined;

        for (let i = 0, j = this.children.length; i < j; i++) {
            let child = this.children[i];
            child.destroy();
        }

        this.children.length = 0;

        return Cesium.destroyObject(this);
    };

    function S3MLayerScheduler() {
        this._stack = [];
    }

    function selectRootTiles(layer, stack, frameState) {
        stack.length = 0;
        for (let i = 0, j = layer._rootTiles.length; i < j; i++) {
            let rootTile = layer._rootTiles[i];
            rootTile.updateVisibility(frameState);
            if (!rootTile.visible) {
                continue;
            }

            stack.push(rootTile);
        }
    }

    function sortComparator(a, b) {
        return a.distanceToCamera - b.distanceToCamera;
    }


    function updateChildren(layer, tile, stack, frameState) {
        let i;
        let children = tile.children;
        let length = children.length;

        for (i = 0; i < length; ++i) {
            children[i].updateVisibility(frameState);
        }

        children.sort(sortComparator);
        for (i = 0; i < length; ++i) {
            let child = children[i];
            if (child.visible) {
                stack.push(child);
            }
        }
    }

    function selectTile(layer, tile, frameState) {
        if (tile.renderable) {
            layer._selectedTiles.push(tile);
            tile.selectedFrame = frameState.frameNumber;
        }
    }

    function loadTile(layer, tile, frameState) {
        if (tile.requestedFrame === frameState.frameNumber || tile.contentState !== ContentState$1.UNLOADED || tile.isLeafTile) {
            return;
        }

        layer._requestTiles.push(tile);
        tile.requestedFrame = frameState.frameNumber;
    }

    function touchTile(layer, tile, frameState) {
        if (tile.touchedFrame === frameState.frameNumber) {
            return;
        }

        layer._cache.touch(tile);
        tile.touchedFrame = frameState.frameNumber;
    }

    function traversal(layer, stack, frameState) {
        while (stack.length) {
            let tile = stack.pop();
            if (!tile.visible) {
                continue;
            }

            touchTile(layer, tile, frameState);

            if (tile.canTraverse()) {
                updateChildren(layer, tile, stack, frameState);
                continue;
            }

            selectTile(layer, tile, frameState);
            loadTile(layer, tile, frameState);
        }
    }

    S3MLayerScheduler.prototype.scheduler = function (layer, frameState) {
        layer._requestTiles.length = 0;
        layer._selectedTiles.length = 0;
        let stack = this._stack;
        selectRootTiles(layer, stack, frameState);
        traversal(layer, stack, frameState);
    };

    function S3MLayerCache() {
        this._list = new Cesium.DoublyLinkedList();
        this._sentinel = this._list.add();
        this._trimTiles = false;
    }

    S3MLayerCache.prototype.reset = function () {
        this._list.splice(this._list.tail, this._sentinel);
    };

    S3MLayerCache.prototype.touch = function (tile) {
        let node = tile.cacheNode;
        if (Cesium.defined(node)) {
            this._list.splice(this._sentinel, node);
        }
    };

    S3MLayerCache.prototype.add = function (tile) {
        if (!Cesium.defined(tile.cacheNode)) {
            tile.cacheNode = this._list.add(tile);
        }
    };

    S3MLayerCache.prototype.unloadTile = function (layer, tile, unloadCallback) {
        let node = tile.cacheNode;
        if (!Cesium.defined(node)) {
            return;
        }

        this._list.remove(node);
        tile.cacheNode = undefined;
        unloadCallback(layer, tile);
    };

    S3MLayerCache.prototype.unloadTiles = function (layer, unloadCallback) {
        let trimTiles = this._trimTiles;
        this._trimTiles = false;
        let list = this._list;
        let maximumMemoryUsageInBytes = layer.maximumMemoryUsage * 1024 * 1024;
        let sentinel = this._sentinel;
        let node = list.head;
        while ((node !== sentinel) && ((layer.totalMemoryUsageInBytes > maximumMemoryUsageInBytes) || trimTiles)) {
            let tile = node.item;
            node = node.next;
            if (tile.isDestroyed()) ;
            this.unloadTile(layer, tile, unloadCallback);
        }
    };

    S3MLayerCache.prototype.trim = function () {
        this._trimTiles = true;
    };

    function S3MTilesLayer(options) {
        options = Cesium.defaultValue(options, Cesium.defaultValue.EMPTY_OBJECT);
        Cesium.Check.defined('options.url', options.url);
        Cesium.Check.defined('options.context', options.context);
        this.context = options.context;
        this._url = undefined;
        this._basePath = undefined;
        this._baseResource = undefined;
        this.modelMatrix = undefined;
        this.fileType = undefined;
        this._position = undefined;
        this._rectangle = undefined;
        this._rootTiles = [];
        this._schuduler = new S3MLayerScheduler();
        this._requestTiles = [];
        this._selectedTiles = [];
        this._cache = new S3MLayerCache();
        this._maximumMemoryUsage = -1;
        this._totalMemoryUsageInBytes = 0;
        this._readyPromise = Cesium.when.defer();
        this.loadConfig(options.url);
    }

    Object.defineProperties(S3MTilesLayer.prototype, {
        ready: {
            get: function () {
                return this._rootTiles.length > 0;
            }
        },
        readyPromise: {
            get: function () {
                return this._readyPromise;
            }
        },
        rectangle: {
            get: function () {
                return this._rectangle;
            }
        },
        totalMemoryUsageInBytes: {
            get: function () {
                return this._totalMemoryUsageInBytes;
            },
            set: function (value) {
                this._totalMemoryUsageInBytes = value;
            }
        },
        maximumMemoryUsage: {
            get: function () {
                return this._maximumMemoryUsage;
            },
            set: function (value) {
                this._maximumMemoryUsage = value;
            }
        }
    });

    S3MTilesLayer.prototype.loadConfig = function (url) {
        let that = this;
        Cesium.when(url)
            .then(function (url) {
                let basePath;
                let resource = Cesium.Resource.createIfNeeded(url);
                basePath = resource.getBaseUri(true);
                that._url = resource.url;
                that._basePath = basePath;
                that._baseResource = resource;
                return resource.fetchJson();
            })
            .then(function (config) {
                let extensions = config.extensions;
                that.fileType = extensions["s3m:FileType"];
                let lon = config.position.x;
                let lat = config.position.y;
                let height = config.position.z;
                that._position = Cesium.Cartesian3.fromDegrees(lon, lat, height);
                that.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(that._position);
                that._rectangle = Cesium.Rectangle.fromDegrees(config.geoBounds.left, config.geoBounds.bottom, config.geoBounds.right, config.geoBounds.top);

                for (let i = 0, len = config.tiles.length; i < len; i++) {
                    let fileName = config.tiles[i].url;
                    let boundingVolume = {
                        box: config.tiles[i].boundingbox
                    };

                    let tile = new S3MTile(that, undefined, boundingVolume, fileName);
                    that._cache.add(tile);
                    that._rootTiles.push(tile);
                }

                that._readyPromise.resolve(that);
            }).otherwise(function (error) {
                that._readyPromise.reject(error);
            });
    };

    function sortRequestByPriority(a, b) {
        return a.priority - b.priority;
    }

    function requestTiles(layer) {
        let requestTiles = layer._requestTiles;
        let length = requestTiles.length;
        requestTiles.sort(sortRequestByPriority);
        for (let i = 0; i < length; ++i) {
            let tile = requestTiles[i];
            tile.requestContent();
        }
    }

    function updateTiles(layer, frameState) {
        let selectedTiles = layer._selectedTiles;
        let length = selectedTiles.length;
        for (let i = 0; i < length; i++) {
            selectedTiles[i].update(frameState);
        }
    }

    function unloadTile(layer, tile) {
        //tile.free();
    }

    function freeResource(layer) {
        layer._cache.unloadTiles(layer, unloadTile);
    }

    S3MTilesLayer.prototype.prePassesUpdate = function (frameState) {
        if (!this.ready) {
            return;
        }

        if (frameState.newFrame) {
            this._cache.reset();
        }
    };

    S3MTilesLayer.prototype.update = function (frameState) {
        if (!this.ready) {
            return;
        }

        this._schuduler.scheduler(this, frameState);
        requestTiles(this);
        updateTiles(this, frameState);
        freeResource(this);
    };

    /**
     *
     * 影像矢量切片图层。
     *
     * @alias VectorImgFeatureLayer
     * @constructor
     *
     */
    function VectorImgFeatureLayer(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._color = new Color(this._viewer, this._cesium);
        this._tree = tree;
        this.item = { show: true };
        this._option = undefined;
        this._primitive = undefined;
        this._Provider = undefined;
    }

    /**
     * 
     * @param {String} name 
     * @param {Object} options
     * @param {Object} queryOptions
     * @param {String} GroupID 
     * @param {Boolean} checked 
     * @param {Function} disFnc 
     */
    VectorImgFeatureLayer.prototype.CreateVectorImageFeatureLayer = function (name, options, queryOptions, styleoption, GroupID, checked, disFnc) {

        var defaultOptions = {
            url: '',
            queryParameters: {
                layer: '',
                style: '',
                tilematrixset: 'EPSG:4326',
                Service: 'WMTS',
                Request: 'GetTile',
                Version: '1.0.0',
                Format: 'image/png',
                TileMatrix: 'EPSG:4326:',
                TileCol: '',
                TileRow: ''
            }
        };

        this._option = this._core.extend(defaultOptions, options, true);
        this._queryOption = queryOptions;

        var _option = this._core.extend(defaultOptions, options, true);
        var _queryOption = queryOptions;
        if (options == undefined)
            console.log('options is required');

        var that = this;
        this._Provider = new VectorTileProvider(this._viewer, this._cesium);

        this._Provider.loadTile = function (frameState, tile) {
            (function (tile1, frameState, _queryOption, that, that1) {
                if (tile.state === Cesium.QuadtreeTileLoadState.START) {
                    tile.data = {
                        lines: [],
                        geometryPrimitive: undefined
                    };
                    if (tile.level >= styleoption.level_min && tile.level < styleoption.level_max && that.item.show) {

                        ////xample
                        // var resource = new Cesium.Resource({
                        //     url: 'http://192.168.1.125:8090/geoserver/gwc/service/wmts',
                        //     queryParameters: {
                        //         layer: 'tiger:poly_landmarks',
                        //         style: 'poly_landmarks',
                        //         tilematrixset: 'EPSG:4326',
                        //         Service: 'WMTS',
                        //         Request: 'GetTile',
                        //         Version: '1.0.0',
                        //         Format: 'image/png',
                        //         TileMatrix: 'EPSG:4326:' + tile1.level,
                        //         TileCol: tile1.x,
                        //         TileRow: tile1.y
                        //     }
                        // });
                        _option.queryParameters.TileMatrix = _option.queryParameters.tilematrixset + ':' + tile1.level;
                        _option.queryParameters.TileCol = tile1.x;
                        _option.queryParameters.TileRow = tile1.y;
                        var resource = new Cesium.Resource(_option);
                        resource.fetchImage().then(function (img) {
                            var rectangle = new Cesium.Rectangle(0, 0, 0, 0);
                            that1._tilingScheme.tileXYToRectangle(tile1.x, tile1.y, tile1.level, rectangle);
                            var groundprivimitvie = new Cesium.GroundPrimitive({
                                geometryInstances: [{
                                    geometry: new Cesium.RectangleGeometry({
                                        rectangle: rectangle
                                    })
                                }],
                                appearance: new Cesium.Appearance({
                                    material: new Cesium.Material({
                                        fabric: {
                                            type: 'Image',
                                            uniforms: {
                                                image: img
                                            }
                                        }
                                    })
                                })
                            });
                            //// Example
                            // groundprivimitvie.cusResource = {
                            //     // url: 'http://192.168.1.125:8090/geoserver/gwc/service/wms',
                            //     url: 'http://192.168.1.125:8090/geoserver/tiger/wms',
                            //     queryParameters: {
                            //         SERVICE: 'WMS',
                            //         VERSION: '1.1.1',
                            //         REQUEST: 'GetFeatureInfo',
                            //         FORMAT: 'image/png',
                            //         TRANSPARENT: 'true',
                            //         QUERY_LAYERS: 'tiger:poly_landmarks',
                            //         LAYERS: 'tiger:poly_landmarks',
                            //         exceptions: 'application/vnd.ogc.se_inimage',
                            //         INFO_FORMAT: 'application/json',
                            //         FEATURE_COUNT: '50',
                            //         X: '50',
                            //         Y: '50',
                            //         SRS: 'EPSG:4326',
                            //         STYLES: '',
                            //         WIDTH: '101',
                            //         HEIGHT: '101',
                            //         BBOX: '118.79495143890381, 32.03793525695801, 118.80362033843994, 32.04660415649414'
                            //     }
                            // }
                            groundprivimitvie.cusResource = _queryOption;
                            tile.data.geometryPrimitive = groundprivimitvie;
                            tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                            if (tile.state === Cesium.QuadtreeTileLoadState.LOADING) {
                                tile.data.geometryPrimitive.update(frameState, []);
                                tile.state = Cesium.QuadtreeTileLoadState.DONE;
                                tile.renderable = true;
                            }
                        }, function (c) {
                            console.log(c);
                        });

                        tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                    } else {
                        tile.state = Cesium.QuadtreeTileLoadState.DONE;
                        tile.renderable = true;
                        // Add more detail to parent lines at every other level.
                        return;
                    }

                    tile.state = Cesium.QuadtreeTileLoadState.LOADING;
                }        })(tile, frameState, _queryOption, that, this);
        };
        this._primitive = new that._cesium.QuadtreePrimitivezh({
            tileProvider: this._Provider
        });
        var scene = this._viewer.scene;
        var primitives = scene.primitives;
        primitives.add(this._primitive);
        if (scene.primitivesQuadTrees)
            scene.primitivesQuadTrees.push(this._primitive);
        //工程树
        if (checked) ; else {
            this.setVisibility(false);
        }
        if (this._core.isnull(options.id)) {
            options.id = this._core.getuid();
        }
        if (this._core.isnull(name)) {
            name = "新建图层" + options.id;
        }

        //导出工程树
        var obj = {
            id: options.id,
            name: name,
            checked: true,
            pId: this._core.isnull(GroupID) ? 0 : GroupID,
            type: 'rasterLayer',
            item: this,
            options: this._option,
            queryOptions: this._queryOption
        };
        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, this._core.isnull(GroupID) ? 0 : GroupID);
        //执行回调函数
        if (typeof disFnc == 'function') {
            disFnc(this.item);
        }
        return this
    };

    //工程树添加
    VectorImgFeatureLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };
    /**
    * 设置数据显示隐藏
    */
    VectorImgFeatureLayer.prototype.setVisibility = function (b) {
        try {
            if (this._Provider && this._Provider.setStatus) {
                this._Provider.setStatus(b);
            }
        } catch (ex) {
        }
    };
    /**
     * 删除数据
     */
    VectorImgFeatureLayer.prototype.deleteObject = function () {
        this._viewer.scene.primitives.remove(this.item);
        try {
            this._Provider.remove();
        } catch (ex) {
        }
    };

    var viewer$1;
    /**
     *
     * 地形修改。
     *
     * @alias TerrainModifier
     * @constructor
     *
     */
    function TerrainModifier(yViewer) {
        this._viewer = yViewer;
        viewer$1 = yViewer;
    }
    TerrainModifier.prototype.findDirectParent = function (rect) {
        try {
            var tiles = [];
            if (rect.width == Math.PI) return null;

            for (var i = 0; i < viewer$1.scene.globe._surface._tilesToRender.length; i++) {
                var tile = viewer$1.scene.globe._surface._tilesToRender[i];
                var tileRect = tile._rectangle;

                if (Cesium.Rectangle.intersection(tileRect, rect)) {
                    tiles.push(tile);
                }
            }
            return tiles;
        } catch (e) { }
        return null;
    };
    /**
     * 创建修改地形对象
     * @param {*} 名称
     * @param {*} 面
     * @param {*} 高度
     */
    TerrainModifier.prototype.createTerrainModifier = function (name, polygon, altitude) {
        var len = polygon.length;
        var heights = new Array(len);
        heights.fill(altitude);
        var guid = Cesium.createGuid();
        var nowTime = Date.now();
        var polygonRect = Cesium.Rectangle.fromCartesianArray(polygon);
        var tiles = this.findDirectParent(polygonRect);
        if (this._viewer.terrainProvider && this._viewer.terrainProvider._modifyTerrainObjects === undefined) {
            this._viewer.terrainProvider._modifyTerrainObjects = [];
        }
        var mtViewer = this._viewer;
        var modifyTerrainObject = {
            id: guid,
            name: name,
            show: true,
            rectangle: polygonRect,
            vertices: polygon,
            heights: heights,
            timeStamp: nowTime,
            remove: function () {
                //console.log(name);
                if (mtViewer.terrainProvider && mtViewer.terrainProvider._modifyTerrainObjects) {
                    for (var i = mtViewer.terrainProvider._modifyTerrainObjects.length - 1; i >= 0; i--) {
                        var mto = mtViewer.terrainProvider._modifyTerrainObjects[i];
                        if (mto.id == guid) {
                            mtViewer.terrainProvider._modifyTerrainObjects.splice(i, 1);
                        }
                    }
                }
                if (tiles) {
                    try {
                        for (var i = 0; i < tiles.length; i++) {
                            try {
                                tiles[i]._parent.freeResources();
                            } catch (e) { }
                        }
                    } catch (e) { }
                }
            },
        };
        this._viewer.terrainProvider._modifyTerrainObjects.push(modifyTerrainObject);
        if (tiles) {
            try {
                for (var i = 0; i < tiles.length; i++) {
                    try {
                        tiles[i]._parent.freeResources();
                    } catch (e) { }
                }
            } catch (e) { }
        }
        return modifyTerrainObject;
    };

    /**
     *
     * 视频融合
     *
     * @alias Video3D
     * @constructor
     *
     */
    function Video3D(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        if (!window.Hls) {
            let SkipTool = new Skip(false);
            SkipTool.addJs(document.body, window.SmartEarthRootUrl + 'Workers/hls.js');
        }

    }

    /**
     * 向三维场景中添加视频。
     * 
     * @param {Object} [options] 参数。
     * @param {Cesium.Cartesian3} [options.cameraPosition] 相机位置
     * @param {Cesium.Cartesian3} [options.position] 投射位置
     * @param {Number} [options.alpha=0.7] 透明度
     * @param {String} [options.url] 视频地址
     * @param {String} [options.type='mp4'] 视频类型
     * @param {DOM} [options.video] 视频容器，(可选)
     * @param {Number} [options.horizonAngle=60] 相机水平视角
     * @param {Number} [options.verticalAngle=30] 相机垂直视角
     * @param {Number} [options.offset=0.1] 视频四周羽化比例
     * @param {Number} [options.angleZ=0] 视频在投影面上得旋转角度
     * @param {Number} [options.near=1] 最近投射面距离
     * @param {Number} [options.far=30] 最远投射面距离
     * @param {Boolean} [options.useLine=true] 是否试用辅助线
     * 
     * @returns {Video3D}
     *
     */
    Video3D.prototype.Video3D = function (options) {
        this.sp = options.cameraPosition || undefined;
        this.ep = options.position || undefined;
        this.alpha = options.alpha || 0.7;
        this.horizonAngle = options.horizonAngle || 60;
        this.verticalAngle = options.verticalAngle || 30;
        this.angleZ = options.angleZ || 0;
        this.angle = new Cesium.Cartesian3(this.horizonAngle / 2, this.verticalAngle / 2, this.angleZ);
        this.near = options.near || 1;
        this.far = options.far || 30;
        this.offset = options.offset || 0.1;
        this.nearAndFar = new Cesium.Cartesian4(this.near, this.far, this.alpha, this.offset);

        this.video = options.video || undefined;
        this.videoType = options.type || 'mp4';
        this.center = new Cesium.Cartesian3();
        this.eupp = new Cesium.Cartesian3();
        this.epp = new Cesium.Cartesian3();
        this.upp = this.setSpHeight(this.sp);
        this.useLine = Cesium.defaultValue(options.useLine, true);
        this.controlPoint = null;
        this.addVideo(options.url);
        return this;
    };

    Video3D.prototype.addVideo = function (url) {
        if (this.video) {
            this.video.oncanplay = () => {
                this.init();
            };
            return
        }

        let id = "Video3D" + this._core.getuid();
        let video = `<video id="${id}" autoplay muted loop crossorigin  style="display: none"></video>`;
        $(this._viewer.container).append(video);
        this.video = document.getElementById(id);

        if (this.videoType === 'hls') {
            if (this.video.canPlayType('application/vnd.apple.mpegurl')) {
                // 浏览器本身支持HLS
                this.video.src = url;
            } else if (Hls.isSupported()) {
                // 检查是否支持HLS.js
                var hls = new Hls();
                hls.loadSource(url);
                hls.attachMedia(this.video);
            }
        } else {
            this.video.src = url;
        }
        this.video.oncanplay = () => {
            this.init();
        };
    };

    Video3D.prototype.setSpHeight = function (p, h = 5000) {
        let tp = Cesium.Cartographic.fromCartesian(p);
        tp.height += h;
        return Cesium.Cartographic.toCartesian(tp);
    };

    Video3D.prototype.createLine = function (sp, ep, upp) {
        if (this.line) {
            this._viewer.scene.primitives.remove(this.line);
            this.line = null;
        }
        if (!this.useLine) {
            return;
        }

        if (!this.controlPoint) {
            this._viewer.entities.add({
                position: this.ep,
                point: {
                    pixelSize: 10,
                    color: Cesium.Color.RED,
                }
            });
        } else {
            this.controlPoint.position = this.ep;
        }

        let direct = Cesium.Cartesian3.subtract(ep, sp, new Cesium.Cartesian3());
        Cesium.Cartesian3.normalize(direct, direct);
        let up = Cesium.Cartesian3.subtract(upp, sp, new Cesium.Cartesian3());
        Cesium.Cartesian3.normalize(up, up);
        let right = Cesium.Cartesian3.cross(direct, up, new Cesium.Cartesian3());
        Cesium.Cartesian3.normalize(right, right);
        Cesium.Cartesian3.cross(right, direct, up);
        Cesium.Cartesian3.normalize(up, up);

        let m = new Cesium.Matrix4.fromArray([
            right.x, right.y, right.z, 0,
            up.x, up.y, up.z, 0,
            direct.x, direct.y, direct.z, 0,
            sp.x, sp.y, sp.z, 1.
        ]);

        const angleZ = -this.angleZ * Math.PI / 180;
        // console.log(this.angleZ);
        let ca = Math.cos(angleZ);
        let sa = Math.sin(angleZ);
        let rm = Cesium.Matrix4.fromArray([
            ca, -sa, 0., 0.,
            sa, ca, 0., 0.,
            0., 0., 1., 0,
            0, 0, 0, 1
        ]);

        let z = this.nearAndFar.y;
        let tanx = Math.tan(this.horizonAngle / 2 / 180 * Math.PI) * z;
        let tany = Math.tan(this.verticalAngle / 2 / 180 * Math.PI) * z;
        let p = [
            new Cesium.Cartesian3(-tanx, -tany, z),
            new Cesium.Cartesian3(tanx, -tany, z),
            new Cesium.Cartesian3(tanx, tany, z),
            new Cesium.Cartesian3(-tanx, tany, z),
        ];


        let inses = [];

        let pts = p.slice();
        for (let i in p) {
            Cesium.Matrix4.multiplyByPoint(rm, p[i], p[i]);
            Cesium.Matrix4.multiplyByPoint(m, p[i], pts[i]);
            let line = new Cesium.PolylineGeometry({
                positions: [sp, pts[i]]
            });
            let is = new Cesium.GeometryInstance({
                geometry: line,
            });
            inses.push(is);
        }

        this.line = new Cesium.Primitive({
            geometryInstances: inses,
            appearance: new Cesium.PolylineMaterialAppearance({
                translucent: false,
                material: new Cesium.Material({
                    translucent: false,
                    fabric: {
                        type: 'Color',
                        uniforms: {
                            color: Cesium.Color.RED,
                        }
                    }
                })
            }),
            asynchronous: false,
        });
        this._viewer.scene.primitives.add(this.line);
    };

    Video3D.prototype.init = function () {
        if (this.video && this.video.readyState === this.video.HAVE_ENOUGH_DATA) {
            this.video.play();
        }

        if (!(this.upp instanceof Cesium.Cartesian3)) {
            throw new Error('计算上方向错误');
        }
        this.createLine(this.sp, this.ep, this.upp);
        const video = this.video;
        const self = this;
        let us = this._viewer.scene.context.uniformState;

        this.texture = new Cesium.Texture({
            context: this._viewer.scene.context,
            source: video,
            width: 1,
            height: 1,
        });
        this.post = new Cesium.PostProcessStage({
            uniforms: {
                cen: function () {
                    return Cesium.Matrix4.multiplyByPoint(us.view3D, self.sp, self.center);
                },
                ep: function () {
                    return Cesium.Matrix4.multiplyByPoint(us.view3D, self.ep, self.epp);
                },
                eupp: function () {
                    return Cesium.Matrix4.multiplyByPoint(us.view3D, self.upp, self.eupp);
                },
                video: function () {
                    if (video && video.readyState >= 2) {
                        self.texture.copyFrom({ source: video });
                    }
                    return self.texture;
                },
                angle: function () {
                    return self.angle;
                },
                nearAndFar: function () {
                    return self.nearAndFar;
                }
            },
            fragmentShader: this.getFS1() + this.getFS2() + `
                      uniform sampler2D colorTexture;
                      uniform sampler2D depthTexture;
                      varying vec2 v_textureCoordinates;
              
                      uniform vec3 cen;
                      uniform vec3 ep;
                      uniform vec3 eupp;
                      uniform vec3 angle;
                      uniform vec4 nearAndFar;
              
                      uniform sampler2D video;
              
                      mat4 computeMat(){
                        vec3 dir = normalize( ep - cen );
                        vec3 up = normalize( eupp - cen);//vec3( 0. ,0. , 1.);
                        vec3 right = cross(dir , up);
                        right = normalize(right);
                        up = cross(right , dir);
                        up = normalize(up);
              
                        return mat4(
                          right.x,right.y,right.z,0.,
                          up.x,up.y,up.z,0.,
                          dir.x,dir.y,dir.z,0.,
                          cen.x,cen.y,cen.z,1.
                        );
                        // return mat4(
                        //   right.x ,up.x ,dir.x , cen.x,
                        //   right.y ,up.y ,dir.y , cen.y,
                        //   right.z ,up.z ,dir.z , cen.z,
                        //   0. ,0.,0.,1.
                        // );
                      }
                      mat3 computeMat3(float an){
                        float sa = sin(an);
                        float ca = cos(an);
                        return mat3( 
                          ca , -sa ,0.,
                          sa , ca , 0.,
                          0.,0.,1.
                        );
                      }
                      void setNormalColor(vec3 p , vec4 oc){
                        if( p.z < nearAndFar.x || p.z > nearAndFar.y){
                          gl_FragColor = oc;
                          return;
                        }
                        
                        mat3 rm = computeMat3( radians( angle.z ) );
                        p = rm * p;
                        
                        vec3 n = p.xyz;
                        vec3 zn = vec3(0.,0.,1.);
                        float dist = dot( n , zn);
                        float dx = p.x ;
                        float xangle = tan(radians( angle.x ));
                        float yangle = tan(radians( angle.y ));
                        float tanx = p.x / dist;
                        float tany = p.y / dist;
                        if( (tanx > -xangle && tanx< xangle) &&(tany > -yangle && tany < yangle)){
                          // gl_FragColor = vec4(1.);
                          // return;
                          float r = (tanx + xangle) / (2. * xangle);
                          float g = (tany + yangle) / (2. * yangle);
                          vec4 col = texture2D( video , vec2( r , g));
                          float f1 = 1.;
              
                          float v1 = nearAndFar.w ;//羽化距离
                          float v2 = 1. - v1;
                          if(r < v1){
                            f1 = r / v1;
                          }
                          if(r > v2){
                            f1 = (1. - r) / v1;
                          }
                          float f2 = 1.;
                          if(g < v1){
                            f2 = g / v1;
                          }
                          if(g > v2){
                            f2 = (1. - g) / v1;
                          }
                          float f12 = f1 * f2;
                          // float ff = f12;
                          float ff = smoothstep(  0. , 1. , f12 );
                          ff *= nearAndFar.z;
                          // ff = pow(ff , 0.5);
                          gl_FragColor = mix(oc , col , ff);
                          // gl_FragColor = mix(oc , vec4(1.) , 0.5);
                        }else{
                          gl_FragColor = oc;
                        }
                      }
                      void main(){
                        vec2 uv = v_textureCoordinates;
                        float depth = getDepth(texture2D( depthTexture , uv));
                        vec4 oc = texture2D(colorTexture , uv);
                        vec4 ec = toEye( uv , depth);
                        ec /= ec.w;
              
                        vec3 snor = normalize( ep - cen);
              
                        vec3 pd = ec.xyz - cen;
                        float dd = length(pd);
                        vec3 n = normalize(ec.xyz - cen);
                        float d = dot(n ,  snor);
              
                        mat4 localMat = computeMat();
              
                        vec4 p = inverse_mat4(localMat) * ec;
                        p/=p.w;
                        // setColor1( p.xyz , oc);
                        setNormalColor( p.xyz , oc);
                      }
                      `,
        });

        this._viewer.scene.postProcessStages.add(this.post);
    };

    Video3D.prototype.update = function (options) {
        const ha = options.horizonAngle;
        const va = options.verticalAngle;
        const az = options.angleZ;
        if (!isNaN(ha) && (typeof ha === 'number')) {
            this.horizonAngle = ha;
            this.angle.x = ha / 2;
        }

        if (!isNaN(va) && (typeof va === 'number')) {
            this.verticalAngle = va;
            this.angle.y = va / 2;
        }

        if (!isNaN(az) && (typeof az === 'number')) {
            this.angleZ = this.angle.z = az;
        }

        const sp = options.startPos;
        if (sp && sp instanceof Cesium.Cartesian3) {
            this.sp.x = sp.x;
            this.sp.y = sp.y;
            this.sp.z = sp.z;
        }
        const ep = options.endPos;
        if (ep && ep instanceof Cesium.Cartesian3) {
            this.ep.x = ep.x;
            this.ep.y = ep.y;
            this.ep.z = ep.z;
        }

        const near = options.near;
        const far = options.far;
        const offset = options.offset;
        const alpha = options.alpha;

        if (near && !isNaN(near) && (typeof near === 'number')) {
            this.nearAndFar.x = near;
        }

        if (far && !isNaN(far) && (typeof far === 'number')) {
            this.nearAndFar.y = far;
        }
        if (offset && !isNaN(offset) && (typeof offset === 'number')) {
            this.nearAndFar.w = offset;
        }

        if (alpha && !isNaN(alpha) && (typeof alpha === 'number')) {
            this.nearAndFar.z = alpha;
        }

        if (options.useLine !== undefined) {
            this.useLine = options.useLine;
        }
        //创建辅助线
        this.createLine(this.sp, this.ep, this.upp);
    };

    Video3D.prototype.destroy = function () {
        if (this.texture) {
            this.texture.destroy();
        }
        if (this.post) {
            this._viewer.scene.postProcessStages.remove(this.post);
        }
        this.video && this.video.remove();
        if (this.line) {
            this._viewer.scene.primitives.remove(this.line);
            this.line = null;
        }

        for (let i in this) {
            delete this[i];
        }
    };

    Video3D.prototype.getFS1 = function () {
        const fs = "vec4 toEye(in vec2 uv, in float depth){\r\n" +
            "    vec2 xy = vec2((uv.x * 2.0 - 1.0),(uv.y * 2.0 - 1.0));\r\n" +
            "    vec4 posInCamera =czm_inverseProjection * vec4(xy, depth, 1.0);\r\n" +
            "    posInCamera =posInCamera / posInCamera.w;\r\n" +
            "    return posInCamera;\r\n" +
            "}\r\n" +
            "float getDepth(in vec4 depth){\r\n" +
            "    float z_window = czm_unpackDepth(depth);\r\n" +
            "    z_window = czm_reverseLogDepth(z_window);\r\n" +
            "    float n_range = czm_depthRange.near;\r\n" +
            "    float f_range = czm_depthRange.far;\r\n" +
            "    return (2.0 * z_window - n_range - f_range) / (f_range - n_range);\r\n" +
            "}\r\n";
        return fs;
    };

    Video3D.prototype.getFS2 = function () {
        const fs1 = `
                    mat4 inverse_mat4(mat4 m)
                      {
                          float Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
                          float Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
                          float Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
              
                          float Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
                          float Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
                          float Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
              
                          float Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
                          float Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
                          float Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
              
                          float Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
                          float Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
                          float Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
              
                          float Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
                          float Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
                          float Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
              
                          float Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
                          float Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
                          float Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
              
                          const vec4 SignA = vec4( 1.0, -1.0,  1.0, -1.0);
                          const vec4 SignB = vec4(-1.0,  1.0, -1.0,  1.0);
              
                          vec4 Fac0 = vec4(Coef00, Coef00, Coef02, Coef03);
                          vec4 Fac1 = vec4(Coef04, Coef04, Coef06, Coef07);
                          vec4 Fac2 = vec4(Coef08, Coef08, Coef10, Coef11);
                          vec4 Fac3 = vec4(Coef12, Coef12, Coef14, Coef15);
                          vec4 Fac4 = vec4(Coef16, Coef16, Coef18, Coef19);
                          vec4 Fac5 = vec4(Coef20, Coef20, Coef22, Coef23);
              
                          vec4 Vec0 = vec4(m[1][0], m[0][0], m[0][0], m[0][0]);
                          vec4 Vec1 = vec4(m[1][1], m[0][1], m[0][1], m[0][1]);
                          vec4 Vec2 = vec4(m[1][2], m[0][2], m[0][2], m[0][2]);
                          vec4 Vec3 = vec4(m[1][3], m[0][3], m[0][3], m[0][3]);
              
                          vec4 Inv0 = SignA * (Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
                          vec4 Inv1 = SignB * (Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
                          vec4 Inv2 = SignA * (Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
                          vec4 Inv3 = SignB * (Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
              
                          mat4 Inverse = mat4(Inv0, Inv1, Inv2, Inv3);
              
                          vec4 Row0 = vec4(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
              
                          float Determinant = dot(m[0], Row0);
              
                          Inverse /= Determinant;
              
                          return Inverse;
                      }
                    `;
        return fs1;
    };

    Video3D.prototype.changeHorizonAngle = function (v) {
        this.update({
            horizonAngle: parseFloat(v)
        });
    };

    Video3D.prototype.changeVerticalAngle = function (v) {
        this.update({
            verticalAngle: parseFloat(v)
        });
    };

    Video3D.prototype.changeRotateAngle = function (v) {
        this.update({
            angleZ: parseFloat(v)
        });
    };

    /**
     *
     * 天地图三维注记
     *
     * @alias TdtLabel
     * @constructor
     *
     */
    function TdtLabel(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        if (!Cesium.GeoWTFS) {
            let SkipTool = new Skip(false);
            //天地图插件
            SkipTool.addJs(document.body, window.SmartEarthRootUrl + 'Workers/cesiumTdt.js');
        }
    }

    /**
     * 添加天地图三维注记。
     * @param {Object} [option] 参数
     *
     */
    TdtLabel.prototype.GeoWTFS = function (option) {
        !option && (option = {});
        var token = option.token || 'c53eb074c3fcba5ac86103d4d711bbe8';
        // 服务域名
        var tdtUrl = option.url || 'https://t{s}.tianditu.gov.cn/';

        var defaultOption = {
            viewer: this._viewer,
            //三维地名服务，使用wtfs服务
            subdomains: ['0', '1', '2', '3', '4', '5', '6', '7'], // 服务负载子域
            metadata: {
                boundBox: {
                    minX: -180,
                    minY: -90,
                    maxX: 180,
                    maxY: 90
                },
                minLevel: 1,
                maxLevel: 20
            },
            aotuCollide: true, //是否开启避让
            collisionPadding: [5, 10, 8, 5], //开启避让时，标注碰撞增加内边距，上、右、下、左
            serverFirstStyle: true, //服务端样式优先
            labelGraphics: {
                font: "28px sans-serif",
                fontSize: 28,
                fillColor: Cesium.Color.WHITE,
                scale: 0.5,
                outlineColor: Cesium.Color.BLACK,
                outlineWidth: 5,
                style: Cesium.LabelStyle.FILL_AND_OUTLINE,
                showBackground: false,
                backgroundColor: Cesium.Color.RED,
                backgroundPadding: new Cesium.Cartesian2(10, 10),
                horizontalOrigin: Cesium.HorizontalOrigin.LEFT,
                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                eyeOffset: Cesium.Cartesian3.ZERO,
                pixelOffset: new Cesium.Cartesian2(0, 8),
                heightReference: 1,
                disableDepthTestDistance: Number.POSITIVE_INFINITY,
            },
            billboardGraphics: {
                horizontalOrigin: Cesium.HorizontalOrigin.RIGHT,
                verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
                eyeOffset: Cesium.Cartesian3.ZERO,
                pixelOffset: Cesium.Cartesian2.ZERO,
                alignedAxis: Cesium.Cartesian3.ZERO,
                color: Cesium.Color.WHITE,
                rotation: 0,
                scale: 1,
                width: 18,
                height: 18,
                heightReference: 1,
                disableDepthTestDistance: Number.POSITIVE_INFINITY,
            }
        };
        option = this._core.extend(defaultOption, option, true);

        //三维地名服务
        var wtfs = new Cesium.GeoWTFS(option);

        //三维地名服务，使用wtfs服务
        wtfs.getTileUrl = function () {
            return tdtUrl + 'mapservice/GetTiles?lxys={z},{x},{y}&tk=' + token;
        };

        // 三维图标服务
        wtfs.getIcoUrl = function () {
            return tdtUrl + 'mapservice/GetIcon?id={id}&tk=' + token;
        };

        wtfs.initTDT([
            { "x": 6, "y": 1, "level": 2, "boundBox": { "minX": 90, "minY": 0, "maxX": 135, "maxY": 45 } },
            { "x": 7, "y": 1, "level": 2, "boundBox": { "minX": 135, "minY": 0, "maxX": 180, "maxY": 45 } },
            { "x": 6, "y": 0, "level": 2, "boundBox": { "minX": 90, "minY": 45, "maxX": 135, "maxY": 90 } },
            { "x": 7, "y": 0, "level": 2, "boundBox": { "minX": 135, "minY": 45, "maxX": 180, "maxY": 90 } },
            { "x": 5, "y": 1, "level": 2, "boundBox": { "minX": 45, "minY": 0, "maxX": 90, "maxY": 45 } },
            { "x": 4, "y": 1, "level": 2, "boundBox": { "minX": 0, "minY": 0, "maxX": 45, "maxY": 45 } },
            { "x": 5, "y": 0, "level": 2, "boundBox": { "minX": 45, "minY": 45, "maxX": 90, "maxY": 90 } },
            { "x": 4, "y": 0, "level": 2, "boundBox": { "minX": 0, "minY": 45, "maxX": 45, "maxY": 90 } },
            { "x": 6, "y": 2, "level": 2, "boundBox": { "minX": 90, "minY": -45, "maxX": 135, "maxY": 0 } },
            { "x": 6, "y": 3, "level": 2, "boundBox": { "minX": 90, "minY": -90, "maxX": 135, "maxY": -45 } },
            { "x": 7, "y": 2, "level": 2, "boundBox": { "minX": 135, "minY": -45, "maxX": 180, "maxY": 0 } },
            { "x": 5, "y": 2, "level": 2, "boundBox": { "minX": 45, "minY": -45, "maxX": 90, "maxY": 0 } },
            { "x": 4, "y": 2, "level": 2, "boundBox": { "minX": 0, "minY": -45, "maxX": 45, "maxY": 0 } },
            { "x": 3, "y": 1, "level": 2, "boundBox": { "minX": -45, "minY": 0, "maxX": 0, "maxY": 45 } },
            { "x": 3, "y": 0, "level": 2, "boundBox": { "minX": -45, "minY": 45, "maxX": 0, "maxY": 90 } },
            { "x": 2, "y": 0, "level": 2, "boundBox": { "minX": -90, "minY": 45, "maxX": -45, "maxY": 90 } },
            { "x": 0, "y": 1, "level": 2, "boundBox": { "minX": -180, "minY": 0, "maxX": -135, "maxY": 45 } },
            { "x": 1, "y": 0, "level": 2, "boundBox": { "minX": -135, "minY": 45, "maxX": -90, "maxY": 90 } },
            { "x": 0, "y": 0, "level": 2, "boundBox": { "minX": -180, "minY": 45, "maxX": -135, "maxY": 90 } }
        ]);

        return wtfs;
    };

    /**
     *
     * 水面geojson要素图层。
     *
     * @alias WaterGeoJsonFeatureLayer
     * @constructor
     *
     * @param {Viewer} Viewer 地图视图。
     *
     */
    function WaterGeoJsonFeatureLayer(Viewer) {
        this._viewer = Viewer;
        this._core = new Core();
        this._tree = tree;
    }

    /**
     * 向三维场景中添加水面图层。
     * @param {Object} [option] 参数。
     * @param {String} [option.id] id（可选）。
     * @param {String} [option.url] geojson路径。
     * @param {String} [option.color="rgba(135,206,235,0.6)"] 水面颜色。
     * @param {String} [option.image] 水面贴图。
     * @param {Number} [option.height] 水面高度，无高度和拉伸高度默认贴地。
     * @param {Number} [option.extrudedHeight] 水面拉伸高度，无高度和拉伸高度默认贴地。
     * @param {Number} [option.frequency=1000] 水波数。
     * @param {Number} [option.speed=10] 流速(m/s)。
     * @param {Number} [option.amplitude=10] 水波幅度。
     * @param {Number} [option.classificationType] 识别的贴地类型。
     * @param {Number} [option.near=0] 最小可视距离。
     * @param {Number} [option.far=Math.MAX_VALUE] 最大可视距离。
     * @returns {WaterGeoJsonFeatureLayer} 返回一个WaterGeoJsonFeatureLayer对象。
     *
     */
    WaterGeoJsonFeatureLayer.prototype.createPolygonLayer = function (option = {}) {
        let options = {
            color: option.color || "rgba(135,206,235,0.6)", //水面的颜色
            image: option.image || window.SmartEarthRootUrl + configData$1.water, // 水面贴图
            height: option.height, // 水面高度
            extrudedHeight: option.extrudedHeight, // 拉伸高度
            frequency: option.frequency || 1000, // 水波数
            speed: option.speed || 10, // 流速
            amplitude: option.amplitude || 10.0, // 水波幅度
            near: option.near,
            far: option.far,
            id: option.id || this._core.getuid(), // id
        };
        Cesium.Color.fromCssColorString(options.color);

        let dataSource = Cesium.GeoJsonDataSource.load(option.url);
        let waterCollection = new Cesium.PrimitiveCollection();
        dataSource.then(dataSource => {
            let entities = dataSource.entities.values;
            for (let i = 0; i < entities.length; i++) {
                let entity = entities[i];
                this.addPolygon(waterCollection, entity, options);
            }
        });
        this.item = this._viewer.scene.primitives.add(waterCollection);
        var obj = {
            id: options.id,
            name: '新建水面图层',
            pId: 0,
            type: 'polygonLayer',
            item: this
        };

        this.setTreeobj(obj);
        this._tree.insertGroupId(obj, 0);

        return this;

    };

    // 创建面
    WaterGeoJsonFeatureLayer.prototype.addPolygon = async function (collection, entity, options) {
        let vertexFormat = Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT;
        let color = Cesium.Color.fromCssColorString(options.color);
        let polygon = new Cesium.PolygonGeometry({
            polygonHierarchy: entity.polygon.hierarchy.getValue(),
            extrudedHeight: options.extrudedHeight,
            height: options.height,
            vertexFormat: vertexFormat
        });
        let GeometryInstance = new Cesium.GeometryInstance({
            geometry: polygon,
            id: entity,
            attributes: {
                color: Cesium.ColorGeometryInstanceAttribute.fromColor(color),
                distanceDisplayCondition: new Cesium.DistanceDisplayConditionGeometryInstanceAttribute(options.near, options.far)
            }
        });
        let Primitive;
        if (!options.height && !options.extrudedHeight) {
            Primitive = Cesium.GroundPrimitive;
        } else {
            Primitive = Cesium.Primitive;
        }
        let water = new Primitive({
            geometryInstances: GeometryInstance,
            appearance: new Cesium.EllipsoidSurfaceAppearance({
                material: new Cesium.Material({
                    fabric: {
                        type: 'Water',
                        uniforms: {
                            baseWaterColor: color,
                            blendColor: color,
                            normalMap: options.image,
                            frequency: options.frequency,
                            animationSpeed: options.speed / 1000,
                            amplitude: options.amplitude
                        }
                    }
                })
            }),
            classificationType: options.classificationType
        });
        collection.add(water);
    };

    //工程树添加
    WaterGeoJsonFeatureLayer.prototype.setTreeobj = function (item) {
        this.treeobj = item;
    };

    /**
     * 删除
     */
    WaterGeoJsonFeatureLayer.prototype.deleteObject = function () {
        try {
            this._viewer.scene.primitives.remove(this.item);
        } catch (ex) {
            console.log(ex);
        }
    };

    /**
     * 显示隐藏
     * @param {Boolean} [show] 是否显示
     */
    WaterGeoJsonFeatureLayer.prototype.setVisibility = function (show) {
        this.item && (this.item.show = show);
    };

    /**
     *
     * 创建模块。
     *
     * @alias Creator
     * @constructor
     *
     */
    function Creator(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._core = new Core();
        this._Label = new Label(this._viewer, this._cesium);
        this._Circle = new Circle(this._viewer, this._cesium);
        this._Box = new Box(this._viewer, this._cesium);
        this._Cone = new Cone(this._viewer, this._cesium);
        this._Color = new Color(this._viewer, this._cesium);
        this._Polyline = new Polyline(this._viewer, this._cesium);
        this._Rectangle = new Rectangle$1(this._viewer, this._cesium);
        this._Polygon = new Polygon(this._viewer, this._cesium);
        this._ImageLabel = new ImageLabel(this._viewer, this._cesium);
        this._GeoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium, this._ImageryProvidererid);
        this._Ellipsoid = new Ellipsoid(this._viewer, this._cesium);
        this._PointModel = new PointModel(this._viewer, this._cesium);
        //this._point = new Point(this._viewer, this._cesium);
        this._wall = new wall(this._viewer, this._cesium);
        //this._D3Tileset = new SE3DTileset(this._viewer, this._cesium);
        this._Terrain = new Terrain(this._viewer, this._cesium);
        this._createdynamicObject = new dynamicObject(this._viewer, this._cesium);
        this._GeometryCreator;
        this._ImageryLayer = new ImageryLayer(this._viewer, this._cesium);
        this._VolumeGeoJsonFeatureLayer = undefined;
        this._PolygonVectorGeoJsonFeatureLayer = undefined;
        this._skyBox = new SkyBox(this._viewer, this._cesium);
        this._flowField = new FlowField(this._viewer, this._cesium);
        //this._trailLine = new TrailLine(this._viewer, this._cesium);
        this.VectorGeoJsonFeatureLayer = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        this._straightArrow = new MilitaryStandard(this._viewer, this._cesium);
        this._SimpleGraphic = new SimpleGraphic(this._viewer, this._cesium);
        this._popupmessage = new PopupMessage(this._viewer, this._cesium);
        this.VectorImgFeatureLayer = new VectorImgFeatureLayer(this._viewer, this._cesium);
        this._TerrainModifier = new TerrainModifier(this._viewer, this._cesium);

        //this._czml = new CZML(this._viewer, this._cesium);
        //this._MapGeoJsonFeatureLayer = new PolygonVectorTileLayerArcgis(this._viewer, this._cesium);
        // PolygonVectorTileLayerArcgis

        if (!cesium.Resource._Implementations.createImageSGS) {
            var I = new WorkerPool({
                workerPath: window.SmartEarthRootUrl + '/Workers/nullValueRemoveWorker.js'
            });
            cesium.Resource._Implementations.createImageSGS = function (e, t, n) {
                var q = 8;
                var r = {
                    r: 0,
                    g: 0,
                    b: 0,
                    a: 255
                };
                if (e.indexOf("nullvalue=") > -1) {
                    var i = e.split("nullvalue=")[1].split("&")[0]
                        , s = i.split("%2C");
                    r.r = s[0],
                        r.g = s[1],
                        r.b = s[2];
                }
                if (e.indexOf("nulltolerance=") > -1)
                    var o = e.split("nulltolerance=")[1].split("&")[0];
                var u = new Image
                    , a = document.createElement("canvas")
                    , f = a.getContext("2d");
                u.url = e,
                    u.onload = function () {
                        if (u.url != undefined && u.url.indexOf("nullvalue") != -1) {
                            delete u.url,
                                a.width = u.width,
                                a.height = u.height,
                                f.drawImage(u, 0, 0),
                                u.imageProcesses = [];
                            var e = u.width / q
                                , t = u.height
                                , i = 0;
                            for (var s = 0; s < q; s++) {
                                var l = s * e
                                    , c = f.getImageData(l, i, e, t).data;
                                u.imageProcesses[s] = I.queueWorkItem({
                                    nullValue: r,
                                    nullTolerance: o,
                                    canvasData: c,
                                    width: e,
                                    height: t,
                                    startX: l
                                });
                            }
                            Cesium.when.all(u.imageProcesses, function (e) {
                                for (var t = 0; t < e.length; t++) {
                                    var r = f.createImageData(e[t].width, e[t].height);
                                    for (var i = 0; i < e[t].canvasData.length; i++)
                                        r.data[i] = e[t].canvasData[i];
                                    f.putImageData(r, e[t].startX, 0);
                                }
                                u.src = a.toDataURL(),
                                    n.resolve(u);
                            }).otherwise(function (e) {
                                console.log(e);
                            });
                        } else
                            n.resolve(u);
                    }
                    ,
                    u.onerror = function (e) {
                        n.reject(e);
                    }
                    ,
                    t && (Cesium.TrustedServers.contains(e) ? u.crossOrigin = "use-credentials" : u.crossOrigin = ""),
                    u.src = e;
            };

        }
    }
    /**
     * 创建模型
     *
     * @param {string} [name] 名称
     * @param {string} [url] 模型路径
     * @param {object} [option] 模型参数（同Cesium3DTileset参数，参考 http://cesium.xin/cesium/Documentation/Cesium3DTileset.html）
     * @param {object} [option.id] 模型id
     * @param {object} [option.Level] 模型显示层级
     * @param {object} [option.time] 模型存在的时间段
     * @param {String} [option.time.start] 模型存在的起始时间
     * @param {String} [option.time.end] 模型存在的结束时间
     * @param {object} [style] 模型样式
     * @param {Boolean} [style.effects=false] 模型特效（常用于建筑白膜特效）
     * @param {Number} [style.effectsMaxHeight=150] 模型特效最大高度（常用于建筑白膜特效）
     * @param {String} [style.fShaderBody] 模型特效Shader
     * @param {Number} [style.groundHeight] 模型高度（用于模型坐标正确，高度不正确的情况，groundHeight: 100）
     * @param {Array} [style.groundCenter] 模型中心位置（用于模型坐标和高度都不正确的情况，groundCenter: [112, 32, 50]）
     * @param {Object} [style.edit] 模型编辑参数（用于模型编辑，修改模型经纬度高度、旋转角、比例）
     * @param {Number} [style.edit.lon] 经度
     * @param {Number} [style.edit.lat] 纬度
     * @param {Number} [style.edit.height] 高度
     * @param {Number} [style.edit.scale] 比例
     * @param {Number} [style.edit.r_x] X反方向旋转角
     * @param {Number} [style.edit.r_y] Y反方向旋转角
     * @param {Number} [style.edit.r_z] Z反方向旋转角
     * @param {string} [GroupID] 所在组
     * @param {Boolean} [checked] 是否显示
     * @param {object} [func] 回调函数
     * 
     * @example
     * model = sgworld.Creator.create3DTilesets('新建模型', './static/model/tileset.json');
     */
    Creator.prototype.create3DTilesets = function (name, url, option, style, GroupID, checked, func) {
        var tileset = this._D3Tileset.create3DTilesets(name, url, option, style, GroupID, checked, func);
        if (!this._D3Tilesets) {
            this._D3Tilesets = [];
            this._3DTilesets = [];
        }
        this._D3Tilesets.push(tileset.item);
        return tileset;
    };

    /**
     * 设置所有3dtiles透明度(对3dtiles有特殊颜色设置的不建议使用此方法)。
     * @param {number} [alpha] 透明度。
     *
     */
    Creator.prototype.set3DTilesetsAlpha = function (alpha) {
        this._D3Tilesets && this._D3Tilesets.forEach((tileset) => {
            if (alpha == 0) {
                tileset.style = new Cesium.Cesium3DTileStyle({
                    show: false,
                });
            } else if (alpha == 1) {
                tileset.style = new Cesium.Cesium3DTileStyle({
                    show: true,
                });
            } else {
                tileset.style = new Cesium.Cesium3DTileStyle({
                    color:
                        `color('rgba(255,255,255,${alpha})')`,
                });
            }
        });
    };
    /**
    *  地形压平
    * @param {string} name 名称
    * @param {Array} polygon 压平面坐标串
    * @param {Number} altitude 压平高度
    */
    Creator.prototype.createTerrainModifier = function (name, polygon, altitude) {
        return this._TerrainModifier.createTerrainModifier(name, polygon, altitude);
    };
    /**
    *
    *  创建s3m图层
    * @param {String} url 模型地址
    * @param {Object} scene 地图场景对象
    * @param {Function} func 回调函数
    */
    Creator.prototype.createS3MLayer = function (url, scene, func) {
        let layer = new S3MTilesLayer({
            context: scene._context,
            url: url
        });

        scene.primitives.add(layer);

        layer.readyPromise.then(function () {
            func && func();
        }).otherwise(function (error) {
            console.log(error);
        });
        return layer;
    };

    /**
     * 向三维场景中添加水面图层。
     * @param {Object} [option] 参数。
     * @param {String} [option.id] id（可选）。
     * @param {String} [option.url] geojson路径。
     * @param {String} [option.color="rgba(135,206,235,0.6)"] 水面颜色。
     * @param {String} [option.image] 水面贴图。
     * @param {Number} [option.height] 水面高度，无高度和拉伸高度默认贴地。
     * @param {Number} [option.extrudedHeight] 水面拉伸高度，无高度和拉伸高度默认贴地。
     * @param {Number} [option.frequency=1000] 水波数。
     * @param {Number} [option.speed=10] 流速(m/s)。
     * @param {Number} [option.amplitude=10] 水波幅度。
     * @param {Number} [option.classificationType] 识别的贴地类型。
     * @param {Number} [option.near=0] 最小可视距离。
     * @param {Number} [option.far=Math.MAX_VALUE] 最大可视距离。
     * @returns {WaterGeoJsonFeatureLayer} 返回一个WaterGeoJsonFeatureLayer对象。
     * 
     * @example
     * model = sgworld.Creator.createWaterPolygonLayer({
     *  url: './static/json/changjiang.json',
     *  speed: 5
     * });
     * 
     */
    Creator.prototype.createWaterPolygonLayer = function (option = {}) {
        let water = new WaterGeoJsonFeatureLayer(this._viewer);
        return water.createPolygonLayer(option);
    };

    /**
    * 创建云图
    * @param {string} name 名称
    * @param {object} area 区域范围
    * @param {array} CloudMap 云图, 云图影像数组
    * @param {double} speed 速度
    */
    Creator.prototype.createCloudMap = function (name, area, CloudMap, speed) {
        var polygon = new Polygon(this._viewer, this._cesium);
        return polygon.createCloudMap(name, area, CloudMap, speed);
    };
    /**
     * 向三维场景中视频。
     * @param {Array} [position] 名称。
     * @param {Object} [option] 参数。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.addVideoPolygon = function (position, option) {
        var polygon = new Polygon(this._viewer, this._cesium);
        return polygon.addVideoPolygon(position, option);
    };
    /**
     * 向三维场景中视频。
     * @param {Array} [position] 名称。
     * @param {Object} [option] 参数。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.addVideoBox = function (position, option) {
        var polygon = new Polygon(this._viewer, this._cesium);
        return polygon.addVideoBox(position, option);
    };
    /**
     * 向三维场景中添加CZML。
     * @param {Object} [czml] czml数据。
     * @param {Object} [option] 参数。{
            linkColor: '#0000ff',     //链路线颜色（可选）
            linkPointColor: '#ffffff',  //链路点颜色（可选）
            linkTime: 3000,         //链路时间（可选）
            coneRadarColor: '#0000ff', //卫星雷达颜色（可选）
            multiCircleColor: '#ff0000',    //扩散圆颜色[多环]（可选）
            multiCircleTime: 3000,    //扩散圆时间[多环]（可选）
            sectorScanColor: '#ff0000',    //扇形扩散颜色（可选）
            sectorScanAngle: 45,    //扇形扩散角度（可选）
            circleScanColor: '#ff0000',    //扩散圆颜色（可选）
            circleScanTime: 3000,    //扩散圆时间（可选）
            radarScanColor: '#ff0000',    //雷达扫描颜色（可选）
            radarScanTime: 3000,    //雷达扫描时间（可选）
     * }
     * @param {Function} [callback] 回调函数。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */

    /**
    *
    *  Creator.CZML(czml,option,callback) 向三维场景中添加CZML
    * @version 3.1.0
    * 向三维场景中添加CZML
    * 创建
    * @param {string} czml czml
    * @param {object} option 
    * @param {object} callback function(){} 
    * @example {object} 参数说明
    * 
    *     czml:czml
    *     option:{
            linkColor: '#0000ff',     //链路线颜色（可选）
            linkPointColor: '#ffffff',  //链路点颜色（可选）
            linkTime: 3000,         //链路时间（可选）
            coneRadarColor: '#0000ff', //卫星雷达颜色（可选）
            multiCircleColor: '#ff0000',    //扩散圆颜色[多环]（可选）
            multiCircleTime: 3000,    //扩散圆时间[多环]（可选）
            sectorScanColor: '#ff0000',    //扇形扩散颜色（可选）
            sectorScanAngle: 45,    //扇形扩散角度（可选）
            circleScanColor: '#ff0000',    //扩散圆颜色（可选）
            circleScanTime: 3000,    //扩散圆时间（可选）
            radarScanColor: '#ff0000',    //雷达扫描颜色（可选）
            radarScanTime: 3000,    //雷达扫描时间（可选）
          }
    *     callback:function(){} 
    * @returns 结果:
    *     {
    *          
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.CZML = function (czml, option, callback) {
        let _czml = new CZML(this._viewer, this._cesium);
        return _czml.addCZML(czml, option, callback);
    };
    /**
     * 向三维场景中添加热力图。
     * @param {String} [name] 名称。
     * @param {Object} [option] 参数。
     * @param {String} [option.type='Heatmap'] 热力图类型[Heatmap/HeatmapGL]（可选）。
     * @param {Object} [option.sourceData] 热力图点数据（可选）。
     * @param {Boolean} [option.flyTo=true] 加载数据后定位。
     * @param {Number} [option.radius=50] 半径。
     * @param {Number} [option.alpha=1] 矩形面透明度。
     * @param {Number} [option.height] 矩形面高度，未设置高度则贴地。
     * @param {Boolean} [option.dynamic=false] 动态半径，半径随高度变化而变化，点数多时慎用。
     * @param {Number} [option.minRadius=1] 最小半径，dynamic为true生效。
     * @param {Number} [option.maxRadius=50] 最大半径，dynamic为true生效。
     * @param {Number} [option.minOpacity=0.1] 最小透明度，HeatmapGL无效。
     * @param {Number} [option.maxOpacity=0.8] 最大透明度，HeatmapGL无效。
     * @param {Number} [option.blur=0.85] 模糊系数，模糊系数越高，渐变就越平滑，HeatmapGL无效。
     * @param {Object} [option.gradient={'.3': 'blue','.5': 'green','.7': 'yellow','.95': 'red'}] 渐变色，HeatmapGL无效。
     * @param {Boolean} [option.tooltip=false] 是否显示tooltip，HeatmapGL无效。
     * @returns {Heatmap} 返回一个Heatmap的对象。
     *
     */
    Creator.prototype.addHeatMap = function (name, option) {
        let _Heatmap = new Heatmap(this._viewer, this._cesium);
        return _Heatmap.addHeatMap(name, option);
    };
    //创建军事标绘
    Creator.prototype.militaryPlotting = function (type, type1, optionOrCallBack, callBack2) {
        var straightArrow = this._straightArrow;
        var Arrow = null;
        let option, callBack;
        if (!optionOrCallBack) {
            option = {};
        } else {
            if (typeof optionOrCallBack === 'function') {
                option = {};
                callBack = optionOrCallBack;
            } else {
                option = optionOrCallBack;
                callBack = callBack2;
            }
        }
        let _callback = (entity) => {
            if (straightArrow.MilitaryStandardObj.length && !straightArrow.editHandler) {
                straightArrow.edit(straightArrow.openEdit, straightArrow.editOption);
            } else if (!straightArrow.MilitaryStandardObj.length && straightArrow.editHandler) {
                straightArrow.edit(false);
            }
            callBack && callBack(entity);
        };
        switch (type) {
            case "StraightArrow":
                //粗直箭头
                //type1判断是二维还是三维（polygon,box）
                var Arrow = straightArrow.createStraightArrow(type1, option, _callback);
                break;
            case "SwallowtailArrow":
                //燕尾箭头
                var Arrow = straightArrow.createSwallowtailArrow(type1, option, _callback);
                break;
            case "PincerArrow":
                //钳击箭头
                var Arrow = straightArrow.createPincerArrow(type1, option, _callback);
                break;
            case "AttackArrow":
                //钳击箭头
                var Arrow = straightArrow.createAttackArrow(type1, option, _callback);
                break;
            case "GatheringPlace":
                //集结地
                var Arrow = straightArrow.createHandlerPolygon(type1, option, _callback);
                break;
            case "RoundedRectangle":
                //圆角矩形
                var Arrow = straightArrow.createRoundedRectangle(type1, option, _callback);
                break;
            case "Sector":
                //扇形
                var Arrow = straightArrow.createSector(type1, option, _callback);
                break;
            case "Bow":
                //弓形;
                var Arrow = straightArrow.createBow(type1, option, _callback);
                break;
            case "Bezierline":
                //贝塞尔曲线

                var Arrow = straightArrow.createBezierline(option, _callback);
                break;
            case "BezierArrow":
                //贝塞尔箭头
                var Arrow = straightArrow.createBezierArrow(option, _callback);
                break;
        }
        return Arrow;
    };
    //军事标绘复制
    Creator.prototype.MilitaryCopy = function (obj) {
        var straightArrow = this._straightArrow;
        var Arrow = straightArrow.copyJb(obj);
        return Arrow;
    };
    //夜间模式
    Creator.prototype.NightMode = function (open) {
        let Viewer = this._viewer;
        let num = Viewer.imageryLayers.length;
        let brightness, imageBasedLightingFactor;
        if (open) {
            brightness = 0.15;
            imageBasedLightingFactor = 0.15;
        } else {
            brightness = 1;
            imageBasedLightingFactor = 1;
        }

        for (let i = 0; i < num; i++) {
            Viewer.imageryLayers.get(i).brightness = brightness;
        }

        if (this._D3Tilesets) {
            this._D3Tilesets.forEach(item => {
                item.imageBasedLightingFactor.x = imageBasedLightingFactor;
                item.imageBasedLightingFactor.y = imageBasedLightingFactor;
            });
        }
        Viewer.scene.skyAtmosphere.show = !open;
    };
    //保存军标
    Creator.prototype.SaveMilitaryStandard = function () {
        var straightArrow = this._straightArrow;
        straightArrow.save();
    };
    //打开军标
    Creator.prototype.OpenMilitaryStandard = function (file) {
        var straightArrow = this._straightArrow;
        straightArrow.open(file);
    };
    //清除军标
    Creator.prototype.ClearMilitaryStandard = function () {
        var straightArrow = this._straightArrow;
        straightArrow.clear();
    };
    //军事标绘根据id查询
    Creator.prototype.getEntityById = function (id) {
        var straightArrow = this._straightArrow;
        var Arrow = straightArrow.getEntityById(id);
        return Arrow;
    };
    //军事标绘编辑
    Creator.prototype.startModify = function (type) {
        var straightArrow = this._straightArrow;
        straightArrow.edit(type);
    };

    //矢量标绘编辑
    Creator.prototype.createSimpleGraphic = function (type, option, callback) {
        let _SimpleGraphic = this._SimpleGraphic;
        return _SimpleGraphic.createSimpleGraphic(type, option, callback);
    };

    //添加矢量标绘数据
    Creator.prototype.addSimpleGraphic = function (type, option, callback) {
        let _SimpleGraphic = this._SimpleGraphic;
        return _SimpleGraphic.addSimpleGraphic(type, option, callback);
    };

    //添加天地图三维注记
    Creator.prototype.GeoWTFS = function (option) {
        if (!this._TdtLabel) {
            this._TdtLabel = new TdtLabel(this._viewer, this._cesium);
        }
        return this._TdtLabel.GeoWTFS(option);
    };

    /**
     * 向三维场景中添加视频。
     * 
     * @param {Object} [options] 参数。
     * @param {Cesium.Cartesian3} [options.cameraPosition] 相机位置
     * @param {Cesium.Cartesian3} [options.position] 投射位置
     * @param {Number} [options.alpha=0.7] 透明度
     * @param {String} [options.url] 视频地址
     * @param {String} [options.type='mp4'] 视频类型
     * @param {DOM} [options.video] 视频容器，(可选)
     * @param {Number} [options.horizonAngle=60] 相机水平视角
     * @param {Number} [options.verticalAngle=30] 相机垂直视角
     * @param {Number} [options.offset=0.1] 视频四周羽化比例
     * @param {Number} [options.angleZ=0] 视频在投影面上得旋转角度
     * @param {Number} [options.near=1] 最近投射面距离
     * @param {Number} [options.far=30] 最远投射面距离
     * @param {Boolean} [options.useLine=true] 是否试用辅助线
     * 
     * @returns {Video3D}
     *
     */
    Creator.prototype.Video3D = function (options) {
        let video = new Video3D(this._viewer, this._cesium);
        return video.Video3D(options);
    };
    /**
    *
    *  Creator.createGeoJsonFeatureLayerProviderOptimization(name,geoOptions,styleOption,GroupID,checked,disFnc) 矢量切片面数据加载
    * @version 3.1.0
    * 矢量切片面数据加载
    * 创建
    * @param {string} name 名称
    * @param {object} geoOptions geo参数配置 
    * @param {object} styleOption 样式参数配置 
    * @param {string} GroupID 组编号
    * @param {bool} checked 是否显示
    * @param {object} disFnc function(){} 
    * @example {object} 参数说明
    *       
    *     name：名称
    *     geoOptions:{
    *       url:'请求地址'
    *       layer:'图层'
    *       upperLevelLimit:'最大请求高度'
    *       lowerLevelLimit:'最小请求高度'
    *     }
    *     option: {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
          }
          GroupID：''
          checked:true
    *     disFnc:function(){} 
    * @returns 结果:
    *     {
    *          item:layer
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createGeoJsonFeatureLayerProviderOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.VolumeVectorGeoJsonFeatureLayerOptimization(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    /**
    *
    *  Creator.createGeoJsonFeatureLayerProviderGisOptimization(name,geoOptions,styleOption,GroupID,checked,disFnc) 矢量切片贴地面面数据加载
    * @version 3.1.0
    * 矢量切片贴地面面数据加载
    * 创建
    * @param {string} name 名称
    * @param {object} geoOptions geo参数配置 
    * @param {object} styleOption 样式参数配置 
    * @param {string} GroupID 组编号
    * @param {bool}checked 是否显示
    * @param {object} disFnc function(){} 
    * @example {object} 参数说明
    *       
    *     name：名称
    *     geoOptions:{
    *       url:'请求地址'
    *       layer:'图层'
    *       upperLevelLimit:'最大请求高度'
    *       lowerLevelLimit:'最小请求高度'
    *     }
    *     option: {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
          }
          GroupID：''
          checked:true
    *     disFnc:function(){} 
    * @returns 结果:
    *     {
    *          item:layer
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createGeoJsonFeatureLayerProviderGisOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.VolumeVectorGeoJsonFeatureLayerGisOptimization(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //矢量切片geojson加载优化版(所有数据加载)gisserverWTS

    Creator.prototype.VolumeVectorGeoJsonFeatureLayerGis = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.VolumeVectorGeoJsonFeatureLayerGis(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //矢量切片(点)geojson加载优化版(所有数据加载)gisserverWTS
    Creator.prototype.PointVectorGeoJsonFeatureLayerGis = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.PointVectorGeoJsonFeatureLayerGis(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //矢量切片(线)geojson加载优化版(所有数据加载)gisserverWTS
    Creator.prototype.PolylineVectorGeoJsonFeatureLayerGis = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.PolylineVectorGeoJsonFeatureLayerGis(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //矢量切片geojson加载优化版(所有数据加载)(贴地)
    /**
    *
    *  Creator.createGeoJsonFeatureLayerProviderClassOptimization(name,geoOptions,styleOption,GroupID,checked,disFnc) 矢量切片拉伸面面数据加载
    * @version 3.1.0
    * 矢量切片拉伸面面数据加载
    * 创建
    * @param {string} name 名称
    * @param {object} geoOptions geo参数配置 
    * @param {object} styleOption 样式参数配置 
    * @param {string} GroupID 组编号
    * @param {bool} checked 是否显示
    * @param {object} disFnc function(){} 
    * @example {object} 参数说明
    *       
    *     name：名称
    *     geoOptions:{
    *       url:'请求地址'
    *       layer:'图层'
    *       upperLevelLimit:'最大请求高度'
    *       lowerLevelLimit:'最小请求高度'
    *     }
    *     option: {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
          }
          GroupID：''
          checked:true
    *     disFnc:function(){} 
    * @returns 结果:
    *     {
    *          CloudMap
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createGeoJsonFeatureLayerProviderClassOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.VolumeVectorGeoJsonFeatureLayerClassOptimization(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    /**
    *
    *  Creator.createVolumeVectorGeoJsonFeatureLayerDthOptimization(name,geoOptions,styleOption,GroupID,checked,disFnc) 矢量切片单体化面数据加载
    * @version 3.1.0
    * 矢量切片单体化面数据加载
    * 创建
    * @param {string} name 名称
    * @param {object} geoOptions geo参数配置 
    * @param {object} styleOption 样式参数配置 
    * @param {string} GroupID 组编号
    * @param {bool} checked 是否显示
    * @param {object} disFnc function(){} 
    * @example {object} 参数说明
    *       
    *     name：名称
    *     geoOptions:{
    *       url:'请求地址'
    *       layer:'图层'
    *       upperLevelLimit:'最大请求高度'
    *       lowerLevelLimit:'最小请求高度'
    *     }
    *     option: {
            show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
            level_max: 20,
            level_min: 10,
          }
          GroupID：''
          checked:true
    *     disFnc:function(){} 
    * @returns 结果:
    *     {
    *          item:layer
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createVolumeVectorGeoJsonFeatureLayerDthOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        //return VectorGeoJsonFeatureLayerfr.createVolumeVectorGeoJsonFeatureLayerDthOptimization(name, geoOptions, styleOption, GroupID, checked, disFnc);
        return VectorGeoJsonFeatureLayerfr.VolumeVectorGeoJsonFeatureLayerOptimization1(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //动态单体化测试（2020/7/31）
    Creator.prototype.createVolumeVectorGeoJsonFeatureLayerDthOptimizationtest = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.createVolumeVectorGeoJsonFeatureLayerDthOptimization(name, geoOptions, styleOption, GroupID, checked, disFnc);
        // return VectorGeoJsonFeatureLayerfr.VolumeVectorGeoJsonFeatureLayerOptimization1(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //动态单体化测试（grodprimate服务测试2020/7/31）
    Creator.prototype.VolumeVectorGeoJsonFeatureLayerOptimizationGroundtest = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.VolumeVectorGeoJsonFeatureLayerOptimizationGroundtest(name, geoOptions, styleOption, GroupID, checked, disFnc);
        // return VectorGeoJsonFeatureLayerfr.VolumeVectorGeoJsonFeatureLayerOptimization1(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //动态单体化测试（图片服务2020/7/31）
    Creator.prototype.VolumeVectorGeoJsonFeatureLayerOptimizationtest = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.VolumeVectorGeoJsonFeatureLayerOptimizationtest(name, geoOptions, styleOption, GroupID, checked, disFnc);
        // return VectorGeoJsonFeatureLayerfr.VolumeVectorGeoJsonFeatureLayerOptimization1(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //矢量切片geojson加载优化版(所有数据加载)(单体化基础面，江苏最终版)
    Creator.prototype.createVolumeVectorGeoJsonFeatureLayerJCDthOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.createVolumeVectorGeoJsonFeatureLayerJCDthOptimization(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //矢量切片geojson加载优化版(所有数据加载)(单体化基础面，江苏最终版)xp修改
    Creator.prototype.createVolumeVectorGeoJsonFeatureLayerJCDthOptimizationxp = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.createVolumeVectorGeoJsonFeatureLayerJCDthOptimizationxp(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };

    /**
     * 矢量切片柱状图
     * @param {String} name 图层名
     * @param {Object} geoOptions 图层参数
     * @param {Object} [styleOption] 样式参数
     * @param {Number} [styleOption.radius=50] 柱状图半径
     * @param {Number} [styleOption.scale=1] 柱状图高度倍数
     * @param {Number} [styleOption.alpha=0.5] 底部面透明度
     * @param {String} [styleOption.defaultColor=#ffffff] 默认颜色
     * @param {String|Array} [styleOption.color=#ffffff] 柱状图颜色配置
     * @param {Number|String} [styleOption.height=100] 柱状图高度
     * @param {Boolean} [styleOption.showLabel=true] 显示文本
     * @param {Cesium.LabelGraphics} [styleOption.label] 文本样式
     * @param {String} GroupID 工程树父节点id
     * @param {Boolean} checked 是否显示
     * @param {Function} disFnc 回调函数
     */
    Creator.prototype.createHistogramVectorGeoJsonFeatureLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.createHistogramVectorGeoJsonFeatureLayer(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };

    /**
     * 矢量切片分层设色
     * @param {String} name 图层名
     * @param {Object} geoOptions 图层参数
     * @param {Object} [styleOption] 样式参数
     * @param {Number} [styleOption.type="2D"] 分层设色类型【2D | 3D】
     * @param {Number|String} [styleOption.height=100] 拉伸高度，仅在3D有效
     * @param {Number} [styleOption.scale=1] 拉伸高度倍数
     * @param {Number} [styleOption.alpha=0.5] 面透明度
     * @param {String} [styleOption.defaultColor=#ffffff] 默认颜色
     * @param {String|Array} [styleOption.color=#ffffff] 颜色配置
     * @param {String} GroupID 工程树父节点id
     * @param {Boolean} checked 是否显示
     * @param {Function} disFnc 回调函数
     */
    Creator.prototype.createLaycolorVectorGeoJsonFeatureLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.createLaycolorVectorGeoJsonFeatureLayer(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };

    /**
     * 矢量切片3dtiles模型
     * @param {String} name 图层名
     * @param {Object} [geoOptions] 图层参数
     * @param {String} geoOptions.url 地址模板
     * @param {Number} [geoOptions._x=0] x偏移量
     * @param {Number} [geoOptions._y=0] y偏移量
     * @param {Object} [styleOption] 样式参数
     * @param {String} [styleOption.color=#ffffff] 颜色
     * @param {Number} [styleOption.level_max=20] 最大显示级别
     * @param {Number} [styleOption.level_min=10] 最小显示级别
     * @param {Cesium.TilingScheme} [styleOption.tilingScheme=Cesium.WebMercatorTilingScheme] 切片方式
     * @param {String} GroupID 工程树父节点id
     * @param {Boolean} checked 是否显示
     * @param {Function} disFnc 回调函数
     */
    Creator.prototype.createVector3DTilesFeatureLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.createVector3DTilesFeatureLayer(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };

    //json转图片测试
    Creator.prototype.createGeojsonImage = function (url) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        return VectorGeoJsonFeatureLayerfr.createGeojsonImage(url);
    };
    //矢量切片geojson加载(所有数据加载)
    Creator.prototype.createGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var VectorGeoJsonFeatureLayerfr = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return VectorGeoJsonFeatureLayerfr.VectorGeoJsonFeatureLayer(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //geojson加载数据（所有数据加载）
    Creator.prototype.createGeojsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createGeojsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);

    };
    //山东kml
    Creator.prototype.createGeojsonKmlFeatureLayer = function (name, geojsonOrurl, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createGeojsonKmlFeatureLayer(name, geojsonOrurl, GroupID, checked, disFnc);

    };
    /**
    *
    *  Creator.sfsterrainprovider(name,option,GroupID,checked,Description) sgs地形加载
    * @version 3.1.0
    *  sgs地形加载
    * 创建
    * @param {string} name 名称
    * @param {object} option option 
    * @param {string} GroupID 组编号
    * @param {bool} checked 是否显示
    * @param {string} Description ''
    * @example {object} 参数说明
    *       
    *     name：名称
    *     option:{
            url: url,
            layerName: layerName,
            requestVertexNormals: requestVertexNormals,
            token: token
        }
          GroupID：''
          checked:true
    *     Description:''
    * @returns 结果:
    *     {
    *          item:layer
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.sfsterrainprovider = function (name, option, GroupID, checked, Description) {
        var terrain = new Terrain(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return terrain.createSFSTerrain(name, option, GroupID, checked, Description);
    };
    /**
     * 加载sgs7.1地形
     * @param {*} name 
     * @param {*} option 
     * @param {*} GroupID 
     * @param {*} checked 
     * @param {*} Description 
     */
    Creator.prototype.sfsterrainprovider71 = function (name, option, GroupID, checked, Description) {
        var terrain = new Terrain(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return terrain.createSFSTerrain71(name, option, GroupID, checked, Description);
    };
    /**
     * 创建地形
     *
     * @param {string} [name] 名称
     * @param {string} [url] 路径
     * @param {string} [option] 地址
     * @param {string} [GroupID] 所在组
     * @param {string} [Description] 描述
     */

    /**
    *  Creator.createTerrain(name,option,GroupID,checked,Description) 创建地形
    * @version 3.1.0
    * 创建地形
    * 创建
    * @param {string} name 名称
    * @param {object} option option 
    * @param {string} GroupID 组编号
    * @param {bool} checked 是否显示
    * @param {string} Description ''
    * @example {object} 参数说明
    *     name：名称
    *     option:{
             url: "",//	Resource | String | Promise.<Resource> | Promise.<String>		The URL of the Cesium terrain server.
            requestVertexNormals: false,//	optional Flag that indicates if the client should request additional lighting information from the server, in the form of per vertex normals if available.
            requestWaterMask: false,//	optional Flag that indicates if the client should request per tile water masks from the server, if available.
            requestMetadata: true,//	optional Flag that indicates if the client should request per tile metadata from the server, if available.
            credit: "",//	optional A credit for the data source, which is displayed on the canvas.
          }
          GroupID：''
          checked:true
    *     Description:''
    * @returns 结果:
    *     {
    *          item:layer
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createTerrain = function (name, option, GroupID, checked, Description) {
        var terrain = new Terrain(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return terrain.createTerrain(name, option, GroupID, checked, Description);
    };
    /**
     * 创建地形
     *
     * @param {string} [name] 名称
     * @param {string} [url] 路径
     * @param {string} [option] 地址
     * @param {string} [GroupID] 所在组
     * @param {string} [Description] 描述
     */
    Creator.prototype.createTerrainLayer = function (name, option, GroupID, checked, Description, lex) {
        var terrain = new Terrain(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return terrain.createTerrainLayer(name, option, GroupID, checked, Description, lex);
    };
    /**
     * ArcGIS创建地形
     *
     * @param {string} [name] 名称
     * @param {string} [url] 路径
     * @param {string} [option] 地址
     * @param {string} [GroupID] 所在组
     * @param {string} [Description] 描述
     */
    Creator.prototype.createArcGISTerrain = function (name, option, GroupID, checked, Description) {
        var terrain = new Terrain(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return terrain.createArcGISTerrain(name, option, GroupID, checked, Description);
    };
    /**
     * 创建Cesium全球地形
     *
     * @param {string} [name] 名称
     * @param {string} [url] 路径
     * @param {string} [option] 地址
     * @param {string} [GroupID] 所在组
     */
    Creator.prototype.createCesiumTerrain = function (name, option, GroupID, checked) {
        var terrain = new Terrain(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return terrain.createCesiumTerrain(name, option, GroupID, checked);
    };

    /**
     * 浏览方式:开始浏览
     */

    Creator.prototype.createDynamicObject = function (pathsData, url, fun) {
        return this._createdynamicObject.Start(pathsData, url, fun);
    };
    /**
     * 浏览方式:添加对象
     */
    Creator.prototype.addmodle = function (url) {
        return this._createdynamicObject.addmodle(url);
    };
    /**
    * 创建卫星轨迹
    * @param {Object} [option] 参数。{
        start: new Cesium.JulianDate(),     //起始时间（可选）
        stop: new Cesium.JulianDate(),     //结束时间（可选）
        speed: 2,     //倍速（可选）
        path: [],    //路径数据（可选）
        radarColor: "#00ff00",   //雷达颜色（可选）
        height: 700000,   //卫星高度（可选）
        width: 5,        //轨迹宽度（可选）  
        model: 'a.gltf',  //卫星模型（可选）
        img:'a.png',   //卫星图标（可选）
        scale: 1,    //卫星比例
    * }
    */
    Creator.prototype.createSatelliteTrail = function (option) {
        let _SatelliteTrail = new SatelliteTrail(this._viewer, this._cesium);
        return _SatelliteTrail.createSatelliteTrail(option);
    };

    /**
    *  Creator.executeSignout()  浏览方式:暂停浏览
    * @version 3.1.0
    * 暂停浏览
    * 创建
    * @returns 结果:
    *     {
    *          
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.executePauseFly3DPaths = function () {
        return this._createdynamicObject.executePauseFly3DPaths();
    };

    /**
    *  Creator.executeSignout()  浏览方式:向前飞行漫游路径
    * @version 3.1.0
    * 向前飞行漫游路径
    * 创建
    * @returns 结果:
    *     {
    *          
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.executePlayForwardFly3DPaths = function () {
        return this._createdynamicObject.executePlayForwardFly3DPaths();
    };

    /**
    *  Creator.executeSignout()  浏览方式:向后飞行漫游路径
    * @version 3.1.0
    * 向后飞行漫游路径
    * 创建
    * @returns 结果:
    *     {
    *          
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.executePlayReverseFly3DPaths = function () {
        return this._createdynamicObject.executePlayReverseFly3DPaths();
    };

    /**
    *  Creator.executeSignout()  浏览方式:退出飞行漫游路径
    * @version 3.1.0
    * 退出飞行漫游路径
    * 创建
    * @returns 结果:
    *     {
    *          
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.executeSignout = function () {
        return this._createdynamicObject.executeSignout();
    };
    /**
     * 创建label标签
     * @param {Array} [position] 一个经纬度数组[x,y]。
     * @param {String} [text] 文本。
     * @param {Object} [labelStyle] 标签样式（例如，颜色，字体和可视距离属性）。
     * @param {String} [GroupID] 所在组编号
     * @param {String} [Description] 描述
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */

    /**
    *
    *  Creator.createLabel(position,text,labelStyle,GroupID,Description) 创建label标签
    * @version 3.1.0
    * 创建label标签
    * 创建
    * @param {Array} position 一个经纬度数组[x,y]。
    * @param {String} text 文本。
    * @param {Object} labelStyle 文本样式
    * @param {String} GroupID 组编号
    * @param {String} Description 描述
    * @example {object} 参数说明
    * 
    *     position:[]
    *     text:'text'
    *     labelStyle:{
            id: '', //获取或设置拾取标签时返回的用户定义值。
            text: Texts, //文本
            backgroundColor: LabelStyle.BackgroundColor, //获取或设置此标签的背景色。
            font: LabelStyle.FontName,
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER,
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,
            show: true,
            scale: LabelStyle.Scale,
            showBackground: false,
            distanceDisplayCondition: new this._cesium.DistanceDisplayCondition(LabelStyle.MinViewingHeight, LabelStyle.MaxViewingHeight)
          }
    * @returns 结果:
    *     {
    *          label
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createLabel = function (position, text, labelStyle, GroupID, Description) {
        var label = new Label(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return label.createLabel(position, text, labelStyle, GroupID, Description);
    };
    /**
    *
    *  Creator.createPosition(x,y,z) 创建position
    * @version 3.1.0
    *  创建position
    * 创建
    * @param {String} x 
    * @param {String} y
    * @param {String} z 
    * @example {object} 参数说明
    *    x
    *    y
    *    z
    * @returns 结果:
    *     {
    *          position
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createPosition = function (x, y, z) {
        var position = new Position(this._viewer, this._cesium);
        return position.createPosition(x, y, z);
    };

    /**
    *
    *  Creator.createLocation(name,position,GroupID) 向三维场景中添加一个兴趣点
    * @version 3.1.0
    *  向三维场景中添加一个兴趣点
    * 创建
    * @param {String} x 
    * @param {String} y
    * @param {String} z 
    * @example {object} 参数说明
    *    name
    *    position
    *    GroupID
    * @returns 结果:
    *     {
    *          location
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createLocation = function (name, position, GroupID) {
        return this._Point.createLocation(name, position, GroupID);
    };
    /**
     * 创建label标签
     * @param {String} [name] 文本
     * @param {Array} [position] 一个经纬度数组[x,y,z]。
     * @param {String} [fillColor] 颜色 #fff
     * @param {String} [GroupID] 所在组编号
     * @param {Object} [option] 参数
     * @param {String} [Description] 描述
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */

    Creator.prototype.createPoint = function (name, position, fillColor, option, GroupID, Description) {
        //var point = new Point(this._viewer, this._cesium);
        //if (this._core.isnull(GroupID) && !this._core.isnull(treeSource.selectedItem) && treeSource.selectedItem.type == 'group')
        //    GroupID = treeSource.selectedItem.id;
        //GroupID = this._core.isnull(GroupID) ? 0 : GroupID
        //return point.createPoint(name, position, fillColor, GroupID, Description);
        return this._Point.createPoint(name, position, fillColor, option, GroupID, Description);
    };
    /**
    *
    *  Creator.createLonlat(method) 获取点击点坐标
    * @version 3.1.0
    *  获取点击点坐标
    * 创建
    * @param {object} method
    * @example {object} 参数说明
    *    function ({
                lng: lng,
                lat: lat,
                height: height
            }){}
    * @returns 结果:
    *     {
    *         
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createLonlat = function (method) {
        return this._Point.createLonlat(method);
    };

    /**
     * 向三维场景中添加一个div点。
     * @param {String} [name] 名称。
     * @param {Object} [degrees] 经纬度
     * @param {Object} [option] 参数
     * @param {String} [option.id] id
     * @param {String} [option.GroupID] GroupID
     * @param {String} [option.type="default"] 类型【default | custom】
     * @param {String|Array} [option.offset="l"] 对齐方式【左: l | 中: c | 右: r | [左|中|右, 20]】
     * @param {String} [option.description] 内容
     * @param {Number} [option.near=0] 最小可视距离
     * @param {Number} [option.far=Infinity] 最大可视距离
     * @param {Function} [option.onclick] 点击事件
     * @param {Function} [option.update] 更新事件
     * @returns {DivPoint} 返回DivPoint对象
     *
     */
    Creator.prototype.createDivPoint = function (name, position, option) {
        let divPoint = new DivPoint(this._viewer);
        return divPoint.createDivPoint(name, position, option);
    };
    /**
     * 向三维场景中添加一个富文本点。
     * @param {String} [Content] 内容。
     * @param {Array} [position] 一个经纬度数组 例如：[x, y, z]。
     * @param {Object} [option] 参数。{
     *     fontColor:颜色，
     *     fontSize:字体大小
     *     ...
     * }
     * @param {String} [GroupID] GroupID。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createRichTextPoint = function (Content, position, option, GroupID) {
        return this._Point.createRichTextPoint(Content, position, option, GroupID);
    };
    /**
     * 创建天空盒子
     * @param {Boolean} [NearGround] 是否近地。
     * @param {Object} [Images] 天空盒子图。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.SkyBox = function (NearGround, Images) {
        return this._skyBox.SkyBox(NearGround, Images);
    };
    /**
    *
    *  Creator.setSpaceBackground(URL)  设置空间背景
    * @version 3.1.0
    *   设置空间背景
    * 创建
    * @param {String} URL
    * @example {object} 参数说明
    *    URL
    * @returns 结果:
    *     {
    *          
    *     }
    * @exception {json} 异常:
    *     exception:{}
    */
    Creator.prototype.setSpaceBackground = function (URL) {
        return this._skyBox.setSpaceBackground(URL);
    };
    /**
     * 这个方法用于添加风场
     *@param {string} [url] 风场配置文件url
     *@param {Object} [option] 参数。{
     *     color:颜色，默认'#ffffff'
     *     speed:速度，默认0.15
     *     num:粒子数，默认2000
     *     maxAge:最大存活时间，默认10
     *     brighten:亮度，默认1.5
     *}
     */
    Creator.prototype.createWindField = function (url, option) {
        return this._flowField.createWindField(url, option);
    };

    /**
     * 向三维场景中添加道路
     * @param {Object} [option] 参数。
     * @param {String} [option.id] id（可选）。
     * @param {Array} option.positions 道路点
     * @param {String} [option.image] 贴图。
     * @param {Number} [option.alpha=1.0] 透明度。
     * @param {Number} [option.width=20] 道路宽。
     * @param {Number} [option.height=1] 道路高。
     * @returns {Road} 返回一个Road对象。
     *
     */
    Creator.prototype.createRoad = function (option = {}) {
        let road = new Road(this._viewer);
        return road.createRoad(option);
    };

    /**
     * 向三维场景中添加流动路径。
     * @param {Object} [center] 中心。
     * @param {Array} [positions] 周围点。
     * @param {Number} [timeOrOption] 持续时间。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createTrailLinePath = function (center, positions, timeOrOption) {
        return this._trailLine.createPath(center, positions, timeOrOption);
    };
    /**
     * 向三维场景中添加垂直飞线。
     * @param {Array} [positions] 飞线点。
     * @param {Object} [option] 参数{
         time:3000,    //时间（可选）
         width: 2,     //线宽（可选）
         color: '#ffffff',  //线颜色（可选）
         alpha: 0.01,  //线透明度（可选）
         minHeight: 0,  //起始高度（可选）
     * }。
     * @returns {TrailLine} 返回一个TrailLine对象。
     *
     */
    Creator.prototype.createFlyingLine = function (positions, option) {
        return this._trailLine.createFlyingLine(positions, option);
    };
    /**
     * 向三维场景中添加流动墙。
     * @param {Array} [Geometry] 坐标。
     * @param {Number} [time] 持续时间。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createTrailLineWall = function (Geometry, time) {
        return this._trailLine.createWall(Geometry, time);
    };
    /**
     * 向三维场景中添加流动线。
     * @param {Array} [Geometry] 坐标。
     * @param {Number} [timeOrOption] 持续时间。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createTrailLine = function (Geometry, timeOrOption) {
        return this._trailLine.createLine(Geometry, timeOrOption);
    };
    /**
     * 创建模型
     * @param {Array} [Position] 一个经纬度数组 例如：[x, y, z]。
     * @param {String} [FileName] 想要加载模型的完整路径名或URL。
     * @param {Object} [Option] 模型参数。
     * @param {String} [GroupID] 组的ID，模型在该组中被创建。如果GroupID设置为零，则对象在根节点下创建。
     * @param {String} [Description] 显示在信息树中模型的名称。
     * @param {function} [callback] 回调函数。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.createModel = function (Position, FileName, Option, GroupID, Description, callback) {
        var pointModel = new PointModel(this._viewer, this._cesium);
        return pointModel.createModel(Position, FileName, Option, GroupID, Description, callback);
    };
    /**
    * 创建模型(标绘模型)
    * @param {Array} [Position] 一个经纬度数组 例如：[x, y, z]。
    * @param {String} [FileName] 想要加载模型的完整路径名或URL。
    * @param {Object} [Option] 模型参数。
    * @param {String} [GroupID] 组的ID，模型在该组中被创建。如果GroupID设置为零，则对象在根节点下创建。
    * @param {String} [Description] 显示在信息树中模型的名称。
    * @param {function} [callback] 回调函数。
    * @returns {Promise.<Object>} 返回一个Cesium的对象。
    */
    Creator.prototype.createModelEditable = function (Position, FileName, Option, GroupID, Description, callback) {
        var pointModel = new PointModel(this._viewer, this._cesium);
        return pointModel.createModelEditable(Position, FileName, Option, GroupID, Description, callback);
    };
    /**
     * 创建点模型
     * @param {object} [parameter] 参数对象。
     * @param {methond} [function] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.createPointModel = function (parameter, methond) {
        return this._PointModel.createPointModel(parameter, methond);
    };
    Creator.prototype.executePolyline = function (method) {
        var polyline = new Polyline(this._viewer, this._cesium);
        return polyline.executePolyline(method);
    };
    Creator.prototype.executePolygon = function (method) {
        var polygon = new Polygon(this._viewer, this._cesium);
        return polygon.executePolygon(method);
    };
    Creator.prototype.executeWall = function (name, GroupID) {
        var walls = new wall(this._viewer, this._cesium);
        return walls.executeWall(name, GroupID);
    };
    //创建墙
    Creator.prototype.createWall = function (name, Geometry, options, GroupID) {
        var walls = new wall(this._viewer, this._cesium);
        return walls.createWall(name, Geometry, options, GroupID);
    };
    Creator.prototype.executePolyline1 = function (m) {
        var polyline = new Polyline(this._viewer, this._cesium);
        return polyline.executePolyline1(method);
    };
    //创建走廊
    Creator.prototype.createPolylineVolume = function (name, Geometry, type, options, GroupID) {
        var polylineVolume = new PolylineVolume(this._viewer, this._cesium);
        return polylineVolume.createPolylineVolume(name, Geometry, type, options, GroupID);
    };
    /**
     * 创建走廊
     * 
     * @param {string} [name] 名称
     * @param {object} [options] 名称
     */
    Creator.prototype.createCorridor = function (name, Geometry, options, GroupID) {
        var corridor = new Corridor(this._viewer, this._cesium);
        return corridor.createCorridor(name, Geometry, options, GroupID);
    };

    /**
    *
    *  Creator.addViewCone(option) 添加视锥
    * @version 3.1.0
    *  添加视锥
    * 创建
    * @param {object} option
    * @example {object} 参数说明
    * {
        *position: this._viewer.camera.position.clone(),
        *heading: 0,
        *pitch: 0,
        *roll: 0,
        *fov: 60,
        *near: 1.0,
        *far: 60,
        *fillColor: 'rgba(0,255,0,0.1)',
        *outlineColor: 'rgba(0,255,0,1)',
    *}
    * @returns 结果:
    *cone
    * @exception {json} 异常:
    *exception:{}
    */
    Creator.prototype.addViewCone = function (option) {
        let _ViewCone = new ViewCone(this._viewer, this._cesium);
        return _ViewCone.addViewCone(option);
    };
    /**
    * 创建视锥
    * 
    * @param {object} [options] 参数
    * @param {function} [callBack] 回调
    */
    Creator.prototype.createViewCone = function (option, callBack) {
        let _ViewCone = new ViewCone(this._viewer, this._cesium);
        return _ViewCone.createViewCone(option, callBack);
    };
    /**
    * 模型压平
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    Creator.prototype.createModifyMesh = function (name, polygon, altitude, meshObject, options) {
        // var modifymesh = new ModifyMesh(this._viewer, this._cesium);
        // return modifymesh.createModifyMesh(name, polygon, altitude, meshObject, options);

        return this.createModelClipping(meshObject, {
            type: "polygon",
            isInner: true,
            positions: polygon
        })
    };
    /**
    * 模型裁剪
    * 
    * @param {object} [options] 名称
    */
    Creator.prototype.createModelClipping = function (tileset, option) {
        var modelClipping = new ModelClipping(this._viewer, this._cesium);
        return modelClipping.addClipping(tileset, option);
    };
    /**
    * 模型压平(遍历所有模型)
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    Creator.prototype.createModelModifier = function (name, polygon, altitude, options) {
        let Modifier = [];
        this._D3Tilesets && this._D3Tilesets.forEach((item, index) => {
            let t = this.createModifyMesh(name, polygon, altitude, item, options);
            Modifier.push(t);
        });
        return {
            remove: () => {
                Modifier.forEach((item, index) => {
                    item.remove();
                });
                Modifier = [];
            }
        };
    };
    /**
    * 创建弹框
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    Creator.prototype.createPopupMessage = function (name) {
        var popupmessage = new PopupMessage(this._viewer, this._cesium);
        return popupmessage.createPopupMessage(name);
    };
    /**
     * 创建测量弹框
     * 
     * @param {string} [name] 名称
     * @param {object} [options] 名称
     */
    Creator.prototype.createMeasurement = function (name) {
        var popupmessage = new PopupMessage(this._viewer, this._cesium);
        return popupmessage.createMeasurement(name);
    };
    /**
    * 创建标绘弹框
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    Creator.prototype.createPlotting = function (name) {
        var popupmessage = new PopupMessage(this._viewer, this._cesium);
        return popupmessage.createPlotting(name);
    };
    /**
    * 创建entity属性弹窗
    * createMeasurement
    * @param {string} [name] 名称
    * @param {object} [options] 参数。{
        width:宽度
        height:高度
        type:类型（GroundPolygon/ExtrudedPolygon）
        fn:回调函数对象。{
            cancel:关闭
            success:成功
            end:销毁
        }
    * }
    */
    Creator.prototype.createPopupProp = function (name, options) {
        return this._popupmessage.createPopupProp(name, options);
    };
    /**
    * 创建模型库弹窗
    * @param {object} [options] 参数。{
        width:宽度
        height:高度
        fn:回调函数对象。{
            cancel:关闭
            success:成功
            end:销毁
        }
    * }
    */
    Creator.prototype.createModelLibrary = function (options) {
        return this._popupmessage.createModelLibrary(options);
    };
    /**
    * 创建鹰眼
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    Creator.prototype.createHawkeye = function (options, style) {
        var hawkeye = new Hawkeye(this._viewer, this._cesium);
        return hawkeye.createHawkeye(options, style);
    };
    /**
    * 创建军标
    * 
    * @param {string} [name] 名称
    * @param {object} [options] 名称
    */
    //Creator.prototype.createHawkeye = function (options, style) {
    //    var hawkeye = new Hawkeye(this._viewer, this._cesium);
    //    return hawkeye.createHawkeye(options, style);
    //}

    /**
    *
    *  Creator.createGeoJsonFeatureLayer(name,geojsonOrurl,option,GroupID,disFnc) 创建geofeaturelayer
    * @version 3.1.0
    *  创建geofeaturelayer
    * 创建
    * @param {String} name
    * @param {String} geojsonOrurl
    * @param {object} option
    * @param {object} GroupID
    * @param {object} disFnc
    * @example {object} 参数说明
    *       name: this._viewer.camera.position.clone(),
            geojsonOrurl: 0,
            option: {
                "layertype": "",                     //图层类型
                "text": "",                      //显示的文本
                "font": "16px",                     //字体
                "fillColor": this._cesium.ALICEBLUE,//字体填充颜色
                "outlineColor": this._cesium.BLACK, //边框颜色
                "outlineWidth": "1.0",              //边框宽度
                "scale": "1.0",                     //缩放
                "maxDistanceDisplay": 55555555,     //最大可视化距离
                "minDistanceDisplay": 5000,         //最小可视化距离
                "icon": ""                       //显示的图标
            },
            GroupID: 0,
            disFnc:function(){}
    * @returns 结果:
    *     {
    *          item:layer
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, disFnc);
    };
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *      image: "",//	Property		optional A Property specifying the Image, URI, or Canvas to use for the billboard.
             show: true,//	optional A boolean Property specifying the visibility of the billboard.
            scale: 1.0,//optional A numeric Property specifying the scale to apply to the image size.
            horizontalOrigin: this._cesium.HorizontalOrigin.CENTER,//	optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
            rotation: 0,//	optional A numeric Property specifying the rotation about the alignedAxis.
            alignedAxis: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the unit vector axis of rotation.
            width: undefined,//		optional A numeric Property specifying the width of the billboard in pixels, overriding the native size.
            height: undefined,//		optional A numeric Property specifying the height of the billboard in pixels, overriding the native size.
            color: this._cesium.Color.WHITE,//	optional A Property specifying the tint Color of the image.
            heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createBillboardGeoJsonFeature = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createBillboardGeoJsonFeature(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    Creator.prototype.createBillboardPointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var billboardGeoJsonFeatureLayer1 = new billboardGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return billboardGeoJsonFeatureLayer1.createBillboardPointGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, disFnc);
    };
    //添加kml服务(自定义)
    Creator.prototype.createKmlLayer = function (url, modelurl, lex) {
        var kmlLayer = new KmlLayer(this._viewer, this._cesium);
        return kmlLayer.createKmlLayer(url, modelurl, lex);
    };
    //添加kml服务
    Creator.prototype.addKmlLayer = function (name, url, checked, callback) {
        var kmlLayer = new KmlLayer(this._viewer, this._cesium);
        return kmlLayer.addKmlLayer(name, url, checked, callback);
    };
    //pbf
    Creator.prototype.createVolumeVectorGeoJsonFeatureLayerArcgis = function (layername, url, option, GroupID, disFnc) {
        var polygonVectorTileLayerArcgis = new PolygonVectorTileLayerArcgis(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polygonVectorTileLayerArcgis.createVolumeVectorGeoJsonFeatureLayer(layername, url, option, GroupID, disFnc);
    };

    Creator.prototype.createBillboardGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var billboardGeoJsonFeatureLayer1 = new billboardGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return billboardGeoJsonFeatureLayer1.createBillboardGeoJsonFeatureLayerProvider(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    /**
     * 创建pointGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
            color: this._cesium.Color.WHITE,//	optional A Property specifying the Color of the point.
            pixelSize: 1,//optional A numeric Property specifying the size in pixels.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the Color of the outline.
            outlineWidth: 0,//	optional A numeric Property specifying the the outline width in pixels.
            show: true,//	optional A boolean Property specifying the visibility of the point.
            near: 0,
            far: 5000
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createPointGeojsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createPointGeojsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };

    /**
     * 创建modelGeofeaturelayer
     */
    Creator.prototype.createModelGeojsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createModelGeojsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };

    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *       radius:1,
             height: 0,
            heightReference: this._cesium.HeightReference.NONE,
            extrudedHeight: 0,
            extrudedHeightReference: this._cesium.HeightReference.NONE,
            show: true,
            fill: true,
            material: this._cesium.Color.WHITE,
            outline: false,
            outlineColor: this._cesium.Color.BLACK,
            outlineWidth: 1,
            near: 0,
            far: 5000
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createCirclePointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createCirclePointGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, disFnc);
    };
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *         uri: "glb/gltf",
        show: true,//	optional A boolean Property specifying the visibility of the model.
        scale: 1.0,	//optional A numeric Property specifying a uniform linear scale.
        minimumPixelSize: 0.0,//	optional A numeric Property specifying the approximate minimum pixel size of the model regardless of zoom.
        incrementallyLoadTextures: true,//optional Determine if textures may continue to stream in after the model is loaded.
        runAnimations: true,//	optional A boolean Property specifying if glTF animations specified in the model should be started.
        clampAnimations: true,//	optional A boolean Property specifying if glTF animations should hold the last pose for time durations with no keyframes.
        shadows: this._cesium.ShadowMode.ENABLED,//	optional An enum Property specifying whether the model casts or receives shadows from each light source.
        heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.

        color: this._cesium.Color.WHITE,//	optional A Property specifying the Color that blends with the model's rendered color.
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createModelPointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createModelPointGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *      Name: "",
            text: "",
            font_size: '30px',
            font_family:'sans-serif'
            stylet: this._cesium.LabelStyle.FILL,
            fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
            outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
            outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
            show: true,//	optional A boolean Property specifying the visibility of the label.
            showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
            backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
            backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
            scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
            horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
            verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
            eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
            pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
            heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
            near: 0,
            far: 5000
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */

    Creator.prototype.createPrimitivLabelPointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        //var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayer(this._viewer, this._cesium);
        var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createLabelPointGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, disFnc);
    };
    Creator.prototype.createLabelPointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createLabelPointGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    Creator.prototype.createSXTLabelGeoJsonFeatureLayerProvider = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createSXTLabelGeoJsonFeatureLayerProvider(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    Creator.prototype.createCustomCallbackGeoJsonFeatureLayerProvider = function (name, geojsonOrurl, option, GroupID, checked, customDataCallback, disFnc) {
        var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createCustomCallbackGeoJsonFeatureLayerProvider(name, geojsonOrurl, option, GroupID, checked, disFnc, customDataCallback);
    };
    //lable点聚合demo
    Creator.prototype.createLabelPolymerizationGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        //var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayer(this._viewer, this._cesium);
        var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createLabelPolymerizationGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, disFnc);
    };
    //point点聚合demo
    Creator.prototype.createPointPolymerizationGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        //var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayer(this._viewer, this._cesium);
        var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createPointPolymerizationGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    //lable聚合
    Creator.prototype.createLabelpolymerizationGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        //var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayer(this._viewer, this._cesium);
        var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createLabelpolymerizationGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    //lable聚合完善版
    Creator.prototype.createLabelpolymerizationGeoJsonFeatureLayers = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        //var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayer(this._viewer, this._cesium);
        var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createLabelpolymerizationGeoJsonFeatureLayers(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //街景
    Creator.prototype.createStreetscapeGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createStreetscapeGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    //lable矢量
    Creator.prototype.createPrimitiveLabelGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        //var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayer(this._viewer, this._cesium);
        var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createLabelGeoJsonFeatureLayerProvider(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //lable+image矢量
    Creator.prototype.createLabelImageGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        //var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayer(this._viewer, this._cesium);
        var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createLabelImageGeoJsonFeatureLayerProvider(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //lable+image矢量
    Creator.prototype.createLabelImageGeoJsonFeatureLayerProvider1 = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        //var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayer(this._viewer, this._cesium);
        var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createLabelImageGeoJsonFeatureLayerProvider1(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };

    //lable富文本geojson
    Creator.prototype.createLabelRichtextGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        //var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayer(this._viewer, this._cesium);
        var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayercopy(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createLabelRichtextGeoJsonFeatureLayerProvider(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //model矢量
    Creator.prototype.createModelGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        // var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayer(this._viewer, this._cesium);
        var labelGeoJsonFeatureLayer = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;

        // return labelGeoJsonFeatureLayer.createModelGeoJsonFeatureLayerProvider0813(name, geoOptions, styleOption, GroupID, checked, disFnc);
        return labelGeoJsonFeatureLayer.createModelGeoJsonFeatureLayerProvider(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //point矢量
    Creator.prototype.createPointGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        // var labelGeoJsonFeatureLayer = new LabelGeoJsonFeatureLayer(this._viewer, this._cesium);
        var labelGeoJsonFeatureLayer = new VectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return labelGeoJsonFeatureLayer.createPointGeoJsonFeatureLayerProvider(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };

    /**
    *
    *  Creator.createArcGisImageryLayer(name,option,GroupID,index,checked,disFnc) 创建arcimagelayer图层
    * @version 3.1.0
    *  创建imagelayer图层
    * 创建
    * @param {String} name
    * @param {object} option
    * @param {object} GroupID
    * @param {object} index
    * @param {bool} checked
    * @param {object} disFnc
    * @example {object} 参数说明
    *       name: this._viewer.camera.position.clone(),
            option: {
                url: "",//The URL of the ArcGIS MapServer service.
                token: "",//		optional The ArcGIS token used to authenticate with the ArcGIS MapServer service.
                usePreCachedTilesIfAvailable: true,//	optional If true, the server's pre-cached tiles are used if they are available. If false, any pre-cached tiles are ignored and the 'export' service is used.
                layers: "",//		optional A comma-separated list of the layers to show, or undefined if all layers should be shown.
                enablePickFeatures: true,//optional If true, ArcGisMapServerImageryProvider#pickFeatures will invoke the Identify service on the MapServer and return the features included in the response. If false, ArcGisMapServerImageryProvider#pickFeatures will immediately return undefined (indicating no pickable features) without communicating with the server. Set this property to false if you don't want this provider's features to be pickable. Can be overridden by setting the ArcGisMapServerImageryProvider#enablePickFeatures property on the object.
                rectangle: this._cesium.Rectangle.MAX_VALUE,//	optional The rectangle of the layer. This parameter is ignored when accessing a tiled layer.
                tilingScheme: new this._cesium.GeographicTilingScheme(),//	optional The tiling scheme to use to divide the world into tiles. This parameter is ignored when accessing a tiled server.
                credit: "",//	optional A credit for the data source, which is displayed on the canvas. This parameter is ignored when accessing a tiled server.
                tileWidth: 256,//	optional The width of each tile in pixels. This parameter is ignored when accessing a tiled server.
                tileHeight: 256,//	optional The height of each tile in pixels. This parameter is ignored when accessing a tiled server.
            },
            GroupID: 0,
            disFnc:function(){}
    * @returns 结果:
    *     {
    *          item:layer
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createArcGisImageryLayer = function (name, option, GroupID, index, checked, disFnc) {
        var imageryLayer = new ImageryLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return imageryLayer.createArcGisImageryLayer(name, option, GroupID, index, checked, disFnc);
    };
    Creator.prototype.createImageryLayerGrid = function (option) {
        var imageryLayer = new ImageryLayer(this._viewer, this._cesium);
        return imageryLayer.createImageryLayerGrid(option);
    };
    /**
    *
    *  Creator.createWebMapServerImageLayer(name,option,GroupID,index,checked,disFnc) 创建webimagelayer图层
    * @version 3.1.0
    *  创建webimagelayer图层
    * 创建
    * @param {String} name
    * @param {object} option
    * @param {object} GroupID
    * @param {object} index
    * @param {bool} checked
    * @param {object} disFnc
    * @example {object} 参数说明
    *       name: this._viewer.camera.position.clone(),
            option: {
                url: "",	//Resource | String		The URL of the WMS service. The URL supports the same keywords as the UrlTemplateImageryProvider.
                layers: "",		//The layers to include, separated by commas.
                parameters: {
                    service: 'WMS',
                    format: 'image/png',
                    transparent: true,

                },//	Object	WebMapServiceImageryProvider.DefaultParameters	optional Additional parameters to pass to the WMS server in the GetMap URL.
                //getFeatureInfoParameters	Object	WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters	optional Additional parameters to pass to the WMS server in the GetFeatureInfo URL.
                enablePickFeatures: true,//	optional If true, WebMapServiceImageryProvider#pickFeatures will invoke the GetFeatureInfo operation on the WMS server and return the features included in the response. If false, WebMapServiceImageryProvider#pickFeatures will immediately return undefined (indicating no pickable features) without communicating with the server. Set this property to false if you know your WMS server does not support GetFeatureInfo or if you don't want this provider's features to be pickable. Note that this can be dynamically overridden by modifying the WebMapServiceImageryProvider#enablePickFeatures property.
                //getFeatureInfoFormats	Array.<GetFeatureInfoFormat>	WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats	optional The formats in which to try WMS GetFeatureInfo requests.
                rectangle: this._cesium.Rectangle.MAX_VALUE,//	optional The rectangle of the layer.
                //tilingScheme	:	new this._cesium.GeographicTilingScheme(),//	optional The tiling scheme to use to divide the world into tiles.
                //ellipsoid	Ellipsoid		optional The ellipsoid. If the tilingScheme is specified, this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither parameter is specified, the WGS84 ellipsoid is used.
                tileWidth: 256,//	optional The width of each tile in pixels.
                tileHeight: 256,//	optional The height of each tile in pixels.
                minimumLevel: 0,//	optional The minimum level-of-detail supported by the imagery provider. Take care when specifying this that the number of tiles at the minimum level is small, such as four or less. A larger number is likely to result in rendering problems.
                maximumLevel: undefined,//		optional The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit. If not specified, there is no limit.
                crs: "",//		optional CRS specification, for use with WMS specification >= 1.3.0.
                srs: "",//		optional SRS specification, for use with WMS specification 1.1.0 or 1.1.1
                credit: "",		//optional A credit for the data source, which is displayed on the canvas.
                subdomains: "",// | Array.<String>	'abc'	optional The subdomains to use for the {s} placeholder in the URL template. If this parameter is a single string, each character in the string is a subdomain. If it is an array, each element in the array is a subdomain.
               },
            GroupID: 0,
            disFnc:function(){}
    * @returns 结果:
    *     {
    *          item:layer
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createWebMapServerImageLayer = function (name, option, GroupID, index, checked, disFnc) {
        var imageryLayer = new ImageryLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return imageryLayer.createWebMapServerImageLayer(name, option, GroupID, index, checked, disFnc);
    };

    /**
    *
    *  Creator.createWebMapTileServerImageLayer(name,option,GroupID,index,checked,disFnc) 创建webtilesimagelayer图层
    * @version 3.1.0
    *  创建webimagelayer图层
    * 创建
    * @param {String} name
    * @param {object} option
    * @param {object} GroupID
    * @param {object} index
    * @param {bool} checked
    * @param {object} disFnc
    * @example {object} 参数说明
    *       name: this._viewer.camera.position.clone(),
            option: {
                url: "",	//Resource | String		The URL of the WMS service. The URL supports the same keywords as the UrlTemplateImageryProvider.
                layers: "",		//The layers to include, separated by commas.
                parameters: {
                    service: 'WMS',
                    format: 'image/png',
                    transparent: true,

                },//	Object	WebMapServiceImageryProvider.DefaultParameters	optional Additional parameters to pass to the WMS server in the GetMap URL.
                //getFeatureInfoParameters	Object	WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters	optional Additional parameters to pass to the WMS server in the GetFeatureInfo URL.
                enablePickFeatures: true,//	optional If true, WebMapServiceImageryProvider#pickFeatures will invoke the GetFeatureInfo operation on the WMS server and return the features included in the response. If false, WebMapServiceImageryProvider#pickFeatures will immediately return undefined (indicating no pickable features) without communicating with the server. Set this property to false if you know your WMS server does not support GetFeatureInfo or if you don't want this provider's features to be pickable. Note that this can be dynamically overridden by modifying the WebMapServiceImageryProvider#enablePickFeatures property.
                //getFeatureInfoFormats	Array.<GetFeatureInfoFormat>	WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats	optional The formats in which to try WMS GetFeatureInfo requests.
                rectangle: this._cesium.Rectangle.MAX_VALUE,//	optional The rectangle of the layer.
                //tilingScheme	:	new this._cesium.GeographicTilingScheme(),//	optional The tiling scheme to use to divide the world into tiles.
                //ellipsoid	Ellipsoid		optional The ellipsoid. If the tilingScheme is specified, this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither parameter is specified, the WGS84 ellipsoid is used.
                tileWidth: 256,//	optional The width of each tile in pixels.
                tileHeight: 256,//	optional The height of each tile in pixels.
                minimumLevel: 0,//	optional The minimum level-of-detail supported by the imagery provider. Take care when specifying this that the number of tiles at the minimum level is small, such as four or less. A larger number is likely to result in rendering problems.
                maximumLevel: undefined,//		optional The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit. If not specified, there is no limit.
                crs: "",//		optional CRS specification, for use with WMS specification >= 1.3.0.
                srs: "",//		optional SRS specification, for use with WMS specification 1.1.0 or 1.1.1
                credit: "",		//optional A credit for the data source, which is displayed on the canvas.
                subdomains: "",// | Array.<String>	'abc'	optional The subdomains to use for the {s} placeholder in the URL template. If this parameter is a single string, each character in the string is a subdomain. If it is an array, each element in the array is a subdomain.
               },
            GroupID: 0,
            disFnc:function(){}
    * @returns 结果:
    *     {
    *          item:layer
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.createWebMapTileServerImageLayer = function (name, option, GroupID, index, checked, disFnc) {
        var imageryLayer = new ImageryLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return imageryLayer.createWebMapTileServerImageLayer(name, option, GroupID, index, checked, disFnc);
    };
    Creator.prototype.createUrlTemplateImageryProvider = function (name, option, GroupID, index, checked, disFnc) {
        var imageryLayer = new ImageryLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return imageryLayer.createUrlTemplateImageryProvider(name, option, GroupID, index, checked, disFnc);
    };
    ////加载天地图
    // Creator.prototype.createPolylineImageryProvider = function (name, option, GroupID, Description) {
    //     return this._ImageryLayer.createPolylineImageryProvider(name, option, GroupID, Description);
    // }
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *       radius:1,
            height: 0,
            heightReference: this._cesium.HeightReference.NONE,
            extrudedHeight: 0,
            extrudedHeightReference: this._cesium.HeightReference.NONE,
            show: true,
            fill: true,
            material: this._cesium.Color.WHITE,
            outline: false,
            outlineColor: this._cesium.Color.BLACK,
            outlineWidth: 1,
            near: 0,
            far: 5000
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createCirclePointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createCirclePointGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, disFnc);
    };
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *        Name: "",
      text: "",
      font_size: '30px',
      font_family:'sans-serif'
      stylet: this._cesium.LabelStyle.FILL,
      fillColor: this._cesium.Color.WHITE,//	optional A Property specifying the fill Color.
      outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the outline Color.
      outlineWidth: 1.0,//	optional A numeric Property specifying the outline width.
      show: true,//	optional A boolean Property specifying the visibility of the label.
      showBackground: false,//	optional A boolean Property specifying the visibility of the background behind the label.
      backgroundColor: new this._cesiumColor(0.165, 0.165, 0.165, 0.8),//optional A Property specifying the background Color.
      backgroundPadding: new Cartesian2(7, 5),//optional A Cartesian2 Property specifying the horizontal and vertical background padding in pixels.
      scale: 1.0,//optional A numeric Property specifying the scale to apply to the text.
      horizontalOrigin: this._cesiumHorizontalOrigin.CENTER,	//optional A Property specifying the HorizontalOrigin.
      verticalOrigin: this._cesium.VerticalOrigin.CENTER,//	optional A Property specifying the VerticalOrigin.
      eyeOffset: this._cesium.Cartesian3.ZERO,//	optional A Cartesian3 Property specifying the eye offset.
      pixelOffset: this._cesium.Cartesian2.ZERO,//	optional A Cartesian2 Property specifying the pixel offset.
      heightReference: this._cesium.HeightReference.NONE,//	optional A Property specifying what the height is relative to.
      near: 0,
      far: 5000
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    // Creator.prototype.createLabelPointGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
    //     var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
    //     if (this._core.isnull(GroupID) && !this._core.isnull(treeSource.selectedItem) && treeSource.selectedItem.type == 'group')
    //         GroupID = treeSource.selectedItem.id;
    //     GroupID = this._core.isnull(GroupID) ? 0 : GroupID
    //     return geoJsonFeatureLayer.createLabelPointGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, disFnc);
    // }
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *     positions: [],
          arcType: this._cesium.ArcType.GEODESIC,//	optional The type of line the polyline segments must follow.
          clampToGround: false,//optional A boolean Property specifying whether the Polyline should be clamped to the ground.
          width: 1.0,//optional A numeric Property specifying the width in pixels.
          show: true,//	optional A boolean Property specifying the visibility of the polyline.
          material: this._cesium.Color.WHITE,//	optional A Property specifying the material used to draw the polyline.
          near: 0,
          far: 5000,
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createPolylineGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createPolylineGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    Creator.prototype.createPrimitivePolylineGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var polylineGeoJsonFeatureLayer = new PolylineGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polylineGeoJsonFeatureLayer.createPolylineGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    Creator.prototype.createPrimitiveGroundPolylineGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var polylineGeoJsonFeatureLayer = new PolylineGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polylineGeoJsonFeatureLayer.createGroundPolylineGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    //沿线模型分布
    Creator.prototype.exectPointModel = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var pointModel = new PointModel(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return pointModel.exectPointModel(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    //沿面模型分布
    Creator.prototype.createPolygonModel = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var pointModel = new PointModel(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return pointModel.createPolygonModel(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    //模型移动
    Creator.prototype.modelMove = function () {
        var pointModel = new PointModel(this._viewer, this._cesium);
        return pointModel.modelMove();
    };
    Creator.prototype.createPrimitivePolylineVectorGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var polylineGeoJsonFeatureLayer = new PolylineGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polylineGeoJsonFeatureLayer.createPolylineVectorGeoJsonFeatureLayerProvider(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //线模型分布(矢量)
    Creator.prototype.createPolylineVectorGeoJsonFeatureLayerProviderModel = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var polylineGeoJsonFeatureLayer = new PolylineGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polylineGeoJsonFeatureLayer.createPolylineVectorGeoJsonFeatureLayerProviderModel(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    /**
     * 创建circleGeofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *     show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createpolylineVolumeGeojsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createpolylineVolumeGeojsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    Creator.prototype.createpolylineVolumeGeojsonPrimitiveLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createpolylineVolumeGeojsonPrimitiveLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    /**
     * 创建VolumeGeoJsonFeatureLayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *      show: true, //	optional A boolean Property specifying the visibility of the volume.
            positions: [], //		optional A Property specifying the array of Cartesian3 positions which define the line strip.
            shape: undefined, //		optional A Property specifying the array of Cartesian2 positions which define the shape to be extruded.
            cornerType: this._cesium.CornerType.ROUNDED, //	optional A CornerType Property specifying the style of the corners.
            granularity: this._cesium.Math.RADIANS_PER_DEGREE, //	optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, //	optional A boolean Property specifying whether the volume is filled with the provided material.
            material: this._cesium.Color.WHITE, //optional ,//A Property specifying the material used to fill the volume.
            outline: false, //optional A boolean Property specifying whether the volume is outlined.
            outlineColor: this._cesium.Color.BLACK, //optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, //optional A numeric Property specifying the width of the outline.
            shadows: this._cesium.ShadowMode.DISABLED, //	optional An enum Property specifying whether the volume casts or receives shadows from each light source.
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createVolumeGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var volumeGeoJsonFeatureLayer = new VolumeGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return volumeGeoJsonFeatureLayer.createVolumeGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, disFnc);
    };
    Creator.prototype.createVolumeGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var volumeGeoJsonFeatureLayer = new VolumeGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return volumeGeoJsonFeatureLayer.createVolumeGeoJsonFeatureLayerProvider(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //优化扫掠体
    Creator.prototype.createVolumeVectorGeoJsonFeatureLayerOptimizations = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var volumeGeoJsonFeatureLayer = new VolumeGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return volumeGeoJsonFeatureLayer.createVolumeVectorGeoJsonFeatureLayerOptimization(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //ajax请求矢量切片
    Creator.prototype.createVolumeVectorGeoJsonFeatureLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var volumeGeoJsonFeatureLayer = new VolumeGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return volumeGeoJsonFeatureLayer.createVolumeVectorGeoJsonFeatureLayer(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //ajax请求矢量切片
    //Creator.prototype.createPolylineVectorGeoJsonFeatureLayer = function (layername, url, option, max, min, GroupID, disFnc) {
    //    var volumeGeoJsonFeatureLayer = new VolumeGeoJsonFeatureLayer(this._viewer, this._cesium);
    //    if (this._core.isnull(GroupID) && !this._core.isnull(treeSource.selectedItem) && treeSource.selectedItem.type == 'group')
    //        GroupID = treeSource.selectedItem.id;
    //    GroupID = this._core.isnull(GroupID) ? 0 : GroupID
    //    return volumeGeoJsonFeatureLayer.createVolumeVectorGeoJsonFeatureLayer(layername, url, option, max, min, GroupID, disFnc);
    //}
    //ajax请求矢量切片
    Creator.prototype.createPolygonVectorGeoJsonFeatureLayer = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var volumeGeoJsonFeatureLayer = new PolygonVectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return volumeGeoJsonFeatureLayer.createVolumeVectorGeoJsonFeatureLayer(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //ajax请求矢量切片优化
    Creator.prototype.createVolumeVectorGeoJsonFeatureLayerOptimization = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var volumeGeoJsonFeatureLayer = new PolygonVectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return volumeGeoJsonFeatureLayer.createVolumeVectorGeoJsonFeatureLayerOptimization(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //ajax请求矢量切片山东
    Creator.prototype.createVolumeVectorGeoJsonFeatureLayersd = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var volumeGeoJsonFeatureLayer = new PolygonVectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return volumeGeoJsonFeatureLayer.createVolumeVectorGeoJsonFeatureLayersd(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    /**
     * 创建墙图层 *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *       show: true, // optional A boolean Property specifying the visibility of the wall.
            positions: [], // optional A Property specifying the array of Cartesian3 positions which define the top of the wall.
            minimumHeights: [], // optional A Property specifying an array of heights to be used for the bottom of the wall instead of the globe surface.
            maximumHeights: [], // optional A Property specifying an array of heights to be used for the top of the wall instead of the height of each position.
            granularity: Cesium.Math.RADIANS_PER_DEGREE, // optional A numeric Property specifying the angular distance between each latitude and longitude point.
            fill: true, // optional A boolean Property specifying whether the wall is filled with the provided material.
            material: Color.WHITE, // optional A Property specifying the material used to fill the wall.
            outline: false, // optional A boolean Property specifying whether the wall is outlined.
            outlineColor: Color.BLACK, // optional A Property specifying the Color of the outline.
            outlineWidth: 1.0, // optional A numeric Property specifying the width of the outline.
            shadows: ShadowMode.DISABLED, // optional An enum Property specifying whether the wall casts or receives shadows from each light source.
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createWallGeoFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createWallGeoFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    Creator.prototype.createWallPrimitiveGeoFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var wallGeoFeatureLayer = new WallGeoFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return wallGeoFeatureLayer.createWallPrimitiveGeoFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    Creator.prototype.createWallGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var wallGeoFeatureLayer = new WallGeoFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return wallGeoFeatureLayer.createWallGeoJsonFeatureLayerProvider(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };

    //影像加载
    Creator.prototype.createImageryProvider = function (name, type, option, GroupID, index, checked, disFnc) {
        //this._ImageryLayer = new ImageryLayer(this._viewer, this._cesium);
        var imageryLayer = new ImageryLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return imageryLayer.createImageryProvider(name, type, option, GroupID, index, checked, disFnc);
    };
    Creator.prototype.createCacheImageryProvider = function (name, option, GroupID, index, checked, disFnc) {
        //this._ImageryLayer = new ImageryLayer(this._viewer, this._cesium);
        var imageryLayer = new ImageryLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return imageryLayer.createCacheImageryProvider(name, option, GroupID, index, checked, disFnc);
    };
    //地形加载
    Creator.prototype.createterrainProvider = function (name, option, GroupID, disFnc) {
        //var ImageryLayer = new ImageryLayer(this._viewer, this._cesium);
        //if (this._core.isnull(GroupID) && !this._core.isnull(treeSource.selectedItem) && treeSource.selectedItem.type == 'group')
        //    GroupID = treeSource.selectedItem.id;
        //GroupID = this._core.isnull(GroupID) ? 0 : GroupID
        return this._TerrainProvider.createterrainProvider(name, option, GroupID, disFnc);
    };
    ////加载天地图
    Creator.prototype.createPolylineImageryProviderer = function (name, option, GroupID, Description) {
        return this._ImageryLayer.createPolylineImageryProviderer(name, option, GroupID, Description);
    };
    //加载
    Creator.prototype.createMVTWithStyle = function (name, option, GroupID, Description) {
        return this._ImageryLayer.createMVTWithStyle(name, option, GroupID, Description);
    };
    /**
     * 创建PolylineGeoJsonFeatureLayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {object} [option] 参数对象{
     *  height: 0,//	optional A numeric Property specifying the altitude of the polygon relative to the ellipsoid surface.
        extrudedHeight: 0,//		optional A numeric Property specifying the altitude of the polygon's extruded face relative to the ellipsoid surface.
        heightReference: this._cesium.HeightReference.NONE,//		optional A Property specifying what the extrudedHeight is relative to.
        show: true,//	optional A boolean Property specifying the visibility of the polygon.
        fill: true,//	optional A boolean Property specifying whether the polygon is filled with the provided material.
        material: this._cesium.Color.WHITE,//optional A Property specifying the material used to fill the polygon.
        outline: false,//optional A boolean Property specifying whether the polygon is outlined.
        outlineColor: this._cesium.Color.BLACK,//	optional A Property specifying the Color of the outline.
        outlineWidth: 1.0,//optional A numeric Property specifying the width of the outline.
        stRotation: 0.0,//	optional A numeric property specifying the rotation of the polygon texture counter-clockwise from north.
        granularity: this._cesium.Math.RADIANS_PER_DEGREE,//	optional A numeric Property specifying the angular distance between each latitude and longitude point.
        perPositionHeight: false,	//optional A boolean specifying whether or not the the height of each position is used.
        closeTop: true,	//optional When false, leaves off the top of an extruded polygon open.
        closeBottom: true,//	optional When false, leaves off the bottom of an extruded polygon open.
        shadows: this._cesium.ShadowMode.DISABLED,//	optional An enum Property specifying whether the polygon casts or receives shadows from each light source.
        near: 0,
        far: 5000
        }
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createPolygonGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createPolygonGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    Creator.prototype.createPolygonGeoJsonFeatureLayer1 = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var polygonGeoJsonFeatureLayer = new PolygonGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polygonGeoJsonFeatureLayer.createPolygonGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, disFnc);
    };
    //Creator.prototype.createPolygonVectorGeoJsonFeatureLayer = function (layername, url, option, max, min, GroupID, checked, disFnc) {
    //    var polygonGeoJsonFeatureLayer = new PolygonGeoJsonFeatureLayer(this._viewer, this._cesium);
    //    if (this._core.isnull(GroupID) && !this._core.isnull(treeSource.selectedItem) && treeSource.selectedItem.type == 'group')
    //        GroupID = treeSource.selectedItem.id;
    //    GroupID = this._core.isnull(GroupID) ? 0 : GroupID
    //    return polygonGeoJsonFeatureLayer.createPolygonVectorGeoJsonFeatureLayer(layername, url, option, max, min, GroupID, checked, disFnc);
    //}
    //普通面
    Creator.prototype.createPolygonVectorGeoJsonFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var polygonGeoJsonFeatureLayer = new PolygonGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polygonGeoJsonFeatureLayer.createPolygonVectorGeoJsonFeatureLayerProvider(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //面单体化
    Creator.prototype.createVolumeVectorGeoJsonFeatureLayerDth = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var volumeGeoJsonFeatureLayer = new PolygonVectorGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return volumeGeoJsonFeatureLayer.createVolumeVectorGeoJsonFeatureLayerDth(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //面模型分布
    Creator.prototype.createPolygonVectorGeoJsonFeatureLayerProviderModel = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var polygonGeoJsonFeatureLayer = new PolygonGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polygonGeoJsonFeatureLayer.createPolygonVectorGeoJsonFeatureLayerProviderModel(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //拉伸面
    Creator.prototype.createPolygonVectorGeoJsonFeatureLayerProviderls = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var polygonGeoJsonFeatureLayer = new PolygonGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polygonGeoJsonFeatureLayer.createPolygonVectorGeoJsonFeatureLayerProviderls(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //拉伸面山东（我们自己的）
    Creator.prototype.createPolygonVectorGeoJsonFeatureLayerProviderlsd = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var polygonGeoJsonFeatureLayer = new PolygonGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polygonGeoJsonFeatureLayer.createPolygonVectorGeoJsonFeatureLayerProviderlsd(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    //拉伸面Arcgis
    Creator.prototype.createArcgisPolygonVectorGeoJsonFeatureLayerProviderls = function (name, geoOptions, styleOption, GroupID, checked, disFnc) {
        var polygonGeoJsonFeatureLayer = new PolygonGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polygonGeoJsonFeatureLayer.createArcgisPolygonVectorGeoJsonFeatureLayerProviderls(name, geoOptions, styleOption, GroupID, checked, disFnc);
    };
    Creator.prototype.createPolygonVectorFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, disFnc) {
        var polygonGeoJsonFeatureLayer = new PolygonGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polygonGeoJsonFeatureLayer.createPolygonVectorFeatureLayerProvider(name, geoOptions, styleOption, GroupID, disFnc);
    };
    Creator.prototype.createPolygonVectorMonomerFeatureLayerProvider = function (name, geoOptions, styleOption, GroupID, disFnc) {
        var polygonGeoJsonFeatureLayer = new PolygonGeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polygonGeoJsonFeatureLayer.createPolygonVectorMonomerFeatureLayerProvider(name, geoOptions, styleOption, GroupID, disFnc);
    };
    /**
     *xp修改
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createPolygonMapGeoJsonFeatureLayer = function (name, geojsonOrurl, option, GroupID, checked, disFnc) {
        return this._MapGeoJsonFeatureLayer.createPolygonMapGeoJsonFeatureLayer(name, geojsonOrurl, option, GroupID, checked, disFnc);
    };
    /**
     * 创建geofeaturelayer
     *
     * @param {String} [name] 图层名称。
     * @param {object|String} [geojsonOrurl] geojosn对象或者地址
     * @param {Function} [disFnc] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的datasource对象。
     */
    Creator.prototype.createGeoJsonDataSource = function (name, geojsonOrurl, option, GroupID, disFnc) {
        var geoJsonFeatureLayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return geoJsonFeatureLayer.createGeoJsonDataSource(name, geojsonOrurl, option, GroupID, disFnc);
    };
    /**
    *
    *  Creator.DeleteObject(obj) 删除对象
    * @version 3.1.0
    *  创建imagelayer图层
    * 创建
    * @param {object} obj
    * @example {object} 参数说明
    *      obj
    * @returns 结果:
    *     {
    *         
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Creator.prototype.DeleteObject = function (obj) {
        if (this._core.isnull(obj._viewer)) {
            console.log("obj is null");
            return;
        }
        obj.deleteObject();
        for (var key in obj) {
            delete obj[key];
        }
        obj = undefined;
    };
    /**
     * 这个方法用于创建圆
     * @param {Array} [position] 一个经纬度数组例如：[-114.0, 40.0, 300000.0]。
     * @param {object} [CircleStyle] 对象。对象{
        semiMinorAxis: 300000.0,
        semiMajorAxis: 300000.0,
        height: 200000.0,
        material: this._cesium.Color.GREEN,
        outline: true,
    }
     * @param {String} [name] 圆的文字。
     * @param {String} [GroupID] 组
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.createCircle = function (position, CircleStyle, name, GroupID) {
        var circle = new Circle(this._viewer, this._cesium);
        return circle.createCircle(position, CircleStyle, name, GroupID);
    };
    /**
     * 向三维场景中添加矩形。
     * @param {String} [name] 名称
     * @param {Array} [position] 位置
     * @param {Object} [option] 矩形参数
     * @param {String} [GroupID] GroupID
     * @param {function} [method] 回调函数
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.CreateRectangle = function (name, position, option, GroupID, method) {
        var rectangle = new Rectangle$1(this._viewer, this._cesium);
        return rectangle.CreateRectangle(name, position, option, GroupID, method);
    };
    /**
     * 这个方法用于创建长方体
     * @param {Array} [position] 一个经纬度数组 例如：[-114.0, 40.0, 300000.0]。
     * @param {object} [box] 对象。对象{
        dimensions: new this._cesium.Cartesian3(400000.0, 300000.0, 500000.0),
        material: this._cesium.Color.RED.withAlpha(0.5),
        fill: false,
        outline: true,
        outlineColor: this._cesium.Color.BLACK
    }
     * @param {String} [name] 圆的文字。
     * @param {String} [GroupID] 组。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createBox = function (position, box, name, GroupID) {
        var box = new Box(this._viewer, this._cesium);
        return box.createBox(position, box, name, GroupID);
    };
    /**
    * 这个方法用于创建图片标签
    * @param {Array} [objs] 一个经纬度数组 例如：[{image:"tup.img",log:-114.0,lat: 40.0, height:300000.0}]。
    * @returns {Promise.<Object>} 返回一个Cesium的对象。
    *
    */
    Creator.prototype.createBillboardbatch = function (objs) {
        var billboard = new Billboard(this._viewer, this._cesium);
        return billboard.createBillboardbatch(objs);
    };
    /**
     * 这个方法用于创建圆锥
     * @param {Array} [position] 一个经纬度数组。
     * @param {object} [cylinder] 对象。对象{
        length: 400000.0,
        topRadius: 0.0,
        bottomRadius: 200000.0,
        material: this._cesium.Color.GREEN
    }
     * @param {String} [name] 圆锥显示的文字。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.createCone = function (position, cylinder, name, GroupID) {
        var cone = new Cone(this._viewer, this._cesium);
        return cone.createCone(position, cylinder, name, GroupID);
    };
    /**
     * 雷达遮罩动态扫描(半球)
     * @param {Array} [position] 一个经纬度数组。
     * @param {object} [cylinder] 对象。对象{
        radius: 100,  //半径
        angle: 30,  //扫描角度（可选）
        speed: 1,  //倍速（可选）
        stackPartitions: 64,  //横向网格数（可选）
        slicePartitions: 64,  //纵向网格数（可选）
        color: 'rgba(255,255,255,0.5)',  //球颜色（可选）
        outlineColor: 'rgba(255,255,255,0.5)',  //球边框线颜色（可选）
        wallColor: 'rgba(255,255,255,0.5)',   //扫描墙颜色（可选）
        wallOutlineColor: 'rgba(255,0,0,0.5)',   //扫描墙颜色（可选）
        surfaceColor: 'rgba(255,0,0,0.5)',   //扫描夹角颜色（可选）
    }
     * @param {String} [name] 圆锥显示的文字。
     * @param {String} [GroupID] 圆锥显示的文字。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.createRectangularSensor = function (position, cylinder, name, GroupID) {
        var cone = new Cone(this._viewer, this._cesium);
        return cone.createRectangularSensor(position, cylinder, name, GroupID);
    };
    /**
     * 雷达遮罩动态扫描(自定义)
     * @param {String} [name] 雷达显示的文字。
     * @param {Array} [position] 一个经纬度数组。
     * @param {object} [option] 雷达参数。对象{
        radius: 100,  //半径
        yaw: 0,  //雷达方向（可选）
        angle: 60,  //雷达夹角（可选）
        scanAngle: 15,  //扫描夹角（可选）
        speed: 1,  //倍速（可选）
        maxLat: 105,  //下维度（可选）
        minLat: 75,  //上维度（可选）
        stackPartitions: 64,  //横向网格数（可选）
        slicePartitions: 64,  //纵向网格数（可选）
        color: 'rgba(255,255,255,0.5)',  //雷达遮罩颜色（可选）
        outlineColor: 'rgba(255,255,255,0.5)',  //雷达遮罩边框线颜色（可选）
        scanColor: 'rgba(255,0,0,0.5)',   //扫描颜色（可选）
     }
     * @param {String} [GroupID] GroupID。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.createRadarMaskScan = function (name, position, option, GroupID) {
        var cone = new Cone(this._viewer, this._cesium);
        return cone.createRadarMaskScan(name, position, option, GroupID);
    }; /**
        * 雷达视角(自定义)
        * @param {String} [name] 雷达显示的文字。
        * @param {Array} [position] 一个经纬度数组。
        * @param {object} [option] 雷达参数。对象{
           radius: 100,  //半径
           yaw: 0,  //雷达方向（可选）
           angle: 60,  //雷达夹角（可选）
           scanAngle: 15,  //扫描夹角（可选）
           speed: 1,  //倍速（可选）
           maxLat: 105,  //下维度（可选）
           minLat: 75,  //上维度（可选）
           stackPartitions: 64,  //横向网格数（可选）
           slicePartitions: 64,  //纵向网格数（可选）
           color: 'rgba(255,255,255,0.5)',  //雷达遮罩颜色（可选）
           outlineColor: 'rgba(255,255,255,0.5)',  //雷达遮罩边框线颜色（可选）
           scanColor: 'rgba(255,0,0,0.5)',   //扫描颜色（可选）
        }
        * @param {String} [GroupID] GroupID。
        * @returns {Promise.<Object>} 返回一个Cesium的对象。
        */
    Creator.prototype.createRadarMask = function (name, position, option, GroupID) {
        var cone = new Cone(this._viewer, this._cesium);
        return cone.createRadarMask(name, position, option, GroupID);
    };
    /**
      * 这个方法用于创建雷达
      * @param {Array} [position] 一个经纬度数组。
      * @param {object} [cylinder] 对象。对象{
         length: 400000.0,
         topRadius: 0.0,
         bottomRadius: 200000.0,
         material: this._cesium.Color.GREEN
     }
      * @param {String} [name] 圆锥显示的文字。
      * @param {String} [GroupID] 圆锥显示的文字。
      * @returns {Promise.<Object>} 返回一个Cesium的对象。
      */
    Creator.prototype.createConeRadar = function (position, option) {
        var cone = new Cone(this._viewer, this._cesium);
        return cone.createConeRadar(position, option);
    };
    /**
     * 这个方法用于创建颜色
     *@param {number} [red] 红色组件。
     * @param {number} [green] 绿色组件。
     * @param {number} [blue] 蓝色组件。
     * @param {number} [alphae] alphea组件。
     * @returns {Promise.<Object>} 返回一个Cesium的颜色对象。
     */
    Creator.prototype.createColor = function (red, green, blue, alpha) {
        var color = new Color(this._viewer, this._cesium);
        return color.createColor(red, green, blue, alpha);
    };
    /**
     * 向三维场景中添加线。
     * @param {Array} [Geometry] 一个经纬度数组 例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
     * @param {String} [LineColor] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createPolyline = function (Geometry, LineColor, AltitudeType, GroupID, Description) {
        var polyline = new Polyline(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polyline.createPolyline(Geometry, LineColor, AltitudeType, this._core.isnull(GroupID) ? 0 : GroupID, Description);
    };
    /**
     * 向三维场景中添加链路。
     * @param {Array} [position1] 点1。
     * @param {Array} [position2] 点2。
     * @param {Object} [options] 参数。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createLink = function (position1, position2, options) {
        var polyline = new Polyline(this._viewer, this._cesium);
        return polyline.createLink(position1, position2, options);
    };
    /**
     * 向三维场景中添加链路(优化版)。
     * @param {Array} [position1] 点1。
     * @param {Array} [position2] 点2。
     * @param {Object} [options] 参数。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createLinkPro = function (position1, position2, options) {
        var polyline = new Polyline(this._viewer, this._cesium);
        return polyline.createLinkPro(position1, position2, options);
    };
    /**
     * 向三维场景中添加链路(优化版)。
     * @param {Array} [position1] 点1。
     * @param {Array} [position2] 点2。
     * @param {Object} [options] 参数。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createLinkPros = function (callback) {
        var polyline = new Polyline(this._viewer, this._cesium);
        return polyline.createLinkPros(callback);
    };

    /**
     * 向三维场景中添加流光线图层。
     * @param {Object} [option] 参数。
     * @param {String} [option.id] id（可选）。
     * @param {String} [option.url] geojson路径。
     * @param {String} [option.color="#0033FF"] 线颜色。
     * @param {Number} [option.alpha=1.0] 线透明度。
     * @param {Number} [option.width=5.0] 线宽。
     * @param {String} [option.pointColor="#FFFFFF"] 点颜色。
     * @param {Number} [option.pointColor=1.0] 点透明度。
     * @param {Number} [option.speed=1] 点移动速度。
     * @param {Number} [option.near=0] 最小可视距离。
     * @param {Number} [option.far=Math.MAX_VALUE] 最大可视距离。
     * @returns {TrailLine} 返回一个TrailLine对象。
     * 
     * 
     * @example
     * layer = sgworld.Creator.createPathLayer({
     *  url: 'line.json',
     *  lineColor: "#0033FF", //线的颜色
     *  lineAlpha: 1.0, //线的透明度
     *  linewidth: 4.0, //线的宽度
     *  pointColor: "#FFFFFF", //移动点的颜色
     *  speed: 1
     * });
     */
    Creator.prototype.createPathLayer = function (option) {
        return this._trailLine.createPathLayer(option);
    };

    /**
     * 向三维场景中添加流动墙图层。
     * @param {Object} [option] 参数。
     * @param {String} [option.id] id（可选）。
     * @param {String} [option.url] geojson路径。
     * @param {String} [option.color="#0000ff"] 颜色。
     * @param {Number} [option.height=50] 墙高。
     * @param {Number} [option.minHeight] 底部高度。
     * @param {Number} [option.near=0] 最小可视距离。
     * @param {Number} [option.far=Math.MAX_VALUE] 最大可视距离。
     * @param {Number} [option.speed=1] 流动速度。
     * @returns {TrailLine} 返回一个TrailLine对象。
     * 
     * 
     * @example
     * layer = sgworld.Creator.createTrailWallLayer({
     *  url: 'wall.json',
     *  color: "#0033FF", //颜色
     *  speed: 1
     * });
     */
    Creator.prototype.createTrailWallLayer = function (option) {
        return this._trailLine.createWallLayer(option);
    };

    /**
     * 向三维场景中添加面。
     * @param {Array} [Geometry] 一个经纬度数组 例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
     * @param {String} [LineColor] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createPolygon = function (Geometry, LineColor, AltitudeType, GroupID, Description) {
        var polygon = new Polygon(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polygon.createPolygon(Geometry, LineColor, AltitudeType, GroupID, Description);
    };
    /**
    * 向三维场景中添加扇形。
    * @param {Array} [posion] 一个经纬度数组 例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
    * @param {int} [radius] 半径。
    * @returns {Promise.<Object>} 返回一个Cesium的对象。
    *
    */
    Creator.prototype.createSector = function (posion, radius, angle, horizontal, pitch) {
        var polygon = new Polygon(this._viewer, this._cesium);
        return polygon.createSector(posion, radius, angle, horizontal, pitch);
    };
    /**
     * 向三维场景中添加面。
     * @param {Array} [Geometry] 一个经纬度数组 例如：[{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204},{x: 1241183.5017659152, y: -4980441.651928518, z: 3769366.996495204}]。
     * @param {String} [LineColor] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.executeEllipsoid = function (position, ellipsoid, name, GroupID) {
        var ellipsoid = new Ellipsoid(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return ellipsoid.createEllipsoid(position, ellipsoid, name, GroupID);
    };
    /**
     * 这个方法用于创建图像标签
     * @param {Array} [position] 一个经纬度数组 例如：[-114.0, 40.0, 300000.0]。
     * @param {object} [ImageLabel] 对象。对象{
    image: '../images/Cesium_Logo_overlay.png', 
        show: true, // default
        color: this._cesium.Color.IVORY,
    }
     * @param {double} [GroupID] 组的ID，高程数据图层在该组中被创建。如果GroupID设置为零，则对象在根节点下创建。你可以通过以下方法获得GroupID。
     * @param {double} [Description] 标签名字。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createImageLabel = function (position, ImageLabels, GroupID, Description) {
        var imageLabel = new ImageLabel(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return imageLabel.createImageLabel(position, ImageLabels, GroupID, Description);
    };

    Creator.prototype.toHtmlColor = function (rgb) {
        return this._Color.toHtmlColor(rgb);
    };
    /**
     仿照te
     */
    Creator.prototype.CreateLabel = function (position, Text, ImageFileName, LabelStyle, GroupID, Description) {
        var label = new Label(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return label.CreateLabel(position, Text, ImageFileName, LabelStyle, GroupID, Description);
    };
    /**
     仿照te
     */
    Creator.prototype.CreateImageLabel = function (Position, ImageFileName, LabelStyle, GroupID, Description) {
        var imageLabel = new ImageLabel(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return imageLabel.CreateImageLabel(Position, ImageFileName, LabelStyle, GroupID, Description);
    };
    Creator.prototype.createImage = function (Position, ImageFileName, LabelStyle, GroupID, Description) {
        var imageLabel = new ImageLabel(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return imageLabel.CreateImageLabel(Position, ImageFileName, LabelStyle, GroupID, Description);
    };
    /**
     仿照te
     */
    Creator.prototype.CreatePolyline = function (Geometry, LineColor, AltitudeType, GroupID, Description) {
        var polyline = new Polyline(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return polyline.CreatePolyline(Geometry, LineColor, AltitudeType, GroupID, Description);
    };
    /**
     *
     * 仿照te修改
     *
     * 这个方法用于创建圆
     * @param {Object} [Position] Position表示地面对象的位置和方向
     * @param {number} [Radius] 对象的半径（单位：米）。
     * @param {String} [LineColor] 组成圆的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 圆的填充色。颜色值由RGB定义。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中圆的名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.CreateCircle = function (Position, Radius, LineColor, FillColor, GroupID, Description) {
        var circle = new Circle(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return circle.CreateCircle(Position, Radius, LineColor, FillColor, GroupID, Description);
    };
    /**
     *
     * 仿照te修改
     *
     * 这个方法用于创建椭圆
     * @param {Object} [Position] Position表示地面对象的位置和方向
     * @param {number} [RadiusX] 椭圆沿X轴半径。
     * @param {number} [RadiusY] 椭圆沿Y轴半径。
     * @param {String} [LineColor] 组成椭圆的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 椭圆的填充色。颜色值由RGB定义。
     * * @param {number} [NumOfSegments] 组成圆锥体的部分数目。部分数据越多，圆锥体越圆滑。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中椭圆的名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.CreateEllipse = function (Position, RadiusX, RadiusY, LineColor, FillColor, NumOfSegments, GroupID, Description) {
        var circle = new Circle(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return circle.CreateEllipse(Position, RadiusX, RadiusY, LineColor, FillColor, NumOfSegments, GroupID, Description);
    };
    /**
     *
     * 仿照te修改
     *
     * 这个方法用于创建长方体
     * @param {Object} [Position] Position表示地面对象的位置和方向。
     * @param {number} [ObjectWidth] 长方体的宽度（单位：米）。
     * @param {number} [ObjectDepth] 长方体的深度（单位：米）。
     * @param {number} [ObjectHeight] 长方体的高度（单位：米）。
     * @param {String} [LineColor] 组成长方体的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 长方体的填充色。颜色值由RGB定义。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中长方体的名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.CreateBox = function (Position, ObjectWidth, ObjectDepth, ObjectHeight, LineColor, FillColor, GroupID, Description) {
        var box = new Box(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return box.CreateBox(Position, ObjectWidth, ObjectDepth, ObjectHeight, LineColor, FillColor, GroupID, Description);
    };
    /**
     * 仿照te修改
     * 这个方法用于创建Position对象
     *
     *@param {number} [X] 兴趣点的东西方向坐标。
     * @param {number} [Y] 兴趣点的南北方向坐标。
     * @param {number} [Altitude] 兴趣点的高程。
     * @param {number} [AltitudeType] 一个枚举值，定义了了高程类型。
     * @param {number} [Yaw] 视点和兴趣点的偏移角度。
     * @param {number} [Pitch] 视点和兴趣点的俯仰角度。
     * @param {number} [Roll] 视点和兴趣点的翻滚角度。
     * @param {number} [Distance] 距离点坐标（X,Y,height）的距离，点必须在视线范围内。
     * @returns {Promise.<Object>} 返回一个Position对象。
     */
    Creator.prototype.CreatePosition = function (X, Y, Altitude, AltitudeType, Yaw, Pitch, Roll, Distance) {
        var position = new Position(this._viewer, this._cesium);
        return position.CreatePosition(X, Y, Altitude, AltitudeType, Yaw, Pitch, Roll, Distance);
    };
    /**
     *
     * 仿照te修改
     *
     * 这个方法用于创建颜色
     *@param {number} [red] 红。
     * @param {number} [green] 绿。
     * @param {number} [blue] 蓝。
     * @param {number} [alpha] 透明度。
     * @returns {Promise.<Object>} 返回一个Cesium的颜色对象。
     */
    Creator.prototype.createColor = function (red, green, blue, alpha) {
        var color = new Color(this._viewer, this._cesium);
        return color.CreateColor(red, green, blue, alpha);
    };
    /**
     * 仿照te修改
     *
     * 这个方法用于创建圆锥
     * @param {Object} [Position] Position表示地面对象的位置和方向。
     * @param {number} [Radius] 圆锥体的半径。
     * @param {number} [ObjectHeight] 圆锥体的高度。
     * @param {String} [LineColor] 组成圆锥体的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 圆锥的填充色。颜色值由RGB定义。
     * @param {number} [NumOfSegments] 组成圆锥体的部分数目。部分数据越多，圆锥体越圆滑。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中圆锥的名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.CreateCone = function (Position, Radius, ObjectHeight, LineColor, FillColor, NumOfSegments, GroupID, Description) {
        var cone = new Cone(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return cone.CreateCone(Position, Radius, ObjectHeight, LineColor, FillColor, NumOfSegments, GroupID, Description);
    };
    /**
     * 仿照te修改
     *
     * 这个方法用于创建圆柱
     * @param {Object} [Position] Position表示地面对象的位置和方向。
     * @param {number} [Radius] 圆柱体的半径。
     * @param {number} [ObjectHeight] 圆柱体的高度。
     * @param {String} [LineColor] 组成圆柱体的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 圆柱的填充色。颜色值由RGB定义。
     * @param {number} [NumOfSegments] 组成圆柱体的部分数目。部分数据越多，圆柱体越圆滑。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中圆柱名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.CreateCylinder = function (Position, Radius, ObjectHeight, LineColor, FillColor, NumOfSegments, GroupID, Description) {
        var cone = new Cone(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return cone.CreateCylinder(Position, Radius, ObjectHeight, LineColor, FillColor, NumOfSegments, GroupID, Description);
    };
    /**
     * 仿照te修改
     *
     * 这个方法用于创建球
     * @param {Object} [Position] Position表示地面对象的位置和方向。
     * @param {number} [Radius] 球的半径。
     * @param {number} [Style] 一个枚举值，定义了球的哪个部分是可见的。
     * @param {String} [LineColor] 组成球的线的颜色。颜色值由RGB定义。
     * @param {String} [FillColor] 球的填充色。颜色值由RGB定义。
     * @param {number} [SegmentDensity] 定义组成球的格网密度。密度值范围1-10，缺省值为4。
     * @param {String} [GroupID] 组。
     * @param {String} [Description] 显示在信息树中球名称。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     */
    Creator.prototype.CreateSphere = function (Position, Radius, Style, LineColor, FillColor, SegmentDensity, GroupID, Description) {
        var ellipsoid = new Ellipsoid(this._viewer, this._cesium);
        if (this._core.isnull(GroupID) && !this._core.isnull(tree.selectedItem) && tree.selectedItem.type == 'group')
            GroupID = tree.selectedItem.id;
        GroupID = this._core.isnull(GroupID) ? 0 : GroupID;
        return ellipsoid.CreateSphere(Position, Radius, Style, LineColor, FillColor, SegmentDensity, GroupID, Description);
    };

    /**
     * 向三维场景中添加对象点（优化可编辑）。
     * @param {String} [name] 名称
     * @param {Array} [position] 一个经纬度数组 例如：[x, y, z]。
     * @param {String|Int} [GroupID] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createPointOptimization = function (entity, parameter) {
        var point = new Point(this._viewer, this._cesium);
        return point.createPointOptimization(entity, parameter);
    };
    /**
     * 向三维场景中添加矩形（优化可编辑）。
     * @param {String} [name] 名称
     * @param {Array} [position] 一个经纬度数组 例如：[x, y, z]。
     * @param {String|Int} [GroupID] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createRectangleOptimization = function (entity, parameter) {
        var rectangle = new Rectangle$1(this._viewer, this._cesium);
        return rectangle.createRectangleOptimization(entity, parameter);
    };
    /**
     * 向三维场景中添加圆（优化可编辑）。
     * @param {String} [name] 名称
     * @param {Array} [position] 一个经纬度数组 例如：[x, y, z]。
     * @param {String|Int} [GroupID] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createCircleOptimization = function (entity, parameter) {
        var circle = new Circle(this._viewer, this._cesium);
        return circle.createCircleOptimization(entity, parameter);
    };
    /**
     * 向三维场景中添加圆柱（优化可编辑）。
     * @param {String} [name] 名称
     * @param {Array} [position] 一个经纬度数组 例如：[x, y, z]。
     * @param {String|Int} [GroupID] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createCylinderOptimization = function (entity, parameter) {
        var cone = new Cone(this._viewer, this._cesium);
        return cone.createCylinderOptimization(entity, parameter);
    };
    /**
     * 向三维场景中添加对象点（优化）。
     * @param {String} [name] 名称
     * @param {Array} [position] 一个经纬度数组 例如：[x, y, z]。
     * @param {String|Int} [GroupID] 线的颜色。
     * @returns {Promise.<Object>} 返回一个Cesium的对象。
     *
     */
    Creator.prototype.createPointOptimization = function (entity, parameter) {
        var point = new Point(this._viewer, this._cesium);
        return point.createPointOptimization(entity, parameter);
    };
    /**
     * 点击编辑
     */
    Creator.prototype.CreatePolygonEdit = function () {
        return this._core.EntityEdit(this._viewer, this._cesium);
    };

    /**
         * 
         * @param {String} name 
         * @param {Object} options 
         * @param {Object} queryOptions 
         * @param {String} GroupID 
         * @param {Boolean} checked 
         * @param {Function} disFnc 
         */
    Creator.prototype.CreateVectorImageFeatureLayer = function (name, options, queryOptions, styleoption, GroupID, checked, disFnc) {
        return this.VectorImgFeatureLayer.CreateVectorImageFeatureLayer(name, options, queryOptions, styleoption, GroupID, checked, disFnc);
    };
    /**
     * 体积方量测量工具
     */
    Creator.prototype.createVolumetricMeasureTool = function () {
        var volumetricMeasure = new VolumetricMeasure(this._viewer, this._cesium);
        return volumetricMeasure;
    };

    Object.defineProperties(Creator.prototype, {
        // _GeoJsonFeatureLayer
        SimpleGraphic: {
            get: function () {
                return this._SimpleGraphic;
            }
        },
        GeoJsonFeatureLayer: {
            get: function () {
                return this._GeoJsonFeatureLayer;
            }
        },
        MilitaryPlotting: {
            get: function () {
                return this._straightArrow;
            }
        },
        _D3Tileset: {
            get: function () {
                return new SE3DTileset(this._viewer, this._cesium);
            }
        }
    });
    Object.defineProperties(Creator.prototype, {
        _trailLine: {
            get: function () {
                return new TrailLine(this._viewer, this._cesium);
            }
        }
    });
    Object.defineProperties(Creator.prototype, {
        _Point: {
            get: function () {
                return new Point(this._viewer, this._cesium);
            }
        },
        GeometryCreator: {
            CreateLinearRingGeometry: function (position) {
                return {};
            }
        }
    });

    /**
    *
    * 向三维场景中时间操作。
    *
    * @alias Current 
    * @constructor
    *
    */
    function Current(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }
    /**
    * 向三维场景时间操作。
    * @param {String} [parameter] 。
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    Current.prototype.currentTime = function (parameter) {
        if (parameter != "" && parameter != null) {
            var date1 = new Date(parameter);
            var julian_time = this.this._cesium.JulianDate.fromDate(date1);
            this._viewer.clock.currentTime = julian_time.clone();
        }
        return this;
    };
    /**
    * 时间倍率加。
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    Current.prototype.currentTimeFaster = function () {
        this._viewer.animation.viewModel.faster();
        return this;
    };
    /**
    * 时间倍率减。
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    Current.prototype.currentTimeSlower = function () {
        this._viewer.animation.viewModel.slower();
        return this;
    };
    /**
    * 时间往前播
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    Current.prototype.currentplayForwardViewModel = function () {
        this._viewer.animation.viewModel.playForwardViewModel.command();
        return this;
    };
    /**
    * 时间往后播
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    Current.prototype.currentplayReverseViewModel = function () {
        this._viewer.animation.viewModel.playReverseViewModel.command();
        return this;
    };
    /**
    * 时间暂停
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    Current.prototype.currentpauseViewModel = function () {
        this._viewer.animation.viewModel.pauseViewModel.command();
        return this;
    };

    /**
    *
    * 创建模块。
    *
    * @alias DataTime 
    * @constructor
    *
    */
    function DataTime(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._current = new Current(this._viewer, this._cesium);
    }/**
    * 向三维场景时间操作。
    * @param {String} [parameter] 。
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    DataTime.prototype.currentTime = function (parameter) {
        var current = new Current(this._viewer, this._cesium);
        return current.currentTime(parameter);
    };
    /**
    * 时间倍率加。
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    DataTime.prototype.currentTimeFaster = function () {
        var current = new Current(this._viewer, this._cesium);
        return current.currentTimeFaster();
    };
    /**
     * 时间倍率减。
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    DataTime.prototype.currentTimeSlower = function () {
        var current = new Current(this._viewer, this._cesium);
        return current.currentTimeSlower();
    };
    /**
     * 时间往前播
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    DataTime.prototype.currentplayForwardViewModel = function () {
        var current = new Current(this._viewer, this._cesium);
        return current.currentplayForwardViewModel();
    };
    /**
    * 时间往后播
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    DataTime.prototype.currentplayReverseViewModel = function () {
        var current = new Current(this._viewer, this._cesium);
        return current.currentplayReverseViewModel();
    };
    /**
     * 时间暂停
    * @returns {Promise.<Object>} 返回一个时间的对象。
    * 
    */
    DataTime.prototype.currentpauseViewModel = function () {
        var current = new Current(this._viewer, this._cesium);
        return current.currentpauseViewModel();
    };

    /**
     *
     * 绑定事件。
     * @alias AttachEvent
     * @constructor
     * 
     * @param {Viewer} viewer 地图视图
     * @param {Cesium} cesium Cesium对象
     * 
     */
    function AttachEvent(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._Core = new Core();
    }

    /**
     * 绑定事件。
     * 
     * @param {EventType} [bstrEventName] 事件名称。
     * @param {Function} [dispFunc] 响应函数。
     * @returns {ScreenSpaceEventHandler} 返回屏幕事件handel。
     */
    AttachEvent.prototype.AttachEvent = function (bstrEventName, dispFunc) {
        var viewer = this._viewer;
        var _Core = this._Core;
        var _Core = this._Core;
        if (bstrEventName === EventType$1.L_Click) {
            //当用户双击鼠标左键时触发事件
            var scene = this._viewer.scene;

            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                let cartesian = viewer.scene.pickPosition(click.position);
                let degrees;
                if (cartesian) {
                    degrees = _Core.toDegrees(cartesian);
                }
                if (typeof dispFunc == 'function')
                    dispFunc(click, degrees);
            }, this._cesium.ScreenSpaceEventType.LEFT_CLICK);
            return handler;
        } else if (bstrEventName === EventType$1.L_DBL_Click) {
            //当用户双击鼠标左键时触发事件
            var scene = this._viewer.scene;

            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                let cartesian = viewer.scene.pickPosition(click.position);
                let degrees;
                if (cartesian) {
                    degrees = _Core.toDegrees(cartesian);
                }
                if (typeof dispFunc == 'function')
                    dispFunc(click, degrees);
            }, this._cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
            return handler;
        } else if (bstrEventName === EventType$1.L_Down) {
            //当用户按下鼠标左键时触发事件。
            var scene = this._viewer.scene;
            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                let cartesian = viewer.scene.pickPosition(click.position);
                let degrees;
                if (cartesian) {
                    degrees = _Core.toDegrees(cartesian);
                }
                if (typeof dispFunc == 'function')
                    dispFunc(click, degrees);
            }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);
            return handler;
        } else if (bstrEventName === EventType$1.L_Up) {
            //用户释放鼠标左键时触发事件。
            var scene = this._viewer.scene;
            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                let cartesian = viewer.scene.pickPosition(click.position);
                let degrees;
                if (cartesian) {
                    degrees = _Core.toDegrees(cartesian);
                }
                if (typeof dispFunc == 'function')
                    dispFunc(click, degrees);
            }, this._cesium.ScreenSpaceEventType.LEFT_UP);
            return handler;
        } else if (bstrEventName === EventType$1.M_Click) {
            //用户按下鼠标中键时触发事件。
            var scene = this._viewer.scene;
            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                let cartesian = viewer.scene.pickPosition(click.position);
                let degrees;
                if (cartesian) {
                    degrees = _Core.toDegrees(cartesian);
                }
                if (typeof dispFunc == 'function')
                    dispFunc(click, degrees);
            }, this._cesium.ScreenSpaceEventType.MIDDLE_CLICK);
            return handler;
        } else if (bstrEventName === EventType$1.M_Down) {
            //用户按下鼠标中键时触发事件。
            var scene = this._viewer.scene;
            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                let cartesian = viewer.scene.pickPosition(click.position);
                let degrees;
                if (cartesian) {
                    degrees = _Core.toDegrees(cartesian);
                }
                if (typeof dispFunc == 'function')
                    dispFunc(click, degrees);
            }, this._cesium.ScreenSpaceEventType.MIDDLE_DOWN);
            return handler;
        } else if (bstrEventName === EventType$1.M_Up) {
            //用户释放鼠标中键时触发事件。
            var scene = this._viewer.scene;
            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                let cartesian = viewer.scene.pickPosition(click.position);
                let degrees;
                if (cartesian) {
                    degrees = _Core.toDegrees(cartesian);
                }
                if (typeof dispFunc == 'function')
                    dispFunc(click, degrees);
            }, this._cesium.ScreenSpaceEventType.MIDDLE_UP);
            return handler;
        } else if (bstrEventName === EventType$1.R_Click) {
            //当用户双击鼠标左键时触发事件
            var scene = this._viewer.scene;

            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                let cartesian = viewer.scene.pickPosition(click.position);
                let degrees;
                if (cartesian) {
                    degrees = _Core.toDegrees(cartesian);
                }
                if (typeof dispFunc == 'function')
                    dispFunc(click, degrees);
            }, this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
            return handler;
        } else if (bstrEventName === EventType$1.R_Down) {
            //用户按下鼠标右键时触发事件。
            var scene = this._viewer.scene;
            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                let cartesian = viewer.scene.pickPosition(click.position);
                let degrees;
                if (cartesian) {
                    degrees = _Core.toDegrees(cartesian);
                }
                if (typeof dispFunc == 'function')
                    dispFunc(click, degrees);
            }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);
            return handler;
        } else if (bstrEventName === EventType$1.R_Up) {
            //用户释放鼠标右键时触发事件。
            var scene = this._viewer.scene;
            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                let cartesian = viewer.scene.pickPosition(click.position);
                let degrees;
                if (cartesian) {
                    degrees = _Core.toDegrees(cartesian);
                }
                if (typeof dispFunc == 'function')
                    dispFunc(click, degrees);
            }, this._cesium.ScreenSpaceEventType.RIGHT_UP);
            return handler;
        } else if (bstrEventName === EventType$1.Wheel) {
            //用户滚动鼠标滚轮并碰到下一个缺口时触发事件。
            var scene = this._viewer.scene;
            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                if (typeof dispFunc == 'function')
                    dispFunc(click);
            }, this._cesium.ScreenSpaceEventType.WHEEL);
            return handler;
        } else if (bstrEventName === EventType$1.Move) {
            //表示鼠标移动事件。
            var scene = this._viewer.scene;
            var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
            handler.setInputAction(function (click) {
                if (typeof dispFunc == 'function')
                    dispFunc(click);
            }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
            return handler;
        }
    };

    /**
     * 绑定鼠标左键双击事件
     * @param {Function} [dispFunc] 回调函数
     *
     */
    AttachEvent.prototype.AttachOnLButtonDblClkEvent = function (dispFunc) {
        var scene = this._viewer.scene;

        var viewer = this._viewer;
        var _Core = this._Core;
        var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
        handler.setInputAction(function (movement) {
            let cartesian = viewer.scene.pickPosition(movement.position);
            let degrees;
            if (cartesian) {
                degrees = _Core.toDegrees(cartesian);
            }
            if (typeof dispFunc == 'function')
                dispFunc(click, degrees);
        }, this._cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
        return handler;
    };
    /**
     * 绑定鼠标左键按下事件
     * @param {Function} [dispFunc] 回调函数
     *
     */
    AttachEvent.prototype.AttachOnLButtonDownEvent = function (dispFunc) {
        //当用户按下鼠标左键时触发事件。
        var viewer = this._viewer;
        var _Core = this._Core;
        var scene = this._viewer.scene;
        var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
        handler.setInputAction(function (movement) {
            let cartesian = viewer.scene.pickPosition(movement.position);
            let degrees;
            if (cartesian) {
                degrees = _Core.toDegrees(cartesian);
            }
            if (typeof dispFunc == 'function')
                dispFunc(click, degrees);
        }, this._cesium.ScreenSpaceEventType.LEFT_DOWN);
        return handler;
    };
    /**
     * 绑定鼠标左键按下弹起事件
     * @param {Function} [dispFunc] 回调函数
     *
     */
    AttachEvent.prototype.AttachOnLButtonUpEvent = function (dispFunc) {
        //用户释放鼠标左键时触发事件。
        var viewer = this._viewer;
        var _Core = this._Core;
        var scene = this._viewer.scene;
        var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
        handler.setInputAction(function (movement) {
            let cartesian = viewer.scene.pickPosition(movement.position);
            let degrees;
            if (cartesian) {
                degrees = _Core.toDegrees(cartesian);
            }
            if (typeof dispFunc == 'function')
                dispFunc(click, degrees);
        }, this._cesium.ScreenSpaceEventType.LEFT_UP);
        return handler;
    };
    /**
     * 绑定鼠标中建双击事件
     * @param {Function} [dispFunc] 回调函数
     *
     */
    AttachEvent.prototype.AttachOnMButtonDblClkEvent = function (dispFunc) {
        //用户按下鼠标中键时触发事件。
        var viewer = this._viewer;
        var _Core = this._Core;
        var scene = this._viewer.scene;
        var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
        handler.setInputAction(function (movement) {
            let cartesian = viewer.scene.pickPosition(movement.position);
            let degrees;
            if (cartesian) {
                degrees = _Core.toDegrees(cartesian);
            }
            if (typeof dispFunc == 'function')
                dispFunc(click, degrees);
        }, this._cesium.ScreenSpaceEventType.MIDDLE_CLICK);
        return handler;
    };
    /**
     * 绑定鼠标中建按下事件
     * @param {Function} [dispFunc] 回调函数
     *
     */
    AttachEvent.prototype.AttachOnMButtonDownEvent = function (dispFunc) {
        //用户按下鼠标中键时触发事件。
        var viewer = this._viewer;
        var _Core = this._Core;
        var scene = this._viewer.scene;
        var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
        handler.setInputAction(function (movement) {
            let cartesian = viewer.scene.pickPosition(movement.position);
            let degrees;
            if (cartesian) {
                degrees = _Core.toDegrees(cartesian);
            }
            if (typeof dispFunc == 'function')
                dispFunc(click, degrees);
        }, this._cesium.ScreenSpaceEventType.MIDDLE_DOWN);
        return handler;
    };
    /**
     * 绑定鼠标中建弹起事件
     * @param {Function} [dispFunc] 回调函数
     *
     */
    AttachEvent.prototype.AttachOnMButtonUpEvent = function (dispFunc) {
        //用户释放鼠标中键时触发事件。
        var viewer = this._viewer;
        var _Core = this._Core;
        var scene = this._viewer.scene;
        var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
        handler.setInputAction(function (movement) {
            let cartesian = viewer.scene.pickPosition(movement.position);
            let degrees;
            if (cartesian) {
                degrees = _Core.toDegrees(cartesian);
            }
            if (typeof dispFunc == 'function')
                dispFunc(click, degrees);
        }, this._cesium.ScreenSpaceEventType.MIDDLE_UP);
        return handler;
    };
    /**
     * 绑定鼠标滚轮滚动事件
     * @param {Function} [dispFunc] 回调函数
     *
     */
    AttachEvent.prototype.AttachOnMouseWheelEvent = function (dispFunc) {
        //用户滚动鼠标滚轮并碰到下一个缺口时触发事件。
        var scene = this._viewer.scene;
        var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
        handler.setInputAction(function (movement) {
            if (typeof dispFunc == 'function')
                dispFunc(movement);
        }, this._cesium.ScreenSpaceEventType.WHEEL);
        return handler;
    };

    /**
     * 绑定实时监听事件
     * @param {Function} [dispFunc] 回调函数
     *
     */
    AttachEvent.prototype.AttachOnFrameEvent = function (dispFunc) {
        //表示鼠标移动事件。
        var scene = this._viewer.scene;
        var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
        handler.setInputAction(function (movement) {
            if (typeof dispFunc == 'function')
                dispFunc(movement);
        }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        return handler;
    };
    /**
     * 绑定鼠标右键按下事件
     * @param {Function} [dispFunc] 回调函数
     *
     */
    AttachEvent.prototype.AttachOnRButtonDownEvent = function (dispFunc) {
        var viewer = this._viewer;
        var _Core = this._Core;
        //用户按下鼠标右键时触发事件。
        var scene = this._viewer.scene;
        var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
        handler.setInputAction(function (movement) {
            let cartesian = viewer.scene.pickPosition(movement.position);
            let degrees;
            if (cartesian) {
                degrees = _Core.toDegrees(cartesian);
            }
            if (typeof dispFunc == 'function')
                dispFunc(click, degrees);
        }, this._cesium.ScreenSpaceEventType.RIGHT_DOWN);
        return handler;
    };
    /**
     * 绑定鼠标右键弹起事件
     * @param {Function} [dispFunc] 回调函数
     *
     */
    AttachEvent.prototype.AttachOnRButtonUpEvent = function (dispFunc) {
        var viewer = this._viewer;
        var _Core = this._Core;
        //用户释放鼠标右键时触发事件。
        var scene = this._viewer.scene;
        var handler = new this._cesium.ScreenSpaceEventHandler(scene.canvas);
        handler.setInputAction(function (movement) {
            let cartesian = viewer.scene.pickPosition(movement.position);
            let degrees;
            if (cartesian) {
                degrees = _Core.toDegrees(cartesian);
            }
            if (typeof dispFunc == 'function')
                dispFunc(click, degrees);
        }, this._cesium.ScreenSpaceEventType.RIGHT_UP);
        return handler;
    };
    /**
     * 绑定相机视角改变事件
     * @param {Function} [Func] 回调函数
     *
     */
    AttachEvent.prototype.AttachCameraChangeEvent = function (Func) {
        this._viewer.scene.camera.percentageChanged = 0.000001;
        //监听视角改变
        this._viewer.scene.camera.changed.addEventListener(Func);
        return Func
    };
    /**
     * 绑定相机飞行结束事件(只触发一次)
     * @param {Function} [Func] 回调函数
     *
     */
    AttachEvent.prototype.CameraMoveEndEvent = function (Func) {
        var viewer = this._viewer;
        var isMoveStart = false;

        function moveStart() {
            isMoveStart = true;
        }

        function moveEnd() {
            if (isMoveStart) {
                Func && Func();
                //移除监听视角
                viewer.scene.camera.moveStart.removeEventListener(moveStart);
                viewer.scene.camera.moveEnd.removeEventListener(moveEnd);
            }
        }

        //监听视角改变
        setTimeout(function () {
            viewer.scene.camera.moveStart.addEventListener(moveStart);
            viewer.scene.camera.moveEnd.addEventListener(moveEnd);
        }, 0);

    };

    /**
     * 解除绑定事件。
     *
     * @alias DetachEvent
     * @constructor
     * 
     * @param {Viewer} viewer 地图视图
     * @param {Cesium} cesium Cesium对象
     * 
     */
    function DetachEvent(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    /**
     * 解除事件绑定
     * @param {ScreenSpaceEventHandler} [handler] 事件。
     * @param {EventType} [bstrEventName] 事件名称。
     */
    DetachEvent.prototype.DetachEvent = function (handler, bstrEventName) {
        if (bstrEventName === EventType$1.L_Click) {
            //当用户双击鼠标左键时触发事件
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.LEFT_CLICK);
            }
        } else if (bstrEventName === EventType$1.L_DBL_Click) {
            //当用户双击鼠标左键时触发事件
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
            }
        } else if (bstrEventName === EventType$1.L_Down) {
            //当用户按下鼠标左键时触发事件。
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.LEFT_DOWN);
            }
        } else if (bstrEventName === EventType$1.L_Up) {
            //用户释放鼠标左键时触发事件。
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.LEFT_UP);
            }
        } else if (bstrEventName === EventType$1.M_Click) {
            //用户按下鼠标中键时触发事件。
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.MIDDLE_CLICK);
            }
        } else if (bstrEventName === EventType$1.M_Down) {
            //用户按下鼠标中键时触发事件。
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.MIDDLE_DOWN);
            }
        } else if (bstrEventName === EventType$1.M_Up) {
            //用户释放鼠标中键时触发事件。
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.MIDDLE_UP);
            }
        } else if (bstrEventName === EventType$1.R_Click) {
            //当用户双击鼠标左键时触发事件
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.RIGHT_CLICK);
            }
        } else if (bstrEventName === EventType$1.R_Down) {
            //用户按下鼠标右键时触发事件。
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.RIGHT_DOWN);
            }
        } else if (bstrEventName === EventType$1.R_Up) {
            //用户释放鼠标右键时触发事件。
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.RIGHT_UP);
            }
        } else if (bstrEventName === EventType$1.Wheel) {
            //用户滚动鼠标滚轮并碰到下一个缺口时触发事件。
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.WHEEL);
            }
        } else if (bstrEventName === EventType$1.Move) {
            //表示鼠标移动事件。
            if (handler) {
                handler.removeInputAction(this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
            }
        } else {
            handler && handler.destroy();
        }
    };

    /**
     *
     * 解除当前绑定的所有事件。
     *
     */
    DetachEvent.prototype.DetachEventAll = function (handler) {
        if (handler) {
            handler.destroy();
            handler = null;
        }
    };

    /**
     * 添加移除默认cesium的双击追踪效果
     */
    DetachEvent.prototype.RemoNormalCesiumLeftDoubleClick = function () {
        this._viewer.cesiumWidget.screenSpaceEventHandler.removeInputAction(this._cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
    };

    /**
     * 移除相机视角改变事件
     * @param {Function} [Func] 回调函数
     *
     */
    DetachEvent.prototype.DetachCameraChangeEvent = function (Func) {
        this._viewer.scene.camera.percentageChanged = 0.5;
        //移除监听视角
        this._viewer.scene.camera.changed.removeEventListener(Func);
    };

    let scope = typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {};

    let currentScript = document.currentScript && document.currentScript.src;
    if (!currentScript) {
        (function () {
            try {
                throw Error("获取当前文件路径");
            } catch (ex) {
                if (ex.fileName) {//Firefox
                    currentScript = ex.fileName;
                } else if (ex.stack) {//Chrome
                    currentScript = (ex.stack.match(/at\s+(.*?):\d+:\d+/) || ['', ''])[1];
                } else if (ex.sourceURL) {//Safari
                    currentScript = ex.sourceURL;
                }
            }
        })();
    }
    if (currentScript.indexOf("(") > -1) {
        currentScript = currentScript.split("(")[1];
    }
    let endIndex = currentScript.indexOf('SmartEarth.js');
    if (endIndex < 0) {
        endIndex = currentScript.indexOf('SmartEarth.min.js');
    }
    let rootUrl = currentScript.substring(0, endIndex);
    let links = document.getElementsByTagName('link');
    let HaveSmartEarthCSS = false;
    for (let i = 0; i < links.length; i++) {
        if (links[i].href.indexOf('smartearth.css') !== -1) {
            HaveSmartEarthCSS = true;
        }
    }

    if (!HaveSmartEarthCSS) {
        let link = document.createElement("link");
        link.rel = "stylesheet";
        link.type = "text/css";
        link.href = rootUrl + 'Workers/css/smartearth.css';
        document.head.appendChild(link);
    }

    scope.SmartEarthRootUrl = rootUrl;

    let SkipTool = new Skip(false);
    try {
        if (!scope.$) {
            SkipTool.addJs(document.body, rootUrl + 'Workers/jquery-2.0.3.js');
        }
        if (scope.layer) {
            scope.SmartEarth.layuiLayer = scope.layuiLayer = scope.layer;
        } else {
            SkipTool.addJs(document.body, rootUrl + 'Workers/layui/lay/modules/layer.js');
            scope.SmartEarth.layuiLayer = scope.layuiLayer = scope.layer;
        }
        if (scope.Cesium && !scope.Cesium.turf) {
            SkipTool.addJs(document.body, rootUrl + 'Workers/turf.min.js');
            scope.Cesium.turf = scope.turf;
        }
        //async兼容
        SkipTool.addJs(document.body, rootUrl + 'Workers/polyfill.min.js');
    } catch (e) {

    }

    scope.SmartEarthPopupData = {};

    scope.logSmartEarthLog = () => {
        let SmartEarthVesion = scope.SmartEarth && scope.SmartEarth.VERSION;
        let SmartEarthCompileTime = scope.SmartEarth && scope.SmartEarth.COMPILETIME;
        let CesiumVesion = scope.Cesium && scope.Cesium.VERSION;
        let SmartEarthLog = `
%c            
%c
版 本 号：${SmartEarthVesion}    Cesium版本：${CesiumVesion}
编译时间：${SmartEarthCompileTime}
授权信息：内部测试版本。
版权声明： SmartEarthSDK版权完全属于【合肥泰瑞数创科技有限公司】



在线示例：http://183.162.245.49:82/05sdkdemo-pro
接口文档：http://183.162.245.49:82/05sdkdemo-pro/static/api
    `;

        setTimeout(
            console.log.bind(console,
                SmartEarthLog,
                `font-size:50px;background:rgba(34,34,34,0.5) url('${rootUrl}Workers/image/logo.png')`,
                'color:#018aff;font-size:13px;font-family:微软雅黑'),
            0);
    };

    /**
    *
    * 放大。
    *
    * @alias zoomIn 
    * @constructor
    *
    */

    function zoomIn(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }
    zoomIn.prototype.zoomIn = function () {
        var height = Math.ceil(this._viewer.camera.positionCartographic.height) * 0.6;
        return this._viewer.camera.zoomIn(height);
    };

    /**
    *
    * 缩小视野
    *
    * @alias zoomOut 
    * @constructor
    *
    */

    function zoomOut(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }
    zoomOut.prototype.zoomOut = function () {
        var height = Math.ceil(this._viewer.camera.positionCartographic.height) * 0.6;
        return this._viewer.camera.zoomOut(height);};

    /**
     *
     * 飞到某个对象
     *
     * @alias flyToObj 
     * @constructor
     *
     */

    function flyToObj(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
    }
    flyToObj.prototype.flyToObj = function (obj) {
        if (obj && obj.west != undefined && obj.west != null) {
            this._viewer.camera.flyTo({
                destination: this._cesium.Rectangle.fromDegrees(obj.west, obj.south, obj.east, obj.north)
            });
            //this._cesium.Rectangle.fromDegrees(obj.west, obj.south, obj.east, obj.north)
        } else {
            if (obj && obj.item && obj.item.id != undefined && obj.item.id != null) {
                var vv = tree.getSourceById(this._tree, obj.item.id);
                try {
                    // viewer.scene.primitives.get
                    var o = this._viewer.scene.primitives.get(vv.id);
                    //var o = this._viewer.scene.primitives._primitives[2];
                    this._viewer.flyTo(o);
                } catch (ex) {
                    //throw ex;
                }
            }
            if (obj && obj.item) {
                if (obj.item.entities) {
                    this._viewer.flyTo(obj.item);
                } else if (obj.item._primitives && obj.item._primitives.length) {
                    var primitives = lodash.filter(obj.item._primitives, function (o) {
                        return o.geometryInstances == undefined;
                    });
                    if (primitives.length > 0) {
                        if (primitives[0]._boundingSpheres != undefined) {
                            this._viewer.camera.flyToBoundingSphere(primitives[0]._boundingSpheres[0]);
                        } else if (primitives[0]._primitive != undefined && primitives[0]._primitive != null && primitives[0]._primitive._boundingSpheres[0] != undefined && primitives[0]._primitive._boundingSpheres[0] != null) {
                            this._viewer.camera.flyToBoundingSphere(primitives[0]._primitive._boundingSpheres[0]);
                        } else {
                            if (primitives[0]._labels != undefined && primitives[0]._labels.length > 0) {
                                var center = primitives[0]._labels[0].position;
                                var Cartographic = this._cesium.Cartographic.fromCartesian(center);
                                var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                                var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                                var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, 2000);
                                this._viewer.camera.flyTo({
                                    destination: position
                                });
                            } else if (primitives[0]._pointPrimitives != undefined && primitives[0]._pointPrimitives.length > 0) {
                                var center = primitives[0]._pointPrimitives[0].position;
                                var Cartographic = this._cesium.Cartographic.fromCartesian(center);
                                var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                                var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                                var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, 2000);
                                this._viewer.camera.flyTo({
                                    destination: position
                                });
                            } else if (primitives[0]._billboards != undefined && primitives[0]._billboards.length > 0) {
                                var center = primitives[0]._billboards[0].position;
                                var Cartographic = this._cesium.Cartographic.fromCartesian(center);
                                var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                                var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                                var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, 2000);
                                this._viewer.camera.flyTo({
                                    destination: position
                                });
                            }
                        }
                    }
                } else if (obj.item._primitives && obj.item._primitives._boundingSpheres) {
                    if (obj.item._primitives._boundingSpheres.length)
                        this._viewer.camera.flyToBoundingSphere(obj.item._primitives._boundingSpheres[0]);
                } else if (obj.item._boundingSpheres && obj.item._boundingSpheres.length > 0) {
                    this._viewer.camera.flyToBoundingSphere(obj.item._boundingSpheres[0]);
                } else if (obj.item._boundingVolumes && obj.item._boundingVolumes.length) {
                    // this._viewer.flyTo(obj.item.readyPromise);
                    var center = obj.item._boundingVolumes[0].center;
                    var Cartographic = this._cesium.Cartographic.fromCartesian(center);
                    var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                    var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                    var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, 5000);
                    this._viewer.camera.flyTo({
                        destination: position
                    });
                } else {
                    this._viewer.flyTo(obj.item);
                }
            } else if (obj) {
                this._viewer.flyTo(obj);
            }
        }
    };

    /**
     *
     * 跳转到某个对象/位置
     *
     * @alias jumpTo
     * @constructor
     *
     */

    function jumpTo(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
    }
    jumpTo.prototype.jumpTo = function (obj) {
        if (obj && obj.west != undefined && obj.west != null) {
            this._viewer.camera.setView({
                destination: this._cesium.Rectangle.fromDegrees(obj.west, obj.south, obj.east, obj.north)
            });
            //this._cesium.Rectangle.fromDegrees(obj.west, obj.south, obj.east, obj.north)
        } else if (obj && obj.destination !== undefined) {
            this._viewer.camera.setView({
                destination: obj.destination,
                orientation: obj.orientation
            });
        } else {
            if (obj && obj.item && obj.item.id != undefined && obj.item.id != null) {
                var vv = tree.getSourceById(this._tree, obj.item.id);
                try {
                    // viewer.scene.primitives.get
                    var o = this._viewer.scene.primitives.get(vv.id);
                    //var o = this._viewer.scene.primitives._primitives[2];
                    this._viewer.zoomTo(o);
                } catch (ex) {
                    //throw ex;
                }
            }
            if (obj && obj.item) {
                if (obj.item.entities) {
                    this._viewer.zoomTo(obj.item);
                } else if (obj.item._primitives && obj.item._primitives.length) {
                    var primitives = lodash.filter(obj.item._primitives, function (o) {
                        return o.geometryInstances == undefined;
                    });
                    if (primitives.length > 0) {
                        if (primitives[0]._boundingSpheres != undefined) {
                            this._viewer.camera.viewBoundingSphere(primitives[0]._boundingSpheres[0]);
                        } else {
                            if (primitives[0]._labels != undefined && primitives[0]._labels.length > 0) {
                                var center = primitives[0]._labels[0].position;
                                var Cartographic = this._cesium.Cartographic.fromCartesian(center);
                                var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                                var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                                var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, 2000);
                                this._viewer.camera.setView({
                                    destination: position
                                });
                            } else if (primitives[0]._pointPrimitives != undefined && primitives[0]._pointPrimitives.length > 0) {
                                var center = primitives[0]._pointPrimitives[0].position;
                                var Cartographic = this._cesium.Cartographic.fromCartesian(center);
                                var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                                var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                                var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, 2000);
                                this._viewer.camera.setView({
                                    destination: position
                                });
                            } else if (primitives[0]._billboards != undefined && primitives[0]._billboards.length > 0) {
                                var center = primitives[0]._billboards[0].position;
                                var Cartographic = this._cesium.Cartographic.fromCartesian(center);
                                var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                                var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                                var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, 2000);
                                this._viewer.camera.setView({
                                    destination: position
                                });
                            }
                        }
                    }
                } else if (obj.item._primitives && obj.item._primitives._boundingSpheres) {
                    if (obj.item._primitives._boundingSpheres.length)
                        this._viewer.camera.viewBoundingSphere(obj.item._primitives._boundingSpheres[0]);
                } else if (obj.item._boundingSpheres && obj.item._boundingSpheres.length > 0) {
                    this._viewer.camera.viewBoundingSphere(obj.item._boundingSpheres[0]);
                } else if (obj.item._boundingVolumes && obj.item._boundingVolumes.length) {
                    // this._viewer.zoomTo(obj.item.readyPromise);
                    var center = obj.item._boundingVolumes[0].center;
                    var Cartographic = this._cesium.Cartographic.fromCartesian(center);
                    var longitude = this._cesium.Math.toDegrees(Cartographic.longitude);
                    var latitude = this._cesium.Math.toDegrees(Cartographic.latitude);
                    var position = this._cesium.Cartesian3.fromDegrees(longitude, latitude, 5000);
                    this._viewer.camera.setView({
                        destination: position
                    });
                } else {
                    this._viewer.zoomTo(obj.item);
                }
            } else if (obj) {
                this._viewer.zoomTo(obj);
            }
        }
    };

    /**
    *
    * 指北
    *
    * @alias northfinger 
    * @constructor
    *
    */

    function northfinger(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }
    northfinger.prototype.northfinger = function () {
        this._viewer.camera.setView({
            destination: this._viewer.camera._destination,//相机位置
            orientation: {
                pitch: this._viewer.camera._pitch,
                roll: 0
            }
        });
    };

    /**
     *
     * 跳转到位置
     *
     * @alias setPosition
     * @constructor
     *
     */

    function setPosition(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }

    setPosition.prototype.setPosition = function (x, y, z) {
        if (Math.abs(x) <= 180 && Math.abs(y) <= 90) {
            this._viewer.camera.setView({
                destination: this._cesium.Cartesian3.fromDegrees(x, y, z)
            });
        } else {
            this._viewer.camera.setView({
                destination: { x: x, y: y, z: z }
            });
        }
    };

    /**
    *
    * 取消飞行。
    *
    * @alias Stop
    * @constructor
    *
    */

    function Stop(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
    }
    Stop.prototype.Stop = function () {
        this._viewer.scene.camera.cancelFlight();
    };

    /**
     *
     * 导航模块。
     *
     * @alias Navigate
     * @constructor
     *
     */


    function Navigate(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._zoomIn = new zoomIn(this._viewer, this._cesium);
        this._zoomOut = new zoomOut(this._viewer, this._cesium);
        this._flyTo = new flyTo(this._viewer, this._cesium, this._tree);
        this._flyToObj = new flyToObj(this._viewer, this._cesium);
        this._jumpTo = new jumpTo(this._viewer, this._cesium, this._tree);
        this._northfinger = new northfinger(this._viewer, this._cesium);
        this._Stop = new Stop(this._viewer, this._cesium);
    }
    /**
    *
    *  Navigate.getPosition() 获取当前摄像机的位置
    * @version 3.1.0
    *    获取当前摄像机的位置
    * 导航
    * @returns Success-Response:
    *      position
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Navigate.prototype.getPosition = function () {
        if (!this._getPosition) {
            this._getPosition = new getPosition(this._viewer, this._cesium);
        }
        return this._getPosition.getPosition();
    };
    /**
     * 获取鼠标当前世界坐标
     * @param {object} [movement] 鼠标屏幕位置
     * @param {Array/Object} [objectsToExclude] 排除的实体对象
     * @param {number} [type] 类型（0为模型优先，1为地形优先）,默认模型优先
     * @param {boolean} [isAdsorption] true|false 是否吸附，默认否
     * @param {number} [distance] 吸附半径，默认30
     */
    Navigate.prototype.getMousePosition = function (movement, objectsToExclude, type, isAdsorption, distance) {
        if (!this._getPosition) {
            this._getPosition = new getPosition(this._viewer, this._cesium);
        }
        return this._getPosition.getMousePosition(movement, objectsToExclude, type, isAdsorption, distance);
    };

    /**
    *
    *  Navigate.getPosition() 获取当前摄像机的经纬度
    * @version 3.1.0
    *    获取当前摄像机的经纬度
    * 导航
    * @returns Success-Response:
    *      position
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Navigate.prototype.getDegrees = function () {
        if (!this._getPosition) {
            this._getPosition = new getPosition(this._viewer, this._cesium);
        }
        return this._getPosition.getDegrees();
    };
    /**
     * 获取鼠标当前经纬度
     * @param {object} [movement] 鼠标屏幕位置
     * @param {Array/Object} [objectsToExclude] 排除的实体对象
     * @param {number} [type] 类型（0为模型优先，1为地形优先）,默认模型优先
     * @param {boolean} [isAdsorption] true|false 是否吸附，默认否
     * @param {number} [distance] 吸附半径，默认30
     */
    Navigate.prototype.getMouseDegrees = function (movement, objectsToExclude, type, isAdsorption, distance) {
        if (!this._getPosition) {
            this._getPosition = new getPosition(this._viewer, this._cesium);
        }
        return this._getPosition.getMouseDegrees(movement, objectsToExclude, type, isAdsorption, distance);
    };
    /**
    *
    *  Creator.setPosition(x,y,z) 跳转到位置
    * @version 3.1.0
    *   跳转到位置
    * 导航
    * @param {String} x
    * @param {String} y
    * @param {String} z
    * @example {object} 参数说明
    *       x: 0,
            y: 0,
            z:0
    * @returns Success-Response:
    *     {
    *       
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Navigate.prototype.setPosition = function (x, y, z) {
        if (!this._setPosition) {
            this._setPosition = new setPosition(this._viewer, this._cesium);
        }
        return this._setPosition.setPosition(x, y, z);
    };

    /**
    *
    *  Creator.zoomIn() 放大视野
    * @version 3.1.0
    *   放大视野
    * 导航
    * @returns Success-Response:
    *     {
    * 
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Navigate.prototype.zoomIn = function () {
        return this._zoomIn.zoomIn();
    };
    /**
    *
    *  Creator.zoomIn() 缩小视野
    * @version 3.1.0
    *   缩小视野
    * 导航
    * @returns Success-Response:
    *     {
    * 
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Navigate.prototype.zoomOut = function () {
        return this._zoomOut.zoomOut();
    };
    /**
    *
    *  Creator.flyTo(target,Pattern) flyTo
    * @version 3.1.0
    *   flyTo
    * 导航
    * @param {object} target
    * @param {object} Pattern
    * @example {object} 参数说明
    *   {
    *       target：object
    *       Pattern:{
    *               duration:duration
                    maximumHeight:maximumHeight
                    offset:offset
    *           }
    *   }
    * @returns Success-Response:
    *     {
    * 
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Navigate.prototype.flyTo = function (target, Pattern) {
        return this._flyTo.flyTo(target, Pattern);
    };
    /**
     * 这个方法用于视点飞到一个对象
     */
    /**
    *
    *  Creator.flyToObj(obj) flyToObj
    * @version 3.1.0
    *   flyToObj
    * 导航
    * @param {object} obj
    * @example {object} 参数说明
    *   {
    *       obj ：object
    *   }
    * @returns Success-Response:
    *     {
    * 
    *     }
    * @exception {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    Navigate.prototype.flyToObj = function (obj) {
        this._flyToObj.flyToObj(obj);
    };
    /**
     * 这个方法用于视点定位到一个对象/位置
     *
     *
     */
    Navigate.prototype.jumpTo = function (target, Pattern) {
        return this._jumpTo.jumpTo(target, Pattern);
    };
    /**
     * 这个方法用于指北
     */
    Navigate.prototype.northfinger = function () {
        this._northfinger.northfinger();
    };
    /**
     * 飞到位置
     */
    Navigate.prototype.flyToPosition = function (x, y, z) {
        this._flyTo.flyToPosition(x, y, z);
    };
    /**
     * 飞到兴趣点
     */
    Navigate.prototype.flyToPointsInterest = function (target, fnc) {
        this._flyTo.flyToPointsInterest(target, fnc);
    };
    /**
     * 取消飞行
     */
    Navigate.prototype.Stop = function () {
        this._Stop.Stop();
    };

    /**
     *
     * 该方法在树中删除一个条目。
     *
     * @alias deleteItem 
     * @constructor
     *
     */
    function deleteItem(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
    }
    /**
     * 该方法在树中删除一个条目
     * @param {String} [ItemID] 组的ID，
     * 
     */
    deleteItem.prototype.deleteItem = function (ItemID) {
        tree.delete(ItemID, this._viewer, this._cesium);
    };
    deleteItem.prototype.testTreeSource = function () {
        console.log(this._tree);
    };

    /**
    *
    * 使用路径查找条目。
    *
    * @alias findItem 
    * @constructor
    *
    */
    function findItem(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
    }
    /**
    * 使用路径查找条目
    * @param {String} [PathName] 查找条目的准确路径。子条目使用’\’分隔（例如，”Cities\Boston”）。
    * @returns {Promise.<string>} 返回id。
    * 
    */
    findItem.prototype.findItem = function (PathName) {
        var arr = [];
        var pid = "";
        var source = lodash.clone(this._tree);
        arr = PathName.split("\\");
        for (var i = 0; i < arr.length; i++) {
            source = tree.getSourceByName(source, arr[i]);
            if (i == arr.length - 1) {
                if (source) {
                    pid = source.id;
                    break;
                }
                else {
                    pid = "";
                }
            }
            else {
                if (source) {
                    source = source.children;
                }
                else {
                    pid = "";
                    source = null;
                    break;
                }
            }
        }
        return pid;
    };

    /**
    *
    * 该方法利用ItemID返回某条目的名称。
    *
    * @alias getItemName 
    * @constructor
    *
    */
    function getItemName(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
    }
    /**
    *该方法利用ItemID返回某条目的名称
    * @param {String} [ItemID] 返回与正在查找的组名称对应的ItemID。
    * @returns {Promise.<string>} 返回名字。
    * 
    */
    getItemName.prototype.getItemName = function (ItemID) {
        var vv = tree.getSourceById(this._tree, ItemID);
        if (vv) {
            return vv.name;
        }
        return '';
    };

    /**
    *
    * 该方法返回信息树条目在地形中的可视化状态。
    *
    * @alias getVisibility 
    * @constructor
    *
    */
    function getVisibility(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
    }
    /**
    * 该方法返回信息树条目在地形中的可视化状态。
    * @param {String} [ItemID] 返回与正在查找的组名称对应的ItemID。
    * 
    */
    getVisibility.prototype.getVisibility = function (ItemID) {
        var vv = vv = tree.getSourceById(this._tree, ItemID);
        if (vv) {
            return vv.item.getVisibility();
        }
        return undefined;
    };

    /**
         *
         * 该方法设置信息树条目在地形场景中的可见性。
         *
         * @alias setVisibility 
         * @constructor
         *
         */
    function setVisibility(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
    }
    /**
     * 该方法设置信息树条目在地形场景中的可见性。
     * @param {String} [ItemID] 返回与正在查找的组名称对应的ItemID。
     * @param {boolean} [bool] 显示与隐藏。
     * 
     */
    setVisibility.prototype.setVisibility = function (ItemID, bool) {
        tree.setVisibility(ItemID, bool, this._viewer, this._cesium);
    };

    /**
    *
    * 重命名信息树中的指定组。
    *
    * @alias renameGroup 
    * @constructor
    *
    */
    function renameGroup(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
    }
    /**
    * 重命名信息树中的指定组。
    * @param {String} [ItemID] 重命名的组对应的ItemID。
    * @param {String} [GroupName] 组的新名称。
    * 
    */
    renameGroup.prototype.rename = function (ItemID, GroupName) {
        var vv = tree.getSourceById(this._tree, ItemID);
        if (vv) {
            vv.name = GroupName;
        }
        var vv1 = tree.getTempSourceById(ItemID);
        if (vv1) {
            vv1.name = GroupName;
        }
    };

    /**
    *
    * 该方法可以检索具有指定关系的树条目。
    *
    * @alias getNextItem 
    * @constructor
    *
    */
    function getNextItem(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
    }
    /**
    * 该方法可以检索具有指定关系的树条目。
    * @param {String} [ItemID] 返回与正在查找的组名称对应的ItemID。
    * 
    */
    getNextItem.prototype.getNextItem = function (ItemID, Code) {

    };

    var exitsObjectType = {
        none: -1,
        point: 0,
        polyline: 1,
        polygon: 2,
        label: 3,
        imageLabel: 4,
        position: 5,
        imageLayer: 6,
        dynamicObject: 7,
        D3titles: 8,
        box: 9,
        circle: 10,
        cone: 11,
        pointfeaturelayer: 12,
        polylinefeaturelayer: 13,
        polygonfeaturelayer: 14,
        pointmodel: 15,
        rectangle: 16,
        ellipsoid: 17,
        wall: 18,
        polylinevolume: 19
    };
    var getExitsObjectType = Object.freeze(exitsObjectType);

    /**
     *
     * 该方法基于ItemID返回对象接口。
     *
     * @alias getObject 
     * @constructor
     *
     */
    function getObject(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
        this._treeSource = tree.Source;
        this._treeTemp = tree.getTempSource();
        this._tree1 = tree;
        this._core = new Core();
    }
    /**
     * 该方法基于ItemID返回对象接口
     * @param {String} [ItemID] 返回与正在查找的组名称对应的ItemID。
     * @returns {Promise.<object>} 返回对象。
     * 
     */
    getObject.prototype.getObject = function (ItemID) {
        var source = lodash.clone(this._tree);
        var vv = tree.getSourceById(source, ItemID);
        if (vv) {
            return vv.item;
        } else {
            var source1 = lodash.clone(tree.PointSelectSource);
            var vv1 = tree.getPointSelectSourceById(source1, ItemID);
            if (vv1) {
                return vv1.item;
            } else {
                return undefined;
            }
        }
    };

    /**
     * 该方法基于ItemID返回对象接口
     * @param {String} [ItemID] 返回与正在查找的组名称对应的ItemID。
     * @returns {Promise.<object>} 返回对象。
     * 
     */
    getObject.prototype.getTreeItem = function (ItemID) {
        var source = lodash.clone(this._tree);
        var vv = tree.getSourceById(source, ItemID);
        if (vv) {
            return vv;
        } else {
            var dataSources = this._viewer.dataSources;
            for (var i = 0; i < dataSources.length; i++) {
                var entity = dataSources.get(i).entities.getById(ItemID);
                if (entity) {
                    if (entity.point && (entity.point.show == undefined || (entity.point.show._value))) {
                        var point = new Point(this._viewer, this._cesium);
                        point.setItem(entity);
                        var obj = {
                            id: this._core.getuid(),
                            name: '',
                            pId: 0,
                            type: 'point',
                            item: point
                        };
                        tree.pusPointSelectSource(obj);
                        return obj;
                    } else if (entity.label && (entity.label.show == undefined || entity.label.show._value)) {
                        var point = new Label(this._viewer, this._cesium);
                        point.setItem(entity);
                        var obj = {
                            id: this._core.getuid(),
                            name: '',
                            pId: 0,
                            type: 'label',
                            item: point
                        };
                        tree.pusPointSelectSource(obj);
                        return obj;
                    } else if (entity.box && (entity.box.show == undefined || entity.box.show._value)) {
                        var box = new Box(this._viewer, this._cesium);
                        box.setItem(entity);
                        var obj = {
                            id: this._core.getuid(),
                            name: '',
                            pId: 0,
                            type: 'box',
                            item: box
                        };
                        tree.pusPointSelectSource(obj);
                        return obj;
                    } else if (entity.model && (entity.model.show == undefined || entity.model.show._value)) {
                        var point = new model(this._viewer, this._cesium);
                        point.setItem(entity);
                        var obj = {
                            id: this._core.getuid(),
                            name: '',
                            pId: 0,
                            type: 'model',
                            item: point
                        };
                        tree.pusPointSelectSource(obj);
                        return obj;
                    } else if (entity.wall && (entity.wall.show == undefined || entity.wall.show._value)) {
                        var wall$1 = new wall(this._viewer, this._cesium);
                        wall$1.setItem(entity);
                        var obj = {
                            id: this._core.getuid(),
                            name: '',
                            pId: 0,
                            type: 'wall',
                            item: wall$1
                        };
                        tree.pusPointSelectSource(obj);
                        return obj;
                    } else if (entity.polyline) {
                        var polyline = new Polyline(this._viewer, this._cesium);
                        polyline.setItem(entity);
                        var obj = {
                            id: this._core.getuid(),
                            name: '',
                            pId: 0,
                            type: 'polyline',
                            item: polyline
                        };
                        tree.pusPointSelectSource(obj);
                        return obj;
                    } else if (entity.polygon) {
                        var polygon = new Polygon(this._viewer, this._cesium);
                        polygon.setItem(entity);
                        var obj = {
                            id: this._core.getuid(),
                            name: '',
                            pId: 0,
                            type: 'polygon',
                            item: polygon
                        };
                        tree.pusPointSelectSource(obj);
                        return obj;
                    } else if (entity.rectangle) {
                        var rectangle = new Rectangle$1(this._viewer, this._cesium);
                        rectangle.setItem(entity);
                        var obj = {
                            id: this._core.getuid(),
                            name: '',
                            pId: 0,
                            type: 'rectangle',
                            item: rectangle
                        };
                        tree.pusPointSelectSource(obj);
                        return obj;
                    } else if (entity.billboard && (entity.billboard.show == undefined || entity.billboard.show._value)) {
                        var point = new ImageLabel(this._viewer, this._cesium);
                        point.setItem(entity);
                        var obj = {
                            id: this._core.getuid(),
                            name: '',
                            pId: 0,
                            type: 'billboard',
                            item: point
                        };
                        tree.pusPointSelectSource(obj);
                        return obj;
                    }
                }
            }
            return undefined;

        }
    };

    getObject.prototype.updateItemId = function (oldItemID, newItemID) {
        var source = this._treeSource;
        var vv = tree.getSourceById(source, oldItemID);
        if (vv) {
            vv.id = newItemID;
            if (vv.type == 'group') {
                if (vv.children && vv.children.length > 0) {
                    for (var i = 0; i < vv.children.length; i++) {
                        vv.children[i].pId = newItemID;
                    }
                }
            }
        }
        var source = this._treeTemp;
        var vv = tree.getSourceById(source, oldItemID);
        if (vv) {
            vv.id = newItemID;
            if (vv.type == 'group') {
                if (vv.children && vv.children.length > 0) {
                    for (var i = 0; i < vv.children.length; i++) {
                        vv.children[i].pId = newItemID;
                    }
                }
            }
        }
    };

    /**
     * 统一工程树节点
     */
    getObject.prototype.unifiedProject = function (des, tar) {
        for (var i = 0; i < tar.length; i++) {
            tar[i].id = des[i].id;
            tar[i].pId = tar[i].pId;
            if (tar[i].children && tar[i].children.length > 0) {
                this.unifiedProject(des[i].children, tar[i].children);
            }
        }
    };

    /**
     * 非sdk创建的对象绑定到工程树
     * @param {String} [parentGroupID] 组ID
     * @param {String} [GroupName] 当前组名称 不为空将会新建一个组 为空在parentGroupID下
     * @param {String} [name] 显示在工程树的名称
     * @param {Float} [objectType] 绑定的对象类型
     *  none: -1,
        point: 0,
        polyline: 1,
        polygon: 2,
        label: 3,
        imageLabel: 4,
        position: 5,
        imageLayer: 6,
        dynamicObject: 7,
        D3titles: 8,
        box: 9,
        circle: 10,
        cone: 11,
        pointfeaturelayer: 12,
        polylinefeaturelayer: 13,
        polygonfeaturelayer: 14,
     * @param {Promise} [entity] 要绑定的对象 
     */
    getObject.prototype.insertProjectTree = function (parentGroupID, name, objectType, entity, ck) {
        var checked = true;
        if (this._core.isnull(name)) {
            name = this._core.getuid();
        }
        if (ck == false) {
            checked = false;
        } else {
            checked = true;
        }
        if (getExitsObjectType.none == objectType) {
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'unknown',
                item: null
            };
            tree.insertGroupId(obj, parentGroupID);

        } else if (getExitsObjectType.position == objectType) {
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'unknown',
                item: null
            };
            tree.insertGroupId(obj, parentGroupID);

        } else if (getExitsObjectType.imageLayer == objectType) {
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                checked: checked,
                type: 'unknown',
                item: null
            };
            tree.insertGroupId(obj, parentGroupID);

        } else if (getExitsObjectType.dynamicObject == objectType) {
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'unknown',
                item: null
            };
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.point == objectType) {
            var point = new Point(this._viewer, this._cesium);
            point.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'point',
                item: point
            };
            point.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.polyline == objectType) {
            var polyline = new Polyline(this._viewer, this._cesium);
            polyline.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'polyline',
                item: polyline
            };
            polyline.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.rectangle == objectType) {
            var rectangle = new Rectangle$1(this._viewer, this._cesium);
            rectangle.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'rectangle',
                item: rectangle
            };
            rectangle.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.ellipsoid == objectType) {
            var ellipsoid = new Ellipsoid(this._viewer, this._cesium);
            ellipsoid.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'ellipsoid',
                item: ellipsoid
            };
            ellipsoid.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.polygon == objectType) {
            var polygon = new Polygon(this._viewer, this._cesium);
            if (entity._entity) {
                polygon.setItem(entity._entity);
                polygon._points = entity._points;
            } else {
                polygon.setItem(entity);
            }
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'polygon',
                item: polygon
            };
            polygon.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.wall == objectType) {
            var wall$1 = new wall(this._viewer, this._cesium);
            wall$1.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'wall',
                item: wall$1
            };
            wall$1.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.polylinevolume == objectType) {
            var polylinevolume = new PolylineVolume(this._viewer, this._cesium);
            polylinevolume.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'polylinevolume',
                item: polylinevolume
            };
            polylinevolume.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.pointmodel == objectType) {
            var pointmodel = new PointModel(this._viewer, this._cesium);
            pointmodel.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'pointmodel',
                item: pointmodel
            };
            pointmodel.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.label == objectType) {
            var point = new Label(this._viewer, this._cesium);
            point.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'label',
                item: point
            };
            point.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.imageLabel == objectType) {
            var point = new ImageLabel(this._viewer, this._cesium);
            point.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                checked: checked,
                type: 'billboard',
                item: point
            };
            point.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.D3titles == objectType) {
            var d3titles = new SE3DTileset(this._viewer, this._cesium);
            d3titles.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: '3DTilesets',
                item: d3titles
            };
            d3titles.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.box == objectType) {
            var box = new Box(this._viewer, this._cesium);
            box.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'box',
                item: box
            };
            box.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.circle == objectType) {
            var circle = new Circle(this._viewer, this._cesium);
            circle.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'circle',
                item: circle
            };
            circle.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.cone == objectType) {
            var cone = new Cone(this._viewer, this._cesium);
            cone.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'cylinder',
                item: cone
            };
            cone.setTreeobj(obj);
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.pointfeaturelayer == objectType) {
            var geojosnfeaturelayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
            geojosnfeaturelayer.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'pointLayer',
                item: geojosnfeaturelayer
            };
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.pointfeaturelayer == objectType) {
            var geojosnfeaturelayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
            geojosnfeaturelayer.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'polylineLayer',
                item: geojosnfeaturelayer
            };
            tree.insertGroupId(obj, parentGroupID);
        } else if (getExitsObjectType.polygonfeaturelayer == objectType) {
            var geojosnfeaturelayer = new GeoJsonFeatureLayer(this._viewer, this._cesium);
            geojosnfeaturelayer.setItem(entity);
            var obj = {
                id: (entity && entity.id) ? entity.id : this._core.getuid(),
                name: name,
                pId: parentGroupID,
                type: 'polygonLayer',
                item: geojosnfeaturelayer
            };
            tree.insertGroupId(obj, parentGroupID);
        }
        return obj;
    };

    /**
    *
    * 该方法返回信息树中的条目是否是一个组。
    *
    * @alias isGroup 
    * @constructor
    *
    */
    function isGroup(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
    }
    /**
    * 该方法返回信息树中的条目是否是一个组。
    * @param {String} [ItemID] 当前条目的ID。
    * @returns {boolean} 返回true。
    * 
    */
    isGroup.prototype.isGroup = function (ItemID) {
        var source = lodash.clone(this._tree);
        var vv = tree.getSourceById(source, ItemID);
        if (vv && vv.type == "group") {
            return true;
        }
        else {
            return false;
        }
    };

    function exportTree(view, cesium) {
        this._viewer = view;
        this._cesium = cesium;
    }

    /**
     * 导出工程树
     */
    exportTree.prototype.exportMethod = function (source) {
        var exportTrees = [];
        
        for (var i = 0; i < source.length; i++) {
            if (typeof source[i].item.export == 'function') {
                var o = source[i].item.export();
                exportTrees.push(o);
                if (source[i].children && source[i].children.length) {
                    var exportTreess = this.exportMethod(source[i].children);
                    exportTrees.push(exportTreess);
                }
            }
        }
        return exportTrees;
    };

    /**
     * 导出工程树
     */
    exportTree.prototype.export = function () {
        var exportTrees = this.exportMethod(tree.Source);
        return exportTrees;
    };

    /**
     *
     * 工程树
     *
     * @alias ProjectTree 
     * @constructor
     *
     */
    function ProjectTree(viewer, cesium, tree$1) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.Source;
        // treeSource.TempSource=_.clone(tree);
        // treeSource.setSource(_.clone(tree));
        this._createGroup = new createGroup(this._viewer, this._cesium, this._tree);
        this._deleteItem = new deleteItem(this._viewer, this._cesium, this._tree);
        this._findItem = new findItem(this._viewer, this._cesium, this._tree);
        this._getItemName = new getItemName(this._viewer, this._cesium, this._tree);
        this._getVisibility = new getVisibility(this._viewer, this._cesium, this._tree);
        this._setVisibility = new setVisibility(this._viewer, this._cesium, this._tree);
        this._renameGroup = new renameGroup(this._viewer, this._cesium, this._tree);
        this._getNextItem = new getNextItem(this._viewer, this._cesium, this._tree);
        this._isGroup = new isGroup(this._viewer, this._cesium, this._tree);
        this._creator = new Creator(this._viewer, this._cesium);
        this._getObject = new getObject(this._viewer, this._cesium);
        this._exportTree = new exportTree(this._viewer, this._cesium);
        this._core = new Core();
        this.InitTree(tree$1, 0);
        this.InitRootImageLayerAndTerrainlayer();

    }/**
    *
    *  ProjectTree.export()  导出工程树
    * @version 3.1.0
    *   导出工程树
    * 工程
    *  Success-Response:
    *     {
    * 
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    ProjectTree.prototype.export = function () {
        var exportTree = this._exportTree.export();
        var blob = new Blob([JSON.stringify(exportTree)], {
            type: ""
        });
        this._core.saveAs(blob, "tree.json");
        return exportTree;
    };
    /**
    *
    *  ProjectTree.createGroup(GroupName,checked,ParentGroupID) 向工程树添加组
    * @version 3.1.0
    * 向工程树添加组
    * 工程
    * @param {String} GroupName
    * @param {String} checked
    * @param {String} ParentGroupID
    *  {object} 参数说明
    * GroupName 名称, 
    * checked 是否勾选, 
    * ParentGroupID 组编号
    *  Success-Response:
    *     {
    * 
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    ProjectTree.prototype.createGroup = function (GroupName, checked, ParentGroupID) {
        this._createGroup = new createGroup(this._viewer, this._cesium);
        return this._createGroup.createGroup(GroupName, checked, ParentGroupID);
    };
    /**
    *
    *  ProjectTree.changeGroup(ItemID,GroupID) 修改组
    * @version 3.1.0
    *   修改组
    * 工程
    * @param {String} ItemID
    * @param {String} GroupID
    *  {object} 参数说明
    *   ItemID, 
    *   GroupID
    *  Success-Response:
    *     {
    * 
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    ProjectTree.prototype.changeGroup = function (ItemID, GroupID) {
        this._createGroup.changeGroup(ItemID, GroupID);
    };
    //临时数据初始化
    ProjectTree.prototype.starttemporaryItem = function () {
        return this._createGroup.starttemporaryItem();
    };
    //临时数据添加
    ProjectTree.prototype.pushtemporaryItem = function (obj) {
        this._createGroup.pushtemporaryItem(obj);
    };
    //临时状态添加
    ProjectTree.prototype.pushStateItem = function (obj) {
        this._createGroup.pushStateItem(obj);
    };
    //临时数据结束
    ProjectTree.prototype.endtemporaryItem = function () {
        this._createGroup.endtemporaryItem();
    };
    /**
    *
    *  ProjectTree.deleteItem(ItemID) deleteItem
    * @version 3.1.0
    *   deleteItem
    * 工程
    * @param {String} ItemID
    *  {object} 参数说明
    *   ItemID
    *  Success-Response:
    *     {
    * 
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    ProjectTree.prototype.deleteItem = function (ItemID) {
        return this._deleteItem.deleteItem(ItemID);
    };

    /**
    *
    *  ProjectTree.findItem(PathName) findItem
    * @version 3.1.0
    *   findItem
    * 工程
    * @param {String} ItemID
    *  {object} 参数说明
    *   ItemID
    *  Success-Response:
    *     {
    * 
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    ProjectTree.prototype.findItem = function (PathName) {
        return this._findItem.findItem(PathName);
    };
    /**
    *
    *  ProjectTree.getItemName(ItemID) getItemName
    * @version 3.1.0
    *   getItemName
    * 工程
    * @param {String} ItemID
    *  {object} 参数说明
    *   ItemID
    *  Success-Response:
    *     {
    *       item
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    ProjectTree.prototype.getItemName = function (ItemID) {
        return this._getItemName.getItemName(ItemID);
    };
    /**
    *
    *  ProjectTree.getObject(ItemID) getObject
    * @version 3.1.0
    *   getObject
    * 工程
    * @param {String} ItemID
    *  {object} 参数说明
    *   ItemID
    *  Success-Response:
    *     {
    *           item
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    ProjectTree.prototype.getObject = function (ItemID) {
        return this._getObject.getObject(ItemID);
    };
    /**
     *  该方法基于ItemID返回对象接口
     * @param {String} [ItemID] 返回与正在查找的组名称对应的ItemID。
     * @returns {Promise.<object>} 返回对象。
     * 
     */
    ProjectTree.prototype.getTreeItem = function (ItemID) {
        return this._getObject.getTreeItem(ItemID);
    };
    ProjectTree.prototype.updateItemId = function (oldItemID, newItemID) {
        return this._getObject.updateItemId(oldItemID, newItemID);
    };
    /**
    *
    *  ProjectTree.getVisibility(ItemID) getVisibility
    * @version 3.1.0
    *   getVisibility
    * 工程
    * @param {String} ItemID
    *  {object} 参数说明
    *   ItemID
    *  Success-Response:
    *     {
    *           item
    *     }
    * {json} 异常:
    *     {
    *		 exception:{}
    *     }
    */
    ProjectTree.prototype.getVisibility = function (ItemID) {
        return this._getVisibility.getVisibility(ItemID);
    };
    /**
     * 该方法设置信息树条目在地形场景中的可见性。
     * @param {String} [ItemID] 返回与正在查找的组名称对应的ItemID。
     * @param {boolean} [bool]  true|false。
     * 
     */
    ProjectTree.prototype.setVisibility = function (ItemID, bool) {
        return this._setVisibility.setVisibility(ItemID, bool);
    };
    /**
     * 重命名信息树中的指定组。
     * @param {String} [ItemID] 重命名的组对应的ItemID。
     * @param {String} [GroupName] 组的新名称。
     * 
     */
    ProjectTree.prototype.rename = function (ItemID, GroupName) {
        return this._renameGroup.rename(ItemID, GroupName);
    };
    /**
     * 该方法可以检索具有指定关系的树条目。
     * @param {String} [ItemID] 返回与正在查找的组名称对应的ItemID。
     * 
     */
    ProjectTree.prototype.getNextItem = function (ItemID, GroupName) {
        return this._getNextItem.getNextItem(ItemID);
    };
    /**
     * 该方法返回信息树中的条目是否是一个组。
     * @param {String} [ItemID] 当前条目的ID。
     * @returns {Promise.<pval>} 返回true。
     * 
     */
    ProjectTree.prototype.isGroup = function (ItemID) {
        return this._isGroup.isGroup(ItemID);
    };
    /**
     * 获取已有的对象类型
     *  none: -1,
        point: 0,
        polyline: 1,
        polygon: 2,
        label: 3,
        imageLabel: 4,
        position: 5,
        imageLayer: 6,
        dynamicObject: 7,
        D3titles: 8,
        box: 9,
        circle: 10,
        cone: 11,
        pointfeaturelayer: 12,
        polylinefeaturelayer: 13,
        polygonfeaturelayer: 14,
     */
    /**
     * 
     * 获取现有的对象类型
     */
    Object.defineProperties(ProjectTree.prototype, {
        /**
         * Gets the Navigate.
         * @memberof SGWorld.prototype
         * @type {Navigate}
         * @readonly
         */
        exitsObjectType: {
            get: function () {
                return getExitsObjectType
            }
        }
    });
    /**
     * 非sdk创建的对象绑定到工程树
     * @param {String} [parentGroupID] 组ID
     * @param {String} [GroupName] 当前组名称 不为空将会新建一个组 为空在parentGroupID下
     * @param {String} [name] 显示在工程树的名称
     * @param {Float} [objectType] 绑定的对象类型
     *  none: -1,
        point: 0,
        polyline: 1,
        polygon: 2,
        label: 3,
        imageLabel: 4,
        position: 5,
        imageLayer: 6,
        dynamicObject: 7,
        D3titles: 8,
        box: 9,
        circle: 10,
        cone: 11,
        pointfeaturelayer: 12,
        polylinefeaturelayer: 13,
        polygonfeaturelayer: 14,
     * @param {Promise} [entity] 要绑定的对象 
     */
    ProjectTree.prototype.insertProjectTree = function (parentGroupID, GroupName, name, objectType, entity, ck) {
        if (this._core.isnull(parentGroupID) && !this._core.isnull(this._tree.selectedItem) && this._tree.selectedItem.type == 'group')
            parentGroupID = this._tree.selectedItem.id;
        parentGroupID = this._core.isnull(parentGroupID) ? 0 : parentGroupID;
        if (!this._core.isnull(GroupName)) {
            parentGroupID = this.createGroup(GroupName, true, parentGroupID);
        }

        return this._getObject.insertProjectTree(parentGroupID, name, objectType, entity, ck);
    };
    /**
     * 是否存在组
     */
    ProjectTree.prototype.exitsGroup = function (id, name) {
        return tree.exitsGroup(id, name);
    };
    /**
     * 获取treeSource数据
     * 
     */
    ProjectTree.prototype.getTreeSource = function () {
        var source = lodash.cloneDeep(tree.getSource());
        return tree.removeItem(source);
    };
    /**
    * 统一工程树节点
    */
    ProjectTree.prototype.unifiedProject = function (tar, des) {
        this._getObject.unifiedProject(tar, des);
    };
    /**
     * 清空工程树
     */
    ProjectTree.prototype.clearn = function () {
        tree.clearn();
    };
    /**
     * 获取treeSource数据
     * 
     */
    Object.defineProperties(ProjectTree.prototype, {
        /**
         * Gets the Navigate.
         * @memberof SGWorld.prototype
         * @type {Navigate}
         * @readonly
         */
        Source: {
            get: function () {
                return tree.TempSource;
            }
        }
    });

    /**
     * 获取treeSource数据
     * 
     */
    Object.defineProperties(ProjectTree.prototype, {
        /**
         * Gets the Navigate.
         * @memberof SGWorld.prototype
         * @type {Navigate}
         * @readonly
         */
        currentObj: {
            get: function () {
                return tree.currentObj;
            }
        }
    });

    /**
     * 初始化工程树数据
     * 
     */
    ProjectTree.prototype.InitTree = function (tree, groupId) {
        if (tree && tree.length)
            for (var i = 0; i < tree.length; i++) {
                var itemi = tree[i];
                switch (itemi.type) {
                    case 'group':
                        var groupid = this.createGroup(itemi.name, groupId);
                        if (itemi.children && itemi.children.length) {
                            this.InitTree(itemi.children, groupid);
                        }
                        break;
                    case 'label':
                        this._creator.createLabel(itemi.position, itemi.text, itemi.option, groupId, itemi.description);
                        break;
                    case 'imgLabel':
                        this._creator.createImageLabel(itemi.position, itemi.imageLabel, groupId, itemi.description);
                        break;
                    case 'polygon':
                        this._creator.createPolygon(itemi.geometry, itemi.lineColor, itemi.altitudeType, groupId, itemi.description);
                        break;
                    case 'polyline':
                        this._creator.createPolyline(itemi.geometry, itemi.lineColor, itemi.altitudeType, groupId, itemi.description);
                        break;
                    case 'box':
                        this._creator.createBox(itemi.position, itemi.box, itemi.name, groupId, itemi.description);
                        break;
                    case 'circle':
                        this._creator.createCircle(itemi.position, itemi.circle, itemi.name, groupId, itemi.description);
                        break;
                    case 'cone':
                        this._creator.createCone(itemi.position, itemi.cylinder, itemi.name, itemi.description);
                        break;
                }
            }
    };

    /**
     * 显示默认的影像和高程
     * 
     */
    ProjectTree.prototype.InitRootImageLayerAndTerrainlayer = function () {
        //var groupid = this.createGroup("默认影像和高程", 0);
        //var groupidImagelayer = this.createGroup("影像", groupid);
        //var groupidImagelayer = this.createGroup("影像", 0);
        //var imageLayers = sgworld._Viewer.imageryLayers._layers;
        //for (var i = 0; i < imageLayers.length; i++) {
        //    var item = this._creator._ImageryLayer;
        //    item.item = imageLayers[i];
        //    var id = this._core.getuid();
        //    treeSource.insertGroupId({
        //        id: id,
        //        name: "默认影像" + id,
        //        pId: this._core.isnull(groupidImagelayer) ? 0 : groupidImagelayer,
        //        type: 'imageLayer',
        //        item: item
        //    }, this._core.isnull(groupidImagelayer) ? 0 : groupidImagelayer);
        //}

        //;
        //var item = this._creator._Terrain;
        //item.item = this._viewer.terrainProvider;
        //if (item.item._layers && item.item._layers[0] && item.item._layers[0].resource) {
        //    item._url = item.item._layers[0].resource._url;
        //    var id = this._core.getuid();
        //    var groupidTerrain = this.createGroup("地形", groupid)
        //    treeSource.insertGroupId({
        //        id: id,
        //        name: "默认地形" + id,
        //        pId: this._core.isnull(groupidTerrain) ? 0 : groupidTerrain,
        //        type: 'terrain',
        //        item: item
        //    }, this._core.isnull(groupidTerrain) ? 0 : groupidTerrain);
        //}
    };
    /**
     * 获取或设置工程树的选中条目
     * 
     */
    Object.defineProperties(ProjectTree.prototype, {
        selectedItem: {
            get: function () {
                return tree.selectedItem;
            },
            set: function (item) {
                tree.selectedItem = item;
            }
        }

    });

    var fixGltf = function (gltf) {
        if (!gltf.extensionsUsed) {
            return;
        }
        if (!gltf.extensionsRequired) {
            return;
        }
        var v = gltf.extensionsUsed.indexOf('KHR_technique_webgl');
        var t = gltf.extensionsRequired.indexOf('KHR_technique_webgl');

        if (v !== -1) {
            gltf.extensionsRequired.splice(t, 1, 'KHR_techniques_webgl');
            gltf.extensionsUsed.splice(v, 1, 'KHR_techniques_webgl');
            gltf.extensions = gltf.extensions || {};
            gltf.extensions['KHR_techniques_webgl'] = {};
            gltf.extensions['KHR_techniques_webgl'].programs = gltf.programs;
            gltf.extensions['KHR_techniques_webgl'].shaders = gltf.shaders;
            gltf.extensions['KHR_techniques_webgl'].techniques = gltf.techniques;
            var techniques = gltf.extensions['KHR_techniques_webgl'].techniques;

            gltf.materials.forEach(function (mat, index) {
                gltf.materials[index].extensions['KHR_technique_webgl'].values = gltf.materials[
                    index].values;
                gltf.materials[index].extensions['KHR_techniques_webgl'] = gltf.materials[index]
                    .extensions['KHR_technique_webgl'];

                var vtxfMaterialExtension = gltf.materials[index].extensions[
                    'KHR_techniques_webgl'];

                for (var value in vtxfMaterialExtension.values) {
                    var us = techniques[vtxfMaterialExtension.technique].uniforms;
                    for (var key in us) {
                        if (us[key] === value) {
                            vtxfMaterialExtension.values[key] = vtxfMaterialExtension.values[value];
                            delete vtxfMaterialExtension.values[value];
                            break;
                        }
                    }
                }        });

            techniques.forEach(function (t) {
                for (var attribute in t.attributes) {
                    var name = t.attributes[attribute];
                    t.attributes[attribute] = t.parameters[name];
                }
                for (var uniform in t.uniforms) {
                    var name = t.uniforms[uniform];
                    t.uniforms[uniform] = t.parameters[name];
                }        });
        }
    };

    var logSmartEarthLogTime = setTimeout(() => {
        logSmartEarthLogTime = undefined;
        logSmartEarthLog && logSmartEarthLog();
    }, 10000);

    /**
     *
     * 框架主要入口，三维的创建、接口的初始化等
     *
     * @alias SGWorld
     * @constructor
     *
     * @param {Element|String} container 三维地球的容器ID或者Dom元素。
     * @param {cesium} cesium Cesium。
     * @param {Object} [option] 初始化参数。
     * @param {String} [option.defaultAccessToken] Cesium服务token（若未使用Cesium官方服务可以忽略）。
     * @param {String} [option.url] 底图图片地址。
     * @param {Number} [option.x] 初始化视角经度。
     * @param {Number} [option.y] 初始化视角纬度。
     * @param {Number} [option.z] 初始化视角高度。
     * @param {Number} [option.heading=0] 初始化水平视角。
     * @param {Number} [option.pitch=-90] 初始化垂直视角。
     * @param {Number} [option.roll=0] 初始化翻滚角。
     * @param {Number} [option.roll=0] 初始化翻滚角。
     * @param {Number} [option.duration=0.5] 定位初始化视角飞行时间。
     * @param {ImageryProvider} [option.imageryProvider=undefined] 影像图层。
     * @param {Boolean} [option.removeGlobe=false] 是否初始化无地球场景
     * @param {Boolean} [option.backgroundImage=undefined] removeGlobe为true时，设置场景背景图片
     * @param {Number} [option.minViewHeight] 最低视角高度（相对地面高度）
     * @param {Number} [option.maxViewPitch] 最大仰角
     * @param {Number} [option.sceneMode=3] 场景模式【2.5D：1 | 2D：2 | 3D：3】
     * @param {Boolean} [option.disableRightClickMenu=true] 是否禁用浏览器默认右键菜单
     * @param {Boolean} [option.navigation=true] 是否显示导航控件
     * @param {Object} [option.navigationOption] 导航控件参数
     * @param {Cesium.Rectangle} [option.navigationOption.defaultResetView] 默认视角范围
     * @param {Boolean} [option.navigationOption.enableCompass=true] 是否启用罗盘
     * @param {Boolean} [option.navigationOption.enableZoomControls=true] 是否启用缩放控件
     * @param {Boolean} [option.navigationOption.enableDistanceLegend=true] 是否启用距离图例
     * @param {Boolean} [option.navigationOption.enableCompassOuterRing=true] 是否启用指南针外环
     * @param {Object} tree 初始工程树数据。
     * @param {Function} func 回调函数。
     *
     * @example
     * // 初始化sgWorld
     * var sgworld = new SmartEarth.SGWorld('cesiumContainer');
     *
     */
    function SGWorld(container, cesium, option = {}, tree, func) {
        this._core = new Core();
        this._cesium = cesium || Cesium;

        if (logSmartEarthLogTime) {
            clearTimeout(logSmartEarthLogTime);
            logSmartEarthLogTime = undefined;
            logSmartEarthLog && logSmartEarthLog();
        }

        //token
        Cesium.Ion.defaultAccessToken = option.defaultAccessToken || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiIwYWRlZDhiNi1hZTljLTQ4MWItYjdjNS0xYTkyMjk2YzdlOTQiLCJpZCI6NjcxNTksImlhdCI6MTYzMTU4NDY2NX0.l2kHF0uC2pTgJYwzQGpEBj6HCCdbYfRThEbXajcXOI8';

        var defaultOption = {
            baseLayerPicker: false,
            shadows: false,
            skyAtmosphere: new this._cesium.SkyAtmosphere(),
            terrainShadows: this._cesium.ShadowMode.ENABLED,
            shouldAnimate: true,
            animation: true,
            // scene3DOnly: true,
            fullscreenButton: false,
            geocoder: false,
            homeButton: false,
            infoBox: false,
            selectionIndicator: false,
            timeline: false,
            navigationHelpButton: false,
            imageryProviderViewModels: [],
            terrainProviderViewModels: [],
            contextOptions: {
                webgl: {
                    preserveDrawingBuffer: true //通过canvas.toDataURL()实现截图需要将该项设置为true
                },
                failIfMajorPerformanceCaveat: false
            },
            navigation: true,
            disableRightClickMenu: true
        };
        if (typeof option === 'string') {
            defaultOption.imageryProvider = new this._cesium.SingleTileImageryProvider({
                url: option,
            });
        } else {
            if (option.url) {
                defaultOption.imageryProvider = new this._cesium.SingleTileImageryProvider({
                    url: option.url,
                });
            }
            this._core.extend(defaultOption, option, true);
        }
        if (!defaultOption.imageryProvider) {
            defaultOption.imageryProvider = new Cesium.ArcGisMapServerImageryProvider({
                name: "ArcGisMapServer",
                url: "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer"
            });
        }

        //默认飞至中国位置
        var defaultPosition = {
            destination: this._cesium.Cartesian3.fromDegrees(option.x ? option.x : 110, option.y ? option.y : 32, option.z ? option.z : 8000000),
            orientation: {
                heading: this._cesium.Math.toRadians(this._core.defaultValue(option.heading, 0)),
                pitch: this._cesium.Math.toRadians(this._core.defaultValue(option.pitch, -90)),
                roll: this._cesium.Math.toRadians(this._core.defaultValue(option.roll, 0))
            },
            duration: option.duration || 0.5
        };

        if (option.removeGlobe) {
            defaultOption.skyBox = false;
            defaultOption.skyAtmosphere = false;
            defaultOption.contextOptions = {
                failIfMajorPerformanceCaveat: false,
                webgl: {
                    alpha: true,
                    preserveDrawingBuffer: true
                }
            };
        }
        //var options = this._core.extend(defaultOption, option, true);
        this._Viewer = new this._cesium.Viewer(container, defaultOption);
        this._Viewer.scene;
        this._tree = tree;
        this._Viewer.scene.globe.baseColor = this._cesium.Color.WHITE;
        this._Viewer.shadowMap.size = 2048;
        // this._Viewer.shadowMap.softShadows = true;
        this._Viewer._cesiumWidget._creditContainer.style.display = "none";
        this._Viewer.terrainShadows = this._cesium.ShadowMode.ENABLED;
        this._AttachEvent = undefined;
        this._DetachEvent = undefined;
        this._Analysis = undefined;
        this._Navigate = undefined;
        this._Creator = undefined;
        this._Command = undefined;
        this._ProjectTree = undefined;
        this._Coordinate = undefined;
        this._VectorTileProvider = undefined;

        if (option.removeGlobe) {
            // 无地球场景设置
            this._Viewer.imageryLayers.removeAll();
            this._Viewer.shadows = false;
            this._Viewer.scene.fog.enabled = false;
            this._Viewer.scene.globe.show = false;
            // 场景颜色
            let baseColor = 'rgba(0,0,0,0)';
            this._Viewer.scene.backgroundColor = Cesium.Color.fromCssColorString(baseColor);
            // 平行光
            this._Viewer.scene.light = new Cesium.DirectionalLight({
                direction: new Cesium.Cartesian3(1, -0.9, -0.9)
            });
            option.backgroundImage && (this._Viewer.container.style.backgroundImage = 'url(' + option.backgroundImage + ')');
        } else {
            this._Viewer.scene.globe.depthTestAgainstTerrain = true;
        }

        this.Navigate.flyToPointsInterest(defaultPosition, func);
        //屏蔽默认双击事件
        this._Viewer.cesiumWidget.screenSpaceEventHandler.removeInputAction(this._cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
        //this._Viewer.extend(this._cesium.viewerCesiumNavigationMixin, {});
        this._Viewer.extend(Cesium.viewerCesiumInspectorMixin);

        //设置最低视角高度
        if (defaultOption.minViewHeight || defaultOption.maxViewPitch) {
            this.minViewHeight = defaultOption.minViewHeight;
            this.maxViewPitch = defaultOption.maxViewPitch && Cesium.Math.toRadians(defaultOption.maxViewPitch);
            let _groundHeightAtCameraPosition = 0;
            let scene = this._Viewer.scene;
            let isRotate = false;
            if (this.maxViewPitch) {
                let pitchHandel = new Cesium.ScreenSpaceEventHandler(this._Viewer.scene.canvas);
                pitchHandel.setInputAction(() => {
                    isRotate = true;
                }, Cesium.ScreenSpaceEventType.MIDDLE_DOWN);
                pitchHandel.setInputAction(() => {
                    isRotate = false;
                }, this._cesium.ScreenSpaceEventType.MIDDLE_UP);
                pitchHandel.setInputAction(() => {
                    isRotate = true;
                }, Cesium.ScreenSpaceEventType.RIGHT_DOWN);
                pitchHandel.setInputAction(() => {
                    isRotate = false;
                }, this._cesium.ScreenSpaceEventType.RIGHT_UP);
            }
            this._Viewer.scene.preRender.addEventListener(() => {
                let camera = this._Viewer.camera;
                if (!camera || !camera.positionCartographic) {
                    return;
                }
                if (this.maxViewPitch) {
                    let pitch = camera.pitch;
                    if (isRotate && pitch > this.maxViewPitch) {
                        pitch = this.maxViewPitch;
                        camera.setView({
                            destination: this.oldPosition || camera.position.clone(),
                            orientation: {
                                heading: camera.heading,
                                pitch: pitch,
                                roll: 0.0
                            }
                        });
                    } else {
                        this.oldPosition = camera.position.clone();
                    }
                }

                if (this.minViewHeight) {
                    let groundHeightAtCameraPosition = scene.globe.getHeight(camera.positionCartographic);
                    _groundHeightAtCameraPosition = groundHeightAtCameraPosition || _groundHeightAtCameraPosition;

                    //禁止进入地下
                    let hitTheGround;
                    let adjustedHeight;
                    let HeightAboveGround = camera.positionCartographic.height - _groundHeightAtCameraPosition;
                    if (this._Viewer.scene.globe.translucency.enabled || this._Analysis && ((this._Analysis._UndergroundMode && this._Analysis._UndergroundMode.isUndergroundMode) || (this._Analysis._StreetView && this._Analysis._StreetView.isStreetView))) {
                        hitTheGround = camera.positionCartographic.height < -200;
                        adjustedHeight = -200;
                    } else {
                        hitTheGround = HeightAboveGround < this.minViewHeight;
                        adjustedHeight = _groundHeightAtCameraPosition + this.minViewHeight;
                    }
                    let pitch = camera.pitch < 0 ? camera.pitch : 0.0;

                    if (hitTheGround) {
                        camera.setView({
                            destination: this._cesium.Cartesian3.fromRadians(camera.positionCartographic.longitude, camera.positionCartographic.latitude, adjustedHeight),
                            orientation: {
                                heading: camera.heading,
                                pitch: pitch,
                                roll: 0.0
                            }
                        });
                    }
                }
            });
        }

        // let cursorHandel = new this._cesium.ScreenSpaceEventHandler(this._Viewer.scene.canvas);
        // let cursorPoint, cursorMovePoint, wheelTime, oldPosition;
        // let getCursorPoint = (event) => {
        //     cursorPoint && this._Viewer.entities.remove(cursorPoint);
        //     cursorMovePoint && this._Viewer.entities.remove(cursorMovePoint);
        //     if (!event) { event = oldPosition }
        //     let position = event.position || event.endPosition;
        //     let ray = this._Viewer.camera.getPickRay(position);
        //     position = this._Viewer.scene.globe.pick(ray, this._Viewer.scene) || new this._cesium.Cartesian3();
        //     // position = this._Viewer.scene.pickPosition(position) || new this._cesium.Cartesian3();

        //     return this._Viewer.entities.add({
        //         position: position,
        //         billboard: {
        //             image: window.SmartEarthRootUrl + "Workers/image/cursor.png",
        //             disableDepthTestDistance: Infinity
        //         }
        //     });
        // }
        // let changeMoveCursorPositon = (event) => {
        //     let position = event.position || event.endPosition;
        //     position = this._Viewer.scene.pickPosition(position) || new this._cesium.Cartesian3();
        //     cursorPoint && (cursorPoint.position = position);
        //     cursorMovePoint && (cursorMovePoint.position = position);
        // }
        // cursorHandel.setInputAction(event => {
        //     oldPosition = event
        //     cursorPoint = getCursorPoint(event)
        // }, this._cesium.ScreenSpaceEventType.MIDDLE_DOWN);
        // cursorHandel.setInputAction(event => {
        //     cursorPoint && this._Viewer.entities.remove(cursorPoint);
        //     cursorPoint = undefined
        // }, this._cesium.ScreenSpaceEventType.MIDDLE_UP);
        // cursorHandel.setInputAction(event => {
        //     oldPosition = event
        //     if (cursorMovePoint) {
        //         changeMoveCursorPositon(event)
        //     }
        // }, this._cesium.ScreenSpaceEventType.MOUSE_MOVE);
        // cursorHandel.setInputAction(event => {
        //     clearTimeout(wheelTime)
        //     if (!cursorMovePoint) {
        //         cursorMovePoint = getCursorPoint()
        //     }
        //     wheelTime = setTimeout(() => {
        //         cursorMovePoint && this._Viewer.entities.remove(cursorMovePoint);
        //         cursorMovePoint = undefined
        //     }, 500)
        // }, this._cesium.ScreenSpaceEventType.WHEEL);

        Object.defineProperties(Cesium.Model.prototype, {
            _cachedGltf: {
                configurable: true,
                set: function (value) {
                    this._vtxf_cachedGltf = value;
                    if (this._vtxf_cachedGltf && this._vtxf_cachedGltf._gltf) {
                        fixGltf(this._vtxf_cachedGltf._gltf);
                    }
                },
                get: function () {
                    return this._vtxf_cachedGltf;
                }
            }
        });

        if (Cesium.Resource) {
            Cesium.loadText = Cesium.Resource.fetchText;
            Cesium.loadJson = Cesium.Resource.fetchJson;
            Cesium.loadBlob = Cesium.Resource.fetchBlob;
            Cesium.loadArrayBuffer = Cesium.Resource.fetchArrayBuffer;
            Cesium.loadImage = Cesium.Resource.fetchImage;
        }
        if (!Cesium.isArray) {
            Cesium.isArray = Array.isArray;
        }

        if (defaultOption.navigation) {
            if (!Cesium.viewerCesiumNavigationMixin) {
                let SkipTool = new Skip(false);
                SkipTool.addJs(document.body, window.SmartEarthRootUrl + 'Workers/viewerCesiumNavigationMixin.js');
            }
            let viewerCesiumNavigationMixinOptions = {
                defaultResetView: Cesium.Rectangle.fromDegrees(80, 22, 130, 50),
                // 用于启用或禁用罗盘。true是启用罗盘，false是禁用罗盘。默认值为true。如果将选项设置为false，则罗盘将不会添加到地图中。
                enableCompass: true,
                // 用于启用或禁用缩放控件。true是启用，false是禁用。默认值为true。如果将选项设置为false，则缩放控件将不会添加到地图中。
                enableZoomControls: true,
                // 用于启用或禁用距离图例。true是启用，false是禁用。默认值为true。如果将选项设置为false，距离图例将不会添加到地图中。
                enableDistanceLegend: true,
                // 用于启用或禁用指南针外环。true是启用，false是禁用。默认值为true。如果将选项设置为false，则该环将可见但无效。
                enableCompassOuterRing: true
            };
            this._Viewer.extend(Cesium.viewerCesiumNavigationMixin, option.navigationOption || viewerCesiumNavigationMixinOptions);
        }

        if (defaultOption.disableRightClickMenu) {
            document.oncontextmenu = function () {
                return false
            };
        }

        // 分辨率调整函数
        var adjustmentPixel = function (viewer) {
            // 判断是否支持图像渲染像素化处理
            var supportsImageRenderingPixelated = viewer.cesiumWidget._supportsImageRenderingPixelated;
            if (supportsImageRenderingPixelated && window && window.devicePixelRatio) {
                // 直接拿到设备的像素比例因子
                var vtxf_dpr = window.devicePixelRatio;
                while (vtxf_dpr >= 2.0) { vtxf_dpr /= 2.0; }
                // 设置渲染分辨率的比例因子
                viewer.resolutionScale = vtxf_dpr;
            }
        };
        adjustmentPixel(this._Viewer);

        var _that = this;
        _that.G = 65535;

        function K(e, t) {
            function r() {
                e.ready ? Cesium.when(J(e, t), function (e) {
                    n.resolve(e);
                }) : setTimeout(r, 10);
            }

            Cesium.Check.typeOf.object("terrainProvider", e),
                Cesium.Check.defined("positions", t);
            var n = Cesium.when.defer();
            return r(),
                n.promise
        }

        function V(e, t) {
            for (var n = 0; n < e.children.length; n++) {
                var r = e.children[n].state >= Cesium.QuadtreeTileLoadState.DONE && (e.children[n].data.terrainData._mesh != undefined || e.children[n].data.terrainData._buffer != undefined);
                if (r && e.children[n].x == t.x && e.children[n].y == t.y) return e.children[n]
            }
            return undefined
        }

        function $$$(e, t) {
            var n = e.tilingScheme,
                r = n.positionToTileXY(t, 0),
                i = _that._Viewer.scene.globe._surface.tileProvider.quadtree._levelZeroTiles,
                s = i[0].x == r.x && i[0].y == r.y ? i[0] : i[1];
            for (var o = 1; o < 22; o++) {
                r = n.positionToTileXY(t, o);
                var u = V(s, r);
                if (u == undefined) break;
                s = u;
            }
            return s
        }

        function Z(e, t) {
            Cesium.Check.defined("positions", e);
            var n = Cesium.when.defer();
            return Cesium.when(Y(e), function (e) {
                n.resolve(e);
            }),
                n.promise
        }

        function Y(t, n) {
            $.grep(_that._Viewer.scene.primitives._primitives, function (e) {
                return e instanceof Cesium.Cesium3DTileset
            });
                var i;
            for (i = 0; i < t.length; ++i) {
                var s = t[i],
                    o = s instanceof Cesium.Cartographic,
                    u = o ? s : Cesium.Cartographic.fromCartesian(s);
                u.height = _that.G;
                // r.forEach(function (e) {
                //     if (e.ready && e.show) {
                //         var t = Q(e, u, n);
                //         t !== undefined && (n ? t.content && t.content._model && t.content._model.floor && (u.height = t.content._model.floor.getHeight(u.longitude, u.latitude), _that.G = t.content._model.floor.nullValue) : u.height = t._boundingVolume.maximumHeight)
                //     }
                // });
                if (!o) {
                    var a = Cesium.Cartesian3.fromRadiansArrayHeights([u.longitude, u.latitude, u.height])[0];
                    s.z = a.z;
                }
            }
            return t
        }

        function J(e, t) {
            var n;
            for (n = 0; n < t.length; ++n) {
                var r = t[n],
                    i = $$$(e, r);
                r.height = i.data.terrainData.interpolateHeight(i.rectangle, r.longitude, r.latitude);
            }
            return t
        }

        function j(e) {
            this.value = new Float32Array([e]);
        }

        j.fromZBias = function (e) {
            if (!Cesium.defined(e)) throw new DeveloperError("zbias is required.");
            return new j(e)
        };
        j.toValue = function (e, t) {
            if (!Cesium.defined(e)) throw new DeveloperError("zbias is required.");
            return Cesium.defined(t) ? color.toBytes(t) : new Float32Array(e)
        };
        j.equals = function (e, t) {
            return e === t || Cesium.defined(e) && Cesium.defined(t) && e.value[0] === t.value[0]
        };
        j.defaultBias = function () {
            // var e = TerraExplorer.zbiaz == undefined ? 15e-6 : TerraExplorer.zbiaz;
            var e = 15e-6 ;
            return j.fromZBias(e)
        };
        this._cesium.ZBiasGeometryInstanceAttribute = j;
        this._cesium.SampleRenderedDataFlags = {
            TERRAIN: 2,
            MESH: 4,
            FLOOR: 8
        };
        this._cesium.DynamicEyeOffset = function (e) {
            return e === undefined && (e = 0),
                new Cesium.Cartesian3(.001234321, 0, e)
        };

        this._cesium.sampleRenderedData = function (e, t) {
            var et = {
                TERRAIN: 2,
                MESH: 4,
                FLOOR: 8
            };
            t == undefined && (t = et.TERRAIN | et.MESH);
            var n = Cesium.when.defer(),
                r = [];
            t > et.TERRAIN ? e.forEach(function (e) {
                r.push(Cesium.Cartographic.fromRadians(e.longitude, e.latitude, e.height));
            }) : r = e;
            var i = [];
            t & et.TERRAIN && i.push(K(_that._Viewer.terrainProvider, e));
            var s = (t & et.FLOOR) > 0;
            return t & (et.MESH | et.FLOOR) && i.push(Z(r)),
                Cesium.when.all(i).then(function (t) {
                    if (i.length > 1)
                        for (var r = 0; r < e.length; r++) {
                            var o = t[0][r],
                                u = t[1][r];
                            if (u.height == _that.G) continue;
                            if (o.height < u.height || s) o.height = u.height;
                        }
                    n.resolve(t[0]);
                }),
                n.promise
        };
        this._cesium.sampleRenderedMesh = function (e, t) {
            Cesium.Check.defined("positions", e);
            var n = Cesium.when.defer();
            return Cesium.when(Y(e), function (e) {
                n.resolve(e);
            }),
                n.promise
        };
        this._cesium.sampleRenderedTerrain = function (e, t) {
            function r() {
                e.ready ? Cesium.when(J(e, t), function (e) {
                    n.resolve(e);
                }) : setTimeout(r, 10);
            }

            Cesium.Check.typeOf.object("terrainProvider", e),
                Cesium.Check.defined("positions", t);
            var n = Cesium.when.defer();
            return r(),
                n.promise
        };
        this._cesium.QuadtreePrimitive.prototype.getRenderedBestLevelInfo = function () {
            var e = this.getRenderedLevelInfo(),
                t = 0;
            for (var n in e) t < Number(n) && (t = Number(n));
            return {
                bestLevel: t,
                count: e[t]
            }
        };
        this._cesium.QuadtreePrimitive.prototype.getRenderedLevelInfo = function () {
            var e = [];
            return this._tilesToRender.forEach(function (t) {
                e[t.level] == undefined && (e[t.level] = 0),
                    e[t.level]++;
            }),
                e
        };
    }

    Object.defineProperties(SGWorld.prototype, {
        /**
         * 分析类.
         * @memberof SGWorld.prototype
         * @type {Analysis}
         * @readonly
         */
        Analysis: {
            get: function () {
                if (this._Analysis == undefined) {
                    this._Analysis = new Analysis(this._Viewer, this._cesium);
                }
                return this._Analysis;
            }
        },
        /**
         * 导航类.
         * @memberof SGWorld.prototype
         * @type {Navigate}
         * @readonly
         */
        Navigate: {
            get: function () {

                if (this._Navigate == undefined) {
                    this._Navigate = new Navigate(this._Viewer, this._cesium, this._tree);
                }
                return this._Navigate;
            }
        },
        /**
         *创建类.
         * @memberof SGWorld.prototype
         * @type {Creator}
         * @readonly
         */
        Creator: {
            get: function () {
                if (this._Creator == undefined) {
                    this._Creator = new Creator(this._Viewer, this._cesium);
                }
                return this._Creator;
            }
        },
        /**
         * 工具类.
         * @memberof SGWorld.prototype
         * @type {Core}
         * @readonly
         */
        Core: {
            get: function () {
                if (this._Core == undefined) {
                    this._Core = new Core();
                }
                return this._Core;
            }
        },
        /**
         * 命令类.
         * @memberof SGWorld.prototype
         * @type {Command}
         * @readonly
         */
        Command: {
            get: function () {
                if (this._Command == undefined) {
                    this._Command = new Command(this._Viewer, this._cesium);
                }
                return this._Command;
            }
        },
        /**
         * 工程树类.
         * @memberof SGWorld.prototype
         * @type {ProjectTree}
         * @readonly
         */
        ProjectTree: {
            get: function () {
                if (this._ProjectTree == undefined) {
                    this._ProjectTree = new ProjectTree(this._Viewer, this._cesium, this._tree);
                }
                return this._ProjectTree;
            }
        },
        /**
         * 工程树数据.
         * @memberof SGWorld.prototype
         * @type {tree}
         * @readonly
         */
        tree: {
            get: function () {
                return this._tree;
            }
        },
        /**
         * 地图视图.
         * @memberof SGWorld.prototype
         * @type {Viewer}
         * @readonly
         */
        Viewer: {
            get: function () {
                return this._Viewer;
            }
        },
        /**
         * 地形三角网.
         * @memberof SGWorld.prototype
         */
        wireframe: {
            get: function () {
                return this._Viewer.cesiumInspector.viewModel.wireframe;
            },
            set: function (value) {
                this._Viewer.cesiumInspector.viewModel.wireframe = value;
            }
        },
        /**
         * 瓦片坐标.
         * @memberof SGWorld.prototype
         */
         tileCoordinates: {
            get: function () {
                return this._Viewer.cesiumInspector.viewModel.tileCoordinates;
            },
            set: function (value) {
                this._Viewer.cesiumInspector.viewModel.tileCoordinates = value;
            }
        },
    });

    /**
     * 导航控件
     * @param {String} type 类型【nav | scale | all】
     * @param {Boolean} show 是否显示
     */
    SGWorld.prototype.navControl = function (type, show) {
        let display = show ? '' : 'none';
        if (this._Viewer.cesiumNavigation) {
            if (type === 'all') {
                this._Viewer.cesiumNavigation.container.style.display = display;
            } else if (type === 'nav') {
                this._Viewer.cesiumNavigation.navigationDiv.style.display = display;
            } else {
                this._Viewer.cesiumNavigation.distanceLegendDiv.style.display = display;
            }
        }
    };

    /**
     *  创建wfs图层
     * 
     * @returns {wfsLayer} 返回wfsLayer。
     *
     */
    SGWorld.prototype.CreateWfs = function (e, t, n, r, i, s, o, u, a) {
        return new WfsLayer$1(e, t, n, r, i, s, o, u, a);
    };

    /**
     *  绑定事件。
     * @param {EventType} [bstrEventName] 事件名称。
     * @param {Function} [dispFunc] 响应函数。
     * @returns {ScreenSpaceEventHandler} 返回屏幕事件handel。
     *
     */
    SGWorld.prototype.AttachEvent = function (bstrEventName, dispFunc) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachEvent(bstrEventName, dispFunc);
    };
    /**
     * 添加移除默认cesium的双击追踪效果
     */
    SGWorld.prototype.RemoNormalCesiumLeftDoubleClick = function () {
        if (this._DetachEvent == undefined) {
            this._DetachEvent = new DetachEvent(this._Viewer, this._cesium);
        }
        return this._DetachEvent.RemoNormalCesiumLeftDoubleClick();
    };

    /**
     *  绑定事件左键双击事件。
     * @param {Function} [dispFunc] 回调函数
     *
     */
    SGWorld.prototype.AttachOnLButtonDblClkEvent = function (dispFunc) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachOnLButtonDblClkEvent(dispFunc);
    };
    /**
     *  绑定事件左键按下事件。
     * @param {Function} [dispFunc] 回调函数
     *
     */
    SGWorld.prototype.AttachOnLButtonDownEvent = function (dispFunc) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachOnLButtonDownEvent(dispFunc);
    };
    /**
     *  绑定事件左键按下弹起事件。
     * @param {Function} [dispFunc] 回调函数
     *
     */
    SGWorld.prototype.AttachOnLButtonUpEvent = function (dispFunc) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachOnLButtonUpEvent(dispFunc);
    };
    /**
     *  绑定事件中键双击事件。
     * @param {Function} [dispFunc] 回调函数
     *
     */
    SGWorld.prototype.AttachOnMButtonDblClkEvent = function (dispFunc) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachOnMButtonDblClkEvent(dispFunc);
    };
    /**
     *  绑定事件中键按下事件。
     * @param {Function} [dispFunc] 回调函数
     *
     */
    SGWorld.prototype.AttachOnMButtonDownEvent = function (dispFunc) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachOnMButtonDownEvent(dispFunc);
    };
    /**
     *  绑定事件中键按下弹起事件。
     * @param {Function} [dispFunc] 回调函数
     *
     */
    SGWorld.prototype.AttachOnMButtonUpEvent = function (dispFunc) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachOnMButtonUpEvent(dispFunc);
    };
    /**
     *  绑定事件鼠标滚轮滚动事件。
     * @param {Function} [dispFunc] 回调函数
     *
     */
    SGWorld.prototype.AttachOnMouseWheelEvent = function (dispFunc) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachOnMouseWheelEvent(dispFunc);
    };
    /**
     *  绑定事件实时监听事件。
     * @param {Function} [dispFunc] 回调函数
     *
     */
    SGWorld.prototype.AttachOnFrameEvent = function (dispFunc) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachOnFrameEvent(dispFunc);
    };
    /**
     *  绑定事件左键按下事件。
     * @param {Function} [dispFunc] 回调函数
     *
     */
    SGWorld.prototype.AttachOnRButtonDownEvent = function (dispFunc) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachOnRButtonDownEvent(dispFunc);
    };
    /**
     *  绑定事件左键按下弹起事件。
     * @param {Function} [dispFunc] 回调函数
     *
     */
    SGWorld.prototype.AttachOnRButtonUpEvent = function (dispFunc) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachOnRButtonUpEvent(dispFunc);
    };
    /**
     *  绑定相机视角要改变事件。
     * @param {Function} [Func] 回调函数
     *
     */
    SGWorld.prototype.AttachCameraChangeEvent = function (Func) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.AttachCameraChangeEvent(Func);
    };
    /**
     *  绑定相机移动结束事件。
     * @param {Function} [Func] 回调函数
     *
     */
    SGWorld.prototype.CameraMoveEndEvent = function (Func) {
        if (this._AttachEvent == undefined) {
            this._AttachEvent = new AttachEvent(this._Viewer, this._cesium);
        }
        return this._AttachEvent.CameraMoveEndEvent(Func);
    };
    /**
     * 解除事件绑定
     * @param {ScreenSpaceEventHandler} [handler] 事件。
     * @param {EventType} [bstrEventName] 事件名称。
     */
    SGWorld.prototype.DetachEvent = function (handler, bstrEventName) {
        if (this._DetachEvent == undefined) {
            this._DetachEvent = new DetachEvent(this._Viewer, this._cesium);
        }
        return this._DetachEvent.DetachEvent(handler, bstrEventName);
    };
    /**
     *  解除绑定事
     * @param {ScreenSpaceEventHandler} [handler] 事件
     *
     */
    SGWorld.prototype.DetachEventAll = function (handler) {
        if (this._DetachEvent == undefined) {
            this._DetachEvent = new DetachEvent(this._Viewer, this._cesium);
        }
        return this._DetachEvent.DetachEventAll(handler);
    };
    /**
     *  解除绑定事
     * @param {Function} [Func] 回调函数
     *
     */
    SGWorld.prototype.DetachCameraChangeEvent = function (Func) {
        if (this._DetachEvent == undefined) {
            this._DetachEvent = new DetachEvent(this._Viewer, this._cesium);
        }
        return this._DetachEvent.DetachCameraChangeEvent(Func);
    };

    /**
    *
    * 该方法在树中删除一个条目。
    *
    * @alias expandGroup 
    * @constructor
    *
    */
    function expandGroup(viewer, cesium) {
        this._viewer = viewer;
        this._cesium = cesium;
        this._tree = tree.getSource();
    }
    /**
    * 该方法在树中删除一个条目
    * @param {String} [GroupName] 创建组的名称。
    * @param {int} [ParentGroupID] 组的ID，组在该组中被创建。如果GroupID设置为零，则对象在根节点下创建。
    * @returns {Promise.<Array>} 返回一个数组。
    * 
    */
    expandGroup.prototype.deleteItem = function (ItemID) {

    };

    var _slicedToArray = function () {
        function sliceIterator(arr, i) {
            var _arr = [];
            var _n = true;
            var _d = false;
            var _e = undefined;
            try {
                for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
                    _arr.push(_s.value);
                    if (i && _arr.length === i) break;
                }
            } catch (err) {
                _d = true;
                _e = err;
            } finally {
                try {
                    if (!_n && _i["return"]) _i["return"]();
                } finally {
                    if (_d) throw _e;
                }
            }
            return _arr;
        }
        return function (arr, i) {
            if (Array.isArray(arr)) {
                return arr;
            } else if (Symbol.iterator in Object(arr)) {
                return sliceIterator(arr, i);
            } else {
                throw new TypeError("Invalid attempt to destructure non-iterable instance");
            }
        };
    }();

    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
        return typeof obj;
    } : function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };

    function _toConsumableArray(arr) {
        if (Array.isArray(arr)) {
            for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
                arr2[i] = arr[i];
            }
            return arr2;
        } else {
            return Array.from(arr);
        }
    }

    function ArcgisNVectorTileProvider(viewer, cesium, options) {
        this._viewer = viewer;
        this._cesium = cesium;

        // Cesium.Viewer 实例
        this._viewer = null;

        // Cesium 对象
        this._Cesium = options.Cesium;

        // 矢量切片服务接口
        this._url = options.url;

        // 矢量切片服务接口请求参数
        this._urlParams = options.urlParams;

        // 矢量切片服务 URL 模板
        this._urlTemplate = this._url + '?' + this._serialize(this._urlParams);

        // 矢量切片服务数据范围
        this._rectangle = options.rectangle;

        // 最大视图等级
        this._maximumLevel = options.maximumLevel || 19;

        // 最小视图等级
        this._minimumLevel = options.minimumLevel || 1;

        // Cesium.TilingScheme 实例
        this._tilingScheme = options.tilingScheme || new this._Cesium.GeographicTilingScheme();

        // 瓦片范围，以 level 索引
        this._tileRangeByLevel = {};

        // 摄像机 moveEnd 事件时间戳
        this._moveEndTimestamp = null;

        // provider 是否已销毁
        this._isRemoved = false;

        // 摄像机是否正在移动
        this._isCameraMoving = false;

        // 将被过滤的属性和值
        this._propertyToBeFiltered = null;
        this._valuesToBeFiltered = null;

        // 瓦片 primitive，以 tile key 索引
        this._primitiveByTile = {};

        // 最新视角下的瓦片标识列表
        this._tileKeys = [];

        // 瓦片层级限制
        this._lowerLevelLimit = options.lowerLevelLimit || 1;
        this._upperLevelLimit = options.upperLevelLimit || null;

        this._cameraMoveEndHandler = this._cameraMoveEndHandler.bind(this);
        this._cameraMoveStartHandler = this._cameraMoveStartHandler.bind(this);

        // 高度属性，以 id 索引
        this.heightById = {};

        // 计算瓦片范围
        var west = this._radianToDegree(this._rectangle.west);
        var south = this._radianToDegree(this._rectangle.south);
        var east = this._radianToDegree(this._rectangle.east);
        var north = this._radianToDegree(this._rectangle.north);

        for (var z = this._minimumLevel; z <= this._maximumLevel; z++) {
            var bottomLeftTile = this._lonLatToTileInWGS84([west, south], z);
            var topRightTile = this._lonLatToTileInWGS84([east, north], z);
            var minRow = Math.min(bottomLeftTile[0], topRightTile[0]);
            var maxRow = Math.max(bottomLeftTile[0], topRightTile[0]);
            var minCol = Math.min(bottomLeftTile[1], topRightTile[1]);
            var maxCol = Math.max(bottomLeftTile[1], topRightTile[1]);

            this._tileRangeByLevel[z] = {
                minCol: minCol,
                maxCol: maxCol,
                minRow: minRow,
                maxRow: maxRow
            };
        }

        this._tileRangeByLevel[0] = {
            minCol: 0,
            maxCol: 0,
            minRow: 0,
            maxRow: 0
        };

        this._primitiveCollection = new this._Cesium.PrimitiveCollection();

        this._stop = false;
    }
    /**
     * 序列化参数对象
     *
     * @param {Object} params 参数对象
     * @returns {String} 序列化字符串
     */
    ArcgisNVectorTileProvider.prototype._serialize = function (params) {
        var queryArray = [];
        var encode = window.encodeURIComponent;

        for (var key in params) {
            var value = params[key];

            if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
                queryArray.push(encode(key) + '=' + encode(JSON.stringify(value)));
            } else {
                queryArray.push(encode(key) + '=' + encode(params[key]));
            }
        }

        return queryArray.join('&');
    };

    /**
     * 模拟 fetch 接口
     *
     * @param {String} url 请求 URL
     * @param {Object} [options] 选项
     * @returns {Promise} 处理请求结果的 Promise
     *
     */
    ArcgisNVectorTileProvider.prototype._fetch = function (url) {
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        var promise = new Promise(function (resolve, reject) {
            var xhr = new XMLHttpRequest();

            xhr.open(options.method || 'GET', url);

            if (options.headers) {
                for (var key in options.headers) {
                    xhr.setRequestHeader(key, options.headers[key]);
                }
            }

            xhr.onload = function () {
                if (xhr.readyState === 4 && xhr.status === 200) {
                    try {
                        var json = JSON.parse(xhr.responseText);

                        resolve(json);
                    } catch (e) {
                        reject(new Error('INVALID RESPONSE'));
                    }
                }
            };

            xhr.onerror = function (e) {
                reject(e);
            };

            xhr.onloadend = function (e) {
                if (e.target.status !== 200) {
                    reject(new Error('[' + e.target.status + ']request failed: ' + url));
                }
            };

            xhr.send(options.body || null);
        });

        return promise;
    };

    /**
     * 通过经纬度获取瓦片 X、Y 值 (WGS84)
     *
     * @param {Number[]} lonLat 经纬度
     * @param {Number} level 地图缩放等级
     * @returns {Number[]} 瓦片的 X、Y 值
     */
    ArcgisNVectorTileProvider.prototype._lonLatToTileInWGS84 = function (lonLat, level) {
        var _lonLat = _slicedToArray(lonLat, 2),
            lon = _lonLat[0],
            lat = _lonLat[1];

        var tileX = Math.floor(Math.pow(2, level) * (90 - lat) / 180);
        var tileY = Math.floor(Math.pow(2, level) * (180 + lon) / 180);

        return [tileX, tileY];
    };

    /**
     * 弧度转角度
     *
     * @param {Number} radian 弧度值
     * @returns {Number} 角度值
     */
    ArcgisNVectorTileProvider.prototype._radianToDegree = function (radian) {
        return radian / Math.PI * 180;
    };

    /**
     * 判断目标瓦片是否在数据范围内
     *
     * @param {QuadtreeTile} tile 瓦片对象
     * @returns {Boolean} 瓦片是否在数据范围内
     */
    ArcgisNVectorTileProvider.prototype._isTileInRange = function (tile) {
        try {
            var _tileRangeByLevel$til = this._tileRangeByLevel[tile.level],
                minCol = _tileRangeByLevel$til.minCol,
                maxCol = _tileRangeByLevel$til.maxCol,
                minRow = _tileRangeByLevel$til.minRow,
                maxRow = _tileRangeByLevel$til.maxRow;

            return tile.x >= minCol && tile.x <= maxCol && tile.y >= minRow && tile.y <= maxRow;
        } catch (e) {
            return false;
        }
    };

    /**
     * 摄像机 moveStart 事件处理程序
     */
    ArcgisNVectorTileProvider.prototype._cameraMoveStartHandler = function () {
        this._isCameraMoving = true;
    };

    /**
     * 处理数据请求回来的数据 创建不同的geometry
     */
    ArcgisNVectorTileProvider.prototype._loadTile = function (json) {
        var geomInstances = [];
        var color = new this._Cesium.ColorGeometryInstanceAttribute(0.75, 0.75, 0.75, 1);
        var _this = this;
        json.features.forEach(function (feature) {
            if (_this._propertyToBeFiltered) {
                if (Array.isArray(_this._valuesToBeFiltered)) {
                    var value = feature.properties[_this._propertyToBeFiltered];

                    if (_this._valuesToBeFiltered.includes(value)) return;
                }
            }

            var geometryType = feature.geometry.type;

            if (geometryType === 'Polygon' || geometryType === 'MultiPolygon') {
                var coordinates = [];

                _this.heightById[feature.properties.house_id] = feature.properties.height;
                feature.geometry.coordinates.forEach(function (coords, index) {
                    coordinates.push([]);
                    coords.forEach(function (coordinate) {
                        if (coordinate.length > 2) {
                            coordinate.forEach(function (coord) {
                                if (coord.length >= 2) {
                                    var _coordinates$index;

                                    (_coordinates$index = coordinates[index]).push.apply(_coordinates$index, _toConsumableArray(coord));
                                }
                            });
                        } else {
                            var _coordinates$index2;

                            (_coordinates$index2 = coordinates[index]).push.apply(_coordinates$index2, _toConsumableArray(coordinate));
                        }
                    });
                    var polygonHierarchy = new _this._Cesium.PolygonHierarchy(_this._Cesium.Cartesian3.fromDegreesArray(coordinates[index]));
                    var center = _this._Cesium.BoundingSphere.fromPoints(polygonHierarchy.positions).center;
                    var height = _this._viewer.scene.globe.getHeight(_this._Cesium.Cartographic.fromCartesian(center)) || 0;
                    var geometry = new _this._Cesium.PolygonGeometry({
                        polygonHierarchy: polygonHierarchy,
                        height: height,
                        vertexFormat: _this._Cesium.PerInstanceColorAppearance.VERTEX_FORMAT,
                        //extrudedHeight: feature.properties.height + height
                        extrudedHeight: 1000
                    });
                    var geomInstance = new _this._Cesium.GeometryInstance({
                        geometry: geometry,
                        attributes: {
                            color: color
                        }
                    });

                    geomInstances.push(geomInstance);
                });
            } else {
                console.warn('GeoJSONVectorTileProvider: geometry type "' + feature.geometry.type + '" detected, but is not going to be rendered');
            }
        });
        var primitive = new this._Cesium.Primitive({
            allowPicking: false,
            appearance: new this._Cesium.PerInstanceColorAppearance({
                translucent: false
            }),
            geometryInstances: geomInstances
        });
        return primitive;
    };

    /**
     * 摄像机 moveEnd 事件处理程序
     */
    ArcgisNVectorTileProvider.prototype._cameraMoveEndHandler = function () {
        if (this._stop) return;
        var _this = this;
        var timestamp = Date.now();
        var tilesToRender = this._viewer.scene.globe._surface._tilesToRender;
        var levels = tilesToRender.map(function (tile) {
            return tile.level;
        });
        var minLevel = Math.min.apply(Math, _toConsumableArray(levels));
        var maxLevel = Math.max.apply(Math, _toConsumableArray(levels));

        if (maxLevel < this._lowerLevelLimit) {

            _this._tileKeys = [];
            _this._removeObsoletePrimitives(_this._primitiveByTile, []);
            tilesToRender = [];
        }
        if (this._upperLevelLimit && minLevel > this._upperLevelLimit) {
            _this._tileKeys = [];
            _this._removeObsoletePrimitives(_this._primitiveByTile, []);
            tilesToRender = [];

        }

        if (maxLevel - minLevel > 2) {
            tilesToRender = tilesToRender.filter(function (tile) {
                return tile.level >= maxLevel - 2;
            });
        }

        tilesToRender.sort(function (val1, val2) {
            return -(val1.level - val2.level);
        });
        tilesToRender = tilesToRender.filter(function (tile) {
            return _this._isTileInRange(tile);
        });

        if (this._upperLevelLimit) {
            tilesToRender = this._refineTiles(tilesToRender, this._upperLevelLimit);
        }

        this._isCameraMoving = false;
        this._moveEndTimestamp = timestamp;
        //this._tileKeys = [];
        //var 
        var newTileKeys = [];
        var tilesLength = 0;
        //tilesToRender.length;
        var returnCount = 0;
        tilesToRender.forEach(function (tile) {
            var tileKey = 'z' + tile.level + 'x' + tile.x + 'y' + tile.y;
            newTileKeys.push(tileKey);
            _this._tileKeys.push(tileKey);

            if (_this._primitiveByTile[tileKey]) {
                //tilesLength--;
                return;
            }

            var tileUrl = _this._urlTemplate.replace(window.encodeURIComponent('{x}'), tile.x).replace(window.encodeURIComponent('{y}'), tile.y).replace(window.encodeURIComponent('{z}'), tile.level);
            tilesLength++;
            _this._fetch(tileUrl).then(function (json) {
                if (_this._isRemoved) throw new Error('DISCARD');
                if (_this._isCameraMoving) throw new Error('DISCARD');
                if (timestamp !== _this._moveEndTimestamp) throw new Error('DISCARD');

                var primitive = _this._loadTile(json);
                _this._primitiveCollection.add(primitive);
                //_this._viewer.scene.primitives.add(primitive);
                _this._primitiveByTile[tileKey] = primitive;
                returnCount++;

                if (returnCount >= tilesLength) {
                    _this._tileKeys = newTileKeys;
                    _this._removeObsoletePrimitives(_this._primitiveByTile, newTileKeys);

                }
                //if (tile.level <= _this._upperLevelLimit && Object.getOwnPropertyNames(_this._primitiveByTile).length > 5)
                //    _this._removeObsoletePrimitives(_this._primitiveByTile, _this._tileKeys);
            }).catch(function (ex) {
                returnCount++;
                if (returnCount >= tilesLength) {
                    _this._tileKeys = newTileKeys;
                    _this._removeObsoletePrimitives(_this._primitiveByTile, newTileKeys);

                }
                if (ex.message !== 'DISCARD') ;
            });
        });



        /**
         *  删除之前加载的数据
         *
         */
        // this._removeObsoletePrimitives(this._primitiveByTile, this._tileKeys);
    };

    /**
     * 通过拆分、合并优化瓦片下载与渲染
     *
     * @param {Object[]} tiles 待处理的瓦片列表
     * @param {Number} targetLevel 目标优化层级
     * @returns {Object[]} 优化后的瓦片列表
     */
    ArcgisNVectorTileProvider.prototype._refineTiles = function (tiles, targetLevel) {
        var newTiles = [];
        var tileKeys = [];

        tiles.forEach(function (tile) {
            var tileKey = 'Z' + tile.level + 'X' + tile.x + 'Y' + tile.y;

            if (tile.level < targetLevel - 1) {
                if (!tileKeys.includes(tileKey)) {
                    newTiles.push(tile);
                    tileKeys.push(tileKey);
                }
            } else if (tile.level === targetLevel - 1) {
                for (var i = 0; i < 2; i++) {
                    for (var j = 0; j < 2; j++) {
                        var _tileKey = 'Z' + (tile.level + 1) + 'X' + (tile.x * 2 + i) + 'Y' + (tile.y * 2 + j);

                        if (!tileKeys.includes(_tileKey)) {
                            newTiles.push({
                                x: tile.x * 2 + i,
                                y: tile.y * 2 + j,
                                level: tile.level + 1
                            });
                            tileKeys.push(_tileKey);
                        }
                    }
                }
            } else {
                var levelDiff = tile.level - targetLevel;

                if (levelDiff === 0) {
                    if (!tileKeys.includes(tileKey)) {
                        newTiles.push(tile);
                        tileKeys.push(tileKey);
                    }
                } else {
                    var factor = levelDiff * 2;
                    var targetX = Math.floor(tile.x / factor);
                    var targetY = Math.floor(tile.y / factor);
                    var _tileKey2 = 'Z' + targetLevel + 'X' + targetX + 'Y' + targetY;

                    if (!tileKeys.includes(_tileKey2)) {
                        newTiles.push({
                            x: targetX,
                            y: targetY,
                            level: targetLevel
                        });
                        tileKeys.push(_tileKey2);
                    }
                }
            }
        });

        return newTiles;
    };

    /**
     * 移除过期的瓦片
     *
     * @param {Object} primitiveByTile 瓦片 primitive，以 tileKey 索引
     * @param {String[]} tileKeys 当前有效的瓦片 keys
     */
    // ArcgisNVectorTileProvider.prototype._removeObsoletePrimitives = function _removeObsoletePrimitives(primitiveByTile, tileKeys) {
    //     // for (var tileKey in primitiveByTile) {
    //     //     if (!tileKeys.includes(tileKey)) {
    //     //         var removed = this._viewer.scene.primitives.remove(primitiveByTile[tileKey]);

    //     //         if (removed) {
    //     //             delete primitiveByTile[tileKey];
    //     //         } else {}
    //     //     }
    //     // }
    // };

    ArcgisNVectorTileProvider.prototype._removeObsoletePrimitives = function (primitiveByTile, tileKeys) {
        var deleteTileKeys = [];
        if (tileKeys.length > 0) {
            // deleteTileKeys = tileKeys.slice(0, Math.ceil(tileKeys.length / 10));
            deleteTileKeys = tileKeys;
        }
        for (var tileKey in primitiveByTile) {
            if (!deleteTileKeys.includes(tileKey)) {
                //var removed = this._viewer.scene.primitives.remove(primitiveByTile[tileKey]);
                var removed = this._primitiveCollection.remove(primitiveByTile[tileKey]);
                if (removed) {
                    delete primitiveByTile[tileKey];
                }
            }
        }
    };

    /**
     * 将 provider 添加到指定 viewer
     *
     * @param {Cesium.Viewer} viewer 目标 viewer
     */
    ArcgisNVectorTileProvider.prototype.addTo = function (viewer) {
        this._viewer = viewer;
        this._viewer.scene.primitives.add(this._primitiveCollection);
        this._isRemoved = false;
        this._viewer.camera.moveEnd.addEventListener(this._cameraMoveEndHandler);
        this._viewer.camera.moveStart.addEventListener(this._cameraMoveStartHandler);
        this._cameraMoveEndHandler();
    };

    /**
     * 移除 provider
     */
    ArcgisNVectorTileProvider.prototype.remove = function () {
        if (this._viewer) {
            for (var tileKey in this._primitiveByTile) {
                this._viewer.scene.primitives.remove(this._primitiveByTile[tileKey]);
            }
            this._primitiveByTile = {};
            this._viewer.camera.moveEnd.removeEventListener(this._cameraMoveEndHandler);
            this._viewer.camera.moveStart.removeEventListener(this._cameraMoveStartHandler);
            this._viewer = null;
            this._isRemoved = true;
        }
    };

    /**
     * 停止 刷新
     */
    ArcgisNVectorTileProvider.prototype.setStatus = function (b) {
        this._stop = b;
    };
    /**
     * provider 是否已移除
     */
    ArcgisNVectorTileProvider.prototype.isRemoved = function () {
        return this._isRemoved;
    };

    /**
     * 添加属性过滤
     *
     * @param {string} property 要过滤的属性名称
     * @param {any[]} values 要过滤的属性值
     * @param {Cesium.Rectangle} [rectangle] 要过滤的数据范围
     */
    ArcgisNVectorTileProvider.prototype.filterBy = function (property, values, rectangle) {
        this._propertyToBeFiltered = property;
        this._valuesToBeFiltered = values;
    };

    /**
     * 移除属性过滤
     */
    ArcgisNVectorTileProvider.prototype.removeFilter = function () {
        this._propertyToBeFiltered = null;
        this._valuesToBeFiltered = null;
    };

    function TileManager() {
        this._quadtree = undefined,
            this._tilingScheme = new Cesium.GeographicTilingScheme,
            this._errorEvent = new Cesium.Event,
            this._loadTileEvent = new Cesium.Event,
            this._levelZeroMaximumError = Cesium.TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap(this._tilingScheme.ellipsoid, 128, this._tilingScheme.getNumberOfXTilesAtLevel(0)),
            this._tileCache = [],
            this._primitivesWaitingToBeAddedToTheScene = [],
            this._pauseStreaming = !1,
            this._numTilesInLevel = [],
            this.STREAM_SPEED_IMIDIATE = 0,
            this.STREAM_SPEED_FAST = 1,
            this.STREAM_SPEED_NORMAL = 2,
            this.STREAM_SPEED_SLOW = 3,
            this._streamSpeed = this.STREAM_SPEED_NORMAL;
    }

    function a$1(e, n) {
        $.each(e._primitives, function (e, r) {
            if (r instanceof Cesium.BillboardCollection) {
                var i = r,
                    e = t$1.indexOf(i);
                return i._parentCollection._primitiveOld = n,
                    e !== -1 ? (viewer.scene.primitives.remove(t$1[e]._parentCollection), t$1[e] = i) : t$1.push(i),
                    !1
            }
        });
    }

    function f(e, t) {
        viewer.scene.primitives.remove(t),
            e._onDestroyTilePrimitive = function () {
                viewer.scene.primitives.remove(t),
                    this._onDestroyTilePrimitive = undefined;
            };
    }

    function l$1(e, t, n) {
        Cesium.when.all(e, function () {
            viewer.scene.primitives.remove(n);
        }),
            t._onDestroyTilePrimitive = function () {
                viewer.scene.primitives.remove(n),
                    this._onDestroyTilePrimitive = undefined;
            };
    }

    function c$1(e, t) {
        var n = $.map(e._primitives, function (e) {
            return e.readyPromise
        });
        l$1(n, e, t);
    }

    function h$1(e, t) {
        var n = $.map(e._primitives[0]._primitives, function (e) {
            return e.readyPromise
        });
        l$1(n, e, t);
    }

    function p$1(e, t) {
        viewer.scene.primitives.remove(t);
    }

    function d$1(e, t) {
        var n = [e.readyPromise];
        l$1(n, e, t);
    }
    Object.defineProperties(TileManager.prototype, {
        quadtree: {
            get: function () {
                return this._quadtree
            },
            set: function (e) {
                this._quadtree = e;
            }
        },
        ready: {
            get: function () {
                return !0
            }
        },
        tilingScheme: {
            get: function () {
                return this._tilingScheme
            }
        },
        errorEvent: {
            get: function () {
                return this._errorEvent
            }
        },
        loadTileEvent: {
            get: function () {
                return this._loadTileEvent
            }
        },
        pauseStreaming: {
            get: function () {
                return this._pauseStreaming
            },
            set: function (e) {
                this._pauseStreaming = e;
            }
        },
        streamSpeed: {
            get: function () {
                return this._streamSpeed
            },
            set: function (e) {
                this._streamSpeed = e;
            }
        },
        bestLevelAvailable: {
            get: function () {
                var e = 0;
                for (var t = 0; t < 22; t++) this._numTilesInLevel[t] != undefined && this._numTilesInLevel[t] > 0 && e < t && (e = t);
                return e
            }
        }
    });
    TileManager.prototype.streamSpeedFactor = function () {
        switch (this._streamSpeed) {
            case this.STREAM_SPEED_FAST:
                return 1;
            case this.STREAM_SPEED_NORMAL:
                return 3;
            case this.STREAM_SPEED_SLOW:
                return 20;
            default:
                return 3
        }
    };
    var t$1 = [];
    var n$1 = 0;
    TileManager.prototype.onPreFrame = function (e, r) {
        n$1++;
        if (this._pauseStreaming) return;
        if (this._streamSpeed == this.STREAM_SPEED_IMIDIATE)
            while (this._primitivesWaitingToBeAddedToTheScene.length > 0) {
                var i = this._primitivesWaitingToBeAddedToTheScene.pop();
                e.primitives.add(i);
            } else if (this._primitivesWaitingToBeAddedToTheScene.length > 0 && n$1 % this.streamSpeedFactor() == 0) {
                var i = this._primitivesWaitingToBeAddedToTheScene.pop();
                i._instanceIds && i._instanceIds.length > 100 && this.streamSpeed === this.STREAM_SPEED_FAST && (this.streamSpeed = this.STREAM_SPEED_NORMAL),
                    e.primitives.add(i);
            }
        $.each(t$1, function (e, t) {
            t.ready && viewer.scene.primitives.remove(t._parentCollection._primitiveOld);
        });
    };
    var r$1 = !1;
    TileManager.prototype.initialize = function (e) {
        r$1 || (viewer.scene.preRender.addEventListener(this.onPreFrame, this), r$1 = !0);
    };
    TileManager.prototype.beginUpdate = function (e) {
        this.quadtree.beginFrame(e);
    };

    TileManager.prototype.endUpdate = function (e) {
        var t = this;
        e.afterRender.push(function () {
            t.quadtree.endFrame(e);
        });
    };

    TileManager.prototype.updateForPick = function (e) { };

    TileManager.prototype.getLevelMaximumGeometricError = function (e) {
        return this._levelZeroMaximumError / (1 << e) * this._quadtree.maximumScreenSpaceError
    };
    var i$1 = 180 / Math.PI;

    TileManager.prototype.placeHolder = function (e, t) {
        t = t || Cesium.Color.fromBytes(0, 255, 0, 255);
        var n = new Cesium.Primitive({
            geometryInstances: new Cesium.GeometryInstance({
                geometry: new Cesium.RectangleOutlineGeometry({
                    rectangle: e.rectangle,
                    height: viewer.camera.positionCartographic.height - TerraExplorer.internal.Navigate.HeightAboveGround * .99
                }),
                attributes: {
                    color: Cesium.ColorGeometryInstanceAttribute.fromColor(t)
                }
            }),
            appearance: new Cesium.PerInstanceColorAppearance({
                flat: !0
            })
        });
        e.data.primitive.add(n);
    };
    TileManager.prototype.loadTile = function (e, t) {
        var n = this;
        this._numTilesInLevel[t._level] == undefined && (this._numTilesInLevel[t._level] = 0),
            this._numTilesInLevel[t._level]++;
        if (t.state === Cesium.QuadtreeTileLoadState.START) {
            t.data = {
                primitive: new Cesium.PrimitiveCollection,
                wfsLayerData: [],
                id: Cesium.createGuid(),
                freeResources: function () {
                    n._tileCache[t.data.id] && n._numTilesInLevel[t._level]--,
                        n._numTilesInLevel[t._level] < 0 && (n._numTilesInLevel[t._level] = 0);
                    if (Cesium.defined(this.wfsLayerData)) {
                        for (var e in this.wfsLayerData) Cesium.defined(this.wfsLayerData[e]) && this.wfsLayerData[e].freeResources();
                        this.wfsLayerData = undefined;
                    }
                    Cesium.defined(this.primitive) && (this.primitive.destroy(), this.primitive = undefined),
                        delete n._tileCache[t.data.id];
                }
            },
                this._tileCache[t.data.id] = t;
            var r = 6371e3;
                Math.abs(r * (t.rectangle.south - t.rectangle.north));
            t.data.boundingSphere3D = Cesium.BoundingSphere.fromRectangle3D(t.rectangle),
                t.data.boundingSphere2D = Cesium.BoundingSphere.fromRectangle2D(t.rectangle, e.mapProjection);
            [i$1 * t.rectangle.west, i$1 * t.rectangle.south, i$1 * t.rectangle.east, i$1 * t.rectangle.north];
            this.loadTileEvent.raiseEvent(t),
                t.state = Cesium.QuadtreeTileLoadState.DONE,
                t.renderable = !0;
        }
    };
    TileManager.prototype.getTile = function (e) {
        return this._tileCache[e]
    };
    TileManager.prototype.getAllTiles = function () {
        var e = [];
        for (var t in this._tileCache) e.push(this._tileCache[t]);
        return e
    };
    TileManager.prototype.computeTileVisibility = function (e, t, n) {
        var r = this.computeDistanceToTile(e, t);
        e._distance = r;
        if (t.fog.enabled && e._level > 9 && Cesium.Math.fog(r, t.fog.density) >= 1) return Cesium.Visibility.NONE;
        var i;
        return t.mode === Cesium.SceneMode.SCENE3D ? i = e.data.boundingSphere3D : i = e.data.boundingSphere2D,
            t.cullingVolume.computeVisibility(i)
    };
    TileManager.prototype.showTileThisFrame = function (e, t) {
        e.data.primitive.update(t);
    };
    TileManager.prototype.computeDistanceToTile = function (e, t) {
        var n;
        var o = new Cesium.Cartesian3;

        t.mode === Cesium.SceneMode.SCENE3D ? n = e.data.boundingSphere3D : n = e.data.boundingSphere2D;
        var r = Cesium.Cartesian3.subtract(n.center, t.camera.positionWC, o),
            i = Cesium.Cartesian3.magnitude(r);
        return Math.max(1, i - TerraExplorer.internal.Navigate.GroundHeightAtCameraPosition)
    };
    TileManager.prototype.isDestroyed = function () {
        return !1
    };
    TileManager.prototype.destroy = function () {
        return Cesium.destroyObject(this)
    };
    TileManager.prototype.getInstance = function (t) {
        if (Cesium.defined(t.TileManager) == 0) {
            t.TileManager = new e;
            var n = new Cesium.QuadtreePrimitive({
                tileProvider: t.TileManager,
                maximumScreenSpaceError: 2
            });
            t.scene.primitives.add(n);
        }
        return t.TileManager
    };
    TileManager.prototype.addToScene = function (e) {
        this._primitivesWaitingToBeAddedToTheScene.push(e);
    };
    TileManager.prototype.removeFromScene = function (e) {
        var t = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        t != -1 ? (this._primitivesWaitingToBeAddedToTheScene[t].destroy(), this._primitivesWaitingToBeAddedToTheScene.splice(t, 1)) : viewer.scene.primitives.remove(e);
    };
    TileManager.prototype.replaceInScene = function (e, t) {
        var n = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        if (n != -1) this._primitivesWaitingToBeAddedToTheScene[n] = t;
        else {
            e.ID != t.ID && console.log("TileManager.replaceInScene Warning: new primitive has a different ID than old primitive"),
                e._replacmentPrimitive != undefined && viewer.scene.primitives.remove(e._replacmentPrimitive),
                e._replacmentPrimitive = t,
                viewer.scene.primitives.add(t);
            var r = t.ID.split(":")[0];
            switch (r) {
                case "billboards":
                    a$1(t, e);
                    break;
                case "labels":
                    f(t, e);
                    break;
                case "polygons":
                    c$1(t, e);
                    break;
                case "models":
                    h$1(t, e);
                    break;
                case "polylines":
                    d$1(t, e);
                    break;
                case "points":
                    p$1(t, e);
                    break;
                default:
                    console.log("Error updating layer"),
                        viewer.scene.primitives.remove(e);
            }
        }
    };
    var v = {
        billboards: a$1,
        labels: f,
        polygons: c$1,
        models: h$1,
        polylines: d$1,
        points: p$1
    };
    TileManager.prototype.replaceInSceneNew = function (e, t) {
        var n = this._primitivesWaitingToBeAddedToTheScene.indexOf(e);
        if (n != -1) this._primitivesWaitingToBeAddedToTheScene[n] = t;
        else {
            e.ID !== t.ID && console.log("TileManager.replaceInScene Warning: new primitive has a different ID than old primitive"),
                this.addToScene(t);
            var i = t.ID.split(":")[0],
                s = v[i];
            s ? s(t, e) : (console.log("Error updating layer"), viewer.scene.primitives.remove(e));
        }
    };

    function Gettreeid(name, pid) {
        var id = "";
        var trees = tree.getSource();
        for (var i = 0; i < trees.length; i++) {
            if (name == trees[i].name && trees[i].pId == pid) {
                id = trees[i].id;
            }
        }
        return id;
    }

    var VERSION = '2.0.0';
    var COMPILETIME = '2022.1.6';

    exports.Analysis = Analysis;
    exports.Angle = Angle;
    exports.ArcgisNVectorTileProvider = ArcgisNVectorTileProvider;
    exports.AttachEvent = AttachEvent;
    exports.BaiduImageryProvider = BaiduImageryProvider;
    exports.Bearing = Bearing;
    exports.Billboard = Billboard;
    exports.Box = Box;
    exports.BoxGeoJsonFeatureLayer = BoxGeoJsonFeatureLayer;
    exports.BufferAnalysis = BufferAnalysis;
    exports.CIMServerTool = CIMServerTool;
    exports.COMPILETIME = COMPILETIME;
    exports.CZML = CZML;
    exports.Cartesian3_to_WGS84 = Cartesian3_to_WGS84;
    exports.Cdcl = Cdcl;
    exports.CesiumHeatmap = CesiumHeatmap;
    exports.CesiumHeatmapGL = CesiumHeatmapGL;
    exports.CesiumRenderPass = CesiumRenderPass;
    exports.Circle = Circle;
    exports.Color = Color;
    exports.CombineEcharts = CombineEcharts;
    exports.Command = Command;
    exports.Cone = Cone;
    exports.ContentState = ContentState$1;
    exports.CoordTransform = CoordTransform;
    exports.Core = Core;
    exports.Corridor = Corridor;
    exports.CreateWfsFeatureLayer = WfsFeatureLayer;
    exports.Creator = Creator;
    exports.Current = Current;
    exports.DDSTexture = DDSTexture;
    exports.DateTime = DataTime;
    exports.DetachEvent = DetachEvent;
    exports.DivPoint = DivPoint;
    exports.EdgeStage = EdgeStage;
    exports.ElevationContour = ElevationContour;
    exports.ElevationTool = ElevationTool;
    exports.Ellipsoid = Ellipsoid;
    exports.EntityCreator = EntityCreator$1;
    exports.EventType = EventType$1;
    exports.FlowField = FlowField;
    exports.GeoJSONVectorTileProvider = GeoJSONVectorTileProvider;
    exports.GeoJSONVectorTileProvider1 = GeoJSONVectorTileProvider1;
    exports.GeoJSONVectorTileProviderPolymerization = GeoJSONVectorTileProviderPolymerization;
    exports.GeoJsonFeatureLayer = GeoJsonFeatureLayer;
    exports.Gettreeid = Gettreeid;
    exports.GmlParser = GmlParser$1;
    exports.Hawkeye = Hawkeye;
    exports.Heatmap = Heatmap;
    exports.Highvolume = Highvolume;
    exports.ImageLabel = ImageLabel;
    exports.ImageryLayer = ImageryLayer;
    exports.JBAlgorithm = JBAlgorithm;
    exports.KmlLayer = KmlLayer;
    exports.Label = Label;
    exports.LabelGeoJsonFeatureLayer = LabelGeoJsonFeatureLayer;
    exports.LabelGeoJsonFeatureLayercopy = LabelGeoJsonFeatureLayercopy;
    exports.LonLatProjection = LonLatProjection;
    exports.MaterialPass = MaterialPass;
    exports.MilitaryStandard = MilitaryStandard;
    exports.Mjcl = Mjcl;
    exports.ModelClipping = ModelClipping;
    exports.ModelEdit = ModelEdit;
    exports.ModifyMesh = ModifyMesh;
    exports.Navigate = Navigate;
    exports.Particle = particle;
    exports.Point = Point;
    exports.PointFly = PointFly;
    exports.PointModel = PointModel;
    exports.Polygon = Polygon;
    exports.PolygonGeoJsonFeatureLayer = PolygonGeoJsonFeatureLayer;
    exports.PolygonVectorGeoJsonFeatureLayer = PolygonVectorGeoJsonFeatureLayer;
    exports.PolygonVectorTileLayerArcgis = PolygonVectorTileLayerArcgis;
    exports.Polyline = Polyline;
    exports.PolylineGeoJsonFeatureLayer = PolylineGeoJsonFeatureLayer;
    exports.PolylineTrailLinkMaterial = PolylineTrailLinkMaterial;
    exports.PolylineVolume = PolylineVolume;
    exports.PopupMessage = PopupMessage;
    exports.ProjectTree = ProjectTree;
    exports.Recorder = Recorder;
    exports.Rectangle = Rectangle$1;
    exports.RenderEntity = RenderEntity;
    exports.Road = Road;
    exports.S3MCacheFileRenderEntity = S3MCacheFileRenderEntity;
    exports.S3MCompressType = S3MCompressType$1;
    exports.S3MContentFactory = S3MContentFactory;
    exports.S3MContentParser = S3MContentParser;
    exports.S3MCreateIndexJob = S3MCreateIndexBufferJob;
    exports.S3MCreateVertexJob = S3MCreateVertexJob;
    exports.S3MLayerCache = S3MLayerCache;
    exports.S3MLayerScheduler = S3MLayerScheduler;
    exports.S3MPixelFormat = S3MPixelFormat$1;
    exports.S3MTile = S3MTile;
    exports.S3MTilesFS = S3MTilesFS;
    exports.S3MTilesLayer = S3MTilesLayer;
    exports.S3MTilesVS = S3MTilesVS;
    exports.S3ModelParser = S3ModelParser;
    exports.SE3DTileset = SE3DTileset;
    exports.SFSTerrainProvider = SFSTerrainProvider;
    exports.SFSTerrainProvider7_2_3 = SFSTerrainProvider723;
    exports.SGWorld = SGWorld;
    exports.SatelliteTrail = SatelliteTrail;
    exports.Scan = Scan;
    exports.Scan_PostProcessStage = ScanPostProcessStage;
    exports.Scopefieldvision = Scopefieldvision;
    exports.Screenshot = Screenshot;
    exports.ShadowsAnalysis = ShadowsAnalysis;
    exports.SightLine = SightLine;
    exports.SimpleGraphic = SimpleGraphic;
    exports.SimpleSqlParser = SimpleSqlParser$1;
    exports.Skip = Skip;
    exports.SkyBox = SkyBox;
    exports.SkylineAnalysis = SkylineAnalysis;
    exports.Stop = Stop;
    exports.StreamerPath = Streamerpath;
    exports.StreamerWall = Streamerwall;
    exports.StreetView = StreetView;
    exports.SunshineAnalysis = SunshineAnalysis;
    exports.TdtLabel = TdtLabel;
    exports.Terrain = Terrain;
    exports.TerrainExcavation = TerrainExcavation;
    exports.TerrainModifier = TerrainModifier;
    exports.TileManager = TileManager;
    exports.TileManager1 = TileManager1$1;
    exports.TrailLine = TrailLine;
    exports.UndergroundMode = UndergroundMode;
    exports.VERSION = VERSION;
    exports.VectorGeoJsonFeatureLayer = VectorGeoJsonFeatureLayer;
    exports.VectorImgFeatureLayer = VectorImgFeatureLayer;
    exports.VectorTileProvider = VectorTileProvider;
    exports.VectorTileProviderEntity = VectorTileProviderEntity;
    exports.VertexCompressOption = VertexCompressOption;
    exports.Video = Video3D;
    exports.ViewCone = ViewCone;
    exports.Viewshed = Viewshed;
    exports.VolumeGeoJsonFeatureLayer = VolumeGeoJsonFeatureLayer;
    exports.VolumetricMeasure = VolumetricMeasure;
    exports.WFSTool = WFSTool;
    exports.WGS84_to_Cartesian3 = WGS84_to_Cartesian3;
    exports.WallGeoFeatureLayer = WallGeoFeatureLayer;
    exports.WaterGeoJsonFeatureLayer = WaterGeoJsonFeatureLayer;
    exports.WfsLayer = WfsLayer$1;
    exports.WorkerPool = WorkerPool;
    exports.billboardGeoJsonFeatureLayer = billboardGeoJsonFeatureLayer;
    exports.clone = clone;
    exports.configData = configData$1;
    exports.createGroup = createGroup;
    exports.createTerrainProfile = createTerrainProfile;
    exports.curtaincontrast = curtaincontrast;
    exports.defaultValue = defaultValue;
    exports.deleteItem = deleteItem;
    exports.depthTestAgainstTerrain = depthTestAgainstTerrain;
    exports.dynamicObject = dynamicObject;
    exports.execute = execute;
    exports.expandGroup = expandGroup;
    exports["export"] = exportTree;
    exports.findItem = findItem;
    exports.flyTo = flyTo;
    exports.flyToObj = flyToObj;
    exports.getExitsObjectType = getExitsObjectType;
    exports.getItemName = getItemName;
    exports.getNextItem = getNextItem;
    exports.getObject = getObject;
    exports.getPosition = getPosition;
    exports.getVisibility = getVisibility;
    exports.indoormode = Indoormode;
    exports.isGroup = isGroup;
    exports.jumpTo = jumpTo;
    exports.lineOfSight = lineOfSight;
    exports.lodash = lodash;
    exports.main = scope;
    exports.measureTerrainArea = measureTerrainArea;
    exports.measureTerrainHeight = measureTerrainHeight;
    exports.measureTerrainPerimeter = measureTerrainPerimeter;
    exports.measureTerrainkPerimeter = measureTerrainkPerimeter;
    exports.northfinger = northfinger;
    exports.pako_inflate = pako;
    exports.pbf_dev = Pbf;
    exports.position = Position;
    exports.renameGroup = renameGroup;
    exports.setPosition = setPosition;
    exports.setVisibility = setVisibility;
    exports.tdtwmtsimageprovider = TDTWMTSImageProvider;
    exports.terrainExaggeration = terrainExaggeration;
    exports.treeSource = tree;
    exports.vectortile = VectorTile;
    exports.wall = wall;
    exports.weather = weather;
    exports.zoomIn = zoomIn;
    exports.zoomOut = zoomOut;

    Object.defineProperty(exports, '__esModule', { value: true });

}));