@xeokit/xeokit-sdk 2.0.17 → 2.0.18

package/dist/xeokit-sdk.es.js

@@ -78940,8 +78940,7 @@ class ModelTreeView {
  * hierarchy of the IFC elements in each model we load.
  *
  * Then we'll use an {@link XKTLoaderPlugin} to load the Schependomlaan model from an
- * [.xkt file](https://github.com/xeokit/xeokit-sdk/tree/master/examples/models/xkt/schependomlaan), along
- * with an accompanying JSON [IFC metadata file](https://github.com/xeokit/xeokit-sdk/tree/master/examples/metaModels/schependomlaan).
+ * [.xkt file](https://github.com/xeokit/xeokit-sdk/tree/master/examples/models/xkt/schependomlaan).
  *
  * [[Run this example](https://xeokit.github.io/xeokit-sdk/examples/#BIMOffline_XKT_Schependomlaan)]
  *
@@ -145473,9 +145472,9 @@ const LASLoader = {
 /**
  * {@link Viewer} plugin that loads lidar point cloud geometry from LAS files.
  *
- * <a href="/examples/#loading_LASLoaderPlugin_Autzen"><img src="/assets/images/autzen.png"></a>
+ * <a href="https://xeokit.github.io/xeokit-sdk/examples/#loading_LASLoaderPlugin_Autzen"><img src="https://xeokit.github.io/xeokit-sdk/assets/images/autzen.png"></a>
  *
- * [[Run this example](/examples/#loading_LASLoaderPlugin_Autzen)]
+ * [[Run this example](https://xeokit.github.io/xeokit-sdk/examples/#loading_LASLoaderPlugin_Autzen)]
  *
  * ## Summary
  *
@@ -145511,10 +145510,10 @@ const LASLoader = {
  * ## Usage
  *
  * In the example below we'll load the Autzen model from
- * a [LAS file](https://github.com/xeokit/xeokit-sdk/tree/master/examples/models/las/Duplex.las). Once the model has
+ * a [LAS file](/assets/models/las/). Once the model has
  * loaded, we'll then find its {@link MetaModel}, and the {@link MetaObject} and {@link Entity} that represent its point cloud.
  *
- * * [[Run this example](/examples/#loading_LASLoaderPlugin_Autzen)]
+ * * [[Run this example](https://xeokit.github.io/xeokit-sdk/examples/#loading_LASLoaderPlugin_Autzen)]
  *
  * ````javascript
  * import {Viewer, LASLoaderPlugin} from "xeokit-sdk.es.js";
@@ -145555,7 +145554,7 @@ const LASLoader = {
  * We have the option to rotate, scale and translate each LAS model as we load it.
  *
  * In the example below, we'll scale our model to half its size, rotate it 90 degrees about its local X-axis, then
- * translate it 100 units along its X axis.
+ * position it at [1842022, 10, -5173301] within xeokit's world coordinate system.
  *
  * ````javascript
  * const modelEntity = lasLoader.load({
@@ -145563,7 +145562,7 @@ const LASLoader = {
  *      src: "../assets/models/las/autzen.laz"
  *      rotation: [90,0,0],
  *      scale: [0.5, 0.5, 0.5],
- *      origin: [100, 0, 0]
+ *      origin: [1842022, 10, -5173301]
  * });
  * ````
  *
@@ -145605,7 +145604,7 @@ const LASLoader = {
  * ````
  *
  * @class LASLoaderPlugin
- * @since 2.0.13
+ * @since 2.0.17
  */
 class LASLoaderPlugin extends Plugin {
 
@@ -145797,6 +145796,48 @@ class LASLoaderPlugin extends Plugin {
 
     _parseModel(arrayBuffer, params, options, performanceModel) {
 
+        function readPositions(attributesPosition) {
+            const positionsValue = attributesPosition.value;
+            if (params.rotateX) {
+                if (positionsValue) {
+                    for (let i = 0, len = positionsValue.length; i < len; i += 3) {
+                        const temp = positionsValue[i + 1];
+                        positionsValue[i + 1] = positionsValue[i + 2];
+                        positionsValue[i + 2] = temp;
+                    }
+                }
+            }
+            return positionsValue;
+        }
+
+        function readColorsAndIntensities(attributesColor, attributesIntensity) {
+            const colors = attributesColor.value;
+            const colorSize = attributesColor.size;
+            const intensities = attributesIntensity.value;
+            const colorsCompressedSize = intensities.length * 4;
+            const colorsCompressed = new Uint8Array(colorsCompressedSize);
+            for (let i = 0, j = 0, k = 0, len = intensities.length; i < len; i++, k += colorSize, j += 4) {
+                colorsCompressed[j + 0] = colors[k + 0];
+                colorsCompressed[j + 1] = colors[k + 1];
+                colorsCompressed[j + 2] = colors[k + 2];
+                colorsCompressed[j + 3] = Math.round((intensities[i] / 65536) * 255);
+            }
+            return colorsCompressed;
+        }
+
+        function readIntensities(attributesIntensity) {
+            const intensities = attributesIntensity.intensity;
+            const colorsCompressedSize = intensities.length * 4;
+            const colorsCompressed = new Uint8Array(colorsCompressedSize);
+            for (let i = 0, j = 0, len = intensities.length; i < len; i++, j += 4) {
+                colorsCompressed[j + 0] = 0;
+                colorsCompressed[j + 1] = 0;
+                colorsCompressed[j + 2] = 0;
+                colorsCompressed[j + 3] = Math.round((intensities[i] / 65536) * 255);
+            }
+            return colorsCompressed;
+        }
+
         return new Promise((resolve, reject) => {
 
             if (performanceModel.destroyed) {
@@ -145820,78 +145861,60 @@ class LASLoaderPlugin extends Plugin {
             try {
                 parse(arrayBuffer, LASLoader, options).then((parsedData) => {
 
+                    const loaderData = parsedData.loaderData;
+                    const loaderDataHeader = loaderData.header;
+                    const pointsFormatId = loaderDataHeader.pointsFormatId;
+
                     const attributes = parsedData.attributes;
-                    const attributesPosition = attributes.POSITION;
-                    const attributesColor = attributes.COLOR_0;
-                    //  const attributesColor_0 = attributes.COLOR_0;
-                    const attributesIntensity = attributes.intensity;
-                    const attributesClassification = attributes.classification;
 
-                    if (!attributesPosition) {
+                    if (!attributes.POSITION) {
                         performanceModel.finalize();
                         reject("No positions found in file");
                         return;
                     }
-
-                    const positionsValue = attributesPosition.value;
-
-                    if (params.rotateX) {
-                        if (positionsValue) {
-                            for (let i = 0, len = positionsValue.length; i < len; i += 3) {
-                                const temp = positionsValue[i + 1];
-                                positionsValue[i + 1] = positionsValue[i + 2];
-                                positionsValue[i + 2] = temp;
+                    
+                    let positionsValue;
+                    let colorsCompressed;
+                    
+                    switch (pointsFormatId) {
+                        case 0:
+                            positionsValue = readPositions(attributes.POSITION);
+                            colorsCompressed = readIntensities(attributes.intensity);
+                            break;
+                        case 1:
+                            if (!attributes.intensity) {
+                                performanceModel.finalize();
+                                reject("No positions found in file");
+                                return;
                             }
-                        }
-                    }
-
-                    let colorsCompressed = null;
-
-                    if (attributesColor) {
-                        colorsCompressed = attributesColor.value;
-                    } else {
-
-                    }
-
-                    if (attributesIntensity) {
-                        const intensities = attributesIntensity.value;
-                        colorsCompressed = new Uint8Array(intensities.length * 4);
-
-                        if (attributesColor) { // Intensities with colors
-                            const colors = attributesColor.value;
-                            const colorsSize = attributesColor.size;
-                            for (let i = 0, j = 0, len = intensities.length; i < len; i++, j += 4) {
-                                const intensity = Math.round((intensities[i] / 65536) * 255); // FIXME: Precision loss converting intensity from 16 to 8 bits
-                                colorsCompressed[j + 0] = colors[i * colorsSize];
-                                colorsCompressed[j + 1] = colors[i * colorsSize + 1];
-                                colorsCompressed[j + 2] = colors[i * colorsSize + 2];
-                                colorsCompressed[j + 3] = intensity;
+                            positionsValue = readPositions(attributes.POSITION);
+                            colorsCompressed = readIntensities(attributes.intensity);
+                            break;
+                        case 2:
+                            if (!attributes.intensity) {
+                                performanceModel.finalize();
+                                reject("No positions found in file");
+                                return;
                             }
-                        } else { // Intensities without colors
-                            for (let i = 0, j = 0, len = intensities.length; i < len; i++, j += 4) {
-                                const intensity = Math.round((intensities[i] / 65536) * 255);
-                                colorsCompressed[j + 0] = 125; // Gray
-                                colorsCompressed[j + 1] = 125;
-                                colorsCompressed[j + 2] = 125;
-                                colorsCompressed[j + 3] = intensity;
+                            positionsValue = readPositions(attributes.POSITION);
+                            colorsCompressed = readColorsAndIntensities(attributes.COLOR_0, attributes.intensity);
+                            break;
+                        case 3:
+                            if (!attributes.intensity) {
+                                performanceModel.finalize();
+                                reject("No positions found in file");
+                                return;
                             }
-                        }
-                    } else if (attributesColor) { // Colors without intensities
-                        const colors = attributesColor.value;
-                        const colorsSize = attributesColor.size;
-                        for (let i = 0, j = 0, len = colors.length / colorsSize; i < len; i++, j += 4) {
-                            colorsCompressed[j + 0] = colors[i * colorsSize];
-                            colorsCompressed[j + 1] = colors[i * colorsSize + 1];
-                            colorsCompressed[j + 2] = colors[i * colorsSize + 2];
-                            colorsCompressed[j + 3] = (colorsSize === 4) ? colors[i * colorsSize + 3] : 255;
-                        }
+                            positionsValue = readPositions(attributes.POSITION);
+                            colorsCompressed = readColorsAndIntensities(attributes.COLOR_0, attributes.intensity);
+                            break;
                     }
 
                     performanceModel.createMesh({
                         id: "pointsMesh",
                         primitive: "points",
                         positions: positionsValue,
-                        colorsCompressed
+                        colorsCompressed: colorsCompressed
                     });
 
                     performanceModel.createEntity({
@@ -145904,7 +145927,6 @@ class LASLoaderPlugin extends Plugin {
 
                     // TODO: Create metamodel
 
-
                     performanceModel.scene.once("tick", () => {
                         if (performanceModel.destroyed) {
                             return;