feat(misc): use uz literals instead of (size_t) casts

Author: Tom94

include/tev/Ipc.h

@@ -151,7 +151,7 @@ class IpcPacket {
         IStream(std::span<const char> data) : mData{data} {
             uint32_t size;
             *this >> size;
-            if ((size_t)size != data.size()) {
+            if (size != data.size()) {
                 throw std::runtime_error{"Trying to read IPC packet with incorrect size."};
             }
         }

include/tev/ThreadPool.h

@@ -163,8 +163,6 @@ class ThreadPool {
 
     size_t numThreads() const { return mNumThreads; }
 
-    std::recursive_mutex& taskQueueMutex() { return mTaskQueueMutex; }
-
 private:
     bool mShuttingDown = false;
 

src/Image.cpp

@@ -1194,7 +1194,7 @@ Task<HeapArray<float>> Image::getRgbaHdrImageData(
     const size_t nColorChannels = alphaChannel ? (channels.size() - 1) : channels.size();
 
     const auto numPixels = (size_t)imageRegion.size().x() * imageRegion.size().y();
-    const auto nColorChannelsToSave = std::min(nColorChannels, (size_t)3);
+    const auto nColorChannelsToSave = std::min(nColorChannels, 3uz);
 
     // Flatten image into vector
     HeapArray<float> result{4 * numPixels};
@@ -1224,7 +1224,7 @@ Task<HeapArray<float>> Image::getRgbaHdrImageData(
     // Divide alpha out if needed (for storing in non-premultiplied formats)
     if (divideAlpha) {
         co_await ThreadPool::global().parallelForAsync(
-            (size_t)0,
+            0uz,
             numPixels,
             numPixels * 4,
             [&result](size_t j) {

src/ImageCanvas.cpp

@@ -818,19 +818,19 @@ Task<shared_ptr<CanvasStatistics>> ImageCanvas::computeCanvasStatistics(
     }
 
     const auto result = make_shared<CanvasStatistics>();
-    const size_t nColorChannels = alphaChannel ? (flattened.size() - 1) : flattened.size();
+    const auto nColorChannels = alphaChannel ? (flattened.size() - 1) : flattened.size();
     result->nChannels = (int)nColorChannels;
 
     result->histogramColors.resize(nColorChannels);
     for (size_t i = 0; i < nColorChannels; ++i) {
         string rgba[] = {"R", "G", "B", "A"};
-        string colorName = nColorChannels == 1 ? "L" : rgba[std::min(i, (size_t)3)];
+        string colorName = nColorChannels == 1 ? "L" : rgba[std::min(i, 3uz)];
         result->histogramColors[i] = Channel::color(colorName, false);
     }
 
     const auto regionSize = region.size();
-    const size_t numPixels = region.area();
-    const size_t numSamples = nColorChannels * numPixels;
+    const auto numPixels = region.area();
+    const auto numSamples = nColorChannels * numPixels;
 
     // If we have 3 color channels, apply alpha, the inspection chroma, and transfer function
     if (nColorChannels >= 3) {
@@ -928,7 +928,7 @@ Task<shared_ptr<CanvasStatistics>> ImageCanvas::computeCanvasStatistics(
     result->minimum = stats.minimum;
 
     // The more pixels we have, the finer we can make the histogram without becoming noisy
-    // const size_t numBins = clamp(numPixels / 512, (size_t)16, (size_t)512);
+    // const size_t numBins = clamp(numPixels / 512, 16uz, 512uz);
     const size_t numBins = 400;
     result->histogram.resize(numBins * nColorChannels);
 
@@ -961,7 +961,7 @@ Task<shared_ptr<CanvasStatistics>> ImageCanvas::computeCanvasStatistics(
     {
         const size_t approxCost = numSamples *
             8; // constant factor to represent the increased workload of log/exp and somewhat random memory writes
-        const size_t numTasks = nextMultiple(ThreadPool::global().nTasks<size_t>(0, numPixels, approxCost), (size_t)nColorChannels);
+        const size_t numTasks = nextMultiple(ThreadPool::global().nTasks<size_t>(0, numPixels, approxCost), nColorChannels);
         const size_t numTasksPerChannel = numTasks / nColorChannels;
 
         vector<float> perTaskHistograms(numBins * nColorChannels * numTasks);

src/imageio/ExrImageSaver.cpp

@@ -71,12 +71,7 @@ class StdOStream : public Imf::OStream {
 };
 
 Task<void> ExrImageSaver::save(ostream& oStream, const fs::path& path, span<const float> data, const Vector2i& imageSize, int nChannels) const {
-    const vector<string> channelNames = {
-        "R",
-        "G",
-        "B",
-        "A",
-    };
+    const vector<string> channelNames = {"R", "G", "B", "A"};
 
     if (nChannels <= 0 || nChannels > 4) {
         throw ImageSaveError{fmt::format("Invalid number of channels {}.", nChannels)};

src/imageio/HeifImageLoader.cpp

@@ -405,7 +405,7 @@ Task<vector<ImageData>> HeifImageLoader::load(
         // 1 thread per 4 million samples (rgba megapixel) seems to be a good heuristic for parallel decoding. Spawning threads is *really*
         // expensive, so even taking into account that decoding does quite a bit of processing per sample, we still need a much larger chunk
         // size than our task-based thread pool. Would be better if libheif exposed a way for us to supply a custom thread pool, but oh well.
-        return clamp(numSamples / (1024 * 1024 * 4), (size_t)1, (size_t)thread::hardware_concurrency());
+        return clamp(numSamples / (1024 * 1024 * 4), 1uz, (size_t)thread::hardware_concurrency());
     };
 
     const auto decodeImageHandle =

src/imageio/TiffImageLoader.cpp

@@ -614,7 +614,7 @@ Task<void> linearizeAndNormalizeRawDng(
                         const float val = rgbaView[c, i];
 
                         // Lerp the transfer function
-                        const size_t idx = clamp((size_t)(val * maxVal), (size_t)0, maxIdx - 1);
+                        const size_t idx = clamp((size_t)(val * maxVal), 0uz, maxIdx - 1);
                         const float w = val * maxIdx - idx;
                         rgbaView[c, i] = (1.0f - w) * linTable[idx] * scale + w * linTable[idx + 1] * scale;
                     }
@@ -1339,7 +1339,7 @@ Task<void> postprocessRgb(
                     const float val = rgbaView[c, i];
 
                     // Lerp the transfer function
-                    const size_t idx = clamp((size_t)(val * maxIdx) + transferRangeBlack[c], (size_t)0, transferFunction[c].size() - 2);
+                    const size_t idx = clamp((size_t)(val * maxIdx) + transferRangeBlack[c], 0uz, transferFunction[c].size() - 2);
                     const float w = val * maxIdx - idx - transferRangeBlack[c];
                     rgbaView[c, i] = ((1.0f - w) * (float)transferFunction[c][idx] + w * (float)transferFunction[c][idx + 1] -
                                       transferRangeBlack[c]) *