Merge pull request #418 from Wulkop/feature/lod-bodies-skip-white-tiles

Feature/lod bodies skip white tiles

Author: JonasGilg

plugins/csp-lod-bodies/src/TileSourceWebMapService.cpp

@@ -136,6 +136,26 @@ bool loadImpl(TileSourceWebMapService* source, BaseTileData* tile, TileId const&
       return false;
     }
 
+    bool isCompletelyWhiteTile = true;
+    // Iterate through pixel values and stop after one non-white pixel in tile
+    for (int i = 0; i < width * height; ++i) {
+      auto pixel = reinterpret_cast<uint8_t*>(data) + i * 4;
+      if (pixel[0] != 255 || pixel[1] != 255 || pixel[2] != 255 || pixel[3] != 255) {
+        isCompletelyWhiteTile = false;
+        break;
+      }
+    }
+    if (isCompletelyWhiteTile) {
+      logger().debug(
+          "Failed to parse tile data: File '{}' is completely white and most likely corrupt.",
+          *cacheFile);
+      source->markTileDataAsInvalid(*cacheFile);
+      if (boost::filesystem::remove(*cacheFile) == 0) {
+        logger().debug("Failed to remove tile data: File '{}'", *cacheFile);
+      }
+      return false;
+    }
+
     // The image data can be read. For some patches (those at the international date boundary)
     // two requests are made. For those, only half of the pixels contain valid data (above or below
     // the diagonal).
@@ -392,6 +412,20 @@ std::optional<std::string> TileSourceWebMapService::loadData(TileId const& tileI
           "Failed to download tile data: Cannot open '{}' for writing!", cacheFile.str()));
     }
 
+    // Check if we already had an error with this tile cache file in the past
+    if (mLastTimeTileFailed.find(cacheFilePath) != mLastTimeTileFailed.end()) {
+      auto cooldownTime = std::chrono::seconds(3);
+      auto timeNow      = std::chrono::system_clock::now();
+      if (timeNow - mLastTimeTileFailed[cacheFilePath] < cooldownTime) {
+        logger().warn(
+            "Failed to download tile data: Waiting for '{}' to cool down", cacheFile.str());
+        // Sleep for the rest of the cooldown time (plus a little longer 500ms)
+        std::this_thread::sleep_until(
+            mLastTimeTileFailed[cacheFilePath] + cooldownTime + std::chrono::milliseconds(500));
+      }
+      mLastTimeTileFailed.erase(cacheFilePath);
+    }
+
     curlpp::Easy request;
     request.setOpt(curlpp::options::Url(url.str()));
     request.setOpt(curlpp::options::WriteStream(&out));
@@ -495,4 +529,10 @@ bool TileSourceWebMapService::isSame(TileSource const* other) const {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void TileSourceWebMapService::markTileDataAsInvalid(boost::filesystem::path const& TileDataPath) {
+  mLastTimeTileFailed[TileDataPath] = std::chrono::system_clock::now();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 } // namespace csp::lodbodies

plugins/csp-lod-bodies/src/TileSourceWebMapService.hpp

@@ -12,6 +12,7 @@
 #include "TileData.hpp"
 #include "TileSource.hpp"
 
+#include <chrono>
 #include <cstdio>
 #include <optional>
 #include <string>
@@ -70,6 +71,12 @@ class TileSourceWebMapService : public TileSource {
   // writable) a std::runtime_error is thrown.
   std::optional<std::string> loadData(TileId const& tileId, int x, int y);
 
+  // This will mark a previously downloaded tile file as invalid together with the current
+  // timestamp. This information is used to avoid quering the same tile immediately after we've
+  // received invalid data from server Tracking the time of the last error allows us to apply a kind
+  // of cooldown mechanism
+  void markTileDataAsInvalid(boost::filesystem::path const& TileDataPath);
+
  private:
   static std::mutex mFileSystemMutex;
 
@@ -79,6 +86,10 @@ class TileSourceWebMapService : public TileSource {
   std::string           mLayers;
   TileDataType          mFormat = TileDataType::eColor;
   uint32_t              mResolution;
+
+  // We keep track of the time a tile has had invalid data from the server.
+  // This timestamp is used for a cooldown mechanism
+  std::map<boost::filesystem::path, std::chrono::system_clock::time_point> mLastTimeTileFailed;
 };
 } // namespace csp::lodbodies