chore: minor emplace() & ranges refactor

Tom94 · Tom94 · commit 02b221bd2ce6 · 2026-05-26T07:41:23.000+02:00
diff --git a/include/tev/Common.h b/include/tev/Common.h
@@ -278,8 +278,13 @@ template <template <typename...> class Vector> struct to_vector_fn {
             Vector<value_type> v;
             v.reserve(std::ranges::size(r));
             for (auto&& e : r) {
-                v.emplace_back(static_cast<decltype(e)&&>(e));
+                if constexpr (std::same_as<Vector<value_type>, std::basic_string<value_type>>) {
+                    v.push_back(static_cast<value_type>(e));
+                } else {
+                    v.emplace_back(static_cast<decltype(e)&&>(e));
+                }
             }
+
             return v;
         } else {
             return Vector<value_type>(std::ranges::begin(r), std::ranges::end(r));
@@ -297,6 +302,7 @@ template <size_t N> struct fixed_chunks_fn {
 } // namespace detail
 
 inline constexpr detail::to_vector_fn<std::vector> toVector{};
+inline constexpr detail::to_vector_fn<std::basic_string> toBasicString{};
 template <std::size_t N> inline constexpr detail::fixed_chunks_fn<N> fixed_chunks{};
 
 // Helper for std::visit on multiple lambdas
@@ -540,12 +546,12 @@ template <typename Int> Int nextMultiple(Int value, Int multiple) { return divRo
 
 template <typename T> std::string join(const T& components, std::string_view delim) {
     std::ostringstream s;
-    for (const auto& component : components) {
-        if (&components[0] != &component) {
+    for (size_t i = 0; i < components.size(); ++i) {
+        if (i != 0) {
             s << delim;
         }
 
-        s << component;
+        s << components[i];
     }
 
     return std::move(s).str();
diff --git a/include/tev/Image.h b/include/tev/Image.h
@@ -120,7 +120,7 @@ struct ImageData {
 
     size_t numPixels() const { return channels.front().numPixels(); }
 
-    std::vector<std::string> channelsInLayer(std::string_view layerName) const;
+    std::vector<std::string_view> channelsInLayer(std::string_view layerName) const;
 
     Task<void> applyColorConversion(const nanogui::Matrix3f& mat, int priority);
 
diff --git a/src/BackgroundImagesLoader.cpp b/src/BackgroundImagesLoader.cpp
@@ -46,7 +46,7 @@ void BackgroundImagesLoader::enqueue(const fs::path& path, string_view channelSe
         vector<fs::directory_entry> entries;
         forEachFileInDir(mRecursiveDirectories, canonicalPath, [&](const auto& entry) {
             if (!entry.is_directory()) {
-                mFilesFoundInDirectories.emplace(PathAndChannelSelector{entry, string{channelSelector}});
+                mFilesFoundInDirectories.emplace(entry, string{channelSelector});
                 entries.emplace_back(entry);
             }
         });
diff --git a/src/Common.cpp b/src/Common.cpp
@@ -163,15 +163,11 @@ vector<string_view> split(string_view text, string_view delim, bool inclusive) {
 vector<string_view> splitWhitespace(string_view s, bool inclusive) { return split(s, ws, inclusive); }
 
 string toLower(string_view str) {
-    string result{str};
-    transform(begin(result), end(result), begin(result), [](unsigned char c) { return (char)tolower(c); });
-    return result;
+    return str | views::transform([](auto c) { return (char)tolower(c); }) | toBasicString;
 }
 
 string toUpper(string_view str) {
-    string result{str};
-    transform(begin(result), end(result), begin(result), [](unsigned char c) { return (char)toupper(c); });
-    return result;
+    return str | views::transform([](auto c) { return (char)toupper(c); }) | toBasicString;
 }
 
 string_view trimLeft(string_view s) {
@@ -297,7 +293,7 @@ bool matchesFuzzy(string_view text, string_view filter, size_t* matchedPartId) {
 
     // Perform matching via smart casing: if the filter is all lowercase, we want to match case-insensitively. If the filter contains any
     // uppercase characters, we want to match case-sensitively.
-    const bool caseInsensitive = all_of(begin(filter), end(filter), [](char c) { return islower(c); });
+    const bool caseInsensitive = ranges::all_of(filter, [](char c) { return islower(c); });
 
     string casedText, casedFilter;
     if (caseInsensitive) {
diff --git a/src/Image.cpp b/src/Image.cpp
@@ -133,8 +133,8 @@ void ImageData::readMetadataFromCicp(const ColorProfile::CICP& cicp) {
     hdrMetadata.bestGuessWhiteLevel = ituth273::bestGuessReferenceWhiteLevel(cicp.transfer);
 }
 
-vector<string> ImageData::channelsInLayer(string_view layerName) const {
-    vector<string> result;
+vector<string_view> ImageData::channelsInLayer(string_view layerName) const {
+    vector<string_view> result;
 
     for (const auto& c : channels) {
         // If the layer name starts at the beginning, and if no other dot is found after the end of the layer name, then we have found a
@@ -834,29 +834,33 @@ Texture* Image::texture(span<const string> channelNames, EInterpolationMode minF
         default: throw runtime_error{"Unsupported number of channels for texture."};
     }
 
-    Texture::ComponentFormat componentFormat = Texture::ComponentFormat::Float16;
-    for (const auto& chanName : channelNames) {
-        const Channel* chan = channel(chanName);
-        if (chan && chan->desiredPixelFormat() == EPixelFormat::F32) {
-            componentFormat = Texture::ComponentFormat::Float32;
-            break; // No need to check further, we already have a channel that requires F32.
-        }
-    }
+    const Texture::ComponentFormat componentFormat = ranges::any_of(
+                                                         channelNames | views::transform([this](const auto& c) { return channel(c); }),
+                                                         [](const auto& c) { return c && c->desiredPixelFormat() == EPixelFormat::F32; }
+                                                     ) ?
+        Texture::ComponentFormat::Float32 :
+        Texture::ComponentFormat::Float16;
 
     mTextures.emplace(
-        lookup,
-        ImageTexture{
+        piecewise_construct,
+        tuple{
+            lookup
+    },
+        tuple{
             new Texture{
-                        pixelFormat, componentFormat,
-                        {size().x(), size().y()},
-                        toNanogui(minFilter),
-                        toNanogui(magFilter),
-                        Texture::WrapMode::ClampToEdge,
-                        1, Texture::TextureFlags::ShaderRead,
-                        true, },
-            {channelNames.begin(), channelNames.end()},
+                pixelFormat,
+                componentFormat,
+                {size().x(), size().y()},
+                toNanogui(minFilter),
+                toNanogui(magFilter),
+                Texture::WrapMode::ClampToEdge,
+                1,
+                Texture::TextureFlags::ShaderRead,
+                true,
+            },
+            channelNames | toVector,
             false,
-    }
+        }
     );
 
     auto& texture = mTextures.at(lookup).nanoguiTexture;
@@ -973,7 +977,7 @@ void Image::ungroup(string_view groupName) {
 }
 
 vector<ChannelGroup> Image::getGroupedChannels(string_view layerName) const {
-    vector<vector<string>> groups = {
+    static const vector<vector<string>> groups = {
         {"R", "G", "B"},
         {"r", "g", "b"},
         {"X", "Y", "Z"},
@@ -984,40 +988,37 @@ vector<ChannelGroup> Image::getGroupedChannels(string_view layerName) const {
         {"z"},
     };
 
-    static constexpr auto createChannelGroup = [](string_view layer, vector<string> channels) {
+    static constexpr auto createChannelGroup = [](string_view layer, span<const string_view> channels) {
         TEV_ASSERT(!channels.empty(), "Can't create a channel group without channels.");
 
-        vector<string_view> channelTails = {channels.begin(), channels.end()};
+        vector<string_view> channelTails = channels | views::transform(Channel::tail) | toVector;
         channelTails.erase(unique(begin(channelTails), end(channelTails)), end(channelTails));
-        transform(begin(channelTails), end(channelTails), begin(channelTails), Channel::tail);
 
         const string channelsString = join(channelTails, ",");
         const string name = layer.empty() ?
             channelsString :
             (channelTails.size() == 1 ? fmt::format("{}{}", layer, channelsString) : fmt::format("{}({})", layer, channelsString));
 
-        return ChannelGroup{name, std::move(channels)};
+        return ChannelGroup{name, channels | views::transform([](const auto& c) { return string{c}; }) | toVector};
     };
 
-    string alphaChannelName = fmt::format("{}A", layerName);
+    const string alphaChannelName = fmt::format("{}A", layerName);
 
-    vector<string> allChannels = mData.channelsInLayer(layerName);
+    vector<string_view> allChannels = mData.channelsInLayer(layerName);
 
-    auto alphaIt = find(begin(allChannels), end(allChannels), alphaChannelName);
-    bool hasAlpha = alphaIt != end(allChannels);
+    const auto alphaIt = ranges::find(allChannels, alphaChannelName);
+    const bool hasAlpha = alphaIt != end(allChannels);
     if (hasAlpha) {
         allChannels.erase(alphaIt);
     }
 
     vector<ChannelGroup> result;
 
     for (const auto& group : groups) {
-        vector<string> groupChannels;
+        vector<string_view> groupChannels;
         for (string_view channel : group) {
-            string name = fmt::format("{}{}", layerName, channel);
-            auto it = find(begin(allChannels), end(allChannels), name);
-            if (it != end(allChannels)) {
-                groupChannels.emplace_back(name);
+            if (const auto it = ranges::find(allChannels, fmt::format("{}{}", layerName, channel)); it != end(allChannels)) {
+                groupChannels.emplace_back(*it);
                 allChannels.erase(it);
             }
         }
@@ -1027,20 +1028,20 @@ vector<ChannelGroup> Image::getGroupedChannels(string_view layerName) const {
                 groupChannels.emplace_back(alphaChannelName);
             }
 
-            result.emplace_back(createChannelGroup(layerName, std::move(groupChannels)));
+            result.emplace_back(createChannelGroup(layerName, groupChannels));
         }
     }
 
-    for (const auto& name : allChannels) {
+    for (auto& name : allChannels) {
         if (hasAlpha) {
-            result.emplace_back(createChannelGroup(layerName, vector<string>{name, alphaChannelName}));
+            result.emplace_back(createChannelGroup(layerName, array<string_view, 2>{name, alphaChannelName}));
         } else {
-            result.emplace_back(createChannelGroup(layerName, vector<string>{name}));
+            result.emplace_back(createChannelGroup(layerName, span{&name, 1}));
         }
     }
 
     if (hasAlpha && result.empty()) {
-        result.emplace_back(createChannelGroup(layerName, vector<string>{alphaChannelName}));
+        result.emplace_back(createChannelGroup(layerName, array<string_view, 1>{alphaChannelName}));
     }
 
     TEV_ASSERT(!result.empty(), "Images with no channels should never exist.");
@@ -1182,7 +1183,7 @@ Task<HeapArray<float>> Image::getRgbaHdrImageData(
     const Channel* alphaChannel = nullptr;
 
     // Only treat the alpha channel specially if it is not the only channel of the image.
-    if (!all_of(begin(channels), end(channels), [](const Channel& c) { return c.isAlpha(); })) {
+    if (ranges::any_of(channels, [](const Channel& c) { return !c.isAlpha(); })) {
         if (channels.back().isAlpha()) {
             alphaChannel = &channels.back();
         }
@@ -1376,21 +1377,21 @@ string Image::toString() const {
 
     sstream << "\nChannels:\n";
 
-    auto localLayers = mData.layers;
-    transform(begin(localLayers), end(localLayers), begin(localLayers), [this](string layer) {
-        auto channels = mData.channelsInLayer(layer);
-        transform(begin(channels), end(channels), begin(channels), [](string channel) { return Channel::tail(channel); });
+    sstream << join(
+        mData.layers | views::transform([this](string_view layer) {
+            const auto channels = mData.channelsInLayer(layer) | views::transform([](string_view c) { return Channel::tail(c); });
 
-        if (layer.empty()) {
-            return join(channels, ",");
-        } else if (channels.size() == 1) {
-            return layer + channels.front();
-        } else {
-            return layer + "("s + join(channels, ",") + ")"s;
-        }
-    });
+            if (layer.empty()) {
+                return join(channels, ",");
+            } else if (channels.size() == 1) {
+                return fmt::format("{}{}", layer, channels.front());
+            } else {
+                return fmt::format("{}({})", layer, join(channels, ","));
+            }
+        }),
+        "\n"
+    );
 
-    sstream << join(localLayers, "\n");
     return std::move(sstream).str();
 }
 
diff --git a/src/ImageCanvas.cpp b/src/ImageCanvas.cpp
@@ -831,7 +831,7 @@ Task<shared_ptr<CanvasStatistics>> ImageCanvas::computeCanvasStatistics(
     const ChannelView<float>* alphaChannel = nullptr;
 
     // Only treat the alpha channel specially if it is not the only channel of the image.
-    if (!all_of(begin(flattened), end(flattened), [](const Channel& c) { return c.isAlpha(); })) {
+    if (ranges::any_of(flattened, [](const Channel& c) { return !c.isAlpha(); })) {
         if (flattened.back().isAlpha()) {
             alphaChannel = &views.back();
         }
diff --git a/src/ImageViewer.cpp b/src/ImageViewer.cpp
@@ -1206,17 +1206,21 @@ bool ImageViewer::keyboard_event(int key, int scancode, int action, int modifier
             }
 
             return true;
-        } else if (key == GLFW_KEY_UP || key == GLFW_KEY_W || key == GLFW_KEY_PAGE_UP ||
-                   (key == GLFW_KEY_TAB && (modifiers & GLFW_MOD_CONTROL) && (modifiers & GLFW_MOD_SHIFT))) {
+        } else if (
+            key == GLFW_KEY_UP || key == GLFW_KEY_W || key == GLFW_KEY_PAGE_UP ||
+            (key == GLFW_KEY_TAB && (modifiers & GLFW_MOD_CONTROL) && (modifiers & GLFW_MOD_SHIFT))
+        ) {
             if (key != GLFW_KEY_TAB && (modifiers & GLFW_MOD_SHIFT)) {
                 selectReference(nextImage(mCurrentReference, Backward));
             } else {
                 selectImage(nextImage(mCurrentImage, Backward));
             }
 
             return true;
-        } else if (key == GLFW_KEY_DOWN || key == GLFW_KEY_S || key == GLFW_KEY_PAGE_DOWN ||
-                   (key == GLFW_KEY_TAB && (modifiers & GLFW_MOD_CONTROL) && !(modifiers & GLFW_MOD_SHIFT))) {
+        } else if (
+            key == GLFW_KEY_DOWN || key == GLFW_KEY_S || key == GLFW_KEY_PAGE_DOWN ||
+            (key == GLFW_KEY_TAB && (modifiers & GLFW_MOD_CONTROL) && !(modifiers & GLFW_MOD_SHIFT))
+        ) {
             if (key != GLFW_KEY_TAB && (modifiers & GLFW_MOD_SHIFT)) {
                 selectReference(nextImage(mCurrentReference, Forward));
             } else {
@@ -1387,7 +1391,7 @@ void ImageViewer::draw_contents() {
     }
 
     const bool anyImageVisible = mCurrentImage || mCurrentReference ||
-        any_of(begin(mImageButtonContainer->children()), end(mImageButtonContainer->children()), [](const auto& c) { return c->visible(); });
+        ranges::any_of(mImageButtonContainer->children(), [](const auto& c) { return c->visible(); });
 
     for (auto button : mAnyImageButtons) {
         button->set_enabled(anyImageVisible);
@@ -2403,7 +2407,7 @@ void ImageViewer::openImageDialog() {
                 allImages.push_back(filter.first);
             }
 
-            filters.emplace(filters.begin(), pair<string, string>{join(allImages, ","), "All images"});
+            filters.emplace(filters.begin(), pair{join(allImages, ","), "All images"});
             const auto paths = file_dialog(this, FileDialogType::OpenMultiple, filters);
 
             for (size_t i = 0; i < paths.size(); ++i) {
@@ -2735,7 +2739,7 @@ void ImageViewer::updateFilter() {
                 do {
                     int len = codePointLength(first[beginOffset]);
 
-                    allStartWithSameChar = all_of(begin(activeImageNames), end(activeImageNames), [&first, beginOffset, len](string_view name) {
+                    allStartWithSameChar = ranges::all_of(activeImageNames, [&first, beginOffset, len](string_view name) {
                         if (beginOffset + len > (int)name.size()) {
                             return false;
                         }
@@ -2755,7 +2759,7 @@ void ImageViewer::updateFilter() {
                 bool allEndWithSameChar;
                 do {
                     char lastChar = first[firstSize - endOffset - 1];
-                    allEndWithSameChar = all_of(begin(activeImageNames), end(activeImageNames), [lastChar, endOffset](string_view name) {
+                    allEndWithSameChar = ranges::all_of(activeImageNames, [lastChar, endOffset](string_view name) {
                         int index = (int)name.size() - endOffset - 1;
                         return index >= 0 && name[index] == lastChar;
                     });
@@ -2851,15 +2855,11 @@ void ImageViewer::updateTitle() {
     // Only treat alpha specially if it is not the only channel.
     const bool hasAlpha = channels.size() > 1 && Channel::isAlpha(channels.back());
 
-    auto channelTails = channels;
-    transform(begin(channelTails), end(channelTails), begin(channelTails), Channel::tail);
-
     caption << fmt::format("{} – {} – {}%", mCurrentImage->shortName(), mCurrentGroup, (int)std::round(mImageCanvas->scale() * 100));
 
     const auto rel = mouse_pos() - mImageCanvas->position();
     const vector<float> values = mImageCanvas->getValuesAtNanoPos({rel.x(), rel.y()}, channels);
     const Vector2i imageCoords = mImageCanvas->getImageCoords(mCurrentImage.get(), {rel.x(), rel.y()});
-    TEV_ASSERT(values.size() >= channelTails.size(), "Should obtain a value for every existing channel.");
 
     caption << fmt::format(
         " – @{},{} ({:.3f},{:.3f}) / {}x{}: ",
diff --git a/src/imageio/Jpeg2000ImageLoader.cpp b/src/imageio/Jpeg2000ImageLoader.cpp
@@ -205,7 +205,7 @@ Jp2Metadata extractJp2Metadata(span<const uint8_t> data) {
 
             if (memcmp(box->data.data(), xmpUuid, 16) == 0) {
                 meta.xmpXml = box->data.subspan(16);
-            } else if (any_of(begin(exifUuids), end(exifUuids), [&box](const uint8_t (&knownUuid)[16]) {
+            } else if (ranges::any_of(exifUuids, [&box](const uint8_t (&knownUuid)[16]) {
                            return memcmp(box->data.data(), knownUuid, 16) == 0;
                        })) {
                 meta.exifData = box->data.subspan(16);
diff --git a/src/imageio/TiffImageLoader.cpp b/src/imageio/TiffImageLoader.cpp

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ void BackgroundImagesLoader::enqueue(const fs::path& path, string_view channelSe`
`46`	`46`	`vector<fs::directory_entry> entries;`
`47`	`47`	`forEachFileInDir(mRecursiveDirectories, canonicalPath, [&](const auto& entry) {`
`48`	`48`	`if (!entry.is_directory()) {`
`49`		`- mFilesFoundInDirectories.emplace(PathAndChannelSelector{entry, string{channelSelector}});`
	`49`	`+ mFilesFoundInDirectories.emplace(entry, string{channelSelector});`
`50`	`50`	`entries.emplace_back(entry);`
`51`	`51`	`}`
`52`	`52`	`});`
Original file line number	Diff line number	Diff line change
`@@ -831,7 +831,7 @@ Task<shared_ptr<CanvasStatistics>> ImageCanvas::computeCanvasStatistics(`
`831`	`831`	`const ChannelView<float>* alphaChannel = nullptr;`
`832`	`832`
`833`	`833`	`// Only treat the alpha channel specially if it is not the only channel of the image.`
`834`		`- if (!all_of(begin(flattened), end(flattened), [](const Channel& c) { return c.isAlpha(); })) {`
	`834`	`+ if (ranges::any_of(flattened, [](const Channel& c) { return !c.isAlpha(); })) {`
`835`	`835`	`if (flattened.back().isAlpha()) {`
`836`	`836`	`alphaChannel = &views.back();`
`837`	`837`	`}`