OGC3DTilesTileset.cpp

#include "OGC3DTilesTileset.h"
 
#include "Context.h"
#include "Engine.h"
 
#include <Foundation/Logging/Logger.h>
#include <Serialization/JsonParser.h>
 
#include <glm/gtc/type_ptr.hpp>
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("OGC3DTilesTileset");
}
 
using namespace Cogs::Core;
using namespace Cogs::Core::OGC3DTilesTileset;
 
OGC3DTiles::BoundingVolume
parseBoundingVolumeJSON(const Value& value)
{
  OGC3DTiles::BoundingVolume bv;
  bv.type = OGC3DTiles::BoundingVolumeType::UNKNOWN;
 
  if (!value.IsObject()) {
    LOG_ERROR(logger, "The 'BoundingVolume' object cannot be an array.");
    return bv;
  }
 
  for (Value::ConstMemberIterator itr = value.MemberBegin(); itr != value.MemberEnd(); ++itr) {
    std::string key = std::string(itr->name.GetString());
 
    if (key != "extensions" && !itr->value.IsArray()) {
      LOG_ERROR(logger, "Value of boundingVolume box/region/sphere is not an array (key=%s)", key.c_str());
      continue;
    }
 
    int i = 0;
    if (key == "box") {
      auto array = itr->value.GetArray();
      if (array.Size() != 12) {
        LOG_ERROR(logger, "Bounding volume box array does not contain 12 elements");
        continue;
      }
      bv.type = OGC3DTiles::BoundingVolumeType::BOX;
      for (auto& v : array) {
        bv.values[i++] = v.GetDouble();
      }
    }
    else if (key == "region") {
      bv.type = OGC3DTiles::BoundingVolumeType::REGION;
      auto array = itr->value.GetArray();
      if (array.Size() != 6) {
        LOG_ERROR(logger, "Bounding volume region array does not contain 6 elements");
        continue;
      }
      for (auto& v : array) {
        bv.values[i++] = v.GetDouble();
      }
    }
    else if (key == "sphere") {
      bv.type = OGC3DTiles::BoundingVolumeType::SPHERE;
      auto array = itr->value.GetArray();
      if (array.Size() != 4) {
        LOG_ERROR(logger, "Bounding volume sphere array does not contain 4 elements");
        continue;
      }
      for (auto& v : array) {
        bv.values[i++] = v.GetDouble();
      }
    }
    else if (key == "extensions" || key == "extras") {
      // Ignored for now
    }
    else {
      // Sometimes the "boundingVolume" struct will only contain an "extensions" dict, nothing else.
      LOG_WARNING(logger, "Unknown BoundingVolume type: '%s'", key.c_str());
    }
  }
 
  return bv;
}
 
Content
parseContentJSON(const Value& value)
{
  Content content;
  if (!value.IsObject()) {
    LOG_ERROR(logger, "The 'Content' object cannot be an array.");
    return content;
  }
 
  for (Value::ConstMemberIterator itr = value.MemberBegin(); itr != value.MemberEnd(); ++itr) {
    std::string key = std::string(itr->name.GetString());
    if (key == "uri") {
      if (!itr->value.IsString()) {
        LOG_ERROR(logger, "The member 'uri' is not a string");
        continue;
      }
      content.URI = std::string(itr->value.GetString());
    }
    else if (key == "group") {
      if (!itr->value.IsString()) {
        LOG_ERROR(logger, "The member 'group' is not an integer");
        continue;
      }
      content.group = itr->value.GetInt();
    }
    // FIXME: "boundingVolume" for a "content" section is not the same as for a "tile". It is a more snug bbox which
    // encompass the actual geometry. It is however optional and could contain other meta-data. Ignored for now.
    /*
    else if (key == "boundingVolume") {
      content.boundingVolume = parseBoundingVolumeJSON(itr->value["boundingVolume"]);
    }
    */
  }
 
  return content;
}
 
ImplicitTiling
parseImplicitTilingJSON(const Value& value)
{
  ImplicitTiling implicitTiling;
  if (!value.IsObject()) {
    LOG_ERROR(logger, "The 'ImplicitTiling' object cannot be an array.");
    return implicitTiling;
  }
 
  for (Value::ConstMemberIterator itr = value.MemberBegin(); itr != value.MemberEnd(); ++itr) {
    std::string key = std::string(itr->name.GetString());
    if (key == "subdivisionScheme") {
      if (!itr->value.IsString()) {
        LOG_ERROR(logger, "The member 'subdivisionScheme' is not a string");
        continue;
      }
      implicitTiling.isOctTree = std::string(itr->value.GetString()) == "OCTREE";
    }
    else if (key == "availableLevels") {
      if (!itr->value.IsInt()) {
        LOG_ERROR(logger, "The member 'availableLevels' is not an integer");
        continue;
      }
      implicitTiling.availableLevels = (uint8_t)itr->value.GetInt();
 
      // FIXME: We should ensure that number of available levels does not exceed our "Morton Index" calculator
      // ie. 16 bits. => (16-1)=15 levels capacity for quadtrees, less for octtrees.
      if (implicitTiling.availableLevels > 15) {
        /*
          We'll only print a warning here as not all datasets rely on the Avilability bitmap and therefore won't use
          the Morton-indexing at all.
        */
        LOG_WARNING(logger, "The number of levels is %d. When the depth exceeds 15 there might be issues with the indexing.",
          implicitTiling.availableLevels);
      }
    }
    else if (key == "subtreeLevels") {
      if (!itr->value.IsInt()) {
        LOG_ERROR(logger, "The member 'subtreeLevels' is not an integer");
        continue;
      }
      implicitTiling.subtreeLevels = (uint8_t)itr->value.GetInt();
    }
    else if (key == "subtrees") {
      if (!itr->value["uri"].IsString()) {
        LOG_ERROR(logger, "The member 'uri' is not a string");
        continue;
      }
      implicitTiling.subTreeURLScheme = itr->value["uri"].GetString();
    }
  }
 
  return implicitTiling;
}
 
std::vector<Content>
parseContentsJSON(const Value& value)
{
  std::vector<Content> contents;
 
  if (!value.IsArray()) {
    LOG_ERROR(logger, "The 'Contents' object must be an array.");
    return contents;
  }
 
  auto array = value.GetArray();
  contents.reserve(array.Size());
 
  for (auto& c : array) {
    contents.emplace_back(parseContentJSON(c));
  }
 
  return contents;
}
 
Tile
parseTileJSON(const Value& value)
{
  Tile tile;
  tile.transform = glm::identity<glm::dmat4>();
  tile.useImplicitTiling = false;
 
  if (!value.IsObject()) {
    LOG_ERROR(logger, "The 'Tile' object cannot be an array.");
    return tile;
  }
 
  for (Value::ConstMemberIterator itr = value.MemberBegin(); itr != value.MemberEnd(); ++itr) {
    std::string key = std::string(itr->name.GetString());
    if (key == "geometricError") {
      tile.geometricError = static_cast<float>(itr->value.GetDouble());
    }
    else if (key == "refine") {
      tile.refine = std::string(itr->value.GetString()) == "ADD" ? RefineType::ADD : RefineType::REPLACE;
    }
    else if (key == "transform") {
      auto array = itr->value.GetArray();
 
      if (array.Size() != 16) {
        LOG_ERROR(logger, "Transform matrix array does not contain 16 elements");
        continue;
      }
 
      int i = 0;
      double tmp[16];
      for (auto& v : array) {
        tmp[i++] = v.GetDouble();
      }
 
      tile.transform = glm::make_mat4(tmp);
    }
    else if (key == "boundingVolume") {
      tile.boundingVolume = parseBoundingVolumeJSON(value["boundingVolume"]);
    }
    else if (key == "content") {
      tile.contents.emplace_back(parseContentJSON(value["content"]));
    }
    else if (key == "contents") {
      //FIXME: It is illegal to have BOTH "content" and "contents". We should check for this.
      std::vector<Content> contents = parseContentsJSON(value["contents"]);
      tile.contents.reserve(tile.contents.size() + contents.size());
      for (Content& c : contents) {
        tile.contents.emplace_back(c);
      }
    }
    else if (key == "children") {
      if (!itr->value.IsArray()) {
        LOG_ERROR(logger, "The 'children' object must be an array.");
        continue;
      }
 
      auto array = itr->value.GetArray();
      tile.children.reserve(array.Size());
      for (Value::ConstValueIterator itr2 = array.Begin(); itr2 != array.End(); ++itr2) {
        Tile childTile = parseTileJSON(*itr2);
        if (childTile.refine == RefineType::DEFAULT) {
          childTile.refine = tile.refine; // Inherit value from parent if not specified
        }
        tile.children.emplace_back(childTile);
      }
    }
    else if (key == "implicitTiling") { // This part is optional
      tile.useImplicitTiling = true;
      tile.implicitTiling = parseImplicitTilingJSON(value["implicitTiling"]);
      LOG_DEBUG(logger, "Tileset uses implicit tiling (%s)", tile.implicitTiling.isOctTree ? "octtree" : "quadtree");
    }
  }
 
  return tile;
}
 
//
// ============================================================================================================
//
 
bool
parseJSON(std::string_view json, Tileset* tileset)
{
  Document doc = parseJson(json, JsonParseFlags::None);
 
  if (doc.HasMember("asset")) {
    GenericObject asset = doc["asset"].GetObject();
    tileset->version = asset["version"].GetString();
 
    if (tileset->version == "1.0") {
      LOG_WARNING(logger, "Tileset is version 1.0 which is not fully tested. Upgrade to 1.1 if possible");
    }
 
    if (asset.HasMember("gltfUpAxis")) {
      LOG_WARNING(logger, "Tileset is using the unofficial/unsupported 'gltfUpAxis' setting ('gltfUpAxis'=%s).", asset["gltfUpAxis"].GetString());
    }
  }
  else {
    LOG_ERROR(logger, "No geometricError asset in tileset");
    return false;
  }
 
  if (doc.HasMember("root")) {
    tileset->root = parseTileJSON(doc["root"].GetObject());
  }
  else {
    LOG_ERROR(logger, "No root attribute in tileset");
    return false;
  }
 
  tileset->geometricError = 0.0;
  if (doc.HasMember("geometricError")) {
    tileset->geometricError = doc["geometricError"].GetFloat();
  }
 
  return true;
}
 
Cogs::Core::DataFetcherManager::FetchId
OGC3DTilesTileset::fetch(Context* context, const std::string& URL, FetchCallback callback)
{
  LOG_INFO(logger, "Fetching tileset: '%s'", URL.c_str());
  Cogs::Core::DataFetcherManager::FetchId fetchId = DataFetcherManager::fetchAsync(context, URL,
    [context, callback, URL](std::unique_ptr<Cogs::FileContents> data) {
      Tileset* tileset = nullptr;
      if (data.get()) {
        // Data is available in worker thread. Create a data parsing task lambda
        Cogs::Memory::MemoryBuffer contentsBuff = data->take();
        std::string_view jsonStr = std::string_view(static_cast<const char*>(contentsBuff.data()), contentsBuff.size());
 
        tileset = new Tileset;
        bool ok = parseJSON(jsonStr, tileset);
        if (!ok) {
          LOG_ERROR(logger, "Error parsing tileset");
          delete tileset;
          tileset = nullptr;
        }
      }
      else {
        LOG_ERROR(logger, "Error fetching tileset from '%s'", URL.c_str());
      }
 
      auto finishTask = [callback, tileset]() {
        callback(tileset);
      };
 
#if defined(EMSCRIPTEN)
      // Cogs.js support - no threading
      (void)context;  // Silence unused capture warning.
      finishTask();
#else
      context->engine->runTaskInMainThread(std::move(finishTask));
#endif
    });
 
  return fetchId;
}