RasterLevel.cpp

#include "RasterLevel.h"
 
#include <algorithm>
 
#include "RasterSource.h"
 
Cogs::RasterLevel::RasterLevel(RasterSource * source,
                               int level,
                               GeodeticExtent extent,
                               float noData,
                               int longitudePosts,
                               int latitudePosts,
                               int longitudePostsPerTile,
                               int latitudePostsPerTile,
                               double postDeltaLongitude,
                               double postDeltaLatitude) :
  source(source),
  level(level),
  extent(extent),
  noData(noData),
  longitudePosts(longitudePosts),
  latitudePosts(latitudePosts),
  longitudePostsPerTile(longitudePostsPerTile),
  latitudePostsPerTile(latitudePostsPerTile),
  postDeltaLongitude(postDeltaLongitude),
  postDeltaLatitude(postDeltaLatitude)
{
  indexExtent = Extent{ 0, 0, longitudePosts - 1, latitudePosts - 1 };
}
 
double Cogs::RasterLevel::longitudeToIndex(double longitude) const
{
  return (longitude - extent.getWest()) / postDeltaLongitude;
}
 
double Cogs::RasterLevel::latitudeToIndex(double latitude) const
{
  return (latitude - extent.getSouth()) / postDeltaLatitude;
}
 
double Cogs::RasterLevel::indexToLongitude(int longitudeIndex) const
{
  return extent.getWest() + longitudeIndex * postDeltaLongitude;
}
 
double Cogs::RasterLevel::indexToLatitude(int latitudeIndex) const
{
  return extent.getSouth() + latitudeIndex * postDeltaLatitude;
}
 
void Cogs::RasterLevel::getTilesInExtent(const Extent & extent, std::vector<RasterTileRegion> & results) const
{
  static std::vector<Extent> extents;
  static std::vector<RasterTileIdentifier> ids;
 
  extents.clear();
  ids.clear();
 
  getTilesInExtent(extent, ids, extents);
    
  ReadLock lock(*source);
 
  for (size_t i = 0; i < ids.size(); ++i) {
    auto tile = source->getTile(ids[i]);
 
    if (tile) {
      results.emplace_back(RasterTileRegion{ tile, extents[i] });
    }
  }
}
 
void Cogs::RasterLevel::getTilesInExtent(const Extent & extent, std::vector<RasterTileIdentifier> & ids, std::vector<Extent> & extents) const
{
  int tileXStart = extent.west / longitudePostsPerTile;
  int tileXStop = extent.east / longitudePostsPerTile;
 
  if (extent.west < 0) {
    --tileXStart;
  }
 
  if (extent.east < 0) {
    --tileXStop;
  }
 
  int tileYStart = extent.south / latitudePostsPerTile;
  int tileYStop = extent.north / latitudePostsPerTile;
 
  if (extent.south < 0) {
    --tileYStart;
  }
 
  if (extent.north < 0) {
    --tileYStop;
  }
 
  // Calculate the max X and Y tile index.
  const int maxTileX = longitudePosts / longitudePostsPerTile + ((longitudePosts % longitudePostsPerTile) ? 1 : 0) - 1;
  const int maxTileY = latitudePosts / latitudePostsPerTile + ((latitudePosts % latitudePostsPerTile) ? 1 : 0) - 1;
 
  for (int tileY = tileYStart; tileY <= tileYStop; ++tileY) {
    const int tileYOrigin = tileY * latitudePostsPerTile;
 
    const int currentTileSouth = std::max(extent.south - tileYOrigin, 0);
    const int currentTileNorth = std::min(extent.north - tileYOrigin, latitudePostsPerTile - 1);
 
    for (int tileX = tileXStart; tileX <= tileXStop; ++tileX) {
      const int tileXOrigin = tileX * longitudePostsPerTile;
 
      const int currentTileWest = std::max(extent.west - tileXOrigin, 0);
      const int currentTileEast = std::min(extent.east - tileXOrigin, longitudePostsPerTile - 1);
 
      // Only return tile regions for tiles that have indexes inside the level.
      if (tileX >= 0 && tileX <= maxTileX && tileY >= 0 && tileY <= maxTileY) {
        ids.emplace_back(RasterTileIdentifier { level, tileX, tileY });
 
        extents.emplace_back(Extent{ currentTileWest, currentTileSouth, currentTileEast, currentTileNorth });
      }
    }
  }
}