@cesium/engine 7.0.0 → 9.0.0

package/Source/Scene/I3SNode.js

@@ -1,4 +1,5 @@
 import Cartographic from "../Core/Cartographic.js";
+import Check from "../Core/Check.js";
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import Ellipsoid from "../Core/Ellipsoid.js";
@@ -15,6 +16,16 @@ import I3SFeature from "./I3SFeature.js";
 import I3SField from "./I3SField.js";
 import I3SGeometry from "./I3SGeometry.js";
 
+/**
+ * @typedef {object} I3SNode.AttributeFilter
+ *
+ * A filter given by an attribute name and values.
+ * The 3D feature object should be hidden if its value for the attribute name is not specified in the collection of values.
+ *
+ * @property {string} name The name of the attribute
+ * @property {string[]|number[]} values The collection of values
+ */
+
 /**
  * This class implements an I3S Node. In CesiumJS each I3SNode creates a Cesium3DTile.
  * <p>
@@ -64,6 +75,7 @@ function I3SNode(parent, ref, isRoot) {
   this._globalTransform = undefined;
   this._inverseGlobalTransform = undefined;
   this._inverseRotationMatrix = undefined;
+  this._symbologyData = undefined;
 }
 
 Object.defineProperties(I3SNode.prototype, {
@@ -192,10 +204,7 @@ I3SNode.prototype.load = async function () {
 
   // If we don't have a nodepage index load from json
   if (!defined(this._nodeIndex)) {
-    const data = await I3SDataProvider.loadJson(
-      this._resource,
-      this._dataProvider._traceFetches
-    );
+    const data = await I3SDataProvider.loadJson(this._resource);
     that._data = data;
     processData();
     return;
@@ -217,6 +226,12 @@ I3SNode.prototype.load = async function () {
   processData();
 };
 
+function createAndLoadField(node, storageInfo) {
+  const newField = new I3SField(node, storageInfo);
+  node._fields[storageInfo.name] = newField;
+  return newField.load();
+}
+
 /**
  * Loads the node fields.
  * @returns {Promise<void>} A promise that is resolved when the I3S Node fields are loaded
@@ -225,23 +240,50 @@ I3SNode.prototype.loadFields = function () {
   // Check if we must load fields
   const fields = this._layer._data.attributeStorageInfo;
 
-  const that = this;
-  function createAndLoadField(fields, index) {
-    const newField = new I3SField(that, fields[index]);
-    that._fields[newField._storageInfo.name] = newField;
-    return newField.load();
-  }
-
   const promises = [];
   if (defined(fields)) {
     for (let i = 0; i < fields.length; i++) {
-      promises.push(createAndLoadField(fields, i));
+      const storageInfo = fields[i];
+      const field = this._fields[storageInfo.name];
+      if (defined(field)) {
+        promises.push(field.load());
+      } else {
+        promises.push(createAndLoadField(this, storageInfo));
+      }
     }
   }
 
   return Promise.all(promises);
 };
 
+/**
+ * Loads the node field.
+ * @param {string} name The field name
+ * @returns {Promise<void>} A promise that is resolved when the I3S Node field is loaded
+ */
+I3SNode.prototype.loadField = function (name) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("name", name);
+  //>>includeEnd('debug');
+
+  const field = this._fields[name];
+  if (defined(field)) {
+    return field.load();
+  }
+
+  const fields = this._layer._data.attributeStorageInfo;
+  if (defined(fields)) {
+    for (let i = 0; i < fields.length; i++) {
+      const storageInfo = fields[i];
+      if (storageInfo.name === name) {
+        return createAndLoadField(this, storageInfo);
+      }
+    }
+  }
+
+  return Promise.resolve();
+};
+
 /**
  * Returns the fields for a given picked position
  * @param {Cartesian3} pickedPosition The picked position
@@ -608,6 +650,15 @@ I3SNode.prototype._create3DTileDefinition = function () {
   return inPlaceTileDefinition;
 };
 
+/**
+ * @private
+ */
+I3SNode.prototype._loadSymbology = async function () {
+  if (!defined(this._symbologyData) && defined(this._layer._symbology)) {
+    this._symbologyData = await this._layer._symbology._getSymbology(this);
+  }
+};
+
 /**
  * @private
  */
@@ -646,6 +697,10 @@ I3SNode.prototype._createContentURL = async function () {
   await Promise.all(dataPromises);
   // Binary glTF
   if (defined(this._geometryData) && this._geometryData.length > 0) {
+    if (this._dataProvider._applySymbology) {
+      await this._loadSymbology();
+    }
+
     const url = this._geometryData[0].resource.url;
     const geometrySchema = this._layer._data.store.defaultGeometrySchema;
     const geometryData = this._geometryData[0];
@@ -653,7 +708,8 @@ I3SNode.prototype._createContentURL = async function () {
       url,
       geometrySchema,
       geometryData,
-      this._featureData[0]
+      this._featureData[0],
+      this._symbologyData
     );
     if (!defined(result)) {
       // Postponed
@@ -666,7 +722,9 @@ I3SNode.prototype._createContentURL = async function () {
       result.meshData.meshes,
       result.meshData.buffers,
       result.meshData.bufferViews,
-      result.meshData.accessors
+      result.meshData.accessors,
+      result.meshData.rootExtensions,
+      result.meshData.extensionsUsed
     );
 
     this._geometryData[0]._customAttributes = result.meshData._customAttributes;
@@ -679,6 +737,91 @@ I3SNode.prototype._createContentURL = async function () {
   return URL.createObjectURL(glbDataBlob);
 };
 
+async function loadFilters(node) {
+  const filters = node._layer._filters;
+  const promises = [];
+  for (let i = 0; i < filters.length; i++) {
+    const promise = node.loadField(filters[i].name);
+    promises.push(promise);
+  }
+  await Promise.all(promises);
+  return filters;
+}
+
+function checkFeatureValue(featureIndex, field, filter) {
+  if (!defined(filter.values) || filter.values.length === 0) {
+    return false;
+  }
+
+  const fieldValues = defined(field) ? field.values : [];
+  let featureValue;
+  if (featureIndex < fieldValues.length) {
+    featureValue = fieldValues[featureIndex];
+  }
+  let matches = false;
+  for (let i = 0; i < filter.values.length; i++) {
+    if (filter.values[i] === featureValue) {
+      matches = true;
+      break;
+    }
+  }
+  return matches;
+}
+
+async function filterFeatures(node, contentModel) {
+  const batchTable = node._tile.content.batchTable;
+  if (defined(batchTable) && batchTable.featuresLength > 0) {
+    batchTable.setAllShow(true);
+
+    const filters = await loadFilters(node);
+    if (filters.length > 0) {
+      for (
+        let featureIndex = 0;
+        featureIndex < batchTable.featuresLength;
+        featureIndex++
+      ) {
+        for (let filterIndex = 0; filterIndex < filters.length; filterIndex++) {
+          const filter = filters[filterIndex];
+          if (
+            !checkFeatureValue(featureIndex, node._fields[filter.name], filter)
+          ) {
+            batchTable.setShow(featureIndex, false);
+            break;
+          }
+        }
+      }
+    }
+  }
+  contentModel.show = true;
+}
+
+/**
+ * @private
+ */
+I3SNode.prototype._filterFeatures = function () {
+  const promises = [];
+  // Forced filtering is required for loaded nodes only
+  for (let i = 0; i < this._children.length; i++) {
+    const promise = this._children[i]._filterFeatures();
+    promises.push(promise);
+  }
+
+  // Filters are applied for nodes with geometry data only
+  const contentModel = this._tile?.content?._model;
+  if (
+    defined(this._geometryData) &&
+    this._geometryData.length > 0 &&
+    defined(contentModel) &&
+    contentModel.ready
+  ) {
+    // The model needs to be hidden till the filters are applied
+    contentModel.show = false;
+    const promise = filterFeatures(this, contentModel);
+    promises.push(promise);
+  }
+  return Promise.all(promises);
+};
+
 // Reimplement Cesium3DTile.prototype.requestContent so that
 // We get a chance to load our own gltf from I3S data
 Cesium3DTile.prototype._hookedRequestContent =
@@ -700,19 +843,33 @@ Cesium3DTile.prototype.requestContent = function () {
 
   if (!this._isLoading) {
     this._isLoading = true;
+    const that = this;
     return this._i3sNode
       ._createContentURL()
       .then((url) => {
         if (!defined(url)) {
-          this._isLoading = false;
+          that._isLoading = false;
           return;
         }
 
-        this._contentResource = new Resource({ url: url });
-        return this._hookedRequestContent();
+        that._contentResource = new Resource({ url: url });
+        return that._hookedRequestContent();
       })
       .then((content) => {
-        this._isLoading = false;
+        // Filters are applied for nodes with geometry data only
+        const contentModel = content?._model;
+        if (
+          defined(that._i3sNode._geometryData) &&
+          that._i3sNode._geometryData.length > 0 &&
+          defined(contentModel)
+        ) {
+          // The model needs to be hidden till the filters are applied
+          contentModel.show = false;
+          contentModel.readyEvent.addEventListener(() => {
+            filterFeatures(that._i3sNode, contentModel);
+          });
+        }
+        that._isLoading = false;
         return content;
       });
   }

package/Source/Scene/I3SStatistics.js

@@ -0,0 +1,94 @@
+import defined from "../Core/defined.js";
+import I3SDataProvider from "./I3SDataProvider.js";
+import Resource from "../Core/Resource.js";
+
+/**
+ * This class implements an I3S statistics for Building Scene Layer.
+ * <p>
+ * Do not construct this directly, instead access statistics through {@link I3SDataProvider}.
+ * </p>
+ * @alias I3SStatistics
+ * @internalConstructor
+ */
+function I3SStatistics(dataProvider, uri) {
+  this._dataProvider = dataProvider;
+
+  this._resource = new Resource({ url: uri });
+  this._resource.setQueryParameters(dataProvider.resource.queryParameters);
+  this._resource.appendForwardSlash();
+}
+
+Object.defineProperties(I3SStatistics.prototype, {
+  /**
+   * Gets the resource for the statistics
+   * @memberof I3SStatistics.prototype
+   * @type {Resource}
+   * @readonly
+   */
+  resource: {
+    get: function () {
+      return this._resource;
+    },
+  },
+
+  /**
+   * Gets the I3S data for this object.
+   * @memberof I3SStatistics.prototype
+   * @type {object}
+   * @readonly
+   */
+  data: {
+    get: function () {
+      return this._data;
+    },
+  },
+
+  /**
+   * Gets the collection of attribute names.
+   * @memberof I3SStatistics.prototype
+   * @type {string[]}
+   * @readonly
+   */
+  names: {
+    get: function () {
+      const names = [];
+      const summary = this._data.summary;
+      if (defined(summary)) {
+        for (let i = 0; i < summary.length; ++i) {
+          names.push(summary[i].fieldName);
+        }
+      }
+      return names;
+    },
+  },
+});
+
+/**
+ * Loads the content.
+ * @returns {Promise<object>} A promise that is resolved when the data of the I3S statistics is loaded
+ * @private
+ */
+I3SStatistics.prototype.load = async function () {
+  this._data = await I3SDataProvider.loadJson(this._resource);
+  return this._data;
+};
+
+/**
+ * @private
+ */
+I3SStatistics.prototype._getValues = function (attributeName) {
+  const summary = this._data.summary;
+  if (defined(summary)) {
+    for (let i = 0; i < summary.length; ++i) {
+      const attribute = summary[i];
+      if (attribute.fieldName === attributeName) {
+        if (defined(attribute.mostFrequentValues)) {
+          return [...attribute.mostFrequentValues];
+        }
+        return [];
+      }
+    }
+  }
+};
+
+export default I3SStatistics;

package/Source/Scene/I3SSublayer.js

@@ -0,0 +1,176 @@
+import Check from "../Core/Check.js";
+import defaultValue from "../Core/defaultValue.js";
+import defined from "../Core/defined.js";
+import I3SDataProvider from "./I3SDataProvider.js";
+import I3SLayer from "./I3SLayer.js";
+import Resource from "../Core/Resource.js";
+
+/**
+ * This class implements an I3S sublayer for Building Scene Layer.
+ * <p>
+ * This object is normally not instantiated directly, use {@link I3SSublayer.fromData}.
+ * </p>
+ * @alias I3SSublayer
+ * @internalConstructor
+ */
+function I3SSublayer(dataProvider, parent, sublayerData) {
+  this._dataProvider = dataProvider;
+  this._parent = parent;
+  this._data = sublayerData;
+  this._name = sublayerData.name;
+  this._modelName = sublayerData.modelName;
+  this._visibility = defaultValue(sublayerData.visibility, true);
+  this._resource = undefined;
+  this._sublayers = [];
+  this._i3sLayers = [];
+}
+
+Object.defineProperties(I3SSublayer.prototype, {
+  /**
+   * Gets the resource for the sublayer
+   * @memberof I3SSublayer.prototype
+   * @type {Resource}
+   * @readonly
+   */
+  resource: {
+    get: function () {
+      return this._resource;
+    },
+  },
+
+  /**
+   * Gets the I3S data for this object.
+   * @memberof I3SSublayer.prototype
+   * @type {object}
+   * @readonly
+   */
+  data: {
+    get: function () {
+      return this._data;
+    },
+  },
+
+  /**
+   * Gets the name for the sublayer.
+   * @memberof I3SSublayer.prototype
+   * @type {string}
+   * @readonly
+   */
+  name: {
+    get: function () {
+      return this._name;
+    },
+  },
+
+  /**
+   * Gets the model name for the sublayer.
+   * @memberof I3SSublayer.prototype
+   * @type {string}
+   * @readonly
+   */
+  modelName: {
+    get: function () {
+      return this._modelName;
+    },
+  },
+
+  /**
+   * Gets the collection of child sublayers.
+   * @memberof I3SSublayer.prototype
+   * @type {I3SSublayer[]}
+   * @readonly
+   */
+  sublayers: {
+    get: function () {
+      return this._sublayers;
+    },
+  },
+
+  /**
+   * Gets or sets the sublayer visibility.
+   * @memberof I3SSublayer.prototype
+   * @type {boolean}
+   */
+  visibility: {
+    get: function () {
+      return this._visibility;
+    },
+    set: function (value) {
+      //>>includeStart('debug', pragmas.debug);
+      Check.defined("value", value);
+      //>>includeEnd('debug');
+
+      if (this._visibility !== value) {
+        this._visibility = value;
+        for (let i = 0; i < this._i3sLayers.length; i++) {
+          this._i3sLayers[i]._updateVisibility();
+        }
+      }
+    },
+  },
+
+  /**
+   * Determines if the sublayer will be shown.
+   * @memberof I3SSublayer.prototype
+   * @type {boolean}
+   * @readonly
+   */
+  show: {
+    get: function () {
+      return this._visibility && this._parent.show;
+    },
+  },
+});
+
+/**
+ * @private
+ */
+I3SSublayer._fromData = async function (
+  dataProvider,
+  buildingLayerUrl,
+  sublayerData,
+  parent
+) {
+  const sublayer = new I3SSublayer(dataProvider, parent, sublayerData);
+  if (sublayer._data.layerType === "group") {
+    const sublayers = sublayer._data.sublayers;
+    if (defined(sublayers)) {
+      const promises = [];
+      for (let i = 0; i < sublayers.length; i++) {
+        const promise = I3SSublayer._fromData(
+          dataProvider,
+          buildingLayerUrl,
+          sublayers[i],
+          sublayer
+        );
+        promises.push(promise);
+      }
+      const childSublayers = await Promise.all(promises);
+      for (let i = 0; i < childSublayers.length; i++) {
+        const childSublayer = childSublayers[i];
+        sublayer._sublayers.push(childSublayer);
+        sublayer._i3sLayers.push(...childSublayer._i3sLayers);
+      }
+    }
+  } else if (sublayer._data.layerType === "3DObject") {
+    const sublayerUrl = buildingLayerUrl.concat(
+      `/sublayers/${sublayer._data.id}`
+    );
+    const resource = new Resource({ url: sublayerUrl });
+    resource.setQueryParameters(dataProvider.resource.queryParameters);
+    resource.appendForwardSlash();
+    sublayer._resource = resource;
+
+    const layerData = await I3SDataProvider.loadJson(sublayer._resource);
+    const layer = new I3SLayer(dataProvider, layerData, sublayer);
+    sublayer._i3sLayers.push(layer);
+  } else {
+    // Filter other scene layer types out
+    console.log(
+      `${sublayer._data.layerType} layer ${sublayer._data.name} is skipped as not supported.`
+    );
+  }
+  return sublayer;
+};
+
+export default I3SSublayer;