4DKanKan_Setup_v1.1.5.0

AppFile/laser/bin/resources/static/dist/static/lib/potree/workers/EptBinaryDecoderWorker.js

@@ -0,0 +1,213 @@
+function parseEpt(event) {
+	let buffer = event.data.buffer;
+	let view = new DataView(buffer);
+	let schema = event.data.schema;
+	let scale = event.data.scale;
+	let offset = event.data.offset;
+	let mins = event.data.mins;
+
+	let dimensions = schema.reduce((p, c) => {
+		p[c.name] = c;
+		return p;
+	}, { });
+
+	let dimOffset = (name) => {
+		let offset = 0;
+		for (var i = 0; i < schema.length; ++i) {
+			if (schema[i].name == name) return offset;
+			offset += schema[i].size;
+		}
+		return undefined;
+	};
+
+	let getExtractor = (name) => {
+		let offset = dimOffset(name);
+		let type = dimensions[name].type;
+		let size = dimensions[name].size;
+
+		if (type == 'signed') switch (size) {
+			case 1: return (p) => view.getInt8(p + offset);
+			case 2: return (p) => view.getInt16(p + offset, true);
+			case 4: return (p) => view.getInt32(p + offset, true);
+			case 8: return (p) => view.getInt64(p + offset, true);
+		}
+		if (type == 'unsigned') switch (size) {
+			case 1: return (p) => view.getUint8(p + offset);
+			case 2: return (p) => view.getUint16(p + offset, true);
+			case 4: return (p) => view.getUint32(p + offset, true);
+			case 8: return (p) => view.getUint64(p + offset, true);
+		}
+		if (type == 'float') switch (size) {
+			case 4: return (p) => view.getFloat32(p + offset, true);
+			case 8: return (p) => view.getFloat64(p + offset, true);
+		}
+
+		let str = JSON.stringify(dimensions[name]);
+		throw new Error(`Invalid dimension specification for ${name}: ${str}`);
+	};
+
+	let pointSize = schema.reduce((p, c) => p + c.size, 0);
+	let numPoints = buffer.byteLength / pointSize;
+
+	let xyzBuffer, rgbBuffer, intensityBuffer, classificationBuffer,
+		returnNumberBuffer, numberOfReturnsBuffer, pointSourceIdBuffer;
+	let xyz, rgb, intensity, classification, returnNumber, numberOfReturns,
+		pointSourceId;
+	let xyzExtractor, rgbExtractor, intensityExtractor, classificationExtractor,
+		returnNumberExtractor, numberOfReturnsExtractor, pointSourceIdExtractor;
+	let twoByteColor = false;
+
+	if (dimensions['X'] && dimensions['Y'] && dimensions['Z']) {
+		xyzBuffer = new ArrayBuffer(numPoints * 4 * 3);
+		xyz = new Float32Array(xyzBuffer);
+		xyzExtractor = [
+			getExtractor('X'),
+			getExtractor('Y'),
+			getExtractor('Z')
+		];
+	}
+
+	if (dimensions['Red'] && dimensions['Green'] && dimensions['Blue']) {
+		rgbBuffer = new ArrayBuffer(numPoints * 4);
+		rgb = new Uint8Array(rgbBuffer);
+		rgbExtractor = [
+			getExtractor('Red'),
+			getExtractor('Green'),
+			getExtractor('Blue')
+		];
+
+		let r, g, b, pos;
+		for (let i = 0; i < numPoints && !twoByteColor; ++i) {
+			pos = i * pointSize;
+			r = rgbExtractor[0](pos);
+			g = rgbExtractor[1](pos);
+			b = rgbExtractor[2](pos);
+			if (r > 255 || g > 255 || b > 255) twoByteColor = true;
+		}
+	}
+
+	if (dimensions['Intensity']) {
+		intensityBuffer = new ArrayBuffer(numPoints * 4);
+		intensity = new Float32Array(intensityBuffer);
+		intensityExtractor = getExtractor('Intensity');
+	}
+
+	if (dimensions['Classification']) {
+		classificationBuffer = new ArrayBuffer(numPoints);
+		classification = new Uint8Array(classificationBuffer);
+		classificationExtractor = getExtractor('Classification');
+	}
+
+	if (dimensions['ReturnNumber']) {
+		returnNumberBuffer = new ArrayBuffer(numPoints);
+		returnNumber = new Uint8Array(returnNumberBuffer);
+		returnNumberExtractor = getExtractor('ReturnNumber');
+	}
+
+	if (dimensions['NumberOfReturns']) {
+		numberOfReturnsBuffer = new ArrayBuffer(numPoints);
+		numberOfReturns = new Uint8Array(numberOfReturnsBuffer);
+		numberOfReturnsExtractor = getExtractor('NumberOfReturns');
+	}
+
+	if (dimensions['PointSourceId']) {
+		pointSourceIdBuffer = new ArrayBuffer(numPoints * 2);
+		pointSourceId = new Uint16Array(pointSourceIdBuffer);
+		pointSourceIdExtractor = getExtractor('PointSourceId');
+	}
+
+	let mean = [0, 0, 0];
+	let bounds = {
+		min: [Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE],
+		max: [-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE],
+	};
+
+	let x, y, z, r, g, b;
+	for (let i = 0; i < numPoints; ++i) {
+		let pos = i * pointSize;
+		if (xyz) {
+			x = xyzExtractor[0](pos) * scale.x + offset.x - mins[0];
+			y = xyzExtractor[1](pos) * scale.y + offset.y - mins[1];
+			z = xyzExtractor[2](pos) * scale.z + offset.z - mins[2];
+
+			mean[0] += x / numPoints;
+			mean[1] += y / numPoints;
+			mean[2] += z / numPoints;
+
+			bounds.min[0] = Math.min(bounds.min[0], x);
+			bounds.min[1] = Math.min(bounds.min[1], y);
+			bounds.min[2] = Math.min(bounds.min[2], z);
+
+			bounds.max[0] = Math.max(bounds.max[0], x);
+			bounds.max[1] = Math.max(bounds.max[1], y);
+			bounds.max[2] = Math.max(bounds.max[2], z);
+
+			xyz[3 * i + 0] = x;
+			xyz[3 * i + 1] = y;
+			xyz[3 * i + 2] = z;
+		}
+
+		if (rgb) {
+			r = rgbExtractor[0](pos);
+			g = rgbExtractor[1](pos);
+			b = rgbExtractor[2](pos);
+
+			if (twoByteColor) {
+				r /= 256;
+				g /= 256;
+				b /= 256;
+			}
+
+			rgb[4 * i + 0] = r;
+			rgb[4 * i + 1] = g;
+			rgb[4 * i + 2] = b;
+		}
+
+		if (intensity) intensity[i] = intensityExtractor(pos);
+		if (classification) classification[i] = classificationExtractor(pos);
+		if (returnNumber) returnNumber[i] = returnNumberExtractor(pos);
+		if (numberOfReturns) numberOfReturns[i] = numberOfReturnsExtractor(pos);
+		if (pointSourceId) pointSourceId[i] = pointSourceIdExtractor(pos);
+	}
+
+	let indicesBuffer = new ArrayBuffer(numPoints * 4);
+	let indices = new Uint32Array(indicesBuffer);
+	for (let i = 0; i < numPoints; ++i) {
+		indices[i] = i;
+	}
+
+	let message = {
+		numPoints: numPoints,
+		tightBoundingBox: bounds,
+		mean: mean,
+
+		position: xyzBuffer,
+		color: rgbBuffer,
+		intensity: intensityBuffer,
+		classification: classificationBuffer,
+		returnNumber: returnNumberBuffer,
+		numberOfReturns: numberOfReturnsBuffer,
+		pointSourceId: pointSourceIdBuffer,
+		indices: indicesBuffer
+	};
+
+	let transferables = [
+		message.position,
+		message.color,
+		message.intensity,
+		message.classification,
+		message.returnNumber,
+		message.numberOfReturns,
+		message.pointSourceId,
+		message.indices
+	].filter((v) => v);
+
+	postMessage(message, transferables);
+}
+
+
+// importScripts('/libs/ept/ParseBuffer.js');
+onmessage = function(event) {
+	parseEpt(event);
+}
+

AppFile/laser/bin/resources/static/dist/static/lib/potree/workers/EptLaszipDecoderWorker.js

@@ -0,0 +1,200 @@
+function readUsingDataView(event) {
+	performance.mark("laslaz-start");
+
+	let buffer = event.data.buffer;
+	let numPoints = event.data.numPoints;
+	let pointSize = event.data.pointSize;
+	let pointFormat = event.data.pointFormatID;
+
+	// gps time byte offsets from LAS specification
+	let gpsOffsets = [null, 20, null, 20, 20, 20, 22, 22, 22, 22, 22] 
+	let gpsOffset = gpsOffsets[pointFormat];
+
+	let scale = event.data.scale;
+	let offset = event.data.offset;
+
+	let sourceUint8 = new Uint8Array(buffer);
+	let sourceView = new DataView(buffer);
+
+	let tightBoundingBox = {
+		min: [
+			Number.POSITIVE_INFINITY,
+			Number.POSITIVE_INFINITY,
+			Number.POSITIVE_INFINITY
+		],
+		max: [
+			Number.NEGATIVE_INFINITY,
+			Number.NEGATIVE_INFINITY,
+			Number.NEGATIVE_INFINITY
+		]
+	};
+
+	let mean = [0, 0, 0];
+
+	let pBuff = new ArrayBuffer(numPoints * 3 * 4);
+	let cBuff = new ArrayBuffer(numPoints * 4);
+	let iBuff = new ArrayBuffer(numPoints * 4);
+	let clBuff = new ArrayBuffer(numPoints);
+	let rnBuff = new ArrayBuffer(numPoints);
+	let nrBuff = new ArrayBuffer(numPoints);
+	let psBuff = new ArrayBuffer(numPoints * 2);
+	let gpsBuff64 = new ArrayBuffer(numPoints * 8);
+	let gpsBuff32 = new ArrayBuffer(numPoints * 4);
+
+	let positions = new Float32Array(pBuff);
+	let colors = new Uint8Array(cBuff);
+	let intensities = new Float32Array(iBuff);
+	let classifications = new Uint8Array(clBuff);
+	let returnNumbers = new Uint8Array(rnBuff);
+	let numberOfReturns = new Uint8Array(nrBuff);
+	let pointSourceIDs = new Uint16Array(psBuff);
+	let gpsTime64 = new Float64Array(gpsBuff64)
+	let gpsTime32 = new Float32Array(gpsBuff32)
+
+	// Point format 3 contains an 8-byte GpsTime before RGB values, so make
+	// sure we have the correct color offset.
+	let hasColor = pointFormat == 2 || pointFormat == 3;
+	let co = pointFormat == 2 ? 20 : 28;
+
+	// TODO This should be cached per-resource since this is an expensive check.
+	let twoByteColor = false;
+	if (hasColor) {
+		let r, g, b, pos;
+		for (let i = 0; i < numPoints && !twoByteColor; ++i) {
+			pos = i * pointSize;
+			r = sourceView.getUint16(pos + co, true)
+			g = sourceView.getUint16(pos + co + 2, true)
+			b = sourceView.getUint16(pos + co + 4, true)
+			if (r > 255 || g > 255 || b > 255) twoByteColor = true;
+		}
+	}
+
+	for (let i = 0; i < numPoints; i++) {
+		// POSITION
+		let ux = sourceView.getInt32(i * pointSize + 0, true);
+		let uy = sourceView.getInt32(i * pointSize + 4, true);
+		let uz = sourceView.getInt32(i * pointSize + 8, true);
+
+		x = ux * scale[0] + offset[0] - event.data.mins[0];
+		y = uy * scale[1] + offset[1] - event.data.mins[1];
+		z = uz * scale[2] + offset[2] - event.data.mins[2];
+
+		positions[3 * i + 0] = x;
+		positions[3 * i + 1] = y;
+		positions[3 * i + 2] = z;
+
+		mean[0] += x / numPoints;
+		mean[1] += y / numPoints;
+		mean[2] += z / numPoints;
+
+		tightBoundingBox.min[0] = Math.min(tightBoundingBox.min[0], x);
+		tightBoundingBox.min[1] = Math.min(tightBoundingBox.min[1], y);
+		tightBoundingBox.min[2] = Math.min(tightBoundingBox.min[2], z);
+
+		tightBoundingBox.max[0] = Math.max(tightBoundingBox.max[0], x);
+		tightBoundingBox.max[1] = Math.max(tightBoundingBox.max[1], y);
+		tightBoundingBox.max[2] = Math.max(tightBoundingBox.max[2], z);
+
+		// INTENSITY
+		let intensity = sourceView.getUint16(i * pointSize + 12, true);
+		intensities[i] = intensity;
+
+		// RETURN NUMBER, stored in the first 3 bits - 00000111
+		// number of returns stored in next 3 bits	 - 00111000
+		let returnNumberAndNumberOfReturns = sourceView.getUint8(i * pointSize + 14, true);
+		let returnNumber = returnNumberAndNumberOfReturns & 0b0111;
+		let numberOfReturn = (returnNumberAndNumberOfReturns & 0b00111000) >> 3;
+		returnNumbers[i] = returnNumber;
+		numberOfReturns[i] = numberOfReturn;
+
+		// CLASSIFICATION
+		let classification = sourceView.getUint8(i * pointSize + 15, true);
+		classifications[i] = classification;
+
+		// POINT SOURCE ID
+		let pointSourceID = sourceView.getUint16(i * pointSize + 18, true);
+		pointSourceIDs[i] = pointSourceID;
+
+		// COLOR, if available
+		if (hasColor) {
+			let r = sourceView.getUint16(i * pointSize + co, true)
+			let g = sourceView.getUint16(i * pointSize + co + 2, true)
+			let b = sourceView.getUint16(i * pointSize + co + 4, true)
+
+			if (twoByteColor) {
+				r /= 256;
+				g /= 256;
+				b /= 256;
+			}
+
+			colors[4 * i + 0] = r;
+			colors[4 * i + 1] = g;
+			colors[4 * i + 2] = b;
+			colors[4 * i + 3] = 255;
+		}
+	}
+
+	let min = Infinity
+	let max = -Infinity
+
+	for (let i = 0; i < numPoints; i++) {
+		min = Math.min(min, gpsTime64[i])
+		max = Math.max(max, gpsTime64[i])
+	}
+
+	for (let i = 0; i < numPoints; i++) {
+		gpsTime32[i] = gpsTime64[i] = min
+	}
+
+	let indices = new ArrayBuffer(numPoints * 4);
+	let iIndices = new Uint32Array(indices);
+	for (let i = 0; i < numPoints; i++) {
+		iIndices[i] = i;
+	}
+
+	performance.mark("laslaz-end");
+
+	//{ // print timings
+	//	  performance.measure("laslaz", "laslaz-start", "laslaz-end");
+	//	  let measure = performance.getEntriesByType("measure")[0];
+	//	  let dpp = 1000 * measure.duration / numPoints;
+	//	  let debugMessage = `${measure.duration.toFixed(3)} ms, ${numPoints} points, ${dpp.toFixed(3)} µs / point`;
+	//	  console.log(debugMessage);
+	//}
+	performance.clearMarks();
+	performance.clearMeasures();
+
+	let message = {
+		mean: mean,
+		position: pBuff,
+		color: cBuff,
+		intensity: iBuff,
+		classification: clBuff,
+		returnNumber: rnBuff,
+		numberOfReturns: nrBuff,
+		pointSourceID: psBuff,
+		tightBoundingBox: tightBoundingBox,
+		indices: indices,
+		gpsTime: gpsBuff32,
+		gpsMeta: { offset: min, range: max-min }
+	};
+
+	let transferables = [
+		message.position,
+		message.color,
+		message.intensity,
+		message.classification,
+		message.returnNumber,
+		message.numberOfReturns,
+		message.pointSourceID,
+		message.indices,
+		message.gpsTime
+	];
+
+	postMessage(message, transferables);
+};
+
+
+
+onmessage = readUsingDataView;
+

AppFile/laser/bin/resources/static/dist/static/lib/potree/workers/LASDecoderWorker.js

@@ -0,0 +1,344 @@
+
+function readUsingTempArrays(event) {
+
+	performance.mark("laslaz-start");
+
+	let buffer = event.data.buffer;
+	let numPoints = event.data.numPoints;
+	let sourcePointSize = event.data.pointSize;
+	let pointFormatID = event.data.pointFormatID;
+	let scale = event.data.scale;
+	let offset = event.data.offset;
+
+	let temp = new ArrayBuffer(4);
+	let tempUint8 = new Uint8Array(temp);
+	let tempUint16 = new Uint16Array(temp);
+	let tempInt32 = new Int32Array(temp);
+	let sourceUint8 = new Uint8Array(buffer);
+
+	let tightBoundingBox = {
+		min: [ Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY ],
+		max: [ Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY ]
+	};
+
+	let mean = [0, 0, 0];
+
+	let pBuff = new ArrayBuffer(numPoints * 3 * 4);
+	let cBuff = new ArrayBuffer(numPoints * 4);
+	let iBuff = new ArrayBuffer(numPoints * 4);
+	let clBuff = new ArrayBuffer(numPoints);
+	let rnBuff = new ArrayBuffer(numPoints);
+	let nrBuff = new ArrayBuffer(numPoints);
+	let psBuff = new ArrayBuffer(numPoints * 2);
+
+	let positions = new Float32Array(pBuff);
+	let colors = new Uint8Array(cBuff);
+	let intensities = new Float32Array(iBuff);
+	let classifications = new Uint8Array(clBuff);
+	let returnNumbers = new Uint8Array(rnBuff);
+	let numberOfReturns = new Uint8Array(nrBuff);
+	let pointSourceIDs = new Uint16Array(psBuff);
+
+	for (let i = 0; i < numPoints; i++) {
+		// POSITION
+		tempUint8[0] = sourceUint8[i * sourcePointSize + 0];
+		tempUint8[1] = sourceUint8[i * sourcePointSize + 1];
+		tempUint8[2] = sourceUint8[i * sourcePointSize + 2];
+		tempUint8[3] = sourceUint8[i * sourcePointSize + 3];
+		let x = tempInt32[0];
+
+		tempUint8[0] = sourceUint8[i * sourcePointSize + 4];
+		tempUint8[1] = sourceUint8[i * sourcePointSize + 5];
+		tempUint8[2] = sourceUint8[i * sourcePointSize + 6];
+		tempUint8[3] = sourceUint8[i * sourcePointSize + 7];
+		let y = tempInt32[0];
+
+		tempUint8[0] = sourceUint8[i * sourcePointSize + 8];
+		tempUint8[1] = sourceUint8[i * sourcePointSize + 9];
+		tempUint8[2] = sourceUint8[i * sourcePointSize + 10];
+		tempUint8[3] = sourceUint8[i * sourcePointSize + 11];
+		let z = tempInt32[0];
+
+		x = x * scale[0] + offset[0] - event.data.mins[0];
+		y = y * scale[1] + offset[1] - event.data.mins[1];
+		z = z * scale[2] + offset[2] - event.data.mins[2];
+
+		positions[3 * i + 0] = x;
+		positions[3 * i + 1] = y;
+		positions[3 * i + 2] = z;
+
+		mean[0] += x / numPoints;
+		mean[1] += y / numPoints;
+		mean[2] += z / numPoints;
+
+		tightBoundingBox.min[0] = Math.min(tightBoundingBox.min[0], x);
+		tightBoundingBox.min[1] = Math.min(tightBoundingBox.min[1], y);
+		tightBoundingBox.min[2] = Math.min(tightBoundingBox.min[2], z);
+
+		tightBoundingBox.max[0] = Math.max(tightBoundingBox.max[0], x);
+		tightBoundingBox.max[1] = Math.max(tightBoundingBox.max[1], y);
+		tightBoundingBox.max[2] = Math.max(tightBoundingBox.max[2], z);
+
+		// INTENSITY
+		tempUint8[0] = sourceUint8[i * sourcePointSize + 12];
+		tempUint8[1] = sourceUint8[i * sourcePointSize + 13];
+		let intensity = tempUint16[0];
+		intensities[i] = intensity;
+
+		// RETURN NUMBER, stored in the first 3 bits - 00000111
+		let returnNumber = sourceUint8[i * sourcePointSize + 14] & 0b111;
+		returnNumbers[i] = returnNumber;
+
+		// NUMBER OF RETURNS, stored in 00111000
+		numberOfReturns[i] = (sourceUint8[i * pointSize + 14] & 0b111000) >> 3;
+
+		debugger;
+
+		// CLASSIFICATION
+		let classification = sourceUint8[i * sourcePointSize + 15];
+		classifications[i] = classification;
+
+		// POINT SOURCE ID
+		tempUint8[0] = sourceUint8[i * sourcePointSize + 18];
+		tempUint8[1] = sourceUint8[i * sourcePointSize + 19];
+		let pointSourceID = tempUint16[0];
+		pointSourceIDs[i] = pointSourceID;
+
+		// COLOR, if available
+		if (pointFormatID === 2) {
+			tempUint8[0] = sourceUint8[i * sourcePointSize + 20];
+			tempUint8[1] = sourceUint8[i * sourcePointSize + 21];
+			let r = tempUint16[0];
+
+			tempUint8[0] = sourceUint8[i * sourcePointSize + 22];
+			tempUint8[1] = sourceUint8[i * sourcePointSize + 23];
+			let g = tempUint16[0];
+
+			tempUint8[0] = sourceUint8[i * sourcePointSize + 24];
+			tempUint8[1] = sourceUint8[i * sourcePointSize + 25];
+			let b = tempUint16[0];
+
+			r = r / 256;
+			g = g / 256;
+			b = b / 256;
+			colors[4 * i + 0] = r;
+			colors[4 * i + 1] = g;
+			colors[4 * i + 2] = b;
+
+		}
+	}
+
+	let indices = new ArrayBuffer(numPoints * 4);
+	let iIndices = new Uint32Array(indices);
+	for (let i = 0; i < numPoints; i++) {
+		iIndices[i] = i;
+	}
+
+	performance.mark("laslaz-end");
+	performance.measure("laslaz", "laslaz-start", "laslaz-end");
+
+	let measure = performance.getEntriesByType("measure")[0];
+	let dpp = 1000 * measure.duration / numPoints;
+	let debugMessage = `${measure.duration.toFixed(3)} ms, ${numPoints} points, ${dpp.toFixed(3)} micros / point`;
+	console.log(debugMessage);
+
+	performance.clearMarks();
+	performance.clearMeasures();
+
+	let message = {
+		mean: mean,
+		position: pBuff,
+		color: cBuff,
+		intensity: iBuff,
+		classification: clBuff,
+		returnNumber: rnBuff,
+		numberOfReturns: nrBuff,
+		pointSourceID: psBuff,
+		tightBoundingBox: tightBoundingBox,
+		indices: indices
+	};
+
+	let transferables = [
+		message.position,
+		message.color,
+		message.intensity,
+		message.classification,
+		message.returnNumber,
+		message.numberOfReturns,
+		message.pointSourceID,
+		message.indices];
+
+	debugger;
+
+	postMessage(message, transferables);
+};
+
+
+function readUsingDataView(event) {
+
+	performance.mark("laslaz-start");
+
+	let buffer = event.data.buffer;
+	let numPoints = event.data.numPoints;
+	let sourcePointSize = event.data.pointSize;
+	let pointFormatID = event.data.pointFormatID;
+	let scale = event.data.scale;
+	let offset = event.data.offset;
+
+	let sourceView = new DataView(buffer);
+
+	let tightBoundingBox = {
+		min: [Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE],
+		max: [-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE]
+	};
+
+	let mean = [0, 0, 0];
+
+	let pBuff = new ArrayBuffer(numPoints * 3 * 4);
+	let cBuff = new ArrayBuffer(numPoints * 4);
+	let iBuff = new ArrayBuffer(numPoints * 4);
+	let clBuff = new ArrayBuffer(numPoints);
+	let rnBuff = new ArrayBuffer(numPoints);
+	let nrBuff = new ArrayBuffer(numPoints);
+	let psBuff = new ArrayBuffer(numPoints * 2);
+
+	let positions = new Float32Array(pBuff);
+	let colors = new Uint8Array(cBuff);
+	let intensities = new Float32Array(iBuff);
+	let classifications = new Uint8Array(clBuff);
+	let returnNumbers = new Uint8Array(rnBuff);
+	let numberOfReturns = new Uint8Array(nrBuff);
+	let pointSourceIDs = new Uint16Array(psBuff);
+	
+	const rangeIntensity = [Infinity, -Infinity];
+	const rangeClassification = [Infinity, -Infinity];
+	const rangeReturnNumber = [Infinity, -Infinity];
+	const rangeNumberOfReturns = [Infinity, -Infinity];
+	const rangeSourceID = [Infinity, -Infinity];
+
+	for (let i = 0; i < numPoints; i++) {
+		// POSITION
+		let ux = sourceView.getInt32(i * sourcePointSize + 0, true);
+		let uy = sourceView.getInt32(i * sourcePointSize + 4, true);
+		let uz = sourceView.getInt32(i * sourcePointSize + 8, true);
+
+		x = ux * scale[0] + offset[0] - event.data.mins[0];
+		y = uy * scale[1] + offset[1] - event.data.mins[1];
+		z = uz * scale[2] + offset[2] - event.data.mins[2];
+
+		positions[3 * i + 0] = x;
+		positions[3 * i + 1] = y;
+		positions[3 * i + 2] = z;
+
+		mean[0] += x / numPoints;
+		mean[1] += y / numPoints;
+		mean[2] += z / numPoints;
+
+		tightBoundingBox.min[0] = Math.min(tightBoundingBox.min[0], x);
+		tightBoundingBox.min[1] = Math.min(tightBoundingBox.min[1], y);
+		tightBoundingBox.min[2] = Math.min(tightBoundingBox.min[2], z);
+
+		tightBoundingBox.max[0] = Math.max(tightBoundingBox.max[0], x);
+		tightBoundingBox.max[1] = Math.max(tightBoundingBox.max[1], y);
+		tightBoundingBox.max[2] = Math.max(tightBoundingBox.max[2], z);
+
+		// INTENSITY
+		let intensity = sourceView.getUint16(i * sourcePointSize + 12, true);
+		intensities[i] = intensity;
+		rangeIntensity[0] = Math.min(rangeIntensity[0], intensity);
+		rangeIntensity[1] = Math.max(rangeIntensity[1], intensity);
+
+		// RETURN NUMBER, stored in the first 3 bits - 00000111
+		// number of returns stored in next 3 bits   - 00111000
+		let returnNumberAndNumberOfReturns = sourceView.getUint8(i * sourcePointSize + 14, true);
+		let returnNumber = returnNumberAndNumberOfReturns & 0b0111;
+		let numberOfReturn = (returnNumberAndNumberOfReturns & 0b00111000) >> 3;
+		returnNumbers[i] = returnNumber;
+		numberOfReturns[i] = numberOfReturn;
+		rangeReturnNumber[0] = Math.min(rangeReturnNumber[0], returnNumber);
+		rangeReturnNumber[1] = Math.max(rangeReturnNumber[1], returnNumber);
+		rangeNumberOfReturns[0] = Math.min(rangeNumberOfReturns[0], numberOfReturn);
+		rangeNumberOfReturns[1] = Math.max(rangeNumberOfReturns[1], numberOfReturn);
+
+		// CLASSIFICATION
+		let classification = sourceView.getUint8(i * sourcePointSize + 15, true);
+		classifications[i] = classification;
+		rangeClassification[0] = Math.min(rangeClassification[0], classification);
+		rangeClassification[1] = Math.max(rangeClassification[1], classification);
+
+		// POINT SOURCE ID
+		let pointSourceID = sourceView.getUint16(i * sourcePointSize + 18, true);
+		pointSourceIDs[i] = pointSourceID;
+		rangeSourceID[0] = Math.min(rangeSourceID[0], pointSourceID);
+		rangeSourceID[1] = Math.max(rangeSourceID[1], pointSourceID);
+
+		// COLOR, if available
+		if (pointFormatID === 2) {
+			let r = sourceView.getUint16(i * sourcePointSize + 20, true) / 256;
+			let g = sourceView.getUint16(i * sourcePointSize + 22, true) / 256;
+			let b = sourceView.getUint16(i * sourcePointSize + 24, true) / 256;
+
+			colors[4 * i + 0] = r;
+			colors[4 * i + 1] = g;
+			colors[4 * i + 2] = b;
+			colors[4 * i + 3] = 255;
+		}
+	}
+
+	let indices = new ArrayBuffer(numPoints * 4);
+	let iIndices = new Uint32Array(indices);
+	for (let i = 0; i < numPoints; i++) {
+		iIndices[i] = i;
+	}
+
+	performance.mark("laslaz-end");
+
+	//{ // print timings
+	//	performance.measure("laslaz", "laslaz-start", "laslaz-end");
+	//	let measure = performance.getEntriesByType("measure")[0];
+	//	let dpp = 1000 * measure.duration / numPoints;
+	//	let debugMessage = `${measure.duration.toFixed(3)} ms, ${numPoints} points, ${dpp.toFixed(3)} µs / point`;
+	//	console.log(debugMessage);
+	//}
+	performance.clearMarks();
+	performance.clearMeasures();
+
+	const ranges = {
+		"intensity": rangeIntensity,
+		"classification": rangeClassification,
+		"return number": rangeReturnNumber,
+		"number of returns": rangeNumberOfReturns,
+		"source id": rangeSourceID,
+	};
+
+	let message = {
+		mean: mean,
+		position: pBuff,
+		color: cBuff,
+		intensity: iBuff,
+		classification: clBuff,
+		returnNumber: rnBuff,
+		numberOfReturns: nrBuff,
+		pointSourceID: psBuff,
+		tightBoundingBox: tightBoundingBox,
+		indices: indices,
+		ranges: ranges,
+	};
+
+	let transferables = [
+		message.position,
+		message.color,
+		message.intensity,
+		message.classification,
+		message.returnNumber,
+		message.numberOfReturns,
+		message.pointSourceID,
+		message.indices];
+
+	postMessage(message, transferables);
+};
+
+
+
+onmessage = readUsingDataView;
+//onmessage = readUsingTempArrays;

AppFile/laser/bin/resources/static/reload.bat

@@ -0,0 +1,5 @@
+@echo off
+set path=%1
+
+call "%path%\static\windows-stop-kill.exe"
+start "" "%path%\..\laser.exe"