QuadtreeRasterOverlayTileProvider.h

#pragma once
 
#include "IPrepareRasterOverlayRendererResources.h"
#include "Library.h"
#include "RasterOverlayTileProvider.h"
 
#include <CesiumAsync/AsyncSystem.h>
#include <CesiumAsync/IAssetAccessor.h>
#include <CesiumAsync/SharedAssetDepot.h>
#include <CesiumGeometry/QuadtreeTileID.h>
#include <CesiumGeometry/QuadtreeTilingScheme.h>
#include <CesiumUtility/CreditSystem.h>
#include <CesiumUtility/Result.h>
#include <CesiumUtility/SharedAsset.h>
 
#include <list>
#include <memory>
#include <optional>
 
namespace CesiumRasterOverlays {
 
class CESIUMRASTEROVERLAYS_API QuadtreeRasterOverlayTileProvider
    : public RasterOverlayTileProvider {
 
public:
  QuadtreeRasterOverlayTileProvider(
      const CesiumUtility::IntrusivePointer<const RasterOverlay>& pOwner,
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      std::optional<CesiumUtility::Credit> credit,
      const std::shared_ptr<IPrepareRasterOverlayRendererResources>&
          pPrepareRendererResources,
      const std::shared_ptr<spdlog::logger>& pLogger,
      const CesiumGeospatial::Projection& projection,
      const CesiumGeometry::QuadtreeTilingScheme& tilingScheme,
      const CesiumGeometry::Rectangle& coverageRectangle,
      uint32_t minimumLevel,
      uint32_t maximumLevel,
      uint32_t imageWidth,
      uint32_t imageHeight) noexcept;
 
  uint32_t getMinimumLevel() const noexcept { return this->_minimumLevel; }
 
  uint32_t getMaximumLevel() const noexcept { return this->_maximumLevel; }
 
  uint32_t getWidth() const noexcept { return this->_imageWidth; }
 
  uint32_t getHeight() const noexcept { return this->_imageHeight; }
 
  const CesiumGeometry::QuadtreeTilingScheme& getTilingScheme() const noexcept {
    return this->_tilingScheme;
  }
 
  uint32_t computeLevelFromTargetScreenPixels(
      const CesiumGeometry::Rectangle& rectangle,
      const glm::dvec2& screenPixels);
 
protected:
  virtual CesiumAsync::Future<LoadedRasterOverlayImage>
  loadQuadtreeTileImage(const CesiumGeometry::QuadtreeTileID& tileID) const = 0;
 
private:
  virtual CesiumAsync::Future<LoadedRasterOverlayImage>
  loadTileImage(RasterOverlayTile& overlayTile) override final;
 
  struct LoadedQuadtreeImage
      : public CesiumUtility::SharedAsset<LoadedQuadtreeImage> {
    LoadedQuadtreeImage(
        const std::shared_ptr<LoadedRasterOverlayImage>& pLoaded_,
        const std::optional<CesiumGeometry::Rectangle>& subset_)
        : pLoaded(pLoaded_), subset(subset_) {}
    std::shared_ptr<LoadedRasterOverlayImage> pLoaded = nullptr;
    std::optional<CesiumGeometry::Rectangle> subset = std::nullopt;
 
    int64_t getSizeBytes() const {
      int64_t accum = 0;
      accum += int64_t(sizeof(LoadedQuadtreeImage));
      if (pLoaded) {
        accum += pLoaded->getSizeBytes();
      }
      return accum;
    }
  };
 
  CesiumAsync::SharedFuture<CesiumUtility::ResultPointer<LoadedQuadtreeImage>>
  getQuadtreeTile(const CesiumGeometry::QuadtreeTileID& tileID);
 
  std::vector<CesiumAsync::SharedFuture<
      CesiumUtility::ResultPointer<LoadedQuadtreeImage>>>
  mapRasterTilesToGeometryTile(
      const CesiumGeometry::Rectangle& geometryRectangle,
      const glm::dvec2 targetScreenPixels);
 
  struct CombinedImageMeasurements {
    CesiumGeometry::Rectangle rectangle;
    int32_t widthPixels;
    int32_t heightPixels;
    int32_t channels;
    int32_t bytesPerChannel;
  };
 
  static CombinedImageMeasurements measureCombinedImage(
      const CesiumGeometry::Rectangle& targetRectangle,
      const std::vector<CesiumUtility::ResultPointer<LoadedQuadtreeImage>>&
          images);
 
  static LoadedRasterOverlayImage combineImages(
      const CesiumGeometry::Rectangle& targetRectangle,
      const CesiumGeospatial::Projection& projection,
      std::vector<CesiumUtility::ResultPointer<LoadedQuadtreeImage>>&& images);
 
  uint32_t _minimumLevel;
  uint32_t _maximumLevel;
  uint32_t _imageWidth;
  uint32_t _imageHeight;
  CesiumGeometry::QuadtreeTilingScheme _tilingScheme;
 
  CesiumUtility::IntrusivePointer<CesiumAsync::SharedAssetDepot<
      LoadedQuadtreeImage,
      CesiumGeometry::QuadtreeTileID>>
      _pTileDepot;
};
} // namespace CesiumRasterOverlays