easy-three-utils 0.0.331 → 0.0.333

package/cesium/js/measure1.ts

@@ -0,0 +1,194 @@
+import * as Cesium from 'cesium'
+
+const useMeasureTools = (viewer: Cesium.Viewer) => {
+    let handler = new Cesium.ScreenSpaceEventHandler((viewer.scene as any)._imageryLayerCollection);
+    const positions = []
+    let positionsCartographic = []
+    let positions_Inter = []
+    let poly = null
+    let distance = null
+    let cartesian = null
+    const DistanceArray = []
+    let profileItem = []
+
+    const measureDistance = () => {
+        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

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

package/cesium/utils/index.ts

@@ -0,0 +1,20 @@
+import { useCustomCollection, ECollectionWhiteListNames } from './useCustomCollection'
+import { useDrawPolygon } from './useDrawPolygon'
+import { useClipping } from './useClipping'
+import { useWeather, EWeatherType } from './useWeather'
+import { useMeasure } from './useMeasure'
+
+const dict = {
+  ECollectionWhiteListNames,
+  EWeatherType
+}
+
+export {
+  useCustomCollection,
+  useDrawPolygon,
+  useClipping,
+  useWeather,
+  useMeasure,
+
+  dict
+}

package/cesium/utils/useClipping.ts

@@ -0,0 +1,90 @@
+import * as Cesium from 'cesium'
+
+const useClipping = (viewer: Cesium.Viewer) => {
+
+  const setClippingPlane = (points: Cesium.Cartesian3[], type: boolean) => {
+
+    const clippingPlanes = []
+
+    const pointsCoor = points.map(({ x, y, z }) => new Cesium.Cartesian3(x, y, z))
+    let sum = 0
+    for (let i = 0; i < pointsCoor.length; i++) {
+      const pointA = pointsCoor[i]
+      const pointB = pointsCoor[(i + 1) % pointsCoor.length]
+      const crossProduct = Cesium.Cartesian3.cross(pointA, pointB, new Cesium.Cartesian3())
+      sum += crossProduct.z
+    }
+
+    if (sum > 0 && type) {
+      points.reverse()
+    } else if (sum < 0 && !type) {
+      points.reverse()
+    }
+
+    for (let i = 0; i < points.length; ++i) {
+      const nextIndex = (i + 1) % points.length
+
+      const midpoint = Cesium.Cartesian3.add(points[i], points[nextIndex], new Cesium.Cartesian3())
+      Cesium.Cartesian3.multiplyByScalar(midpoint, 0.5, midpoint)
+
+      const up = Cesium.Cartesian3.normalize(midpoint, new Cesium.Cartesian3())
+
+      const right = Cesium.Cartesian3.subtract(points[nextIndex], midpoint, new Cesium.Cartesian3())
+      Cesium.Cartesian3.normalize(right, right)
+
+      const normal = Cesium.Cartesian3.cross(right, up, new Cesium.Cartesian3())
+      Cesium.Cartesian3.normalize(normal, normal)
+
+      const originCenteredPlane = new Cesium.Plane(normal, 0.0)
+      const distance = Cesium.Plane.getPointDistance(originCenteredPlane, midpoint)
+
+      clippingPlanes.push(new Cesium.ClippingPlane(normal, distance))
+    }
+
+    return clippingPlanes
+  }
+
+  const dig = (points: Cesium.Cartesian3[], type?: boolean) => {
+
+    viewer.scene.globe.clippingPolygons = null
+
+    const planes = setClippingPlane(points, type)
+
+    viewer.scene.globe.clippingPlanes = new Cesium.ClippingPlaneCollection({
+      planes,
+      enabled: true,
+      modelMatrix: Cesium.Matrix4.IDENTITY,
+      unionClippingRegions: type === undefined ? false : true,
+      edgeColor: Cesium.Color.YELLOW,
+      edgeWidth: 1.0
+    })
+  }
+
+  const digMultiple = (pointsArr: Cesium.Cartesian3[][]) => {
+
+    viewer.scene.globe.clippingPlanes = null
+
+    const polygons = pointsArr.map(positions => new Cesium.ClippingPolygon({ positions }))
+
+    const clippingCollection = new Cesium.ClippingPolygonCollection({
+      polygons
+    });
+
+    viewer.scene.globe.clippingPolygons = clippingCollection;
+  }
+
+  const clear = () => {
+    viewer.scene.globe.clippingPlanes = null
+    viewer.scene.globe.clippingPolygons = null
+  }
+
+  return {
+    dig,
+    digMultiple,
+    clear
+  }
+}
+
+export {
+  useClipping
+}