traffic-laser/src/sdk/laser/core/enter.js

import parameter from "./parameter";
import mitt from "mitt";
import {
    CoordType
}
from "../../types";
import {
    Loading
}
from "@kankan/components/index";
import revision from "./REVISION";
import {
    ui18n
}
from "@/lang";
import libTransform from "coordtransform";
//交通版laser

 
 
var CloneJson = function (data) {
    var str = JSON.stringify(data);
    return JSON.parse(str);
};

var enter = ({
    dom,
    mapDom,
    number,
    //datasetId, //初始数据集
    webSite, //废弃，改为用dataset.webBin
    isLocal = false,
    basePath,
    isDebug = false,
    mapCompany, // 地图版本  'default' | 'google' default就跟现在一样
    axios,
    version, //'V3''V4' 废弃，改为从getDataset获取
    staticPrefix,
    cropArgs,
}) => {
    let isScreenshoting = false;
    let lastSiteModelData;
    let page; //所在页面
    const sceneBus = mitt();
     
    Potree.settings.isOfficial = true; //标记为正式、非测试版本
    Potree.settings.isDebug = isDebug;
    //Potree.settings.originDatasetId = datasetId;
    
    if (isLocal) {
        //本地配置
        Potree.settings.isLocal = isLocal;
        for (let i in Potree.settings.urls) {
            Potree.settings.urls[i] = basePath; //全部替换
        }
    }
    webSite && (Potree.settings.webSite = webSite);
    axios && (Potree.fileServer = axios);

    if (staticPrefix) {
        // "/dev/SS-t-4pMXagRDjk"
        Potree.settings.isLocal = true;
        Potree.settings.urls.prefix1 = Potree.settings.urls.prefix3 = staticPrefix;
        Potree.settings.webSite = "wwwroot";
    }
 
    Potree.start(dom, mapDom, number);
  

    parameter.dom = dom;
    parameter.number = number;
    parameter.viewer = viewer;
    parameter.sceneBus = sceneBus; 
    //Potree.settings.rotAroundPoint = false; //试验
        

    sceneBus.on("visible", (v) => {
        viewer.visible = v;
        //console.log('sceneBus visible', v)
    });

    viewer.addEventListener("allLoaded", (e) => {
        //全部加载完，除了地图
        sceneBus.emit("allLoaded");
    });
    viewer.addEventListener("webglError", (e) => {
        console.error("viewer webglError: " + e);
        sceneBus.emit("webglError", {
            msg: e.msg
        });
    });

    let cameraChange = (e) => {
        var camera = e.viewport.camera;
        var pos = camera.position;
        if (e.viewport.name == "MainView") {
            sceneBus.emit("posChange", {
                x: pos.x,
                y: pos.y,
                z: pos.z,
                rotate: camera.rotation,
                //dataset: viewer.atDatasets.map((e) => e.dataset_id),
            });
        } 
    };
    viewer.addEventListener("camera_changed", cameraChange);
    viewer.addEventListener("shelterComputed", () => {
        cameraChange({
            viewport: viewer.mainViewport
        });
    });

 

    {
        Potree.loadingByTex = false;
        let delayShow = 400;
        let timer;
        viewer.addEventListener("loading", (e) => {
            //加载的等待页面
            if (e.show) {
                if (!isScreenshoting) {
                    //截图时不显示
                    Potree.loadingByTex = true;
                    timer && clearTimeout(timer);
                    timer = setTimeout(() => {
                            if (Potree.loadingByTex) {
                                Loading.show();
                            }
                        }, delayShow);
                }
            } else {
                Potree.loadingByTex = false;
                timer && clearTimeout(timer);
                Loading.hide();
            }
        });
    }

    let info;
    const units = {
        1: "metric",
        2: "imperial"
    };
    let getMeasureType = function (type, unit) {
        switch (type) {
        case "LINE":
            info = {
                measureType: "Distance"
            };
            break;
        case "SERIES":
            info = {
                measureType: "MulDistance"
            };
            break;
        case "AREA":
            info = {
                measureType: "Area"
            };
            break;
        case "L_LINE":
            info = {
                measureType: "Hor Distance"
            };
            break;
        case "L_SERIES":
            info = {
                measureType: "Hor MulDistance"
            };
            break;
        case "L_AREA":
            info = {
                measureType: "Hor Area"
            };
            break;
        case "L_RECTANGLE":
            info = {
                measureType: "Hor Rect Area"
            };
            break;
        case "V_LINE":
            info = {
                measureType: "Ver Distance"
            };
            break;
        case "V_SERIES":
            info = {
                measureType: "Ver MulDistance"
            };
            break;
        case "V_AREA":
            info = {
                measureType: "Ver Area"
            };
            break;
        case "V_RECTANGLE":
            info = {
                measureType: "Ver Rect Area"
            };
            break;
        default:
            console.error("无此 measure type", type);
        }
        info.unit = units[unit];
        return info;
    };

    let getMeasureFunction = function (measure, bus) {
        measure.addEventListener("marker_dropped", (e) => {
            //拖拽结束后发送changeCallBack
            if (measure.parent) {
                //未被删除
                bus.emit("update");
            }
        });
        /* measure.addEventListener("highlight", (e) => {
            bus.emit("highlight", e.state);
        }); */
        
        measure.addEventListener("selected", (e) => {
            bus.emit("selected", e.state);
        });
        
        
        return {
            quit: () => {
                Potree.Log("quit结束且删除: " + measure.id, {
                    font: {
                        color: "#00c7b2"
                    },
                });
                viewer.dispatchEvent({
                    type: "cancel_insertions",
                    remove: true,
                    measure,
                });
            }, //触发结束。退出测量模式，清除之前操作
            clear: () => {
                //删除
                Potree.Log("clear删除: " + measure.id, {
                    font: {
                        color: "#00c7b2"
                    }
                });

                viewer.dispatchEvent({
                    type: "cancel_insertions",
                    remove: true,
                    measure,
                });
                viewer.scene.removeMeasurement(measure);
            },
            end: () => {
                //完成 相当于右键
                measure.dispatchEvent({
                    type: "finish",
                    measure
                });
            },
            getPoints: () => {
                return measure.points;
            },
            getDatasetLocations: () => {
                return measure.dataset_points;
            },
            getDatasets: () => {
                return [1]//measure.points_datasets;
            },
            getDatasetId: () => {
                return 1//measure.datasetId;
            }, 

            getArea: () => {
                return measure.area; //{value:area, string:..}
            },
            getDistance: () => {
                if (measure.points.length < 2)
                    return null;

                var value = measure.getTotalDistance(); //measure.points[0].distanceTo(measure.points[1])

                return {
                    value, //米
                    string: viewer.unitConvert.convert(
                        value,
                        "distance",
                        void 0,
                        measure.unitSystem,
                        0.1,
                        true),
                };
            },
            changeUnit: (unit) => {
                //公制|英制 , 1 | 2 单位
                measure.setUnitSystem(units[unit]);
            },
            toDataURL: (width, height) => {
                //截图
                isScreenshoting = true;
                var {
                    getImagePromise,
                    finishPromise
                } = viewer.startScreenshot({
                        type: "measure",
                        measurement: measure,
                        hideMarkers: true,
                        hideMeasures:true,
                        ifGetPose: true,
                    },
                        width,
                        height);
                finishPromise.done(() => {
                    isScreenshoting = false;
                });
                return finishPromise; //getImagePromise.done时是可以getPose的， finishPromise.done时才开始截下一张图
            },
            //手动开启或关闭:
            show: () => {
                Potree.Utils.updateVisible(measure, "inListByUser", true);
            },
            hide: () => {
                Potree.Utils.updateVisible(measure, "inListByUser", false);
            },
            highlight: (isHight) => {
                measure.setSelected(isHight, "byList");
            },
        };
    };

    var sdk = {
        temp: {}, //记录
        debug: isDebug,
        scene: {
            getScreenByPoint(pos, canShelter) {
                //通过真实坐标获取DOM坐标
                let pos3d = new THREE.Vector3().copy(pos);

                if (canShelter) {
                    if (viewer.ifPointBlockedByIntersect(pos3d)) {
                        //console.log('shelter')
                        return {
                            trueSide: false
                        };
                    }
                }

                var viewport = viewer.mainViewport;
                var camera = viewport.camera;
                var dom = viewer.renderArea;
                //Potree.Log('getScreenByPoint scene' , pos3d.toArray(), {font:{toFixed:2,fontSize:10}})

                return Potree.Utils.getPos2d(pos3d, camera, dom, viewport);
            },
            getPointByScreen(pos2d) {
                //获取当前画面鼠标所在位置的三维点(必须是点云点)
                let position,
                /* datasetId,
                dataset_location, */
                intersect;
                let Handler = viewer.inputHandler;

                let needReGet =
                    !Potree.settings.depTexLocBindDataset &&
                    Potree.settings.useDepthTex &&
                    Handler.intersect &&
                    !Handler.intersect.pointcloud; //如果开启了depTexLocBindDataset，热点就可能使用深度图了，属于该漫游点。全景得到的位置更均匀
                if ((pos2d && pos2d.inDrag) || needReGet) {
                    //不使用当前鼠标所在位置的intersect，单独算
                    if (!pos2d) {
                        // needReGet
                        intersect = Handler.getIntersect(
                                Handler.hoverViewport,
                                true,
                                null,
                                null,
                                true); //数据集多的时候卡顿
                    } else {
                        pos2d.clientX = pos2d.x;
                        pos2d.clientY = pos2d.y;
                        pos2d.onlyGetIntersect = true;
                        pos2d.whichPointcloud = !Potree.settings.depTexLocBindDataset;
                        intersect = Handler.onMouseMove(pos2d);
                    }
                } else {
                    intersect = Handler.intersect;
                }

                if (intersect && intersect.location) {
                    position = intersect.location.clone();
                    /* datasetId = intersect.pointcloud.dataset_id;
                    dataset_location = Potree.Utils.datasetPosTransform({
                            toDataset: true,
                            pointcloud: intersect.pointcloud,
                            position,
                        }); */
                } else
                    return null;
                //console.log(position, datasetId, dataset_location)
                return {
                    position,
                    /* datasetId,
                    dataset_location */
                };
            }, //全景模式一直获取会很卡
 

            getPose2() {
                const camera = viewer.scene.getActiveCamera();
                const target = viewer.scene.view.getPivot();
                const position = viewer.scene.view.position;
                return {
                    position,
                    target
                };
            },

            currentCamera() {
                return viewer.scene.getActiveCamera().position.clone();
            },
            //  切换模式 1 点云 0 全景图
            changeMode(v) {
                //Potree.settings.displayMode = Potree.settings.displayMode == 'showPointCloud' ? 'showPanos' : 'showPointCloud'
                Potree.settings.displayMode = v == 0 ? "showPanos" : "showPointCloud";
            },
            getCurrentMode() {
                return Potree.settings.displayMode == "showPanos" ? 0 : 1;
            },

            comeToTag(tag) {
                let dontLookUp = page == "geoRegistration"; //防止相机在地面以下
                return viewer.focusOnObject({
                    position: new THREE.Vector3().copy(tag)
                },
                    "tag",
                    null, {
                    dontLookUp,
                    maxDis: Potree.config.panoFieldRadius,
                    checkIntersect: true /*,  sameFloor:true */,
                }).promise;
            },
            comeToMeasure(measure) {
                let result = viewer.focusOnObject(measure.object, "measure", 1200);

                return result.msg ? result.msg : result.promise;
                //返回值 1 deferred 表示即将位移 2 'posNoChange' 表示已在最佳位置 3 'tooFar' 表示距离最佳位置太远
                //后两种都代表停在原位
            },
            comeTo(o = {}) {
                //飞到某个点 暂时没写全景模式
                let deferred = $.Deferred();
                viewer.scene.view.setView(
                    $.extend({}, o, {
                        duration: o.dur,
                        callback: () => {
                            o.callback && o.callback();
                            deferred.resolve(true);
                        },
                    }));
                return deferred.promise();
            },

            /**
             * 开始测量
             */
            startMeasure(type, unit) {
                const bus = mitt();
                let info = getMeasureType(type, unit);
                //info.bus = bus

                let measure = viewer.measuringTool.startInsertion(
                        info,
                        () => {
                        //done:
                        bus.emit("end", ret); //完成
                    },
                        () => {
                        //cancel
                        bus.emit("quit", ret); //删除
                    });
                Potree.Log("startMeasure: " + measure.id, {
                    font: {
                        color: "#00c7b2"
                    },
                });
                viewer.setPointStandardMat(true);
                const ret = {
                    bus,
                    type,
                    object: measure,
                    ...getMeasureFunction(measure, bus),
                };
                
                measure.addEventListener("intersectNoPointcloud", () => {
                    bus.emit("invalidPoint");
                });
                measure.addEventListener("firstClick", () => {
                    bus.emit("firstClickMarker");
                });
                
                
                
                return ret;
            },
            quitMeasure() {
                viewer.setPointStandardMat(false);
            },

            /**
             * 绘画测量点
             */
            drawMeasure(
                type,
                unit,
                points,
                datasetId,
                dataset_points,
                points_datasets,
                sid) {
                const bus = mitt();
                let info = getMeasureType(type, unit);
                info.points = points;
                //info.datasetId = datasetId;
                info.dataset_points = dataset_points;
                info.points_datasets = points_datasets;
                info.sid = sid;
                info.bus = bus;

                let measure = viewer.measuringTool.createMeasureFromData(info);
                Potree.Log("drawMeasure由数据新建: " + measure.id, {
                    font: {
                        color: "#00c7b2"
                    },
                });
                //console.log(info)

                const ret = {
                    // 退出测量模式，清除之前操作
                    object: measure,
                    bus,
                    ...getMeasureFunction(measure, bus),
                };

                return ret;
            },

            // 开启放大镜
            openMagnifier() {
                viewer.magnifier.dispatchEvent({
                    type: "setEnable",
                    value: true
                });
            },
            // 关闭放大镜
            closeMagnifier() {
                viewer.magnifier.dispatchEvent({
                    type: "setEnable",
                    value: false
                });
            },

            changePointDensity(levelType) {
                //点云密度：低中高
                Potree.settings.UserPointDensity = levelType;
                return {
                    percent: Potree.config.pointDensity[levelType].maxLevelPercent,
                }; //回调需要更改密度百分比滑动条
            },

            changeDensityPercent(percent) {
                //点云密度百分比（细节） percent : 0-1
                //console.log('changeDensityPercent ', percent) //有出现过首次加载大于1的情况？？？
                Potree.settings.UserDensityPercent = percent;

                viewer.setPointLevels();
            },

            // 设置far
            changeViewRange(num) {
                Potree.settings.cameraFar = num;
            },

            // 设置色彩模式  0 彩色 1 海拔 2 半透明（透明色）
            changeColorMode: function (mode) {
                const modes = ["rgba", "elevation", "color"];
                mode = modes[mode];
                //console.log('设置色彩模式 ', mode)

                let otherChange = {};

                switch (mode) {
                case "rgba": //每个点的颜色
                    otherChange.opacity = 1;
                    otherChange.size = 0.4 / 4;
                    break;
                case "elevation":
                    otherChange.opacity = 0.3;
                    otherChange.size = 0.4 / 4;
                    break;
                case "color": //透明色
                    //otherChange.color = ''
                    otherChange.opacity = 0.3;
                    otherChange.size = 0.4 / 4;

                    break;
                }
                viewer.scene.pointclouds.forEach((e) => {
                    e.material.activeAttributeName = mode;
                });
                sdk.scene.changePointSize(otherChange.size);
                sdk.scene.changePointOpacity(otherChange.opacity);

                delete otherChange.color;
                return otherChange;
            },

            // 设置点大小
            changePointSize(num) {
                viewer.scene.pointclouds.forEach((e) => {
                    e.changePointSize(num);
                });
            },
            // 设置点透明度
            changePointOpacity: function (num) {
                //num:0-1   navvis用的是亮度
                viewer.scene.pointclouds.forEach((e) => {
                    e.changePointOpacity(num);
                });
            },

            // 设置点形状  传入参数 1 矩形 2 圆形
            changePointShape(shape) {
                viewer.scene.pointclouds.forEach((e) => {
                    e.material.shape =
                        Potree.PointShape[shape == 1 ? "SQUARE" : "CIRCLE"]; // and PARABOLOID
                });
            },
            // 设置是否强化边缘
            changePointEdge(isStrong) {
                //console.log('强化边缘', isStrong)
                viewer.setEDLEnabled(isStrong);
            },

            // 设置漫游点位显示
            changePanoPoint(show) {
                Potree.settings.ifShowMarker = !!show;
            }, 

            getDownloadInfo() {
                //获取直接下载点云的参数给后台
                return viewer.modules.Clip.downloadNoCrop();
            },

            /* getDataSets() {
                //获取所有数据集对象
                let datasets = CloneJson(Potree.datasetData);
                datasets.forEach((e) => {
                    var pointcloud = viewer.scene.pointclouds.find( (p) => p.dataset_id == e.id);

                    e.changeDisplay = function (show) {
                        Potree.Utils.updateVisible(pointcloud, "datasetSelection", !!show);
                        pointcloud.panos.forEach((pano) => {
                            //数据集隐藏时漫游点也隐藏 //还是不隐藏了,仅隐藏点云
                            Potree.Utils.updateVisible(pano, "pointcloudVisi", show, 0);
                        });
                        if (
                            viewer.modules.SiteModel.editing ||
                            viewer.modules.Alignment.editing) {
                            viewer.updateFpVisiDatasets();
                        }
                    };
                    e.changeColor = function (color) {
                        pointcloud.material.color = color;
                    };
                    e.getColor = function () {
                        return pointcloud.material.color;
                    };
                    e.focus = function () {
                        viewer.modules.Alignment.SplitScreen.focusOnPointCloud(pointcloud);
                    };
                    e.flyTo = function () {
                        return viewer.flyToDataset({
                            pointcloud
                        }) || false;
                    };
                    e.getAttachPloygon = function () {
                        //计算完后才会有
                        return (
                            pointcloud.belongToEntity && pointcloud.belongToEntity.polygon);
                    };
                });

                return datasets;
            }, */

            screenshot: (width, height) => {
                //截图
                let meterPerPixel,
                    isScreenshoting = true;
                var {
                    getImagePromise,
                    finishPromise
                } = viewer.startScreenshot({
                        type: "default"
                    },
                        width,
                        height);
                finishPromise.done(() => {
                    isScreenshoting = false;
                });
                if(viewer.mainViewport.camera.type == 'OrthographicCamera'){
                   meterPerPixel = 1 / viewer.mainViewport.camera.zoom 
                }
                return {finishPromise, meterPerPixel};
            },

            canTurnToPanoMode(pos) {
                /* if(viewer.hasNoPanoDataset){
                return
                } */
                pos = pos ? new THREE.Vector3().copy(pos) : viewer.images360.position;

                let pano = viewer.images360.findNearestPano(pos);
                if (
                    pano &&
                    pano.position.distanceTo(pos) < Potree.config.panoFieldRadius) {
                    return true;
                }
                //poschange后会调用这个，如果返回false会变为点云模式，且不会自动变回原先的模式
            },
            
            
            /* 
            添加一个方法  单击场景某个位置 返回当前三维坐标，   调用时场景不能漫游与选择直到获取完成
            sdk.scene.trackScenePos()
            返回
            {
              promise: Promise<Pos3D>,   //获取的promise, 获取到了返回三维坐标，没获取到返回null
              quit: function()  //取消获取 
            }志彬5月15日 14:46 */
  
            trackScenePos(){
                let deferred = $.Deferred();
                let quit = ()=>{ //取消获取 
                    viewer.removeEventListener('global_click',gotIntersect)
                    Potree.settings.unableNavigate = false 
                    viewer.controls.setEnable(true) 
                }
                
                let gotIntersect = (e)=>{
                    if(e.intersect && e.intersect.location){ 
                        console.log('quit', e.intersect.location)
                        quit()
                        deferred.resolve(e.intersect.location)
                    } 
                }
                
                viewer.addEventListener('global_click',gotIntersect) 
                Potree.settings.unableNavigate = true
                viewer.controls.setEnable(false)
                
                return {
                    promise: deferred.promise() ,   //获取的promise, 获取到了返回三维坐标，没获取到返回null
                    quit 
                }
                
            },
            
            
            
            
            ...parameter.sceneBus, 
            
        },

         
        
        transformPoint(point, datasetId, dataset_location) {
            /* //获取由dataset_location转出的position
            var r = datasetId != void 0
                 ? Potree.Utils.datasetPosTransform({
                    fromDataset: true,
                    datasetId,
                    position: dataset_location,
                })
                 : point;

            return r; */
            return point
        },
        
        // 坐标转换
        coordTransform: (originType, pos, targetType, datasetId) => {
            // pos 坐标的类型， 当类型为SCREEN时为 { x, y } 其余为 {x, y, z}
            if (pos.z == void 0)
                pos.z = 0; //否则datasetPosTransform NAN 地理注册
            let needMeshLocal;
            if (originType == targetType)
                return pos;

            if (
                originType == CoordType.SCENE_SCREEN ||
                originType == CoordType.MAP_SCREEN) {
                let tool = originType == CoordType.SCENE_SCREEN ? sdk.scene : sdk.map;

                let result = tool.getPointByScreen(pos) || {}; //{ position, datasetId, dataset_location }

                pos = result.position;
                if (!pos)
                    return;

                datasetId = result.datasetId;
                originType = CoordType.LOCAL;
            }

            let pointcloud;
            if (datasetId != void 0) {
                pointcloud = viewer.scene.pointclouds.find(
                        (p) => p.dataset_id == datasetId);
            }

            if (originType == CoordType.MESH_LOCAL) { 
                pos = Potree.Utils.datasetPosTransform({
                        fromDataset: true,
                        pointcloud,
                        position: pos,
                    });

                originType = CoordType.LOCAL;
            }

            if (targetType == CoordType.MESH_LOCAL) {
                needMeshLocal = true;
                targetType = CoordType.LOCAL; //先转化为求CoordType.LOCAL
            }

            if (originType == targetType) {
                //for控制点，获取点云未移动前的坐标值。暂且这么写。
                if (needMeshLocal) {
                    //var invMatrix = new THREE.Matrix4().getInverse(viewer.scene.pointclouds[0].transformMatrix)
                     
                    pos = Potree.Utils.datasetPosTransform({
                            toDataset: true,
                            pointcloud,
                            position: pos,
                        });
                }
                return pos;
            }

            //先转成lonlat(高德)
            switch (originType) {
                //EPSG: 4550大地坐标
            case CoordType.EPSE:
                pos = viewer.transform.lonlatTo4550.inverse(pos);
                break;
                //Wgs84 经纬度
            case CoordType.WGS84: //84转高德
                //pos = wgs84ToAMap(pos)
                break;
                // 本地坐标
            case CoordType.LOCAL:
                pos = viewer.transform.lonlatToLocal.inverse(pos);
            }

            // 需要转换成什么类型的坐标
            switch (targetType) {
            case CoordType.SCENE_SCREEN: // 场景屏幕坐标
                pos = sdk.scene.getScreenByPoint(pos);
                break;
            case CoordType.MAP_SCREEN: // 地图屏幕坐标
                pos = sdk.map.getScreenByPoint(pos);
                break;
                //EPSG: 4550大地坐标
            case CoordType.EPSE:
                pos = viewer.transform.lonlatTo4550.forward(pos);
                break;
                //Wgs84 经纬度
            case CoordType.WGS84:
                //pos = aMapToWgs84(pos)
                break;
                //本地坐标
            case CoordType.LOCAL:
                pos = viewer.transform.lonlatToLocal.forward(pos);
            }

            if (needMeshLocal) {
                 

                pos = Potree.Utils.datasetPosTransform({
                        toDataset: true,
                        pointcloud,
                        position: pos,
                    });
            }

            return pos;
        },
 
        enterMeasurement() {
            //进入测量模块
            viewer.setLimitFar(false); 
        },
        leaveMeasurement() {
            //退出测量模块
            viewer.setLimitFar(true); 
        },
        
  

        loadModel(info) {
            info.moveWithPointcloud = true;
            viewer.loadModel(info); 
        },
 
 
 
        
 
    };
    Potree.sdk = sdk;
    return sdk;
};

export default enter;
 











 
/*
热点poi加载到的数据中，pos是错误的，只使用dataset_location

 

关于webgl context lost报错：

已知有一iphoneX在创建shadowMap后才报错。

所以报错的话很可能是代码中的某一句，去除后就会正常。





*/