ClipmapQueryHandler.cpp

#include "ClipmapQueryHandler.h"
#include "ClipmapLevel.h"
#include "RenderContext.h"
#include "Raster/RasterSource.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <algorithm>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ClipmapQueryHandler");
}
 
void Cogs::ClipmapQueryHandler::initialize(std::vector<ClipmapLevel> * terrainLevels, std::vector<std::vector<ClipmapLevel>> * imagery)
{
  this->imagery = imagery;
  this->terrainLevels = terrainLevels;
}
 
void Cogs::ClipmapQueryHandler::postInitialize()
{
  std::lock_guard<std::mutex> lock(mutex);
 
  for (auto & data : elevationQueries) {
    if (!data.inputLevels) {
      data.inputLevels = terrainLevels;
 
      if (data.targetLevel == -1) {
        auto terrainSource = (*terrainLevels)[0].rasterLevel->getSource();
        data.targetLevel = static_cast<int>(terrainSource->getLevels().size()) - 1;
      }
    }
  }
 
  for (auto & data : colorQueries) {
    if (!data.inputLevels) {
      data.inputLevels = &(*imagery)[data.queryLayer - 1];
 
      if (data.targetLevel == -1) {
        data.targetLevel = static_cast<int>((*imagery)[data.queryLayer - 1].size()) - 1;
      }
    }
  }
 
  allowToProcessQueries = true;
}
 
void Cogs::ClipmapQueryHandler::postRequest(Cogs::TerrainQuery * query, Cogs::TerrainQueryCallback callback, const WorldOptions & worldOptions)
{
  if (query->layer == 0) {
    auto terrainSource = (terrainLevels && !terrainLevels->empty()) ? (*terrainLevels)[0].rasterLevel->getSource() : nullptr;
 
    ElevationQueryData data;
    data.userData = query->userData;
    data.callback = callback;
    data.positions.assign(query->positions, query->positions + query->numPositions);
    data.results.resize(query->numPositions / 2, 0.0);
    data.resultStride = 1;
    data.levels.resize(query->numPositions / 2, (int)-1);
    data.inputLevels = terrainLevels;
    data.queryLayer = query->layer;
    data.worldOptions = worldOptions;
 
    data.targetLevel = query->level;
 
    if (data.targetLevel == -1 && terrainSource) {
      data.targetLevel = static_cast<int>(terrainSource->getLevels().size()) - 1;
    }
 
    data.requestedLevel.resize(query->numPositions / 2, -1);
    data.resultLevel = -1;
    data.complete = false;
 
    std::lock_guard<std::mutex> lock(mutex);
    elevationQueries.push_back(data);
  } else {
    assert((!imagery || ((query->layer - 1) >= 0 && (query->layer - 1) < (int)(*imagery).size())) && "Query layer not a valid imagery layer.");
 
    ColorQueryData data;
    data.userData = query->userData;
    data.callback = callback;
    data.positions.assign(query->positions, query->positions + query->numPositions);
    data.results.resize(4 * (query->numPositions / 2), 0);
    data.resultStride = 4;
    data.levels.resize(query->numPositions / 2, (int)-1);
    data.queryLayer = query->layer;
    data.worldOptions = worldOptions;
 
    if (imagery) {
      data.inputLevels = &(*imagery)[query->layer - 1];
      data.targetLevel = query->level == -1 ? static_cast<int>((*imagery)[query->layer - 1].size()) - 1 : query->level;
    } else {
      data.inputLevels = nullptr;
      data.targetLevel = query->level;
    }
 
    data.requestedLevel.resize(query->numPositions / 2, -1);
    data.resultLevel = -1;
    data.complete = false;
 
    std::lock_guard<std::mutex> lock(mutex);
    colorQueries.push_back(data);
  }
}
 
void Cogs::ClipmapQueryHandler::processQueries()
{
  if (!allowToProcessQueries) return;
 
  processQueries_T(elevationQueries);
  processQueries_T(colorQueries);
}
 
template<>
bool Cogs::ClipmapQueryHandler::readData(const RasterTileData * tileData, const int x, const int y, const int width, double * result)
{
  const size_t requiredSize = (y * width + x + 1) * sizeof(float);
 
  if (tileData->data.size() < requiredSize) {
    LOG_ERROR(logger, "Tile data insufficient size to query (x, y, width): %d, %d, %d", x, y, width);
    return false;
  }
 
  const float * elevations = reinterpret_cast<const float *>(tileData->data.data());
 
  *result = elevations[y * width + x];
 
  return true;
}
 
template<>
bool Cogs::ClipmapQueryHandler::readData(const RasterTileData * tileData, const int x, const int y, const int width, unsigned char * result)
{
  const size_t requiredSize = (y * width + x + 1) * sizeof(float);
 
  if (tileData->data.size() < requiredSize) {
    LOG_ERROR(logger, "Tile data insufficient size to query (x, y, width): %d, %d, %d", x, y, width);
    return false;
  }
 
  const auto & colors = tileData->data;
 
  int bpp = 0;
  int stride = 0;
 
  switch (tileData->format) {
  case TextureFormat::R8G8B8_UNORM:
    bpp = 3;
    break;
  case TextureFormat::R8G8B8A8_UNORM:
    bpp = 4;
    break;
  case TextureFormat::R8G8B8A8_UNORM_SRGB:
          bpp = 4;
          break;
  case TextureFormat::R32_FLOAT:
        bpp = 4;
        break;
  default:
    // Format not supported for query.
    break;
  }
 
  if (!bpp) return false;
 
  // Assign full alpha to result.
  result[3] = 255;
 
  stride = bpp * width;
 
  // We don't want to read outside data array.
  if (static_cast<int>(colors.size()) < (y * stride + (x + 1) * bpp)) return false;
 
  for (int i = 0; i < bpp; ++i) {
    result[i] = colors[y * stride + x * bpp + i];
  }
 
  return true;
}
 
template<typename DataType>
void Cogs::ClipmapQueryHandler::processQueries_T(std::vector<TerrainQueryData<DataType>> & queries)
{
  std::vector<size_t> completed;
  std::vector<TerrainQueryData<DataType>> currentQueries;
 
  {
    std::lock_guard<std::mutex> lock(mutex);
 
    currentQueries = std::move(queries);
  }
 
  for (size_t i = 0; i < currentQueries.size(); ++i) {
    TerrainQueryData<DataType> & data = currentQueries[i];
 
    std::vector<ClipmapLevel> & levels = *data.inputLevels;
 
    for (size_t j = 0; j < data.levels.size(); ++j) {
      if (data.levels[j] != data.targetLevel && data.levels[j] <= data.resultLevel && !levels.empty()) {
        const int level = std::min(data.targetLevel, data.resultLevel <= 0 ? data.resultLevel + 1 : data.resultLevel * 2);
 
        assert(level >= 0 && level < static_cast<int>(levels.size()));
        const auto rasterLevel = levels[level].rasterLevel;
 
        // Positions are stored as [long, lat] pairs (x, y).
        const double queryPositionLong = data.positions[j * 2];
        const double queryPositionLat = data.positions[j * 2 + 1];
 
        auto & extent = rasterLevel->getGeoExtent();
        if (queryPositionLong < extent.getWest() ||
          queryPositionLong > extent.getEast() ||
          queryPositionLat < extent.getSouth() ||
          queryPositionLat > extent.getNorth()) {
          LOG_WARNING(logger, "Query outside extents: [%f, %f].", queryPositionLong, queryPositionLat);
 
          // Do not process this index any more.
          data.levels[j] = level;
 
          continue;
        }
 
        const double latitudeIndex = rasterLevel->latitudeToIndex(queryPositionLat / data.worldOptions.worldScale.y);
        const double longitudeIndex = rasterLevel->longitudeToIndex(queryPositionLong / data.worldOptions.worldScale.x);
 
        const int tileY = static_cast<int>(latitudeIndex / rasterLevel->getLatitudePostsPerTile());
        const int tileX = static_cast<int>(longitudeIndex / rasterLevel->getLongitudePostsPerTile());
 
        if (tileX < 0 || tileY < 0) {
          LOG_WARNING(logger, "Query outside valid range: [%f, %f].", queryPositionLong, queryPositionLat);
 
          // Do not process this index any more.
          data.levels[j] = level;
 
          continue;
        }
 
        RasterTileIdentifier id = { rasterLevel->getLevel(), tileX, tileY };
 
        auto source = rasterLevel->getSource();
 
        {
          std::lock_guard<RasterSource> sourceLock(*source);
 
          const auto tile = source->getTile(id);
 
          if (!tile) {
            LOG_WARNING(logger, "Error reading tile %d, %d, %d from source.", id.level, id.x, id.y);
 
            data.levels[j] = level;
 
            continue;
          }
 
          const auto tileData = source->getTileData(tile);
 
          if (tileData) {
            const int stride = tile->getWidth();
            const int y = static_cast<int>(latitudeIndex) % rasterLevel->getLatitudePostsPerTile();
            const int x = static_cast<int>(longitudeIndex) % rasterLevel->getLongitudePostsPerTile();
 
            if (tileData->data.size() && readData(tileData, x, y, stride, &data.results[j * data.resultStride])) {
              data.levels[j] = level;
 
              if (data.requestedLevel[j] == level) {
                // We have read from the current detail level. No longer need to pin the tile data.
                source->unrefTile(tile);
              }
            } else {
              if (tileData->data.empty()) {
                LOG_WARNING(logger, "Empty tile data for tile at %d, %d, %d.", id.level, id.x, id.y);
              } else {
                LOG_WARNING(logger, "Failed reading data from tile at %d, %d, %d.", id.level, id.x, id.y);
              }
 
              data.levels[j] = level;
            }
          } else {
            if (level > data.requestedLevel[j]) {
              TileLoadRequest request = { tile };
              data.requestedLevel[j] = level;
              source->refTile(tile);
              source->requestTile(request);
            }
          }
        }
      }
    }
 
    bool done = true;
    int doneLevel = std::numeric_limits<int>::max();
 
    for (size_t j = 0; j < data.levels.size(); ++j) {
      done &= (data.levels[j] >= 0);
      doneLevel = std::min(doneLevel, data.levels[j]);
    }
 
    if (done && doneLevel > data.resultLevel) {
      TerrainQueryResults results;
      results.userData = data.userData;
      results.numResults = static_cast<int>(data.results.size());
      results.results = data.results.data();
      results.resultLevel = doneLevel;
 
      data.callback(&results);
 
      data.resultLevel = doneLevel;
    }
 
    data.complete = doneLevel == data.targetLevel;
  }
 
  std::lock_guard<std::mutex> lock(mutex);
 
  // Insert queries that are not completed back in the queue and retry on next iteration.
  for (auto & query : currentQueries) {
    if (!query.complete) {
      queries.emplace_back(std::move(query));
    }
  }
}