easy-three-utils 0.0.348 → 0.0.350

package/cesium/js/measure1.ts

@@ -1,208 +0,0 @@
-import * as Cesium from 'cesium'
-
-const useMeasureTools = (viewer: Cesium.Viewer) => {
-    let handler = new Cesium.ScreenSpaceEventHandler((viewer.scene as any)._imageryLayerCollection)
-    let positions = []
-    let positionsCartographic = []
-    let positions_Inter = []
-    let poly = null
-    let distance = null
-    let cartesian = null
-    let DistanceArray = []
-    let profileItem = []
-
-    const reset = () => {
-        handler = new Cesium.ScreenSpaceEventHandler((viewer.scene as any)._imageryLayerCollection)
-        positions = []
-        positionsCartographic = []
-        positions_Inter = []
-        poly = null
-        distance = null
-        cartesian = null
-        DistanceArray = []
-        profileItem = []
-    }
-
-    const measureDistance = () => {
-        reset()
-        
-        handler.setInputAction(((movement) => {
-            cartesian = viewer.scene.pickPosition(movement.endPosition);
-            if (positions.length >= 2) {
-                if (!Cesium.defined(poly)) {
-                    poly = new PolyLinePrimitive(positions);
-                } else {
-                    positions.pop();
-                    positions.push(cartesian);
-                }
-            }
-        }) as Cesium.ScreenSpaceEventHandler.MotionEventCallback, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
-
-        handler.setInputAction(((movement) => {
-            cartesian = viewer.scene.pickPosition(movement.position);
-            if (positions.length == 0) {
-                positions.push(cartesian.clone());
-            }
-            positions.push(cartesian);
-            if (poly) {
-                interPoints(poly.positions);
-                distance = getSpaceDistance(positions_Inter);
-            } else {
-                distance = getSpaceDistance(positions);
-            }
-
-            const textDisance = distance + "米";
-            DistanceArray.push(distance);
-            viewer.entities.add({
-                position: positions[positions.length - 1],
-                point: {
-                    color: Cesium.Color.fromCssColorString("rgb(249, 157, 11)"),
-                    outlineColor: Cesium.Color.WHITE,
-                    outlineWidth: 2,
-                    pixelSize: 10
-                },
-                label: {
-                    text: textDisance,
-                    font: '18px sans-serif',
-                    fillColor: Cesium.Color.GOLD,
-                    style: Cesium.LabelStyle.FILL_AND_OUTLINE,
-                    outlineWidth: 2,
-                    verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
-                    pixelOffset: new Cesium.Cartesian2(20, -20),
-                    heightReference: Cesium.HeightReference.NONE
-                }
-            });
-        }) as Cesium.ScreenSpaceEventHandler.PositionedEventCallback, Cesium.ScreenSpaceEventType.LEFT_CLICK);
-
-        handler.setInputAction((() => {
-            destoryHandler()
-        }) as Cesium.ScreenSpaceEventHandler.PositionedEventCallback, Cesium.ScreenSpaceEventType.RIGHT_CLICK);
-
-        class PolyLinePrimitive {
-            options: any;
-            positions: any;
-
-            constructor(positions) {
-                this.options = {
-                    polyline: {
-                        show: true,
-                        positions: [],
-                        material: Cesium.Color.fromCssColorString("rgb(249, 157, 11)"),
-                        width: 2,
-                        clampToGround: true
-                    }
-                };
-                this.positions = positions;
-                this.init()
-            }
-
-            init = () => {
-                const _self = this;
-                const _update = function () {
-                    return _self.positions;
-                };
-                this.options.polyline.positions = new Cesium.CallbackProperty(_update, false);
-                viewer.entities.add(this.options);
-            }
-        }
-
-        const cartesian3ToDegrees = (pos) => {
-            const ellipsoid = viewer.scene.globe.ellipsoid;
-            const cartographic = ellipsoid.cartesianToCartographic(pos);
-            const lat = Cesium.Math.toDegrees(cartographic.latitude);
-            const lon = Cesium.Math.toDegrees(cartographic.longitude);
-            const height = cartographic.height;
-
-            return {
-                lat,
-                lon,
-                height
-            }
-        }
-
-        const getSpaceDistance = (positions) => {
-            profileItem = [
-                {
-                    point: cartesian3ToDegrees(positions[0]),
-                    distance: 0
-                }
-            ];
-            let distance = 0;
-            for (let i = 0; i < positions.length - 1; i++) {
-                const point1cartographic = Cesium.Cartographic.fromCartesian(positions[i]);
-                const point2cartographic = Cesium.Cartographic.fromCartesian(positions[i + 1]);
-                const geodesic = new Cesium.EllipsoidGeodesic();
-                geodesic.setEndPoints(point1cartographic, point2cartographic);
-                let s = geodesic.surfaceDistance;
-                s = Math.sqrt(Math.pow(s, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2));
-                distance = distance + s;
-
-                const m_Item = {
-                    point: cartesian3ToDegrees(positions[i + 1]),
-                    distance: distance
-                };
-                profileItem.push(m_Item);
-            }
-            return distance.toFixed(2);
-        }
-
-        const interPoints = (positions) => {
-            positionsCartographic = [];
-            var terrainSamplePositions = [];
-            for (let index = 0; index < positions.length - 1; index++) {
-                const element = positions[index];
-                var ellipsoid = viewer.scene.globe.ellipsoid;
-                var cartographic = ellipsoid.cartesianToCartographic(element);
-                positionsCartographic.push(cartographic);
-            }
-            for (let i = 0; i < positionsCartographic.length; i++) {
-                const m_Cartographic0 = positionsCartographic[i];
-                const m_Cartographic1 = positionsCartographic[i + 1];
-                if (m_Cartographic1) {
-                    var a = Math.abs(m_Cartographic0.longitude - m_Cartographic1.longitude) * 10000000;
-                    var b = Math.abs(m_Cartographic0.latitude - m_Cartographic1.latitude) * 10000000;
-                    if (a > b) b = a;
-                    let length = parseInt((b / 2) as any);
-                    if (length > 1000) length = 1000;
-                    if (length < 2) length = 2;
-                    for (var j = 0; j < length; j++) {
-                        terrainSamplePositions.push(
-                            new Cesium.Cartographic(
-                                Cesium.Math.lerp(m_Cartographic0.longitude, m_Cartographic1.longitude, j / (length - 1)),
-                                Cesium.Math.lerp(m_Cartographic0.latitude, m_Cartographic1.latitude, j / (length - 1))
-                            )
-                        );
-                    }
-                    terrainSamplePositions.pop();
-                } else {
-                    terrainSamplePositions.push(m_Cartographic0);
-                }
-            }
-            positions_Inter = [];
-            for (var n = 0; n < terrainSamplePositions.length; n++) {
-                var m_cartographic = terrainSamplePositions[n];
-                var height = viewer.scene.globe.getHeight(m_cartographic);
-                var point = Cesium.Cartesian3.fromDegrees(m_cartographic.longitude / Math.PI * 180, m_cartographic.latitude / Math.PI * 180, height);
-                positions_Inter.push(point);
-            }
-        }
-
-        const destoryHandler = () => {
-            if (handler) {
-                handler.removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE)
-                handler.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_CLICK)
-                handler.removeInputAction(Cesium.ScreenSpaceEventType.RIGHT_CLICK)
-                handler.destroy()
-                handler = null
-            }
-        }
-    }
-
-    return {
-        measureDistance
-    }
-}
-
-export {
-    useMeasureTools
-}

package/cesium/js/slope.js

@@ -1,379 +0,0 @@
-import CreatePolygonOnGround from "./lib/CreatePolygonOnGround";
-import CreateRemindertip from "./lib/ReminderTip";
-import * as turf from "@turf/turf";
-import * as Cesium from 'cesium'
-
-class SlopeAspect {
-    constructor(viewer, cb, cb1) {
-        if (!viewer) throw new Error("no viewer object!");
-        this.viewer = viewer;
-        this.result = []; //存储创建的坡度分析结果，primitive集合
-        this.handler = undefined;
-        this.toolTip = "";
-        this.cb = cb
-        this.cb1 = cb1
-    }
-    openTip() {
-        const $this = this;
-        const viewer = this.viewer;
-        this.handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
-        this.handler.setInputAction(function (movement) {
-            let endPos = movement.endPosition;
-            var pick = viewer.scene.pick(endPos);
-            if (pick && pick.id && pick.id.type === "SlopeAspect") {
-                $this.toolTip = pick.id.value.toFixed(2);
-                // CreateRemindertip($this.toolTip, endPos, true);
-            } else {
-                $this.toolTip = "";
-                // CreateRemindertip($this.toolTip, endPos, false);
-            }
-        }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
-    }
-    closeTip() {
-        if (this.handler) {
-            this.handler.destroy();
-            this.handler = undefined;
-        }
-    }
-    //等距离切分网格
-    createNew4Distance(distance) {
-        distance = distance || 0.1; //默认0.1km精度
-        let width = distance * 200 > 35 ? 35 : distance * 200;
-        this.arrowWidth = width < 15 ? 15 : width;
-        const $this = this;
-        const viewer = this.viewer;
-        CreatePolygonOnGround(
-            viewer,
-            [],
-            {
-                color: Cesium.Color.RED.withAlpha(0.1),
-                outlineColor: Cesium.Color.YELLOW,
-                outlineWidth: 2,
-            },
-            function (polygon) {
-                let degrees = $this.Cartesian3ListToWGS84(polygon.pottingPoint);
-                viewer.entities.remove(polygon);
-                let boundary = [];
-                let minX = 10000,
-                    minY = 10000,
-                    maxX = -10000,
-                    maxY = -1000;
-                for (let index = 0; index < degrees.length; index++) {
-                    const element = degrees[index];
-                    const x = element.lng;
-                    const y = element.lat;
-                    boundary.push([x, y]);
-                    minX = x < minX ? x : minX;
-                    minY = y < minY ? y : minY;
-                    maxX = x > maxX ? x : maxX;
-                    maxY = y > maxY ? y : maxY;
-                }
-                boundary.push(boundary[0]);
-                let bbox = [minX, minY, maxX, maxY];
-                let mask = turf.polygon([boundary]);
-                let gridSquare = turf.squareGrid(bbox, distance, { mask: mask });
-                $this.createEllipse(gridSquare);
-                $this.cb && $this.cb()
-            },
-            function (handler) {
-                $this.cb1(handler)
-            }
-        );
-    }
-    // 等分切分网格，切分成一个num*num的网格
-    createNew4Num(num) {
-        const $this = this;
-        const viewer = this.viewer;
-        CreatePolygonOnGround(
-            viewer,
-            [],
-            {
-                color: Cesium.Color.RED.withAlpha(0.1),
-                outlineColor: Cesium.Color.YELLOW,
-                outlineWidth: 2,
-            },
-            function (polygon) {
-                let degrees = $this.Cartesian3ListToWGS84(polygon.pottingPoint);
-                viewer.entities.remove(polygon);
-                let boundary = [];
-                let minX = 10000,
-                    minY = 10000,
-                    maxX = -10000,
-                    maxY = -1000;
-                for (let index = 0; index < degrees.length; index++) {
-                    const element = degrees[index];
-                    const x = element.lng;
-                    const y = element.lat;
-                    boundary.push([x, y]);
-                    minX = x < minX ? x : minX;
-                    minY = y < minY ? y : minY;
-                    maxX = x > maxX ? x : maxX;
-                    maxY = y > maxY ? y : maxY;
-                }
-                boundary.push(boundary[0]);
-                let bbox = [minX, minY, maxX, maxY];
-                let a = maxX - minX;
-                let b = maxY - minY;
-                b = b > a ? b : a;
-                const step = b / num;
-                let width = step * 2000 > 35 ? 35 : step * 2000;
-                $this.arrowWidth = width < 15 ? 15 : width;
-                let mask = turf.polygon([boundary]);
-                let gridSquare = turf.squareGrid(bbox, step, {
-                    units: "degrees",
-                    mask: mask,
-                });
-                $this.createEllipse(gridSquare);
-                $this.cb && $this.cb()
-            },
-            function (handler) {
-                $this.cb1(handler)
-            }
-        );
-    }
-    createEllipse(gridSquare) {
-        let boxResults = [];
-        for (let index = 0; index < gridSquare.features.length; index++) {
-            const feature = gridSquare.features[index];
-            const coordinates = feature.geometry.coordinates[0];
-            const centerdegree = [
-                (coordinates[0][0] + coordinates[2][0]) / 2,
-                (coordinates[0][1] + coordinates[2][1]) / 2,
-            ];
-            let centerCartographic = Cesium.Cartographic.fromDegrees(
-                centerdegree[0],
-                centerdegree[1]
-            );
-            boxResults.push(centerCartographic);
-            for (let i = 0; i < coordinates.length; i++) {
-                const coord = coordinates[i];
-                let cartographic = Cesium.Cartographic.fromDegrees(coord[0], coord[1]);
-                boxResults.push(cartographic);
-                const coord1 = coordinates[i + 1];
-                if (coord1) {
-                    let newCoord = [
-                        (coord[0] + coord1[0]) / 2,
-                        (coord[1] + coord1[1]) / 2,
-                    ];
-                    let newCartographic = Cesium.Cartographic.fromDegrees(
-                        newCoord[0],
-                        newCoord[1]
-                    );
-                    boxResults.push(newCartographic);
-                }
-            }
-        }
-        Cesium.sampleTerrainMostDetailed(
-            this.viewer.scene.terrainProvider,
-            boxResults
-        ).then((updatePositions) => {
-            let arrr = [];
-            let ellipseResults = updatePositions.reduce(function (
-                pre,
-                item,
-                index,
-                updatePositions
-            ) {
-                var begin = index * 10;
-                var end = begin + 10;
-                var res = updatePositions.slice(begin, end);
-                if (res.length != 0) {
-                    arrr[index] = res;
-                }
-                return arrr;
-            },
-                []);
-            this.calculateSlope(ellipseResults);
-        });
-    }
-
-    createPolygonInsrance(points, color) {
-        let positions = [];
-        for (let index = 1; index < points.length - 1; index++) {
-            const element = points[index];
-            positions.push(Cesium.Cartographic.toCartesian(element));
-        }
-        let polygon = new Cesium.PolygonGeometry({
-            polygonHierarchy: new Cesium.PolygonHierarchy(positions),
-        });
-
-        let polygonInstance = new Cesium.GeometryInstance({
-            geometry: polygon,
-            attributes: {
-                color: Cesium.ColorGeometryInstanceAttribute.fromColor(
-                    Cesium.Color.fromCssColorString(color)
-                ),
-                show: new Cesium.ShowGeometryInstanceAttribute(true), //显示或者隐藏
-            },
-        });
-        return polygonInstance;
-    }
-    createArrowInstance(
-        targetPoint,
-        center,
-        diagonalPoint,
-        heightDifference,
-        curSlope
-    ) {
-        let cartographic_0 = new Cesium.Cartographic(
-            (targetPoint.longitude + center.longitude) / 2,
-            (targetPoint.latitude + center.latitude) / 2,
-            (targetPoint.height + center.height) / 2
-        );
-        let cartographic_1 = new Cesium.Cartographic(
-            (diagonalPoint.longitude + center.longitude) / 2,
-            (diagonalPoint.latitude + center.latitude) / 2,
-            (diagonalPoint.height + center.height) / 2
-        );
-        //偏移的
-        let positions1 =
-            heightDifference > 0
-                ? [
-                    Cesium.Cartographic.toCartesian(cartographic_0),
-                    Cesium.Cartographic.toCartesian(cartographic_1),
-                ]
-                : [
-                    Cesium.Cartographic.toCartesian(cartographic_1),
-                    Cesium.Cartographic.toCartesian(cartographic_0),
-                ];
-        //箭头线
-        const instance = new Cesium.GeometryInstance({
-            id: {
-                type: "SlopeAspect",
-                value: curSlope,
-            },
-            geometry: new Cesium.GroundPolylineGeometry({
-                positions: positions1,
-                width: this.arrowWidth,
-            }),
-            attributes: {
-                color: Cesium.ColorGeometryInstanceAttribute.fromColor(
-                    Cesium.Color.BLUE.withAlpha(0.6)
-                ),
-                show: new Cesium.ShowGeometryInstanceAttribute(true), //显示或者隐藏
-            },
-        });
-        return instance;
-    }
-    calculateSlope(ellipseResults) {
-        let instances = [];
-        let polygonInstance = [];
-        for (let index = 0; index < ellipseResults.length; index++) {
-            const ellipse = ellipseResults[index];
-
-            const center = ellipse[0];
-            let heightDifference = 0;
-            let maxIndex = 0;
-            for (let i = 1; i < ellipse.length - 1; i++) {
-                const point = ellipse[i];
-                let curHD = point.height - center.height;
-                if (Math.abs(curHD) > heightDifference) {
-                    heightDifference = curHD;
-                    maxIndex = i;
-                }
-            }
-            let pos0 = new Cesium.Cartographic(center.longitude, center.latitude, 0);
-            let pos1 = new Cesium.Cartographic(
-                ellipse[maxIndex].longitude,
-                ellipse[maxIndex].latitude,
-                0
-            );
-            let distance = Cesium.Cartesian3.distance(
-                Cesium.Cartographic.toCartesian(pos0),
-                Cesium.Cartographic.toCartesian(pos1)
-            );
-            let curSlope = Math.abs(heightDifference / distance); //坡度的tan值
-            let curColor = this.calculateSlopeColor(curSlope, 0.4);
-            const curPolygonInstance = this.createPolygonInsrance(ellipse, curColor);
-            polygonInstance.push(curPolygonInstance);
-
-            let diagonalPoint =
-                maxIndex > 4 ? ellipse[maxIndex - 4] : ellipse[maxIndex + 4]; //对角点
-            let targetPoint = ellipse[maxIndex];
-            const arrowInstance = this.createArrowInstance(
-                targetPoint,
-                center,
-                diagonalPoint,
-                heightDifference,
-                curSlope
-            );
-            instances.push(arrowInstance);
-        }
-        const mapPrimitive = this.viewer.scene.primitives.add(
-            new Cesium.GroundPrimitive({
-                geometryInstances: polygonInstance,
-                appearance: new Cesium.PerInstanceColorAppearance({
-                    translucent: true, //false时透明度无效
-                    closed: false,
-                }),
-            })
-        );
-        const arrowPrimitive = this.viewer.scene.primitives.add(
-            new Cesium.GroundPolylinePrimitive({
-                geometryInstances: instances,
-                appearance: new Cesium.PolylineMaterialAppearance({
-                    material: new Cesium.Material({
-                        fabric: {
-                            type: "PolylineArrow",
-                            uniforms: {
-                                color: new Cesium.Color(1.0, 1.0, 0.0, 0.8),
-                            },
-                        },
-                    }),
-                }),
-            })
-        );
-        this.result.push(arrowPrimitive, mapPrimitive);
-    }
-    clearAll() {
-        this.result.forEach((element) => {
-            this.viewer.scene.primitives.remove(element);
-        });
-        this.result = [];
-    }
-    //根据坡度值赋值颜色
-    calculateSlopeColor(value, alpha) {
-        // 0°～0.5°为平原0.00872686779075879,rgb(85,182,43)
-        // 0.5°～2°为微斜坡0.03492076949174773,rgb(135,211,43)
-        // 2°～5°为缓斜坡0.08748866352592401,rgb(204,244,44)
-        // 5°～15°为斜坡0.2679491924311227,rgb(245,233,44)
-        // 15°～35°为陡坡0.7002075382097097,rgb(255,138,43)
-        // 35°～55°为峭坡1.4281480067421144,rgb(255,84,43)
-        // 55°～90°为垂直壁,rgb(255,32,43)
-        if (value < 0.00872686779075879) {
-            return "rgba(85,182,43," + alpha + ")";
-        } else if (value < 0.03492076949174773) {
-            return "rgba(135,211,43," + alpha + ")";
-        } else if (value < 0.08748866352592401) {
-            return "rgba(204,244,44," + alpha + ")";
-        } else if (value < 0.2679491924311227) {
-            return "rgba(245,233,44," + alpha + ")";
-        } else if (value < 0.7002075382097097) {
-            return "rgba(255,138,43," + alpha + ")";
-        } else if (value < 1.4281480067421144) {
-            return "rgba(255,84,43," + alpha + ")";
-        } else {
-            return "rgba(255,32,43," + alpha + ")";
-        }
-    }
-    /**
-     * 笛卡尔坐标数组转WGS84
-     * @param {Array} cartesianList 笛卡尔坐标数组
-     * @returns {Array} WGS84经纬度坐标数组
-     */
-    Cartesian3ListToWGS84(cartesianList) {
-        let ellipsoid = Cesium.Ellipsoid.WGS84;
-        let result = [];
-        for (let index = 0; index < cartesianList.length; index++) {
-            const cartesian = cartesianList[index];
-            let cartographic = ellipsoid.cartesianToCartographic(cartesian);
-            result.push({
-                lng: Cesium.Math.toDegrees(cartographic.longitude),
-                lat: Cesium.Math.toDegrees(cartographic.latitude),
-                alt: cartographic.height,
-            });
-        }
-        return result;
-    }
-}
-export default SlopeAspect;