Merge pull request #1222 from CesiumGS/more-tileset-parsing

Make more properties from tileset.json available on `TilesetMetadata`

Author: j9liu

CHANGES.md

@@ -13,6 +13,7 @@
 
 - Added `element_type` to `IntrusivePointer`, allowing it to be used with `std::pointer_types`.
 - Added implicit conversion of `IntrusivePointer<T>` to `T*`.
+- All properties and extensions from `tileset.json`, except `"root"`, are now parsed into `TilesetMetadata` when a tileset is loaded by `Cesium3DTilesSelection::Tileset`.
 
 ##### Fixes :wrench:
 

Cesium3DTilesSelection/include/Cesium3DTilesSelection/TilesetMetadata.h

@@ -1,12 +1,17 @@
 #pragma once
 
+#include <Cesium3DTiles/Asset.h>
 #include <Cesium3DTiles/GroupMetadata.h>
+#include <Cesium3DTiles/Properties.h>
 #include <Cesium3DTiles/Schema.h>
+#include <Cesium3DTiles/Statistics.h>
 #include <Cesium3DTilesSelection/Library.h>
 #include <CesiumAsync/SharedFuture.h>
+#include <CesiumUtility/ExtensibleObject.h>
 
 #include <optional>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 namespace CesiumAsync {
@@ -18,12 +23,24 @@ namespace Cesium3DTilesSelection {
 
 /**
  * @brief Holds the metadata associated with a {@link Tileset} or an external
- * tileset.
+ * tileset. This holds all of the fields of {@link Cesium3DTiles::Tileset}
+ * except for the root tile.
  */
-class CESIUM3DTILESSELECTION_API TilesetMetadata {
+class CESIUM3DTILESSELECTION_API TilesetMetadata
+    : public CesiumUtility::ExtensibleObject {
 public:
   ~TilesetMetadata() noexcept;
 
+  /**
+   * @brief Metadata about the entire tileset.
+   */
+  Cesium3DTiles::Asset asset;
+
+  /**
+   * @brief A dictionary object of metadata about per-feature properties.
+   */
+  std::unordered_map<std::string, Cesium3DTiles::Properties> properties;
+
   /**
    * @brief An object defining the structure of metadata classes and enums. When
    * this is defined, then `schemaUri` shall be undefined.
@@ -36,6 +53,11 @@ class CESIUM3DTILESSELECTION_API TilesetMetadata {
    */
   std::optional<std::string> schemaUri;
 
+  /**
+   * @brief An object containing statistics about metadata entities.
+   */
+  std::optional<Cesium3DTiles::Statistics> statistics;
+
   /**
    * @brief An array of groups that tile content may belong to. Each element of
    * this array is a metadata entity that describes the group. The tile content
@@ -48,6 +70,24 @@ class CESIUM3DTILESSELECTION_API TilesetMetadata {
    */
   std::optional<Cesium3DTiles::MetadataEntity> metadata;
 
+  /**
+   * @brief The error, in meters, introduced if this tileset is not rendered. At
+   * runtime, the geometric error is used to compute screen space error (SSE),
+   * i.e., the error measured in pixels.
+   */
+  std::optional<double> geometricError;
+
+  /**
+   * @brief Names of 3D Tiles extensions used somewhere in this tileset.
+   */
+  std::vector<std::string> extensionsUsed;
+
+  /**
+   * @brief Names of 3D Tiles extensions required to properly load this tileset.
+   * Each element of this array shall also be contained in `extensionsUsed`.
+   */
+  std::vector<std::string> extensionsRequired;
+
   /**
    * @brief Asynchronously loads the {@link schema} from the {@link schemaUri}.
    * If the {@link schemaUri} does not contain a value, this method does

Cesium3DTilesSelection/src/TilesetContentManager.cpp

@@ -847,7 +847,7 @@ TilesetContentManager::TilesetContentManager(
                            pLogger,
                            url,
                            pCompletedRequest->headers(),
-                           tilesetJson,
+                           std::move(tilesetJson),
                            ellipsoid)
                     .thenImmediately(
                         [](TilesetContentLoaderResult<TilesetContentLoader>&&

Cesium3DTilesSelection/src/TilesetJsonLoader.cpp

@@ -12,9 +12,7 @@
 #include <Cesium3DTilesReader/BoundingVolumeReader.h>
 #include <Cesium3DTilesReader/ContentReader.h>
 #include <Cesium3DTilesReader/ExtensionContent3dTilesContentVoxelsReader.h>
-#include <Cesium3DTilesReader/GroupMetadataReader.h>
-#include <Cesium3DTilesReader/MetadataEntityReader.h>
-#include <Cesium3DTilesReader/SchemaReader.h>
+#include <Cesium3DTilesReader/TilesetReader.h>
 #include <Cesium3DTilesSelection/BoundingVolume.h>
 #include <Cesium3DTilesSelection/Tile.h>
 #include <Cesium3DTilesSelection/TileContent.h>
@@ -24,6 +22,7 @@
 #include <Cesium3DTilesSelection/TilesetContentLoader.h>
 #include <Cesium3DTilesSelection/TilesetContentLoaderResult.h>
 #include <Cesium3DTilesSelection/TilesetExternals.h>
+#include <Cesium3DTilesSelection/TilesetMetadata.h>
 #include <CesiumAsync/AsyncSystem.h>
 #include <CesiumAsync/HttpHeaders.h>
 #include <CesiumAsync/IAssetAccessor.h>
@@ -60,6 +59,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
+#include <iterator>
 #include <memory>
 #include <optional>
 #include <span>
@@ -710,41 +710,55 @@ TilesetContentLoaderResult<TilesetJsonLoader> parseTilesetJson(
       ErrorList{}};
 }
 
-void parseTilesetMetadata(
+void removeRootPropertyAndParseTilesetMetadata(
+    const std::shared_ptr<spdlog::logger>& pLogger,
     const std::string& baseUrl,
-    const rapidjson::Document& tilesetJson,
+    rapidjson::Document&& tilesetJson,
     TileExternalContent& externalContent) {
-  auto schemaIt = tilesetJson.FindMember("schema");
-  if (schemaIt != tilesetJson.MemberEnd()) {
-    Cesium3DTilesReader::SchemaReader schemaReader;
-    auto schemaResult = schemaReader.readFromJson(schemaIt->value);
-    if (schemaResult.value) {
-      externalContent.metadata.schema = std::move(*schemaResult.value);
-    }
-  }
-
-  auto schemaUriIt = tilesetJson.FindMember("schemaUri");
-  if (schemaUriIt != tilesetJson.MemberEnd() && schemaUriIt->value.IsString()) {
-    externalContent.metadata.schemaUri =
-        CesiumUtility::Uri::resolve(baseUrl, schemaUriIt->value.GetString());
-  }
-
-  const auto metadataIt = tilesetJson.FindMember("metadata");
-  if (metadataIt != tilesetJson.MemberEnd()) {
-    Cesium3DTilesReader::MetadataEntityReader metadataReader;
-    auto metadataResult = metadataReader.readFromJson(metadataIt->value);
-    if (metadataResult.value) {
-      externalContent.metadata.metadata = std::move(*metadataResult.value);
-    }
+  // Remove the root tile from the RapidJSON document. Parsing the complete tile
+  // tree will take too long, and we don't need it.
+  tilesetJson.RemoveMember("root");
+
+  Cesium3DTilesReader::TilesetReader tilesetReader;
+  auto tilesetResult = tilesetReader.readFromJson(tilesetJson);
+
+  if (!tilesetResult.errors.empty() || !tilesetResult.warnings.empty()) {
+    ErrorList errorList;
+    errorList.warnings.resize(
+        tilesetResult.errors.size() + tilesetResult.warnings.size());
+    std::copy(
+        std::make_move_iterator(tilesetResult.errors.begin()),
+        std::make_move_iterator(tilesetResult.errors.end()),
+        errorList.warnings.begin());
+    std::copy(
+        std::make_move_iterator(tilesetResult.warnings.begin()),
+        std::make_move_iterator(tilesetResult.warnings.end()),
+        errorList.warnings.begin() + std::vector<std::string>::difference_type(
+                                         tilesetResult.errors.size()));
+    errorList.logWarning(pLogger, "Could not parse metadata from tileset.json");
   }
 
-  const auto groupsIt = tilesetJson.FindMember("groups");
-  if (groupsIt != tilesetJson.MemberEnd()) {
-    Cesium3DTilesReader::GroupMetadataReader groupMetadataReader;
-    auto groupsResult = groupMetadataReader.readArrayFromJson(groupsIt->value);
-    if (groupsResult.value) {
-      externalContent.metadata.groups = std::move(*groupsResult.value);
+  if (tilesetResult.value) {
+    Cesium3DTiles::Tileset& tileset = *tilesetResult.value;
+    Cesium3DTilesSelection::TilesetMetadata& metadata =
+        externalContent.metadata;
+
+    metadata.asset = std::move(tileset.asset);
+    metadata.extensions = std::move(tileset.extensions);
+    metadata.extensionsRequired = std::move(tileset.extensionsRequired);
+    metadata.extensionsUsed = std::move(tileset.extensionsUsed);
+    metadata.extras = std::move(tileset.extras);
+    metadata.geometricError = tileset.geometricError;
+    metadata.groups = std::move(tileset.groups);
+    metadata.metadata = std::move(tileset.metadata);
+    metadata.properties = std::move(tileset.properties);
+    metadata.schema = std::move(tileset.schema);
+    if (tileset.schemaUri) {
+      metadata.schemaUri =
+          CesiumUtility::Uri::resolve(baseUrl, *tileset.schemaUri);
     }
+    metadata.statistics = std::move(tileset.statistics);
+    metadata.unknownProperties = std::move(tileset.unknownProperties);
   }
 }
 
@@ -792,9 +806,10 @@ TileLoadResult parseExternalTilesetInWorkerThread(
           ellipsoid);
 
   // Populate the root tile with metadata
-  parseTilesetMetadata(
+  removeRootPropertyAndParseTilesetMetadata(
+      pLogger,
       tileUrl,
-      tilesetJson,
+      std::move(tilesetJson),
       externalContentInitializer.externalContent);
 
   // check and log any errors
@@ -893,7 +908,7 @@ TilesetJsonLoader::createLoader(
             pLogger,
             pCompletedRequest->url(),
             pCompletedRequest->headers(),
-            tilesetJson,
+            std::move(tilesetJson),
             ellipsoid);
       });
 }
@@ -905,7 +920,7 @@ TilesetJsonLoader::createLoader(
     const std::shared_ptr<spdlog::logger>& pLogger,
     const std::string& tilesetJsonUrl,
     const CesiumAsync::HttpHeaders& requestHeaders,
-    const rapidjson::Document& tilesetJson,
+    rapidjson::Document&& tilesetJson,
     const CesiumGeospatial::Ellipsoid& ellipsoid) {
   TilesetContentLoaderResult<TilesetJsonLoader> result = parseTilesetJson(
       pLogger,
@@ -963,7 +978,11 @@ TilesetJsonLoader::createLoader(
       result.pRootTile->getContent().getExternalContent();
   CESIUM_ASSERT(pExternal);
   if (pExternal) {
-    parseTilesetMetadata(tilesetJsonUrl, tilesetJson, *pExternal);
+    removeRootPropertyAndParseTilesetMetadata(
+        pLogger,
+        tilesetJsonUrl,
+        std::move(tilesetJson),
+        *pExternal);
   }
 
   return asyncSystem.createResolvedFuture(std::move(result))

Cesium3DTilesSelection/src/TilesetJsonLoader.h

@@ -49,7 +49,7 @@ class TilesetJsonLoader : public TilesetContentLoader {
       const std::shared_ptr<spdlog::logger>& pLogger,
       const std::string& tilesetJsonUrl,
       const CesiumAsync::HttpHeaders& requestHeaders,
-      const rapidjson::Document& tilesetJson,
+      rapidjson::Document&& tilesetJson,
       const CesiumGeospatial::Ellipsoid& ellipsoid CESIUM_DEFAULT_ELLIPSOID);
 
 protected: