xzw 2 tahun lalu
induk
melakukan
5d0149bdfc

+ 61 - 47
src/custom/modules/panos/Images360.js

@@ -1188,74 +1188,74 @@ export class Images360 extends THREE.EventDispatcher{
     fitPanoTowardPoint(o){  //寻找最适合的点位
 		var point = o.point,     //相机最佳位置
             target = o.target || o.point,   //实际要看的位置 
-			require = o.require || [],
-			rank = o.rank || [],
-			force = o.force,
-			getAll = o.getAll,  
+            require = o.require || [],
+            rank = o.rank || [],
+            force = o.force,
+            getAll = o.getAll,  
             bestDistance = o.bestDistance || 0,
             sameFloor = o.sameFloor,
             maxDis = o.maxDis,
-            dir = o.dir
+            dir = o.dir;
             
-        let camera = viewer.scene.getActiveCamera()
+        let camera = viewer.scene.getActiveCamera();
         if(target && !dir){
-            dir = new THREE.Vector3().subVectors(target,point).normalize()
+            dir = new Vector3().subVectors(target,point).normalize();
         }
-        let atFloor = sameFloor && viewer.modules.SiteModel.pointInWhichEntity(point, 'floor')
+        let atFloor = sameFloor && viewer.modules.SiteModel.pointInWhichEntity(point, 'floor');
         
         //if(o.floor)require.push(Panorama.filters.atFloor(o.floor))
                
-        let checkIntersect = o.checkIntersect 
+        let checkIntersect = o.checkIntersect; 
         let base = Math.max(300, viewer.bound.boundSize.length()*3);      
                      
               
         if(o.boundSphere){//只接受boundSphere
-            let aspect = 1//size.x / size.y
-            let dis
+            let aspect = 1;//size.x / size.y
+            let dis;
             if(camera.aspect > aspect){//视野更宽则用bound的纵向来决定
-                dis = /* size.y */o.boundSphere.radius/* / 2  *// THREE.Math.degToRad(camera.fov / 2)
-            }else{
+                dis = /* size.y */o.boundSphere.radius/* / 2  *// MathUtils.degToRad(camera.fov / 2);
+            }else {
                 let hfov = cameraLight.getHFOVForCamera(camera , true  );
-                dis = /* size.x */ o.boundSphere.radius /* / 2 */ /  (hfov / 2) 
+                dis = /* size.x */ o.boundSphere.radius /* / 2 */ /  (hfov / 2); 
             }  
-            bestDistance = dis//*0.8  
+            bestDistance = dis;//*0.8  
             
         } 
-        let disSquareMap = new Map()
+        let disSquareMap = new Map();
         
-        let bestDisSquared = bestDistance * bestDistance
-        let maxDisSquared = maxDis && (maxDis * maxDis)
+        let bestDisSquared = bestDistance * bestDistance;
+        let maxDisSquared = maxDis && (maxDis * maxDis);
         this.panos.forEach(pano=>{
             let dis2 = pano.position.distanceToSquared(target);  //距离目标点
-            disSquareMap.set(pano, dis2)
-        })
-        let panos = this.panos.sort((p1,p2)=>{return disSquareMap.get(p1)-disSquareMap.get(p2)})
+            disSquareMap.set(pano, dis2);
+        });
+        let panos = this.panos.sort((p1,p2)=>{return disSquareMap.get(p1)-disSquareMap.get(p2)});
          
          
         if(maxDisSquared){//热点超过最大距离不可见的
-            let panos2 = [], pano, i=0 
+            let panos2 = [], pano, i=0; 
             while(pano = panos[i],  disSquareMap.get(pano) < maxDisSquared){
-                panos2.push(pano)
+                panos2.push(pano);
                 i++;
             }
             if(panos2.length == 0)return {pano, msg:'tooFar'} //全部都大于maxDis, 就返回最近的
-            panos = panos2
+            panos = panos2;
         }
         
         
         
         rank.push((pano)=>{
                 let dis1 = Math.abs(pano.position.distanceToSquared(point) - bestDisSquared); //距离最佳位置
-                disSquareMap.set(pano, dis1)
+                disSquareMap.set(pano, dis1);
                 if(!target){
                     return -dis1 
-                }else{
-                    let dis2 = disSquareMap.get(pano)
-                    let vec2 = new THREE.Vector3().subVectors(target,pano.position).normalize()
-                    let cos = dir.dot(vec2)  
+                }else {
+                    let dis2 = disSquareMap.get(pano);
+                    let vec2 = new Vector3().subVectors(target,pano.position).normalize();
+                    let cos = dir.dot(vec2);  
                     //let result = (- dis1  - Math.pow(dis2 , 1.5)) / (cos + 2)  // cos+2是为了调整到1-3, 
                     
-                    let result =  (dis1 + dis2*0.3) * ( -1 + cos*0.9 ) //尽量贴近最佳位置的角度, 或贴近相机原来的角度 。尽量靠近最佳观测点,并且优先选择靠近目标点的位置.(注意cos的乘数不能太接近1,否则容易只考虑角度)
+                    let result =  (dis1 + dis2*0.3) * ( -1 + cos*0.9 ); //尽量贴近最佳位置的角度, 或贴近相机原来的角度 。尽量靠近最佳观测点,并且优先选择靠近目标点的位置.(注意cos的乘数不能太接近1,否则容易只考虑角度)
                     //Potree.Log(pano.id, dis1, dis2,  cos,  result,{font:{toFixed:2,fontSize:10}}) 
                      
                     return  result
@@ -1264,40 +1264,54 @@ export class Images360 extends THREE.EventDispatcher{
                 //注:热点最好加上法线信息,这样可以多加一个限制,尽量顺着热点像展示的方向。 
             },
             (pano)=>{
-                let  score = 0
+                let  score = 0;
                 if(pano.depthTex && checkIntersect){    
-                    let intersect = !!viewer.ifPointBlockedByIntersect(target, pano.id, true)       //viewer.inputHandler.ifBlockedByIntersect({pos3d:target, margin:0.1, cameraPos:pano})
+                    let intersect = !!viewer.ifPointBlockedByIntersect(target, pano.id, true);       //viewer.inputHandler.ifBlockedByIntersect({pos3d:target, margin:0.1, cameraPos:pano})
                     if(intersect){ 
-                        score = 0
+                        score = 0;
                     }else { 
-                        score = base * 2 
+                        score = base * 2; 
                     } 
-                }else{
-                    score = base * 1.5  //没加载好的话,不管了 , 几乎当做无遮挡,否则容易到不了最近点 
+                }else {
+                    score = base * 1.5;  //没加载好的话,不管了 , 几乎当做无遮挡,否则容易到不了最近点 
                 }
                 return score
             }
         
-        ) 
-        
-		 
-		var g = Common.sortByScore(panos,  require, rank);
-        console.log(g)
+        ); 
         
-		 
-        let pano = g && g.length > 0 && g[0].item
+         
+        var g = Common$1.sortByScore(panos,  require, rank);
+        //console.log(g)
+        
+        /* let result1 = g && g.slice(0, 10)
+        if(result1){ 
+            g = Common.sortByScore(result1,  [], [(e)=>{//避免遮挡
+                let pano = e.item;
+                let  score = 0, log = '' 
+                  
+                if(atFloor && atFloor.panos.includes(pano)){//如果不在任何一楼呢?
+                    score += 600,  log+='atFloor' 
+                } 
+                return  {score, log}
+            }]);
+            if(g){
+                g.forEach(e=>{e.item = e.item.item})
+            }   
+            console.log(g)            
+        } */
+        let pano = g && g.length > 0 && g[0].item;
         if(pano && checkIntersect){
-            let intersect = !!viewer.ifPointBlockedByIntersect(target, pano.id, true)
+            let intersect = !!viewer.ifPointBlockedByIntersect(target, pano.id, true);
             
             if(intersect){
                 return {pano, msg : 'sheltered'}
             } 
         } 
         
-		//if(getAll)return g;
-		return pano
+        //if(getAll)return g;
+        return pano
 
-        
 		//注:深度图有的位置会不准确,以至于会算出错误的遮挡、选择错误的pano,解决办法只能是移动下热点到更好的位置
 	}
 

+ 12 - 29
src/custom/objects/Reticule.js

@@ -218,38 +218,21 @@ export default class Reticule extends THREE.Mesh{
                  return //this.hide();   
             }
                 
-            var atMap = !intersect.location
-            let location = intersect.location || intersect.orthoIntersect.clone()
+ 
+            let location = intersect.location //|| intersect.orthoIntersect.clone()
             let normal  
-            this.orthoPos = atMap
-            
-            //地图上要瞬间变化 , 因为要使needRender为true很麻烦
-            this.show(atMap ? 0 : 300);
-            
+ 
             
-            if(atMap){ 
-                normal =  new THREE.Vector3(0,0,1)//地图无normal
-                location.setZ(0);//低于相机高度即可
-                this.direction = normal.clone()
-            }else{
-                /* if(intersect.point){ 
-                    if(intersect.pointcloud){
-                        normal = new THREE.Vector3().fromArray(intersect.point.normal ).applyMatrix4( intersect.pointcloud.rotateMatrix  );
-                    }else{//mesh 
-                        normal = new THREE.Vector3().copy(intersect.point.normal).applyQuaternion(intersect.object.quaternion) 
-                    } 
-                }else{
-                    normal = intersect.normal  //when showPanos
-                } */
-                normal = intersect.normal 
-                if(normal){
-                    let ratio = /* Potree.settings.useDepthTex ? 1 : */ 0.2;   
-                    this.direction = this.direction.multiplyScalar(1-ratio); 
-                    this.direction.add(normal.clone().multiplyScalar(ratio)); 
-                }
-                //this.direction = normal.clone() //改为瞬间变化,否则刚hover上某个点时看起来不太对
+            if(!location)return
+            this.show( 300); 
+         
+            normal = intersect.normal 
+            if(normal){
+                let ratio = /* Potree.settings.useDepthTex ? 1 : */ 0.2;   
+                this.direction = this.direction.multiplyScalar(1-ratio); 
+                this.direction.add(normal.clone().multiplyScalar(ratio)); 
             }
-             
+         
              
             
             

+ 29 - 21
src/custom/viewer/ViewerNew.js

@@ -3680,19 +3680,23 @@ export class Viewer extends ViewerBase{
                     bestDistance : 0 , 
                     checkIntersect: true//o.checkIntersect                    
                 })
-                if(pano){
+                let result = {promise:deferred.promise() }    
+                if(pano && pano.msg){
+                    pano = pano.pano
+                    result.msg = pano.msg 
+                }                        
+                if(pano){  
                     viewer.images360.flyToPano({pano, target : target2 || target, duration, deferred, dontMoveMap:true  , basePanoSize:o.basePanoSize})//dontMoveMap不要移动map,否则flytopano会自动在map中focus到漫游点的位置,而非测量线了
+                 
+                    if(viewer.images360.currentPano == pano){ 
+                        let dis1 = viewer.images360.currentPano.position.distanceTo(target)
+                        let dis2 = position.distanceTo(target)
+                        //console.log('dis1 / dis2',dis1 / dis2, 'dis1-dis2', dis1-dis2)
+                        return {msg: (dis1 / dis2 > 1.5 && dis1-dis2>10)? 'tooFar' : 'posNoChange',  promise : deferred.promise()  }
+                       
+                    }
                 }
-                if(viewer.images360.currentPano == pano){ 
-                    let dis1 = viewer.images360.currentPano.position.distanceTo(target)
-                    let dis2 = position.distanceTo(target)
-                    //console.log('dis1 / dis2',dis1 / dis2, 'dis1-dis2', dis1-dis2)
-                    return {msg: (dis1 / dis2 > 1.5 && dis1-dis2>10)? 'tooFar' : 'posNoChange',  promise : deferred.promise()  }
-                  
-                }else{
-                    return {promise : deferred.promise()}
-                }
-                  
+                return result
                 //出现过到达位置后测量线标签闪烁的情况
             }
             
@@ -3775,16 +3779,20 @@ export class Viewer extends ViewerBase{
             position = getPosWithFullBound(object.points, object.boundingBox.clone(), target, cameraPos  )
             if(Potree.settings.displayMode == 'showPanos'){//全景 (比较难校准)
                 let pano = viewer.images360.fitPanoTowardPoint({ 
-                    point : position,
-                    bestDistance : 0 , 
-                })
-                
-                pano && viewer.images360.flyToPano({pano, target, duration, deferred, dontMoveMap:true  , basePanoSize:o.basePanoSize})//dontMoveMap不要移动map,否则flytopano会自动在map中focus到漫游点的位置,而非测量线了
-                
-                if(!pano){
-                    console.error('no pano')
-                }
-                return {promise:deferred.promise() }
+	                    point : position,
+	                    bestDistance : 0 , 
+	                });
+	                let result = {promise:deferred.promise() };    
+	                if(pano && pano.msg){
+	                    pano = pano.pano;
+	                    result.msg = pano.msg; 
+	                }
+	                pano && viewer.images360.flyToPano({pano, target, duration, deferred, dontMoveMap:true  , basePanoSize:o.basePanoSize});//dontMoveMap不要移动map,否则flytopano会自动在map中focus到漫游点的位置,而非测量线了
+	                
+	                if(!pano){
+	                    console.error('no pano');
+	                }
+	                return result
                 //出现过到达位置后测量线标签闪烁的情况
             }else{
                

+ 1 - 1
src/materials/shaders/pointcloud_new.vs

@@ -748,7 +748,7 @@ float getPointSize(){
 			//pointSize = size * 100.0;  //加个乘数
             
             pointSize = size / uOrthoWidth  * resolution.x; //改成近似adaptive_point_size根据窗口缩放
-            maxSize_ = 3.0;  //for panoEditor, when zoom in, need more details, rather than always same size
+            maxSize_ = 6.0;  //for panoEditor, when zoom in, need more details, rather than always same size
 
 		}else{  //近大远小,模拟真实mesh,边缘放大
 			//pointSize = size * spacing * projFactor;  //spacing是attribute  为空  如果有这个值就能更自适应填补

+ 18 - 79
src/navigation/FirstPersonControlsNew.js

@@ -92,12 +92,14 @@ export class FirstPersonControls extends THREE.EventDispatcher {
                 }else{
                     mode = (!e.dragViewport || e.dragViewport.name == 'MainView') ? 'pan' : 'scale' 
                 } 
-            }else{
-                //mode = e.buttons === Buttons.LEFT && (!e.dragViewport || e.dragViewport.name == 'MainView') ? 'rotate' : 'pan'
-                mode = e.buttons === Buttons.LEFT && camera.type != 'OrthographicCamera' ? 'rotate' : 'pan'
+            }else{ 
+                mode = (camera.type == 'OrthographicCamera' && e.buttons === Buttons.LEFT || camera.type != 'OrthographicCamera' && e.buttons === Buttons.RIGHT) ? 'pan' : 'rotate'
+            
             }
             
             
+     
+            
             
             //console.log('mode  ', mode )
             let moveSpeed = this.currentViewport.getMoveSpeed();
@@ -108,8 +110,14 @@ export class FirstPersonControls extends THREE.EventDispatcher {
 			}
             
             
-            if (mode.includes('rotate')) {//旋转 
-				
+            if (mode.includes('rotate')) {//旋转  
+            
+                if(camera.type == "OrthographicCamera"){ 
+                    let moveVec = Utils.getOrthoCameraMoveVec(e.drag.pointerDelta, camera )//最近一次移动向量 
+                    return viewer.navCubeViewer.rotateSideCamera( -e.drag.pointerDelta.x)
+                }
+                     
+                
                 //来自panoramaControl updateRotation
                 if(!this.pointerDragStart){
                    return this.pointerDragStart = e.pointer.clone()
@@ -194,68 +202,11 @@ export class FirstPersonControls extends THREE.EventDispatcher {
                 } 
                 
                 if(camera.type == "OrthographicCamera"){
-                   
-                     //console.log(e.drag.pointerDelta, e.pointer, e.drag.end)
-                    let moveVec = Utils.getOrthoCameraMoveVec(e.drag.pointerDelta, camera )//最近一次移动向量
-                  
-                    if(e.buttons === Buttons.RIGHT  ){ 
                     
-                        return viewer.navCubeViewer.rotateSideCamera( -e.drag.pointerDelta.x)
-     
-                    }
-                  
-                    /*let pointclouds;
-                    let Alignment = window.viewer.modules.Alignment
-                    let MergeEditor = window.viewer.modules.MergeEditor
-                    let handleState = Alignment.handleState
-                    //右键平移视图、左键操作点云 
-                    let a = e.buttons === Buttons.LEFT && viewport.alignment && handleState && viewport.alignment[handleState] 
-                    if(Potree.settings.editType == 'pano'){
-                        let PanoEditor = window.viewer.modules.PanoEditor
-                             
-                        if(a && PanoEditor.selectedPano){
-                            if(!PanoEditor.selectedGroup || !PanoEditor.checkIfAllLinked({group:PanoEditor.selectedGroup}) ){
-                                if(handleState == 'translate' && ( e.drag.intersectStart.pointclouds && Common.getMixedSet(PanoEditor.selectedClouds, e.drag.intersectStart.pointclouds).length  || PanoEditor.selectedPano.hovered)//平移时 拖拽到点云上 或 circle。(其中点云只需要intersect的点云中包含选择的点云中之一即可)
-                                    || handleState == 'rotate' ) //旋转模式不需要intersect
-                                {                                           
-                                    pointclouds = PanoEditor.selectedClouds
-                                }  
-                            }else{
-                                PanoEditor.dispatchEvent('needToDisConnect')
-                                console.warn('选中的漫游点连通了整个数据集,不允许移动')
-                            } 
-                        }
-                        
-                        if(!pointclouds && e.buttons === Buttons.LEFT && viewport.rotateSide){//侧视图  (有时候会卡顿,是mousemove执行延迟了,一般发生在突然加载很多点云时)
-                            //console.log('rotateSide') 
-                            return PanoEditor.rotateSideCamera(-e.drag.pointerDelta.x) 
-                        }
-                    }else if(Potree.settings.editType == 'merge'){ 
-                        if(e.buttons === Buttons.LEFT && viewport.rotateSide){ 
-                            return MergeEditor.rotateSideCamera(-e.drag.pointerDelta.x)
-                        }  
+                    let moveVec = Utils.getOrthoCameraMoveVec(e.drag.pointerDelta, camera )//最近一次移动向量
+                   
+                    this.translationWorldDelta.add(moveVec.negate())  
                     
-                    }else{  
-                        pointclouds = a && e.drag.intersectStart.pointcloud && [e.drag.intersectStart.pointcloud]
-                     
-                    } */
-                      
-                    /* if(pointclouds){
-                        if(handleState == 'translate' && viewport.alignment.translateVec){//只能沿某个方向移动
-                            moveVec.projectOnVector(viewport.alignment.translateVec)
-                        } 
-                        
-                        this.dispatchEvent({
-                            type : "transformPointcloud", 
-                            intersect: e.intersect.orthoIntersect,   
-                            intersectStart: e.drag.intersectStart.orthoIntersect,
-                            moveVec,        
-                            pointclouds, 
-                            camera
-                        }) 
-                    }else{ */  
-                        this.translationWorldDelta.add(moveVec.negate())  
-                    //}
                      
                 }else{ //perspectiveCamera: 
                     if(e.drag.intersectStart){//如果拖拽着点云 
@@ -263,9 +214,7 @@ export class FirstPersonControls extends THREE.EventDispatcher {
                         let pointerStartPos2d = e.drag.intersectStart.location.clone().project(camera);//识别到的点云点的位置
                         e.drag.z = pointerStartPos2d.z //记录z,保持拖拽物体到屏幕距离不变,所以z深度不变(如果拖拽过程中没有缩放,这个z其实不变)
                         
-                        if(ifInit){//拖拽开始 
-                        
-                        
+                        if(ifInit){//拖拽开始  
                             e.drag.projectionMatrixInverse = camera.projectionMatrixInverse.clone()
                             //防止吸附到最近点上(因为鼠标所在位置并非识别到的点云点的位置,需要得到鼠标所在位置的3d坐标。)
                             let pointerStartPos2dReal = new THREE.Vector3(this.pointerDragStart.x,this.pointerDragStart.y, e.drag.z);
@@ -289,17 +238,7 @@ export class FirstPersonControls extends THREE.EventDispatcher {
                         //四指松开剩三指时会偏移一下,暂不知道哪里的问题,或许跟开头防止点云吸附有关?
                          
                     }else{ //如果鼠标没有找到和点云的交点,就假设移动整个模型(也可以去扩大范围寻找最近点云)
-                         
-                        /* let center = viewer.scene.pointclouds[0].position;
-                        let radius = camera.position.distanceTo(center);
-                        let ratio = radius * Math.tan(THREE.Math.degToRad(camera.fov)/2) / 1000 */
-                        
-                        
-                        /* let speed = this.currentViewport.getMoveSpeed()
-                        if(FirstPersonControls.boundPlane){
-                            speed = FirstPersonControls.boundPlane.distanceToPoint(this.currentViewport.position)   
-                            speed = Math.max(1 , speed) 
-                        }  */
+                       
                         let lastIntersect = this.target || viewport.lastIntersect && (viewport.lastIntersect.location || viewport.lastIntersect)//该viewport的最近一次鼠标和点云的交点
                         if(!lastIntersect || !(lastIntersect instanceof THREE.Vector3))lastIntersect = viewer.bound.center  
                         let speed = camera.position.distanceTo(lastIntersect)   

+ 10 - 4
src/viewer/ExtendView.js

@@ -217,15 +217,21 @@ class ExtendView extends View {
         let endPosition = new THREE.Vector3().copy(info.position)
         let startPosition = this.position.clone();
 		let startQuaternion, endQuaternion, endTarget = null,  
-            endYaw = info.endYaw, startYaw, endPitch = info.endPitch,  startPitch ;
+            endYaw, startYaw, endPitch, startPitch ;
         
         
         this.restrictPos(endPosition)
          
          
-        if(endYaw != void 0) {
-            startYaw = this.yaw  
-            startPitch = this.pitch  
+        if(info.endYaw != void 0) { 
+            startPitch = this.pitch
+            endPitch = info.endPitch;
+            startYaw = this.yaw
+            endYaw = info.endYaw 
+            if(Math.abs(startYaw - endYaw)>Math.PI){//如果差距大于半个圆,就要反个方向转(把大的那个数字减去360度)
+                startYaw > endYaw ? (startYaw -= Math.PI*2) : (endYaw -= Math.PI*2) 
+            }
+            
 		}else if(info.target ){
 			endTarget = new THREE.Vector3().copy(info.target)  
             endQuaternion = math.getQuaFromPosAim(endPosition,endTarget) //若为垂直,会自动偏向x负的方向