Added Draco support to point clouds

Apps/Sandcastle/gallery/3D Tiles Formats.html

@@ -82,6 +82,9 @@
         }, {
             name: 'PointCloudBatched',
             resource: Cesium.IonResource.fromAssetId(3878)
+        }, {
+            name: 'PointCloudDraco',
+            resource: Cesium.IonResource.fromAssetId(4702)
         }
     ],
     selectedTileset: undefined,

CHANGES.md

@@ -3,10 +3,13 @@ Change Log
 
 ### 1.48 - 2018-08-01
 
-#### Deprecated :hourglass_flowing_sand:
+##### Additions :tada:
+* Added support for loading Draco compressed Point Cloud tiles for 2-3x better compression. [#6559](https://github.com/AnalyticalGraphicsInc/cesium/pull/6559)
+
+##### Deprecated :hourglass_flowing_sand:
 * Support for 3D Tiles `content.url` is deprecated to reflect updates to the [3D Tiles spec](https://github.com/AnalyticalGraphicsInc/3d-tiles/pull/301). Use `content.uri instead`. Support for `content.url` will remain for backwards compatibility. [#6744](https://github.com/AnalyticalGraphicsInc/cesium/pull/6744)
 
-#### Fixes :wrench:
+##### Fixes :wrench:
 * Fixed bug causing billboards and labels to appear the wrong size when switching scene modes [#6745](https://github.com/AnalyticalGraphicsInc/cesium/issues/6745)
 
 ### 1.47 - 2018-07-02

Source/Scene/DracoLoader.js

@@ -203,7 +203,7 @@ define([
      * Schedules decoding tasks available this frame.
      * @private
      */
-    DracoLoader.decode = function(model, context) {
+    DracoLoader.decodeModel = function(model, context) {
         if (!DracoLoader.hasExtension(model)) {
             return when.resolve();
         }
@@ -245,6 +245,19 @@ define([
         return when.all(decodingPromises);
     };
 
+    /**
+     * Decodes a compressed point cloud. Returns undefined if the task cannot be scheduled.
+     * @private
+     */
+    DracoLoader.decodePointCloud = function(parameters) {
+        var decoderTaskProcessor = DracoLoader._getDecoderTaskProcessor();
+        if (!DracoLoader._taskProcessorReady) {
+            // The task processor is not ready to schedule tasks
+            return;
+        }
+        return decoderTaskProcessor.scheduleTask(parameters, [parameters.buffer.buffer]);
+    };
+
     /**
      * Caches a models decoded data so it doesn't need to decode more than once.
      * @private

Source/Scene/Model.js

@@ -4281,7 +4281,7 @@ define([
                 }
 
                 if (!loadResources.finishedDecoding()) {
-                    DracoLoader.decode(this, context)
+                    DracoLoader.decodeModel(this, context)
                         .otherwise(getFailedLoadFunction(this, 'model', this.basePath));
                 }
 

Source/Workers/decodeDraco.js

@@ -13,9 +13,8 @@ define([
     'use strict';
 
     var draco;
-    var dracoDecoder;
 
-    function decodeIndexArray(dracoGeometry) {
+    function decodeIndexArray(dracoGeometry, dracoDecoder) {
         var numPoints = dracoGeometry.num_points();
         var numFaces = dracoGeometry.num_faces();
         var faceIndices = new draco.DracoInt32Array();
@@ -40,15 +39,18 @@ define([
         };
     }
 
-    function decodeQuantizedDracoTypedArray(dracoGeometry, attribute, quantization, vertexArrayLength) {
+    function decodeQuantizedDracoTypedArray(dracoGeometry, dracoDecoder, dracoAttribute, quantization, vertexArrayLength) {
         var vertexArray;
-        var attributeData = new draco.DracoInt32Array();
-        if (quantization.octEncoded) {
-            vertexArray = new Int16Array(vertexArrayLength);
+        var attributeData;
+        if (quantization.quantizationBits <= 8) {
+            attributeData = new draco.DracoUInt8Array();
+            vertexArray = new Uint8Array(vertexArrayLength);
+            dracoDecoder.GetAttributeUInt8ForAllPoints(dracoGeometry, dracoAttribute, attributeData);
         } else {
+            attributeData = new draco.DracoUInt16Array();
             vertexArray = new Uint16Array(vertexArrayLength);
+            dracoDecoder.GetAttributeUInt16ForAllPoints(dracoGeometry, dracoAttribute, attributeData);
         }
-        dracoDecoder.GetAttributeInt32ForAllPoints(dracoGeometry, attribute, attributeData);
 
         for (var i = 0; i < vertexArrayLength; ++i) {
             vertexArray[i] = attributeData.GetValue(i);
@@ -58,46 +60,46 @@ define([
         return vertexArray;
     }
 
-    function decodeDracoTypedArray(dracoGeometry, attribute, vertexArrayLength) {
+    function decodeDracoTypedArray(dracoGeometry, dracoDecoder, dracoAttribute, vertexArrayLength) {
         var vertexArray;
         var attributeData;
 
         // Some attribute types are casted down to 32 bit since Draco only returns 32 bit values
-        switch (attribute.data_type()) {
+        switch (dracoAttribute.data_type()) {
             case 1: case 11: // DT_INT8 or DT_BOOL
                 attributeData = new draco.DracoInt8Array();
                 vertexArray = new Int8Array(vertexArrayLength);
-                dracoDecoder.GetAttributeInt8ForAllPoints(dracoGeometry, attribute, attributeData);
+                dracoDecoder.GetAttributeInt8ForAllPoints(dracoGeometry, dracoAttribute, attributeData);
                 break;
             case 2: // DT_UINT8
                 attributeData = new draco.DracoUInt8Array();
                 vertexArray = new Uint8Array(vertexArrayLength);
-                dracoDecoder.GetAttributeUInt8ForAllPoints(dracoGeometry, attribute, attributeData);
+                dracoDecoder.GetAttributeUInt8ForAllPoints(dracoGeometry, dracoAttribute, attributeData);
                 break;
             case 3: // DT_INT16
                 attributeData = new draco.DracoInt16Array();
                 vertexArray = new Int16Array(vertexArrayLength);
-                dracoDecoder.GetAttributeInt16ForAllPoints(dracoGeometry, attribute, attributeData);
+                dracoDecoder.GetAttributeInt16ForAllPoints(dracoGeometry, dracoAttribute, attributeData);
                 break;
             case 4: // DT_UINT16
                 attributeData = new draco.DracoUInt16Array();
                 vertexArray = new Uint16Array(vertexArrayLength);
-                dracoDecoder.GetAttributeUInt16ForAllPoints(dracoGeometry, attribute, attributeData);
+                dracoDecoder.GetAttributeUInt16ForAllPoints(dracoGeometry, dracoAttribute, attributeData);
                 break;
             case 5: case 7: // DT_INT32 or DT_INT64
                 attributeData = new draco.DracoInt32Array();
                 vertexArray = new Int32Array(vertexArrayLength);
-                dracoDecoder.GetAttributeInt32ForAllPoints(dracoGeometry, attribute, attributeData);
+                dracoDecoder.GetAttributeInt32ForAllPoints(dracoGeometry, dracoAttribute, attributeData);
                 break;
             case 6: case 8: // DT_UINT32 or DT_UINT64
-                attributeData = new draco.DracoUint32Array();
+                attributeData = new draco.DracoUInt32Array();
                 vertexArray = new Uint32Array(vertexArrayLength);
-                dracoDecoder.GetAttributeUInt32ForAllPoints(dracoGeometry, attribute, attributeData);
+                dracoDecoder.GetAttributeUInt32ForAllPoints(dracoGeometry, dracoAttribute, attributeData);
                 break;
             case 9: case 10: // DT_FLOAT32 or DT_FLOAT64
                 attributeData = new draco.DracoFloat32Array();
                 vertexArray = new Float32Array(vertexArrayLength);
-                dracoDecoder.GetAttributeFloatForAllPoints(dracoGeometry, attribute, attributeData);
+                dracoDecoder.GetAttributeFloatForAllPoints(dracoGeometry, dracoAttribute, attributeData);
                 break;
         }
 
@@ -109,72 +111,103 @@ define([
         return vertexArray;
     }
 
-    function decodeAttributeData(dracoGeometry, compressedAttributes) {
+    function decodeAttribute(dracoGeometry, dracoDecoder, dracoAttribute) {
         var numPoints = dracoGeometry.num_points();
-        var decodedAttributeData = {};
-        var vertexArray;
+        var numComponents = dracoAttribute.num_components();
+
         var quantization;
-        for (var attributeName in compressedAttributes) {
-            if (compressedAttributes.hasOwnProperty(attributeName)) {
-                var compressedAttribute = compressedAttributes[attributeName];
-                var attribute = dracoDecoder.GetAttributeByUniqueId(dracoGeometry, compressedAttribute);
-                var numComponents = attribute.num_components();
-
-                var i;
-                var transform = new draco.AttributeQuantizationTransform();
-                if (transform.InitFromAttribute(attribute)) {
-                    var minValues = new Array(numComponents);
-                    for (i = 0; i < numComponents; ++i) {
-                        minValues[i] = transform.min_value(i);
-                    }
+        var transform = new draco.AttributeQuantizationTransform();
+        if (transform.InitFromAttribute(dracoAttribute)) {
+            var minValues = new Array(numComponents);
+            for (var i = 0; i < numComponents; ++i) {
+                minValues[i] = transform.min_value(i);
+            }
+            quantization = {
+                quantizationBits : transform.quantization_bits(),
+                minValues : minValues,
+                range : transform.range(),
+                octEncoded : false
+            };
+        }
+        draco.destroy(transform);
+
+        transform = new draco.AttributeOctahedronTransform();
+        if (transform.InitFromAttribute(dracoAttribute)) {
+            quantization = {
+                quantizationBits : transform.quantization_bits(),
+                octEncoded : true
+            };
+        }
+        draco.destroy(transform);
 
-                    quantization = {
-                        quantizationBits : transform.quantization_bits(),
-                        minValues : minValues,
-                        range : transform.range(),
-                        octEncoded : false
-                    };
-                }
-                draco.destroy(transform);
-
-                transform = new draco.AttributeOctahedronTransform();
-                if (transform.InitFromAttribute(attribute)) {
-                    quantization = {
-                        quantizationBits : transform.quantization_bits(),
-                        octEncoded : true
-                    };
-                }
-                draco.destroy(transform);
+        var vertexArrayLength = numPoints * numComponents;
+        var vertexArray;
+        if (defined(quantization)) {
+            vertexArray = decodeQuantizedDracoTypedArray(dracoGeometry, dracoDecoder, dracoAttribute, quantization, vertexArrayLength);
+        } else {
+            vertexArray = decodeDracoTypedArray(dracoGeometry, dracoDecoder, dracoAttribute, vertexArrayLength);
+        }
 
-                var vertexArrayLength = numPoints * numComponents;
-                if (defined(quantization)) {
-                    vertexArray = decodeQuantizedDracoTypedArray(dracoGeometry, attribute, quantization, vertexArrayLength);
-                } else {
-                    vertexArray = decodeDracoTypedArray(dracoGeometry, attribute, vertexArrayLength);
-                }
+        var componentDatatype = ComponentDatatype.fromTypedArray(vertexArray);
 
-                var componentDatatype = ComponentDatatype.fromTypedArray(vertexArray);
-                decodedAttributeData[attributeName] = {
-                    array : vertexArray,
-                    data : {
-                        componentsPerAttribute : numComponents,
-                        componentDatatype : componentDatatype,
-                        byteOffset : attribute.byte_offset(),
-                        byteStride : ComponentDatatype.getSizeInBytes(componentDatatype) * numComponents,
-                        normalized : attribute.normalized(),
-                        quantization : quantization
-                    }
-                };
+        return {
+            array : vertexArray,
+            data : {
+                componentsPerAttribute : numComponents,
+                componentDatatype : componentDatatype,
+                byteOffset : dracoAttribute.byte_offset(),
+                byteStride : ComponentDatatype.getSizeInBytes(componentDatatype) * numComponents,
+                normalized : dracoAttribute.normalized(),
+                quantization : quantization
+            }
+        };
+    }
 
-                quantization = undefined;
+    function decodePointCloud(parameters) {
+        var dracoDecoder = new draco.Decoder();
+
+        if (parameters.dequantizeInShader) {
+            dracoDecoder.SkipAttributeTransform(draco.POSITION);
+            dracoDecoder.SkipAttributeTransform(draco.NORMAL);
+        }
+
+        var buffer = new draco.DecoderBuffer();
+        buffer.Init(parameters.buffer, parameters.buffer.length);
+
+        var geometryType = dracoDecoder.GetEncodedGeometryType(buffer);
+        if (geometryType !== draco.POINT_CLOUD) {
+            throw new RuntimeError('Draco geometry type must be POINT_CLOUD.');
+        }
+
+        var dracoPointCloud = new draco.PointCloud();
+        var decodingStatus = dracoDecoder.DecodeBufferToPointCloud(buffer, dracoPointCloud);
+        if (!decodingStatus.ok() || dracoPointCloud.ptr === 0) {
+            throw new RuntimeError('Error decoding draco point cloud: ' + decodingStatus.error_msg());
+        }
+
+        draco.destroy(buffer);
+
+        var result = {};
+
+        var properties = parameters.properties;
+        for (var propertyName in properties) {
+            if (properties.hasOwnProperty(propertyName)) {
+                var attributeId = properties[propertyName];
+                var dracoAttribute = dracoDecoder.GetAttributeByUniqueId(dracoPointCloud, attributeId);
+                result[propertyName] = decodeAttribute(dracoPointCloud, dracoDecoder, dracoAttribute);
             }
         }
 
-        return decodedAttributeData;
+        draco.destroy(dracoPointCloud);
+        draco.destroy(dracoDecoder);
+
+        return result;
     }
 
-    function decodeDracoPrimitive(parameters) {
-        // Skip all paramter types except generic
+    function decodePrimitive(parameters) {
+        var dracoDecoder = new draco.Decoder();
+
+        // Skip all parameter types except generic
         var attributesToSkip = ['POSITION', 'NORMAL', 'COLOR', 'TEX_COORD'];
         if (parameters.dequantizeInShader) {
             for (var i = 0; i < attributesToSkip.length; ++i) {
@@ -199,20 +232,38 @@ define([
 
         draco.destroy(buffer);
 
+        var attributeData = {};
+
+        var compressedAttributes = parameters.compressedAttributes;
+        for (var attributeName in compressedAttributes) {
+            if (compressedAttributes.hasOwnProperty(attributeName)) {
+                var compressedAttribute = compressedAttributes[attributeName];
+                var dracoAttribute = dracoDecoder.GetAttributeByUniqueId(dracoGeometry, compressedAttribute);
+                attributeData[attributeName] = decodeAttribute(dracoGeometry, dracoDecoder, dracoAttribute);
+            }
+        }
+
         var result = {
-            indexArray : decodeIndexArray(dracoGeometry),
-            attributeData : decodeAttributeData(dracoGeometry, parameters.compressedAttributes)
+            indexArray : decodeIndexArray(dracoGeometry, dracoDecoder),
+            attributeData : attributeData
         };
 
         draco.destroy(dracoGeometry);
+        draco.destroy(dracoDecoder);
 
         return result;
     }
 
+    function decode(parameters) {
+        if (defined(parameters.primitive)) {
+            return decodePrimitive(parameters);
+        }
+        return decodePointCloud(parameters);
+    }
+
     function initWorker(dracoModule) {
         draco = dracoModule;
-        dracoDecoder = new draco.Decoder();
-        self.onmessage = createTaskProcessorWorker(decodeDracoPrimitive);
+        self.onmessage = createTaskProcessorWorker(decode);
         self.postMessage(true);
     }
 

Specs/Data/Cesium3DTiles/PointCloud/PointCloudDraco/tileset.json

@@ -0,0 +1,27 @@
+{
+  "asset": {
+    "version": "1.0"
+  },
+  "extensionsUsed": [
+    "3DTILES_draco_point_compression"
+  ],
+  "extensionsRequired": [
+    "3DTILES_draco_point_compression"
+  ],
+  "geometricError": 17.32,
+  "root": {
+    "refine": "ADD",
+    "boundingVolume": {
+      "sphere": [
+        1215012.8828876738,
+        -4736313.051199594,
+        4081605.22126042,
+        5
+      ]
+    },
+    "geometricError": 0,
+    "content": {
+      "uri": "pointCloudDraco.pnts"
+    }
+  }
+}