Proper image rendering ux (#5)

* can draw from selection

* add light-weight render manager to render many images simultaneously

* [debug me] currently the image close button does not do

* the unselected image can be closed now

* can close images and manually open them on demand

* cosmetic

* image view stuff in render subdirectory

* cosmetic

* generate docs

* review

windows support

some cosmetics

💅 and pin libCZI module

lib/rendering/CMakeLists.txt

@@ -1,7 +1,10 @@
 set(RENDERLIBNAME pixelariumrenderlib)
 
 set(RENDERLIBSRC
-  CvMatRender.cpp)
+  CvMatRender.cpp
+  RenderImageManager.cpp
+  PixelariumImageView.cpp
+  ImageViewFactory.cpp)
 
 add_library(${RENDERLIBNAME} STATIC
   ${RENDERLIBSRC})
@@ -10,4 +13,5 @@ target_link_libraries(${RENDERLIBNAME}
   PRIVATE pixelariumimagelib)
 
 target_include_directories(${RENDERLIBNAME}
-  PRIVATE ${CMAKE_SOURCE_DIR}/lib)
+  PRIVATE ${CMAKE_SOURCE_DIR}/lib
+  PRIVATE ${imgui_DIR})

lib/rendering/ImageViewFactory.cpp

@@ -0,0 +1,22 @@
+#include "ImageViewFactory.hpp"
+
+#include <memory>
+#include <optional>
+
+/// @brief Creates a PixelariumImageView from a resource image.
+/// @param image_id The ID of the image resource to render.
+/// @return A unique pointer to the PixelariumImageView, or nullptr if the image resource is not found or is empty.  The image data is copied.
+std::unique_ptr<pixelarium::render::PixelariumImageView> pixelarium::render::ImageViewFactory::RenderImage(
+    size_t image_id)
+{
+    auto img{this->image_pool_.GetResource(image_id)};
+
+    if (!img.has_value() || img.value()->Empty())
+    {
+        return nullptr;
+    }
+
+    // beware: here we copy the actual image resource over to the new image
+    return std::make_unique<PixelariumImageView>(std::make_shared<Image>(*img.value()));
+}
+

lib/rendering/ImageViewFactory.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "PixelariumImageView.hpp"
+#include "imaging/PixelariumImage.hpp"
+#include "resources/resource.hpp"
+namespace pixelarium::render
+{
+class ImageViewFactory
+{
+    using Image = imaging::PixelariumImage;
+    using Pool = resources::ImageResourcePool;
+
+   public:
+    explicit ImageViewFactory(Pool& pool) : image_pool_(pool) {}
+
+    std::unique_ptr<PixelariumImageView> RenderImage(size_t id);
+
+   private:
+    Pool& image_pool_;
+};
+}  // namespace pixelarium::render

lib/rendering/PixelariumImageView.cpp

@@ -0,0 +1,70 @@
+#include "PixelariumImageView.hpp"
+
+#include <format>
+
+#include "imgui.h"
+
+/// @brief Checks if the dimensions of two ImVec2 vectors have changed significantly.
+/// @param ref_rect The reference ImVec2 vector.
+/// @param new_rect The new ImVec2 vector to compare against.
+/// @return True if the absolute difference between the y-coordinates is greater than 5 or the x-coordinates are
+/// different; otherwise, false.
+static bool dim_changed_p(const ImVec2& ref_rect, const ImVec2& new_rect)
+{
+    if (std::abs(ref_rect.y - new_rect.y) > 5 || std::abs(ref_rect.x - new_rect.x))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+/// @brief Calculates dimensions to maintain aspect ratio.
+/// @param img The input image.
+/// @param curr_dim The current dimensions.
+/// @return The calculated dimensions maintaining aspect ratio.
+ImVec2 aspect_const_dimensions(const pixelarium::imaging::PixelariumImage& img, const ImVec2& curr_dim)
+{
+    const auto w_fact = (static_cast<float>(curr_dim.x) / img.GetImage().cols);
+    const auto h_fact = (static_cast<float>(curr_dim.y) / img.GetImage().rows);
+
+    const auto fact = w_fact < h_fact ? w_fact : h_fact;
+
+    return ImVec2(img.GetImage().cols * fact, img.GetImage().rows * fact);
+}
+
+/// @brief Displays the image in an ImGui window.
+///
+/// If the image is null, empty, or has an empty name, the function returns immediately.  Otherwise, it creates an ImGui
+/// window with a horizontal scrollbar and menu bar. The image is rendered using the CvMatRender object, resizing it to
+/// fit the available window space.  The raw and rendered dimensions are displayed below the image.
+void pixelarium::render::PixelariumImageView::ShowImage()
+{
+    if (this->img_ == nullptr || this->img_->Empty() || this->img_->Name().empty())
+    {
+        // do nothing
+        return;
+    }
+
+    ImGui::Begin(img_->Name().c_str(), &this->open_p, ImGuiWindowFlags_HorizontalScrollbar | ImGuiWindowFlags_MenuBar);
+
+    this->curr_dim_ = ImGui::GetContentRegionAvail();
+    auto new_dim = ImGui::GetContentRegionAvail();
+    auto texture =
+        dim_changed_p(this->curr_dim_, new_dim)
+            ? this->render_.Render(static_cast<size_t>(this->curr_dim_.x), static_cast<size_t>(this->curr_dim_.y))
+            : this->render_.Render();
+
+    this->curr_dim_ = new_dim;
+
+    ImVec2 dim(this->img_->GetImage().cols, this->img_->GetImage().rows);
+
+    ImGui::Image(reinterpret_cast<ImTextureID>(reinterpret_cast<void*>(texture)),
+                 aspect_const_dimensions(*this->img_, new_dim));
+
+    ImGui::Separator();
+    ImGui::Text("%s", std::format("   Raw Dimensions W : {}, H: {}", dim.x, dim.y).c_str());
+    ImGui::Text("%s", std::format("Render Dimensions W : {}, H: {}", curr_dim_.x, curr_dim_.y).c_str());
+
+    ImGui::End();
+}

lib/rendering/PixelariumImageView.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <memory>
+
+#include "imaging/PixelariumImage.hpp"
+#include "imgui.h"
+#include "rendering/CvMatRender.hpp"
+
+namespace pixelarium::render
+{
+class PixelariumImageView
+{
+    using Image = imaging::PixelariumImage;
+    using Render = render::CvMatRender;
+
+   public:
+    explicit PixelariumImageView(const std::shared_ptr<Image>& img) : img_(img) { render_ = Render(img_); }
+    PixelariumImageView() = delete;
+    PixelariumImageView(PixelariumImageView&) = delete;
+    PixelariumImageView(const PixelariumImageView&) = delete;
+    PixelariumImageView(PixelariumImageView&&) = delete;
+    PixelariumImageView& operator=(PixelariumImageView&) = delete;
+    PixelariumImageView& operator=(PixelariumImageView&&) = delete;
+
+    // void ToggleView(bool target) { open_p = target; }
+    const bool* GetStatus() const noexcept { return &this->open_p; }
+    void ShowImage();
+
+   private:
+    const std::shared_ptr<Image> img_;
+    Render render_;
+    bool open_p{true};
+    ImVec2 curr_dim_{};
+};
+}  // namespace pixelarium::render

lib/rendering/RenderImageManager.cpp

@@ -0,0 +1,76 @@
+#include "RenderImageManager.hpp"
+
+#include <format>
+
+using namespace std;
+
+/// @brief Updates the collection of rendered images by removing images marked for deletion.
+/// This function iterates through the \c keys_to_delete_ list and removes the corresponding images from the collection.
+/// It does not acquire the mutex to avoid deadlocks with the `Remove` function.
+void pixelarium::render::RenderImageManager::UpdateCollection()
+{
+    for (const auto& key : keys_to_delete_)
+    {
+        this->Remove(key);
+    }
+
+    keys_to_delete_.clear();
+}
+
+/// @brief Marks a resource for deletion.
+/// @param key The ID of the resource to mark for deletion.
+void pixelarium::render::RenderImageManager::MarkForDeletion(resources::ResourceKey key)
+{
+    this->log_.Debug(std::format("{} marking key: \"{}\" for deletion.", __PRETTY_FUNCTION__, key));
+    lock_guard<mutex> guard(this->mut_);
+    keys_to_delete_.insert(key);
+}
+
+/// @brief Removes a render image from the manager.
+/// @param key The key of the render image to remove.
+/// @return True if the render image was removed, false otherwise.
+bool pixelarium::render::RenderImageManager::Remove(resources::ResourceKey key) noexcept
+{
+    bool remove_state{false};
+    this->log_.Debug(std::format("{} removing key: \"{}\" from renderlist.", __PRETTY_FUNCTION__, key));
+    {
+        lock_guard<mutex> guard(this->mut_);
+        remove_state = this->render_image_map_.erase(key) == 1;
+    }
+
+    return remove_state;
+}
+
+/// @brief Adds a resource to the render image map.
+/// @param key The ID of the resource to add.
+/// @return void.  No exception is thrown.
+void pixelarium::render::RenderImageManager::Add(resources::ResourceKey key) noexcept
+{
+    // we don't want to add what's already there
+    // or empty render images
+    auto current_view = this->view_factory_->RenderImage(key);
+    if (this->render_image_map_.contains(key) || current_view == nullptr)
+    {
+        return;
+    }
+
+    this->log_.Debug(std::format("{}: adding key: \"{}\" to renderlist.", __PRETTY_FUNCTION__, key));
+
+    lock_guard<mutex> guard(this->mut_);
+    // clang-format off
+        this->render_image_map_.insert(
+            {
+                key,
+                RenderImageStateWrapper
+                {
+                    .view{ std::move(current_view) },
+                    .show_state = current_view->GetStatus(),
+                }
+            }
+            );
+    // clang-format on
+}
+
+/// @brief Clears all render images from the manager.
+/// @note This function is noexcept.
+void pixelarium::render::RenderImageManager::Clear() noexcept { this->render_image_map_.clear(); }

lib/rendering/RenderImageManager.hpp

@@ -0,0 +1,64 @@
+#pragma once
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "ImageViewFactory.hpp"
+#include "PixelariumImageView.hpp"
+#include "resources/resource.hpp"
+#include "utilities/ILog.hpp"
+
+// This is intended as an additional abstraction
+// aggregating views that should be rendered (or not)
+namespace pixelarium::render
+{
+struct RenderImageStateWrapper
+{
+    std::unique_ptr<PixelariumImageView> view;
+    const bool* show_state;
+};
+
+class RenderImageManager
+{
+    using Pool = resources::ImageResourcePool;
+
+   public:
+    explicit RenderImageManager(Pool& pool, const utils::log::ILog& log)
+        : view_factory_(std::make_unique<ImageViewFactory>(pool)), log_(log)
+    {
+    }
+
+    void Clear() noexcept;
+
+    void Add(resources::ResourceKey key) noexcept;
+
+    bool Remove(resources::ResourceKey key) noexcept;
+
+    // can't be const because func mutates the state
+    template <typename Callable>
+        requires std::invocable<Callable, resources::ResourceKey, RenderImageStateWrapper&>
+    void Enumerate(Callable&& func)
+    {
+        for (auto& [key, val] : this->render_image_map_)
+        {
+            if (val.view != nullptr)
+            {
+                func(key, val);
+            }
+        }
+    }
+
+    void MarkForDeletion(resources::ResourceKey key);
+
+    void UpdateCollection();
+
+   private:
+    std::unordered_map<resources::ResourceKey, RenderImageStateWrapper> render_image_map_;
+    std::unique_ptr<ImageViewFactory> view_factory_;
+    std::mutex mut_;
+    std::unordered_set<resources::ResourceKey> keys_to_delete_;
+
+    const utils::log::ILog& log_;
+};
+}  // namespace pixelarium::render