Resources (#1)

* start some resource fiddling

* start some resource fiddling

* initiate a real resource manager

* fix color flicker in rendering

* delete unintended constructors

and add a convenience function to reset the render-image (from the
original image, aka. clone again)

* [OpenGL deprecation warning]

The compiler said that these functions are "deprecated". They seem to
be useless anyway...

* various improvements

* add resource enumerator and documentation

* fix constness stuff

* use existing iterator for insertion

* init unit tests

* rm bogus file

---------

Co-authored-by: m-aXimilian <keuffnermax@gmail.com>

lib/CMakeLists.txt

@@ -1,3 +1,4 @@
 add_subdirectory(utilities)
 add_subdirectory(imaging)
-add_subdirectory(rendering)
+add_subdirectory(rendering)
+add_subdirectory(resources)

lib/imaging/CMakeLists.txt

@@ -6,7 +6,7 @@ message(STATUS "Found opencv: " ${OpenCV_INCLUDE_DIRS})
 message(STATUS "OpenCV_LIBs from: " ${OpenCV_LIBS})
 
 set(IMAGELIBSRC
-  Image.cpp)
+  PixelariumImage.cpp)
 
 set(IMAGELIBLIBNAME pixelariumimagelib)
 
@@ -20,4 +20,4 @@ target_link_libraries(${IMAGELIBLIBNAME}
 
 target_include_directories(${IMAGELIBLIBNAME}
   PUBLIC ${OpenCV_INCLUDE_DIRS}
-  PRIVATE ${LIBCZI_INCLUDE_DIR})
+  PRIVATE ${LIBCZI_INCLUDE_DIR})

lib/imaging/Image.hpp

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <opencv2/core/mat.hpp>
-#include <string>
-
-namespace pixelarium::imaging
-{
-class Image
-{
-   public:
-
-    explicit Image(const std::string& uri);
-
-    // get back the defaults
-    Image() = default;
-    // we cannot copy an Image since this conflicts with the _img field
-    Image(const Image& other) = delete;
-    Image(Image&& other) noexcept = default;
-    // requires a copy ctor which we don't have
-    Image& operator=(const Image& other) = delete;
-    Image& operator=(Image&& other) noexcept = default;
-    ~Image() = default;
-
-    const cv::Mat& GetImage() const { return *this->_img.get(); }
-
-   private:
-    std::unique_ptr<cv::Mat> _img;
-};
-
-}  // namespace pixelarium::imaging

lib/imaging/PixelariumImage.cpp

@@ -1,18 +1,17 @@
-#include "Image.hpp"
+#include "PixelariumImage.hpp"
 
 #include <filesystem>
 #include <format>
 #include <memory>
 #include <opencv2/imgcodecs.hpp>
 #include <stdexcept>
-#include <string_view>
 
-pixelarium::imaging::Image::Image(const std::string& uri)
+pixelarium::imaging::PixelariumImage::PixelariumImage(const std::string& uri)
 {
     if (!std::filesystem::exists(uri))
     {
         throw std::runtime_error(std::format("File not {} found", uri));
     }
 
-    this->_img = std::make_unique<cv::Mat>(cv::imread(uri));
-}
+    this->img_ = std::make_unique<cv::Mat>(cv::imread(uri));
+}

lib/imaging/PixelariumImage.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <memory>
+#include <opencv2/core/mat.hpp>
+#include <string>
+
+namespace pixelarium::imaging
+{
+class PixelariumImage
+{
+   public:
+
+    explicit PixelariumImage(const std::string& uri);
+
+    // get back the defaults
+    PixelariumImage() = default;
+    // we cannot copy an Image since this conflicts with the _img field
+    PixelariumImage(const PixelariumImage& other) = delete;
+    PixelariumImage(PixelariumImage&& other) noexcept
+        : img_(std::move(other.img_)) {}
+    // requires a copy ctor which we don't have
+    PixelariumImage& operator=(const PixelariumImage& other) = delete;
+    PixelariumImage& operator=(PixelariumImage&& other) noexcept
+    {
+        if (this != &other)
+        {
+            img_ = std::move(other.img_);
+        }
+
+        return *this;
+    }
+
+    ~PixelariumImage() = default;
+
+    const cv::Mat& GetImage() const { return *this->img_.get(); }
+
+   protected:
+    std::unique_ptr<cv::Mat> img_;
+};
+
+}  // namespace pixelarium::imaging

lib/rendering/CvMatRender.cpp

@@ -1,90 +1,118 @@
 #include "CvMatRender.hpp"
 
-#include <cstdint>
 #include <memory>
 #include <opencv2/core/mat.hpp>
-#include <tuple>
-#include <utility>
-#include "imaging/Image.hpp"
 #include <opencv2/imgproc.hpp>
+#include <stdexcept>
+
+#include "imaging/PixelariumImage.hpp"
 
 using namespace pixelarium::imaging;
 
-pixelarium::render::CvMatRender::CvMatRender(const std::shared_ptr<Image>& img)
-    : _base(img), _texture(0)
+/// @brief Constructor for the CvMatRender class.
+/// @param img A shared pointer to the PixelariumImage to be rendered.
+pixelarium::render::CvMatRender::CvMatRender(const std::shared_ptr<PixelariumImage>& img) : base_(img), texture_(0)
 {
-    // this->_img = this->_base->GetImage().clone();
-    // // storing a copy of the to-be-rendered image with a "well-behaved"
-    // cv::cvtColor(this->_img, this->_img, cv::COLOR_BGR2RGBA);
-    this->_img = this->_base->GetImage().clone();
+    // storing a copy of the to-be-rendered image
+    // because it will be resized and filtered eventually which we absolutely
+    // must not do on the original image
+    this->ResetRenderImage();
+    cv::cvtColor(this->img_, this->img_, cv::COLOR_BGR2RGBA);
 }
 
-/*static*/ void pixelarium::render::matToTexture(const cv::Mat& image,
-                                                 GLuint* texture)
+/// @brief Destructor for the CvMatRender class.
+/// Deallocates the OpenGL texture if it exists.
+pixelarium::render::CvMatRender::~CvMatRender()
 {
-    // only generate the texture when it's not already present
-    if (*texture == 0)
+    if (texture_)
     {
-        glGenTextures(1, texture);
+        glDeleteTextures(1, &texture_);
+        texture_ = 0;
+    }
+}
+
+/// @brief Resets the render image with a new PixelariumImage.
+/// @param img A shared pointer to the new PixelariumImage.
+void pixelarium::render::CvMatRender::ResetRenderImage(const std::shared_ptr<pixelarium::imaging::PixelariumImage>& img)
+{
+    this->base_ = img;
+    this->ResetRenderImage();
+    cv::cvtColor(this->img_, this->img_, cv::COLOR_BGR2RGBA);
+}
+
+/// @brief Uploads the current image data to an OpenGL texture.
+/// @return The ID of the uploaded OpenGL texture.
+/// @throws std::runtime_error if the image data is empty or if there is an OpenGL error.
+GLuint pixelarium::render::CvMatRender::uploadTexture()
+{
+    if (img_.empty())
+    {
+        throw std::runtime_error("Image data is empty.");
     }
 
-    glBindTexture(GL_TEXTURE_2D, *texture);
+    if (!this->texture_)
+    {
+        glGenTextures(1, &this->texture_);
+        if (this->texture_ == 0)
+        {
+            throw std::runtime_error("Failed to generate OpenGL texture.");
+        }
+    }
+
+    glBindTexture(GL_TEXTURE_2D, this->texture_);
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
-    // auto image = img.GetImage();
-    switch (image.type())
+    const int width = img_.cols;
+    const int height = img_.rows;
+
+    GLenum format = (img_.type() == CV_32FC3 || img_.type() == CV_32FC1) ? GL_RGB : GL_RGBA;
+    GLenum type = (img_.type() == CV_16U || img_.type() == CV_16UC3) ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE;
+    GLenum internalFormat = GL_RGBA;
+    if (img_.type() == CV_32FC3 || img_.type() == CV_32FC1)
     {
-        case CV_16U:
-        case CV_16UC3:
-        case 26:
-            glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.cols, image.rows, 0,
-                         GL_RGBA, GL_UNSIGNED_SHORT, image.data);
-            break;
-        case 5:
-        case 29:
-            glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.cols, image.rows, 0,
-                         GL_RGBA, GL_FLOAT, image.data);
-            break;
-        default:
-            glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.cols, image.rows, 0,
-                         GL_RGBA, GL_UNSIGNED_BYTE, image.data);
-            break;
+        internalFormat = GL_RGB;
     }
-}
 
-GLuint* pixelarium::render::CvMatRender::Render()
-{
-    // storing a copy of the to-be-rendered image with a "well-behaved"
-    cv::cvtColor(this->_img, this->_img, cv::COLOR_BGR2RGBA);
+    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, format, type, img_.data);
 
-    matToTexture(this->_img, &this->_texture);
-    return &this->_texture;
-}
-
-GLuint* pixelarium::render::CvMatRender::Render(float factor)
-{
-    cv::resize(this->_base->GetImage(), this->_img, cv::Size(0,0), factor, factor, cv::INTER_LINEAR_EXACT);
-
-    return this->Render();
-}
-
-GLuint* pixelarium::render::CvMatRender::Render(size_t width, size_t height)
-{
-    // this is nasty as it knows about what Render is doing
-    const auto sz{this->_base->GetImage().size()};
-
-    const auto get_factor = [](auto opt1, auto opt2) -> float
+    GLenum error = glGetError();
+    if (error != GL_NO_ERROR)
     {
-        return opt1 < opt2 ? opt1 : opt2;
-    };
+        throw std::runtime_error("OpenGL error during texture upload: " + std::to_string(error));
+    }
+
+    return this->texture_;
+}
+
+/// @brief Renders the image by uploading it as a texture.
+/// @return The ID of the OpenGL texture.
+GLuint pixelarium::render::CvMatRender::Render() { return this->uploadTexture(); }
+
+/// @brief Renders the image with a specified scaling factor.
+/// @param factor The scaling factor for resizing the image.
+/// @return The ID of the OpenGL texture.
+GLuint pixelarium::render::CvMatRender::Render(float factor)
+{
+    cv::resize(this->base_->GetImage(), this->img_, cv::Size(0, 0), factor, factor, cv::INTER_LINEAR_EXACT);
+
+    return this->uploadTexture();
+}
+
+/// @brief Renders the image to fit within the specified width and height.
+/// @param width The maximum width of the rendered image.
+/// @param height The maximum height of the rendered image.
+/// @return The ID of the OpenGL texture.
+GLuint pixelarium::render::CvMatRender::Render(size_t width, size_t height)
+{
+    const auto sz{this->base_->GetImage().size()};
+
+    const auto get_factor = [](auto opt1, auto opt2) -> float { return opt1 < opt2 ? opt1 : opt2; };
 
     auto factor = get_factor(width / static_cast<float>(sz.width), height / static_cast<float>(sz.height));
-    // cv::resize(this->_base->GetImage(), this->_img, cv::Size(0,0), factor, factor, cv::INTER_LINEAR_EXACT);
 
     return this->Render(factor);
 }
-

lib/rendering/CvMatRender.hpp

@@ -13,25 +13,41 @@
 #endif
 #include <GLFW/glfw3.h>  // Will drag system OpenGL headers
 #endif
-#include "imaging/Image.hpp"
+#include "imaging/PixelariumImage.hpp"
 // clang-format on
 
 namespace pixelarium::render
 {
-static void matToTexture(const cv::Mat& image, GLuint* texture);
 class CvMatRender
 {
    public:
+    // we want the default constructor for the time being
+    // (although it does not make much sense and should
+    // get removed in the future)
+    // as the using AppGLFW constructs it empty as a member
+    // when coming to life.
     CvMatRender() = default;
-    explicit CvMatRender(const std::shared_ptr<pixelarium::imaging::Image>& img);
-    GLuint* Render();
-    GLuint* Render(float factor);
-    GLuint* Render(size_t width, size_t height);
+    CvMatRender(CvMatRender&) = delete;
+    CvMatRender(const CvMatRender&) = delete;
+    CvMatRender(CvMatRender&&) = delete;
+    CvMatRender& operator=(CvMatRender&) = default;
+    CvMatRender& operator=(CvMatRender&&) = default;
+    ~CvMatRender();
+    explicit CvMatRender(const std::shared_ptr<pixelarium::imaging::PixelariumImage>& img);
+
+   public:
+    GLuint Render();
+    GLuint Render(float factor);
+    GLuint Render(size_t width, size_t height);
+    void ResetRenderImage() { this->img_ = this->base_->GetImage().clone(); }
+    void ResetRenderImage(const std::shared_ptr<pixelarium::imaging::PixelariumImage>& img);
 
    private:
-    cv::Mat _img;
-    std::shared_ptr<pixelarium::imaging::Image> _base;
-    GLuint _texture;
+    cv::Mat img_;
+    std::shared_ptr<pixelarium::imaging::PixelariumImage> base_;
+    GLuint texture_;
+
+    GLuint uploadTexture();
 };
 
-}  // namespace pixelarium::render
+}  // namespace pixelarium::render

lib/resources/CMakeLists.txt

@@ -0,0 +1,13 @@
+set(RESOURCELIBNAME pixelariumresourcelib)
+
+set(RESOURCELIBSRC
+  resource.cpp)
+
+add_library(${RESOURCELIBNAME} STATIC
+  ${RESOURCELIBSRC})
+
+target_link_libraries(${RESOURCELIBNAME}
+  PRIVATE pixelariumimagelib)
+
+target_include_directories(${RESOURCELIBNAME}
+  PRIVATE ${CMAKE_SOURCE_DIR}/lib)

lib/resources/resource.cpp

@@ -0,0 +1,78 @@
+#include "resource.hpp"
+
+#include <atomic>
+#include <optional>
+
+using pixelarium::imaging::PixelariumImage;
+using namespace std;
+
+namespace
+{
+/// @brief Atomic counter for generating unique IDs.
+static std::atomic<size_t> id_;
+
+/// @brief Generates a unique ID.
+/// @return A unique ID.
+size_t GenerateId() { return id_.fetch_add(1, memory_order_relaxed); }
+}  // namespace
+
+/// @brief Retrieves a resource from the pool.
+/// @param id The ID of the resource to retrieve.
+/// @return A pointer to the resource if found, otherwise an empty optional.
+std::optional<const PixelariumImage*> pixelarium::resources::ImageResourcePool::GetResource(size_t id) const
+{
+    auto search{this->resources_.find(id)};
+    if (search == this->resources_.end()) return std::nullopt;
+
+    return search->second.get();
+}
+
+/// @brief Sets a resource in the pool.
+/// @param res A unique pointer to the resource to set.
+/// @return The ID of the new resource.
+size_t pixelarium::resources::ImageResourcePool::SetResource(unique_ptr<PixelariumImage> res)
+{
+    auto key{::GenerateId()};
+    this->resources_.insert({key, std::move(res)});
+
+    return key;
+}
+
+/// @brief Updates a resource in the pool.
+/// @param id The ID of the resource to update.
+/// @param res A unique pointer to the new resource.
+/// @return True if the resource was updated, false otherwise.
+bool pixelarium::resources::ImageResourcePool::UpdateResource(size_t id, std::unique_ptr<imaging::PixelariumImage> res)
+{
+    auto search{this->resources_.find(id)};
+    if (search == this->resources_.end()) return false;
+
+    search->second = std::move(res);
+
+    return true;
+}
+
+/// @brief Deletes a resource from the pool.
+/// @param id The ID of the resource to delete.
+/// @return True if the resource was deleted, false otherwise.
+bool pixelarium::resources::ImageResourcePool::DeleteResource(size_t id)
+{
+    auto search{this->resources_.find(id)};
+    if (search == this->resources_.end()) return false;
+
+    this->resources_.erase(search);
+
+    return true;
+}
+
+/// @brief Enumerates all resources in the pool.
+/// @param func A function to call for each resource.  The function should accept the resource ID and a const reference
+/// to a PixelariumImage.
+void pixelarium::resources::ImageResourcePool::EnumerateResources(
+    const std::function<void(size_t, const imaging::PixelariumImage&)>& func)
+{
+    for (const auto& e : this->resources_)
+    {
+        func(e.first, *e.second);
+    }
+}

lib/resources/resource.hpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <unordered_map>
+
+#include "imaging/PixelariumImage.hpp"
+
+namespace pixelarium::resources
+{
+struct IResource
+{
+    virtual ~IResource() = 0;
+};
+
+template <typename R>
+concept ResT = requires(R& r) { static_cast<IResource&>(r); };
+
+// template <ResT R>
+template <typename R>
+class IResourcePool
+{
+   public:
+    virtual ~IResourcePool() = default;
+    virtual std::optional<const R*> GetResource(size_t id) const = 0;
+    virtual size_t SetResource(std::unique_ptr<R> res) = 0;
+    virtual bool UpdateResource(size_t id, std::unique_ptr<R> res) = 0;
+    virtual bool DeleteResource(size_t id) = 0;
+    virtual void EnumerateResources(const std::function<void(size_t, const R&)>& func) = 0;
+};
+
+// Now with the =GetResource= method, I do not want to transfer ownership to the caller of that method. The ownership
+// should still
+// reside with the =ResourcePool=!
+// In fact, the intention is, that there is no way back once the =ResourcePool= took ownership of an object.
+// Callers can get references, but no ownership. A caller might delete a resource though.
+class ImageResourcePool : public IResourcePool<imaging::PixelariumImage>
+{
+   public:
+    ImageResourcePool() = default;
+    ImageResourcePool(ImageResourcePool&) = delete;
+    ImageResourcePool(const ImageResourcePool&) = delete;
+    ImageResourcePool(ImageResourcePool&&) = delete;
+    ImageResourcePool& operator=(ImageResourcePool&) = delete;
+    ImageResourcePool& operator=(ImageResourcePool&&) = delete;
+
+    std::optional<const imaging::PixelariumImage*> GetResource(size_t id) const override;
+    size_t SetResource(std::unique_ptr<imaging::PixelariumImage> res) override;
+    bool UpdateResource(size_t id, std::unique_ptr<imaging::PixelariumImage> res) override;
+    bool DeleteResource(size_t id) override;
+
+    void EnumerateResources(const std::function<void(size_t, const imaging::PixelariumImage&)>& func) override;
+
+   private:
+    std::unordered_map<size_t, std::unique_ptr<imaging::PixelariumImage>> resources_;
+};
+}  // namespace pixelarium::resources

lib/utilities/ILog.hpp

@@ -3,6 +3,14 @@
 
 namespace pixelarium::utils::log
 {
+enum class LogLevel
+{
+    Trace = 1 << 0,
+    Debug = 1 << 1,
+    Info = 1 << 2,
+    Warn = 1 << 3,
+    Error = 1 << 4,
+};
 class ILog
 {
    public:
@@ -10,8 +18,9 @@ class ILog
     virtual void Debug(const std::string& msg) = 0;
     virtual void Warn(const std::string& msg) = 0;
     virtual void Error(const std::string& msg) = 0;
+    virtual void ChangeLevel(LogLevel lvl) = 0;
 
     virtual ~ILog() {}
 };
 
-}  // namespace pixelarium::utils::log
+}  // namespace pixelarium::utils::log

lib/utilities/SpdLogger.cpp

@@ -5,31 +5,58 @@
 #include <spdlog/sinks/basic_file_sink.h>
 #include <memory>
 #include <string>
+#include "ILog.hpp"
 
 
 using namespace pixelarium::utils::log;
 
 SpdLogger::SpdLogger(const std::string& file_sink, const std::string& name)
-    : _logger(spdlog::basic_logger_mt(name, file_sink)), _file(file_sink), _name(name)
+    : logger_(spdlog::basic_logger_mt(name, file_sink)), file_(file_sink), name_(name)
 {
-    spdlog::set_default_logger(this->_logger);
+    spdlog::set_default_logger(this->logger_);
     spdlog::flush_on(spdlog::level::info);
-    _logger->info("Logger initiated");
+    logger_->info("Logger initiated");
 }
 
 void SpdLogger::Info(const std::string& msg)
 {
-    this->_logger->info(msg);
+    this->logger_->info(msg);
 }
 void SpdLogger::Debug(const std::string& msg)
 {
-    this->_logger->debug(msg);
+    this->logger_->debug(msg);
 }
 void SpdLogger::Warn(const std::string& msg)
 {
-    this->_logger->warn(msg);
+    this->logger_->warn(msg);
 }
-void SpdLogger::Error(const std::string& msg)
+void SpdLogger::Error(const std::string& msg) { this->logger_->error(msg); }
+
+void SpdLogger::ChangeLevel(LogLevel lvl)
 {
-    this->_logger->error(msg);
-}
+    switch (lvl)
+    {
+        case LogLevel::Trace:
+            this->logger_->set_level(spdlog::level::trace);
+            spdlog::flush_on(spdlog::level::trace);
+            break;
+        case LogLevel::Info:
+            this->logger_->set_level(spdlog::level::info);
+            spdlog::flush_on(spdlog::level::info);
+            break;
+        case LogLevel::Warn:
+            this->logger_->set_level(spdlog::level::warn);
+            spdlog::flush_on(spdlog::level::warn);
+            break;
+        case LogLevel::Error:
+            this->logger_->set_level(spdlog::level::err);
+            spdlog::flush_on(spdlog::level::err);
+            break;
+        case LogLevel::Debug:
+        default:
+            this->logger_->set_level(spdlog::level::debug);
+            spdlog::flush_on(spdlog::level::debug);
+    }
+
+    this->logger_->debug("Changed log level;");
+}

lib/utilities/SpdLogger.hpp

@@ -17,10 +17,11 @@ class SpdLogger : public ILog
     void Debug(const std::string& msg) override;
     void Warn(const std::string& msg) override;
     void Error(const std::string& msg) override;
+    void ChangeLevel(LogLevel lvl) override;
 
    private:
-    std::shared_ptr<spdlog::logger> _logger;
-    std::string _file;
-    std::string _name;
+    std::shared_ptr<spdlog::logger> logger_;
+    std::string file_;
+    std::string name_;
 };
-}  // namespace pixelarium::utils::log
+}  // namespace pixelarium::utils::log