[qtAliceVision] SequenceCache: Remove useless includes and fix warnings

Author: cbentejac

src/qtAliceVision/AsyncFetcher.cpp

@@ -60,7 +60,7 @@ void AsyncFetcher::run()
     _isAsynchronous = true;
     _requestSynchronous = false;
 
-    int previousCacheSize = getDiskLoads();
+    std::size_t previousCacheSize = getDiskLoads();
 
     while (1)
     {
@@ -76,7 +76,7 @@ void AsyncFetcher::run()
         }
         else
         {
-            const std::string& lpath = _sequence[_currentIndex];
+            const std::string& lpath = _sequence[static_cast<std::size_t>(_currentIndex)];
 
             // Load in cache
             if (_cache)
@@ -87,12 +87,12 @@ void AsyncFetcher::run()
                     ratio = _resizeRatio;
                 }
 
-                _cache->get<image::RGBAfColor>(lpath, _currentIndex, ratio, false);
+                _cache->get<image::RGBAfColor>(lpath, static_cast<unsigned int>(_currentIndex), ratio, false);
             }
 
             _currentIndex++;
 
-            int size = _sequence.size();
+            int size = static_cast<int>(_sequence.size());
             if (_currentIndex >= size)
             {
                 _currentIndex = 0;
@@ -101,7 +101,7 @@ void AsyncFetcher::run()
             std::this_thread::sleep_for(1ms);
         }
 
-        int cacheSize = getDiskLoads();
+        std::size_t cacheSize = getDiskLoads();
         if (cacheSize != previousCacheSize)
         {
             previousCacheSize = cacheSize;
@@ -118,22 +118,22 @@ void AsyncFetcher::stopAsync()
     _requestSynchronous = true;
 }
 
-void AsyncFetcher::updateCacheMemory(size_t maxMemory)
+void AsyncFetcher::updateCacheMemory(std::size_t maxMemory)
 {
     if (_cache)
     {
         _cache->updateMaxMemory(maxMemory);
     }
 }
 
-size_t AsyncFetcher::getCacheSize() const
+std::size_t AsyncFetcher::getCacheSize() const
 {
-    return (_cache) ? _cache->info().getContentSize() : 0.0f;
+    return (_cache) ? static_cast<std::size_t>(_cache->info().getContentSize()) : 0;
 }
 
-size_t AsyncFetcher::getDiskLoads() const
+std::size_t AsyncFetcher::getDiskLoads() const
 {
-    return (_cache) ? _cache->info().getLoadFromDisk() : 0.0f;
+    return (_cache) ? static_cast<std::size_t>(_cache->info().getLoadFromDisk()) : 0;
 }
 
 QVariantList AsyncFetcher::getCachedFrames() const
@@ -209,11 +209,11 @@ bool AsyncFetcher::getFrame(const std::string& path,
     bool onlyCache = _isAsynchronous;
 
     // Upgrade the thread with the current Index
-    for (int idx = 0; idx < _sequence.size(); ++idx)
+    for (std::size_t idx = 0; idx < _sequence.size(); ++idx)
     {
         if (_sequence[idx] == path)
         {
-            _currentIndex = idx;
+            _currentIndex = static_cast<int>(idx);
             break;
         }
     }

src/qtAliceVision/AsyncFetcher.hpp

@@ -51,8 +51,8 @@ class AsyncFetcher : public QObject, public QRunnable
     bool getFrame(const std::string& path,
                   std::shared_ptr<aliceVision::image::Image<aliceVision::image::RGBAfColor>>& image,
                   oiio::ParamValueList& metadatas,
-                  size_t& originalWidth,
-                  size_t& originalHeight);
+                  std::size_t& originalWidth,
+                  std::size_t& originalHeight);
 
     /**
      * @brief Internal function for QT to start the asynchronous mode
@@ -71,19 +71,19 @@ class AsyncFetcher : public QObject, public QRunnable
      * @brief get the cache content size in bytes
      * @return the cache content size in bytes
      */
-    size_t getCacheSize() const;
+    std::size_t getCacheSize() const;
 
     /**
      * @brief get the number of images loaded
      * @return the count of images loaded since the creation of the cache object
      */
-    size_t getDiskLoads() const;
+    std::size_t getDiskLoads() const;
 
     /**
      * @brief update maxMemory for the cache
      * @param maxMemory the number of bytes allowed in the cache
      */
-    void updateCacheMemory(size_t maxMemory);
+    void updateCacheMemory(std::size_t maxMemory);
 
     /**
      * @brief get a list of regions containing the image frames

src/qtAliceVision/ImageCache.cpp

@@ -1,7 +1,5 @@
 #include "ImageCache.hpp"
 
-#include <aliceVision/system/Logger.hpp>
-
 namespace qtAliceVision {
 
 ImageCache::ImageCache(unsigned long maxSize, const aliceVision::image::ImageReadOptions& options)

src/qtAliceVision/ImageCache.hpp

@@ -10,14 +10,6 @@
 
 #include <boost/functional/hash.hpp>
 
-#include <filesystem>
-#include <memory>
-#include <unordered_map>
-#include <functional>
-#include <list>
-#include <mutex>
-#include <thread>
-#include <algorithm>
 
 namespace qtAliceVision {
 /**
@@ -187,7 +179,7 @@ class CacheInfo
         }
     }
 
-    size_t getAvailableSize() const
+    std::size_t getAvailableSize() const
     {
         const std::scoped_lock<std::mutex> lock(_mutex);
 
@@ -199,7 +191,7 @@ class CacheInfo
         return _maxSize - _contentSize;
     }
 
-    bool isSmallEnough(size_t value) const
+    bool isSmallEnough(std::size_t value) const
     {
         const std::scoped_lock<std::mutex> lock(_mutex);
 
@@ -288,7 +280,7 @@ class ImageCache
      * @param requestedSize the required size for the new image
      * @param toAdd the key of the image to add after cleanup
      */
-    void cleanup(size_t requestedSize, const CacheKey& toAdd);
+    void cleanup(std::size_t requestedSize, const CacheKey& toAdd);
 
     /**
      * @return information on the current cache state and usage
@@ -397,7 +389,7 @@ std::optional<CacheValue> ImageCache::load(const CacheKey& key, unsigned frameId
     int th = static_cast<int>(std::max(1, int(std::ceil(dh))));
 
     using TInfo = aliceVision::image::ColorTypeInfo<TPix>;
-    cleanup(tw * th * size_t(TInfo::size), key);
+    cleanup(tw * th * std::size_t(TInfo::size), key);
 
     // apply downscale
     aliceVision::imageAlgo::resizeImage(tw, th, img, *resized);

src/qtAliceVision/SequenceCache.cpp

@@ -1,7 +1,6 @@
 #include "SequenceCache.hpp"
 
 #include <aliceVision/system/MemoryInfo.hpp>
-#include <aliceVision/image/Image.hpp>
 
 using namespace aliceVision;
 
@@ -68,7 +67,7 @@ void SequenceCache::setMemoryLimit(int memory)
 {
     // Convert parameter in gigabytes to bytes
     const double gigaBytesToBytes = 1024. * 1024. * 1024.;
-    _maxMemory = static_cast<double>(memory) * gigaBytesToBytes;
+    _maxMemory = static_cast<std::size_t>(static_cast<double>(memory) * gigaBytesToBytes);
     _fetcher.updateCacheMemory(_maxMemory);
 }
 
@@ -95,7 +94,7 @@ QPointF SequenceCache::getRamInfo() const
     // Get available RAM in bytes and cache occupied memory
     const auto memInfo = aliceVision::system::getMemoryInfo();
 
-    double availableRam = memInfo.availableRam / (1024. * 1024. * 1024.);
+    double availableRam = static_cast<double>(memInfo.availableRam) / (1024. * 1024. * 1024.);
     double contentSize = static_cast<double>(_fetcher.getCacheSize()) / (1024. * 1024. * 1024. * 1024.);
 
     // Return in GB
@@ -119,7 +118,7 @@ ResponseData SequenceCache::request(const RequestData& reqData)
 
     response.metadata.clear();
     response.img = image;
-    response.dim = QSize(originalWidth, originalHeight);
+    response.dim = QSize(static_cast<int>(originalWidth), static_cast<int>(originalHeight));
 
     // Convert metadatas
     for (const auto& item : metadatas)