QuadtreeRasterOverlayTileProvider.h

#pragma once
 
#include <CesiumAsync/AsyncSystem.h>
#include <CesiumAsync/IAssetAccessor.h>
#include <CesiumAsync/SharedAssetDepot.h>
#include <CesiumGeometry/QuadtreeTileID.h>
#include <CesiumGeometry/QuadtreeTilingScheme.h>
#include <CesiumRasterOverlays/IPrepareRasterOverlayRendererResources.h>
#include <CesiumRasterOverlays/Library.h>
#include <CesiumRasterOverlays/RasterOverlayTileProvider.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>& pCreator,
      const CreateRasterOverlayTileProviderParameters& parameters,
      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(const 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