fix: add

public/lib/plasio/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Uday Verma, uday.karan@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

public/lib/plasio/js/laslaz.js

@@ -0,0 +1,398 @@
+// laslaz.js
+// LAS/LAZ loading
+//
+
+//var common = require("./common"),
+//	Promise = require("bluebird");
+
+(function(scope) {
+	"use strict";
+
+	var pointFormatReaders = {
+		0: function(dv) {
+			return {
+				"position": [ dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+				"intensity": dv.getUint16(12, true),
+				"classification": dv.getUint8(16, true)
+			};
+		},
+		1: function(dv) {
+			return {
+				"position": [ dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+				"intensity": dv.getUint16(12, true),
+				"classification": dv.getUint8(16, true)
+			};
+		},
+		2: function(dv) {
+			return {
+				"position": [ dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+				"intensity": dv.getUint16(12, true),
+				"classification": dv.getUint8(16, true),
+				"color": [dv.getUint16(20, true), dv.getUint16(22, true), dv.getUint16(24, true)]
+			};
+		},
+		3: function(dv) {
+			return {
+				"position": [ dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+				"intensity": dv.getUint16(12, true),
+				"classification": dv.getUint8(16, true),
+				"color": [dv.getUint16(28, true), dv.getUint16(30, true), dv.getUint16(32, true)]
+			};
+		}
+	};
+
+	function readAs(buf, Type, offset, count) {
+		count = (count === undefined || count === 0 ? 1 : count);
+		var sub = buf.slice(offset, offset + Type.BYTES_PER_ELEMENT * count);
+
+		var r = new Type(sub);
+		if (count === undefined || count === 1)
+			return r[0];
+
+		var ret = [];
+		for (var i = 0 ; i < count ; i ++) {
+			ret.push(r[i]);
+		}
+
+		return ret;
+	}
+
+	function parseLASHeader(arraybuffer) {
+		var o = {};
+
+		o.pointsOffset = readAs(arraybuffer, Uint32Array, 32*3);
+		o.pointsFormatId = readAs(arraybuffer, Uint8Array, 32*3+8);
+		o.pointsStructSize = readAs(arraybuffer, Uint16Array, 32*3+8+1);
+		o.pointsCount = readAs(arraybuffer, Uint32Array, 32*3 + 11);
+
+
+		var start = 32*3 + 35;
+		o.scale = readAs(arraybuffer, Float64Array, start, 3); start += 24; // 8*3
+		o.offset = readAs(arraybuffer, Float64Array, start, 3); start += 24;
+
+
+
+		var bounds = readAs(arraybuffer, Float64Array, start, 6); start += 48; // 8*6;
+		o.maxs = [bounds[0], bounds[2], bounds[4]];
+		o.mins = [bounds[1], bounds[3], bounds[5]];
+
+		return o;
+	}
+
+	var msgIndex = 0;
+	var waitHandlers = {};
+
+	// This method is scope-wide since the nacl module uses this fuction to notify
+	// us of events
+	scope.handleMessage = function(message_event) {
+		var msg = message_event.data;
+		var resolver = waitHandlers[msg.id];
+		delete waitHandlers[msg.id];
+
+		// call the callback in a separate context, make sure we've cleaned our
+		// state out before the callback is invoked since it may queue more doExchanges
+		setTimeout(function() { 
+			if (msg.error)
+				return resolver.reject(new Error(msg.message || "Unknown Error"));
+
+			if (msg.hasOwnProperty('count') && msg.hasOwnProperty('hasMoreData')) {
+				return resolver.resolve({
+					buffer: msg.result,
+					count: msg.count,
+					hasMoreData: msg.hasMoreData});
+			}
+
+			resolver.resolve(msg.result);
+		}, 0);
+	};
+
+	var doDataExchange = function(cmd, callback) {
+		cmd.id = msgIndex.toString();
+		msgIndex ++;
+
+		var resolver = Promise.defer();
+		waitHandlers[cmd.id] = resolver;
+
+		nacl_module.postMessage(cmd);
+
+		return resolver.promise.cancellable();
+	};
+
+	// LAS Loader
+	// Loads uncompressed files
+	//
+	var LASLoader = function(arraybuffer) {
+		this.arraybuffer = arraybuffer;
+	};
+
+	LASLoader.prototype.open = function() {
+		// nothing needs to be done to open this file
+		//
+		this.readOffset = 0;
+		return new Promise(function(res, rej) {
+			setTimeout(res, 0);
+		});
+	};
+
+	LASLoader.prototype.getHeader = function() {
+		var o = this;
+
+		return new Promise(function(res, rej) {
+			setTimeout(function() {
+				o.header = parseLASHeader(o.arraybuffer);
+				res(o.header);
+			}, 0);
+		});
+	};
+
+	LASLoader.prototype.readData = function(count, offset, skip) {
+		var o = this;
+
+		return new Promise(function(res, rej) {
+			setTimeout(function() {
+				if (!o.header)
+					return rej(new Error("Cannot start reading data till a header request is issued"));
+
+				var start;
+				if (skip <= 1) {
+					count = Math.min(count, o.header.pointsCount - o.readOffset);
+					start = o.header.pointsOffset + o.readOffset * o.header.pointsStructSize;
+					var end = start + count * o.header.pointsStructSize;
+					res({
+						buffer: o.arraybuffer.slice(start, end),
+						count: count,
+						hasMoreData: o.readOffset + count < o.header.pointsCount});
+					o.readOffset += count;
+				}
+				else {
+					var pointsToRead = Math.min(count * skip, o.header.pointsCount - o.readOffset);
+					var bufferSize = Math.ceil(pointsToRead / skip);
+					var pointsRead = 0;
+
+					var buf = new Uint8Array(bufferSize * o.header.pointsStructSize);
+					for (var i = 0 ; i < pointsToRead ; i ++) {
+						if (i % skip === 0) {
+							start = o.header.pointsOffset + o.readOffset * o.header.pointsStructSize;
+							var src = new Uint8Array(o.arraybuffer, start, o.header.pointsStructSize);
+
+							buf.set(src, pointsRead * o.header.pointsStructSize);
+							pointsRead ++;
+						}
+
+						o.readOffset ++;
+					}
+
+					res({
+						buffer: buf.buffer,
+						count: pointsRead,
+						hasMoreData: o.readOffset < o.header.pointsCount
+					});
+				}
+			}, 0);
+		});
+	};
+
+	LASLoader.prototype.close = function() {
+		var o = this;
+		return new Promise(function(res, rej) {
+			o.arraybuffer = null;
+			setTimeout(res, 0);
+		});
+	};
+
+	// LAZ Loader
+	// Uses NaCL module to load LAZ files
+	//
+	var LAZLoader = function(arraybuffer) {
+		this.arraybuffer = arraybuffer;
+		
+		let workerPath = Potree.scriptPath + "/workers/LASLAZWorker.js";
+		this.ww = Potree.workerPool.getWorker(workerPath);
+
+		this.nextCB = null;
+		var o = this;
+
+		this.ww.onmessage = function(e) {
+			if (o.nextCB !== null) {
+				o.nextCB(e.data);
+				o.nextCB = null;
+			}
+		};
+
+		this.dorr = function(req, cb) {
+			o.nextCB = cb;
+			o.ww.postMessage(req);
+		};
+	};
+
+	LAZLoader.prototype.open = function() {
+
+		// nothing needs to be done to open this file
+		//
+		var o = this;
+		return new Promise(function(res, rej) {
+			o.dorr({type:"open", arraybuffer: o.arraybuffer}, function(r) {
+				if (r.status !== 1)
+					return rej(new Error("Failed to open file"));
+
+				res(true);
+			});
+		});
+	};
+
+	LAZLoader.prototype.getHeader = function() {
+		var o = this;
+
+		return new Promise(function(res, rej) {
+			o.dorr({type:'header'}, function(r) {
+				if (r.status !== 1)
+					return rej(new Error("Failed to get header"));
+
+				res(r.header);
+			});
+		});
+	};
+
+	LAZLoader.prototype.readData = function(count, offset, skip) {
+		var o = this;
+
+		return new Promise(function(res, rej) {
+			o.dorr({type:'read', count: count, offset: offset, skip: skip}, function(r) {
+				if (r.status !== 1)
+					return rej(new Error("Failed to read data"));
+				res({
+					buffer: r.buffer,
+					count: r.count,
+					hasMoreData: r.hasMoreData
+				});
+			});
+		});
+	};
+
+	LAZLoader.prototype.close = function() {
+		var o = this;
+
+		return new Promise(function(res, rej) {
+			o.dorr({type:'close'}, function(r) {
+				let workerPath = Potree.scriptPath + "/workers/LASLAZWorker.js";
+				Potree.workerPool.returnWorker(workerPath, o.ww);
+			
+				if (r.status !== 1)
+					return rej(new Error("Failed to close file"));
+
+				res(true);
+			});
+		});
+	};
+
+	// A single consistent interface for loading LAS/LAZ files
+	var LASFile = function(arraybuffer) {
+		this.arraybuffer = arraybuffer;
+
+		this.determineVersion();
+		if (this.version > 12)
+			throw new Error("Only file versions <= 1.2 are supported at this time");
+
+		this.determineFormat();
+		if (pointFormatReaders[this.formatId] === undefined)
+			throw new Error("The point format ID is not supported");
+
+		this.loader = this.isCompressed ?
+			new LAZLoader(this.arraybuffer) :
+			new LASLoader(this.arraybuffer);
+	};
+
+	LASFile.prototype.determineFormat = function() {
+		var formatId = readAs(this.arraybuffer, Uint8Array, 32*3+8);
+		var bit_7 = (formatId & 0x80) >> 7;
+		var bit_6 = (formatId & 0x40) >> 6;
+
+		if (bit_7 === 1 && bit_6 === 1)
+			throw new Error("Old style compression not supported");
+
+		this.formatId = formatId & 0x3f;
+		this.isCompressed = (bit_7 === 1 || bit_6 === 1);
+	};
+
+	LASFile.prototype.determineVersion = function() {
+		var ver = new Int8Array(this.arraybuffer, 24, 2);
+		this.version = ver[0] * 10 + ver[1];
+		this.versionAsString = ver[0] + "." + ver[1];
+	};
+
+	LASFile.prototype.open = function() {
+		return this.loader.open();
+	};
+
+	LASFile.prototype.getHeader = function() {
+		return this.loader.getHeader();
+	};
+
+	LASFile.prototype.readData = function(count, start, skip) {
+		return this.loader.readData(count, start, skip);
+	};
+
+	LASFile.prototype.close = function() {
+		return this.loader.close();
+	};
+
+	// Decodes LAS records into points
+	//
+	var LASDecoder = function(buffer, pointFormatID, pointSize, pointsCount, scale, offset, mins, maxs) {
+		this.arrayb = buffer;
+		this.decoder = pointFormatReaders[pointFormatID];
+		this.pointsCount = pointsCount;
+		this.pointSize = pointSize;
+		this.scale = scale;
+		this.offset = offset;
+		this.mins = mins;
+		this.maxs = maxs;
+	};
+
+	LASDecoder.prototype.getPoint = function(index) {
+		if (index < 0 || index >= this.pointsCount)
+			throw new Error("Point index out of range");
+
+		var dv = new DataView(this.arrayb, index * this.pointSize, this.pointSize);
+		return this.decoder(dv);
+	};
+
+	// NACL Module support
+	// Called by the common.js module.
+	//
+	//window.startNaCl = function(name, tc, config, width, height) {
+	//	// check browser support for nacl
+	//	//
+	//	if(!common.browserSupportsNaCl()) {
+	//		return $.event.trigger({
+	//			type: "plasio.nacl.error",
+	//			message: "NaCl support is not available"
+	//		});
+	//	}
+
+	//	navigator.webkitPersistentStorage.requestQuota(2048 * 2048, function(bytes) {
+	//		common.updateStatus(
+	//			'Allocated ' + bytes + ' bytes of persistant storage.');
+	//			common.attachDefaultListeners();
+	//			common.createNaClModule(name, tc, config, width, height);
+	//	},
+	//	function(e) { 
+	//		$.event.trigger({
+	//			type: "plasio.nacl.error",
+	//			message: "Could not allocate persistant storage"
+	//		});
+	//	});
+
+	//	$(document).on("plasio.nacl.available", function() {
+	//		scope.LASModuleWasLoaded = true;
+	//	});
+	//};
+
+	scope.LAZLoader = LAZLoader;
+	scope.LASLoader = LASLoader;
+	scope.LASFile = LASFile;
+	scope.LASDecoder = LASDecoder;
+	scope.LASModuleWasLoaded = false;
+//})(module.exports);
+})(this);
+

public/lib/plasio/workers/laz-loader-worker.js

@@ -0,0 +1,165 @@
+// laz-loader-worker.js
+//
+
+//import {Module} from "./laz-perf.js";
+
+let instance = null; // laz-perf instance
+
+function readAs(buf, Type, offset, count) {
+	count = (count === undefined || count === 0 ? 1 : count);
+	var sub = buf.slice(offset, offset + Type.BYTES_PER_ELEMENT * count);
+
+	var r = new Type(sub);
+	if (count === undefined || count === 1)
+		return r[0];
+
+	var ret = [];
+	for (var i = 0 ; i < count ; i ++) {
+		ret.push(r[i]);
+	}
+
+	return ret;
+}
+
+function parseLASHeader(arraybuffer) {
+	var o = { };
+
+	o.pointsOffset = readAs(arraybuffer, Uint32Array, 32*3);
+	o.pointsFormatId = readAs(arraybuffer, Uint8Array, 32*3+8) & 0b111111;
+	o.pointsStructSize = readAs(arraybuffer, Uint16Array, 32*3+8+1);
+
+	o.extraBytes = 0;
+
+	switch (o.pointsFormatId) {
+		case 0: o.extraBytes = o.pointsStructSize - 20; break;
+		case 1: o.extraBytes = o.pointsStructSize - 28; break;
+		case 2: o.extraBytes = o.pointsStructSize - 26; break;
+		case 3: o.extraBytes = o.pointsStructSize - 34; break;
+	}
+
+	o.pointsCount = readAs(arraybuffer, Uint32Array, 32 * 3 + 11);
+
+	var start = 32 * 3 + 35;
+	o.scale = readAs(arraybuffer, Float64Array, start, 3); start += 24;
+	o.offset = readAs(arraybuffer, Float64Array, start, 3); start += 24;
+
+	var bounds = readAs(arraybuffer, Float64Array, start, 6); start += 48;
+	o.maxs = [bounds[0], bounds[2], bounds[4]];
+	o.mins = [bounds[1], bounds[3], bounds[5]];
+
+	return o;
+}
+
+function handleEvent(msg) {
+	switch(msg.type) {
+		case "open":
+			try {
+				instance = new Module.LASZip();
+				var abInt = new Uint8Array(msg.arraybuffer);
+				var buf = Module._malloc(msg.arraybuffer.byteLength);
+
+				instance.arraybuffer = msg.arraybuffer;
+				instance.buf = buf;
+				Module.HEAPU8.set(abInt, buf);
+				instance.open(buf, msg.arraybuffer.byteLength);
+
+				instance.readOffset = 0;
+
+				postMessage({ type: "open", status: 1});
+			}catch(e) {
+				debugger;
+				postMessage({ type: "open", status: 0, details: e });
+			}
+			break;
+
+		case "header":
+			if (!instance)
+				throw new Error(
+						"You need to open the file before reading the header");
+
+			var header = parseLASHeader(instance.arraybuffer);
+			header.pointsFormatId &= 0x3f;
+			instance.header = header;
+			postMessage({type: "header", status: 1, header: header});
+			break;
+
+		case "read":
+			if (!instance)
+				throw new Error(
+						"You need to open the file before trying to read");
+
+			var start = msg.start, count = msg.count, skip = msg.skip;
+			var o = instance;
+
+			if (!o.header)
+				throw new Error(
+						"You need to query header before reading");
+
+			let h = o.header;
+
+			var pointsToRead = Math.min(
+					count * skip, h.pointsCount - o.readOffset);
+			var bufferSize = Math.ceil(pointsToRead / skip);
+			var pointsRead = 0;
+
+			let buffer = new ArrayBuffer(bufferSize * h.pointsStructSize);
+			let this_buf = new Uint8Array(buffer);
+			var buf_read = Module._malloc(h.pointsStructSize);
+
+			for (var i = 0 ; i < pointsToRead ; i ++) {
+				o.getPoint(buf_read);
+
+				if (i % skip === 0) {
+					var a = new Uint8Array(
+							Module.HEAPU8.buffer,
+							buf_read,
+							h.pointsStructSize);
+
+					this_buf.set(
+							a,
+							pointsRead * h.pointsStructSize,
+							h.pointsStructSize);
+
+					++pointsRead;
+				}
+
+				++o.readOffset;
+			}
+			Module._free(buf_read);
+
+			let transferables = [buffer];
+
+			postMessage({
+				type: 'header',
+				status: 1,
+				buffer: buffer,
+				count: pointsRead,
+				hasMoreData: o.readOffset < o.header.pointsCount
+			}, transferables);
+
+			break;
+
+		case "close":
+			if (instance !== null) {
+				Module._free(instance.buf);
+				instance.delete();
+				instance = null;
+			}else{
+				debugger;
+			}
+
+			postMessage({ type: "close", status: 1});
+			break;
+	}
+}
+
+onmessage = function(event) {
+	try {
+		handleEvent(event.data);
+	} catch(e) {
+		debugger;
+		postMessage({type: event.data.type, status: 0, details: e});
+	}
+};
+
+

public/lib/potree/potree.js

@@ -80976,7 +80976,7 @@ void main()
 	        
 	        //raycaster.layers.enableAll()//add
 	        Potree.Utils.setCameraLayers(raycaster,   //设置能识别到的layers（如空间模型里只有mapViewer能识别到marker）
-	            ['sceneObjects','mapObjects','measure',  'transformationTool', 'model'],
+	            ['sceneObjects','mapObjects','measure',  'transformationTool', 'model', 'bothMapAndScene'],
 	            this.hoverViewport && this.hoverViewport.extraEnableLayers
 	        );
 	        //this.hoverViewport.beforeRender && this.hoverViewport.beforeRender()
@@ -90570,9 +90570,9 @@ void main()
 	        //绘制其他物体
 	        Potree.Utils.setCameraLayers(this.camera, ['mapObjects'  , 'bothMapAndScene'  ]);
 	        viewer.dispatchEvent({type: "render.begin",  viewer: this, viewport:this.viewports[0], params }); 
-	        renderer.render(this.scene, this.camera);
-	        this.attachedToViewer || renderer.render(viewer.scene.scene, this.camera); //类同renderOverlay
 	        
+	        this.attachedToViewer || renderer.render(viewer.scene.scene, this.camera); //类同renderOverlay
+	        renderer.render(this.scene, this.camera);
 	        if(!this.attachedToViewer && this.renderMeasure){//在未attach到主页面时也要渲染测量线
 	            viewer.dispatchEvent({type: "render.pass.perspective_overlay", camera:this.camera, /* screenshot:params.screenshot, */viewport:this.viewports[0], renderer});
 	        }
@@ -120764,6 +120764,7 @@ ENDSEC
 	        
 	        model.lastMatrixWorld = model.matrixWorld.clone();
 	        viewer.dispatchEvent('content_changed');
+	        viewer.mapViewer && viewer.mapViewer.dispatchEvent('content_changed');
 	    },
 	    
 	    
@@ -120878,24 +120879,29 @@ ENDSEC
 	    
 	    
 	    setGroundPlaneImg(src){//设置地面图
-	        const s = 0.01;
+	        const s = 0.1;
 	        this.curGroundImgSrc = src;
 	        if(src){
+	            let map = texLoader$a.load(src,(tex)=>{
+	                if(this.curGroundImgSrc == src){
+	                    this.groundPlane.scale.set(tex.image.width*s, tex.image.height*s);  
+	                }
+	            }); 
 	            if(!this.groundPlane){
 	                this.groundPlane = new Mesh(new PlaneBufferGeometry(1,1,1), new MeshBasicMaterial({
-	                    map : texLoader$a.load(src,(tex)=>{
-	                        if(this.curGroundImgSrc == src){
-	                            this.groundPlane.scale.set(tex.image.width*s, tex.image.height*s);  
-	                        }
-	                    }),
+	                    map,  
 	                    side : 2,
 	                    
 	                }));
 	                viewer.scene.scene.add(this.groundPlane);
+	                this.groundPlane.position.z = -1;
+	            }else {
+	                this.groundPlane.material.map = map;
 	            }
-	            Potree.settings.updateVisible(this.groundPlane,'show',true );
+	            
+	            Potree.Utils.updateVisible(this.groundPlane,'show',true );
 	        }else {
-	            this.groundPlane && Potree.settings.updateVisible(this.groundPlane,'show',false );
+	            this.groundPlane && Potree.Utils.updateVisible(this.groundPlane,'show',false );
 	        } 
 	        
 	        
@@ -161756,8 +161762,7 @@ ENDSEC
 	        
 	 	
 	        if(Potree.settings.editType != 'pano' && Potree.settings.editType != 'merge'){
-	            this.modules.ParticleEditor.update(delta); 
-	                   
+	            this.modules.ParticleEditor.update(delta);  
 	        }
 	        this.mapViewer && this.mapViewer.update(delta);     //地图更新
 	        
@@ -164118,7 +164123,7 @@ ENDSEC
 	            json.root.refine = 'ADD';
 	            json.refine = 'ADD';
 	        }else { 
-	            Potree.Utils.setObjectLayers(object,'model');  
+	            Potree.Utils.setObjectLayers(object, Potree.settings.showObjectsOnMap ? 'bothMapAndScene' : 'model');  
 	            
 	            
 	            object.traverse( ( child )=>{ 

src/sdk/cover/index.js

@@ -406,7 +406,13 @@ export const enter = (dom, mapDom, isLocal, lonlat) => {
                 } 
                 //--------------------------------
                 viewer.mapViewer = new Potree.MapViewer(mapArea)
-                viewer.mapViewer.initProjection()
+                viewer.mapViewer.initProjection() 
+                //focus
+                let boundSize = new THREE.Vector3(300,150,1).max(viewer.bound.boundSize)
+                setTimeout(()=>{
+                    viewer.mapViewer.moveTo(viewer.bound.center, boundSize,  0)
+                },100)
+                
             }
         },
 
@@ -1026,8 +1032,6 @@ export const enter = (dom, mapDom, isLocal, lonlat) => {
     
     //sdk.hideGrid()
     
-    
-    console.log('版本： 2022.12.20-1')
      
     return sdk 
 }