Misc Improvements (#7)

* get rid of optional<ptr> -> double indirection

* more optional cleanup

* fix

* add more render pixel type options

* towards different views

* missing virtual declaration of ShowImage

* fix runtime

* init image view factory

* fix build

Render Image close button re-enable

add readme

init documentation

use awesomeDoxygen

ci build docs

install doxygen

id token permission

add pages write permission

lib/rendering/CMakeLists.txt

@@ -1,9 +1,14 @@
 set(RENDERLIBNAME pixelariumrenderlib)
 
 set(RENDERLIBSRC
+  CvMatRender.hpp
   CvMatRender.cpp
+  RenderImageManager.hpp
   RenderImageManager.cpp
-  PixelariumImageView.cpp
+  IPixelariumImageView.hpp
+  PixelariumImageViewDefault.hpp
+  PixelariumImageViewDefault.cpp
+  ImageViewFactory.hpp
   ImageViewFactory.cpp)
 
 add_library(${RENDERLIBNAME} STATIC

lib/rendering/CvMatRender.cpp

@@ -61,24 +61,30 @@ GLuint pixelarium::render::CvMatRender::uploadTexture()
 
     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);
 
     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)
-    {
-        internalFormat = GL_RGB;
+    switch (img_.type()) {
+        case CV_16U:
+        case CV_16UC3:
+        case 26:
+            glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_SHORT, img_.data);
+            break;
+        case 5:
+        case 29:
+            glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_FLOAT, img_.data);
+            break;
+        default:
+            glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, img_.cols, img_.rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, img_.data);
+            break;
     }
 
-    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, format, type, img_.data);
-
     GLenum error = glGetError();
     if (error != GL_NO_ERROR)
     {
@@ -98,9 +104,9 @@ GLuint pixelarium::render::CvMatRender::Render() { return this->uploadTexture();
 GLuint pixelarium::render::CvMatRender::Render(float factor)
 {
     auto res_val {this->base_->TryGetImage()};
-    if (res_val.has_value())
+    if (res_val)
     {
-        cv::resize(*res_val.value(), this->img_, cv::Size(0, 0), factor, factor, cv::INTER_LINEAR_EXACT);
+        cv::resize(*res_val, this->img_, cv::Size(0, 0), factor, factor, cv::INTER_LINEAR_EXACT);
     }
 
     return this->uploadTexture();
@@ -114,12 +120,12 @@ GLuint pixelarium::render::CvMatRender::Render(size_t width, size_t height)
 {
     auto res_val {this->base_->TryGetImage()};
 
-    if (!res_val.has_value())
+    if (!res_val)
     {
         return this->Render(1.0f);
     }
 
-    const auto sz{res_val.value()->size()};
+    const auto sz{res_val->size()};
 
     const auto get_factor = [](auto opt1, auto opt2) -> float { return opt1 < opt2 ? opt1 : opt2; };
 
@@ -137,16 +143,11 @@ void pixelarium::render::CvMatRender::ResetRenderImage()
 
     auto root_res = this->base_->TryGetImage();
 
-    if (!root_res.has_value())
-    {
-        return;
-    }
-
-    if (root_res.value() == nullptr)
+    if (!root_res)
     {
         return;
     }
 
     // we copy here
-    this->img_ = (*root_res.value()).clone();
+    this->img_ = root_res->clone();
 }

lib/rendering/IPixelariumImageView.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <memory>
+
+#include "imaging/IPixelariumImage.hpp"
+#include "rendering/CvMatRender.hpp"
+
+namespace pixelarium::render
+{
+class IPixelariumImageView
+{
+   public:
+    virtual ~IPixelariumImageView() = default;
+    virtual void ShowImage() = 0;
+
+    // default implemented
+   public:
+    virtual const bool* GetStatus() const noexcept { return &this->open_p; }
+    virtual void ForceUpdate() noexcept { this->is_dirty_ = true; }
+
+   protected:
+    std::shared_ptr<imaging::IPixelariumImage> img_{};
+    std::unique_ptr<cv::Mat> cached_image_{};
+    render::CvMatRender render_;
+    bool open_p{true};
+    bool is_dirty_{true};
+};
+}  // namespace pixelarium::render

lib/rendering/ImageViewFactory.cpp

@@ -1,29 +1,49 @@
 #include "ImageViewFactory.hpp"
 
 #include <memory>
-#include <optional>
+#include "imaging/PixelariumImageFactory.hpp"
+#include "rendering/IPixelariumImageView.hpp"
+#include "rendering/PixelariumImageViewDefault.hpp"
 
 /// @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(
+std::unique_ptr<pixelarium::render::IPixelariumImageView> pixelarium::render::ImageViewFactory::RenderImage(
     size_t image_id)
 {
     auto res{this->image_pool_.GetResource(image_id)};
 
-    if (!res.has_value())
+    auto img{res.lock()};
+
+    if (img == nullptr)
     {
         return {};
     }
 
-    auto img {res.value().lock()};
-
     if (img->Empty())
     {
         return {};
     }
 
-    // beware: here we copy the actual image resource over to the new image
-    return std::make_unique<PixelariumImageView>(img);
+    auto type = imaging::ExtensionToType(img->Uri().extension().string());
+
+    switch (type)
+    {
+        case imaging::ImageFileType::UNKNOWN:
+        case imaging::ImageFileType::ABSTRACT:
+            return {};
+        case imaging::ImageFileType::PNG:
+        case imaging::ImageFileType::JPG:
+            log_.Info("Creating a Default View");
+            // beware: here we copy the actual image resource over to the new image
+            return std::make_unique<PixelariumImageViewDefault>(img);
+        case imaging::ImageFileType::CZI:
+            log_.Info("{}: Creating a CZI View");
+            // beware: here we copy the actual image resource over to the new image
+            return std::make_unique<PixelariumImageViewDefault>(img);
+            // return std::make_unique<PixelariumImageViewCzi>(img);
+        default:
+            return {};
+    }
 }
 

lib/rendering/ImageViewFactory.hpp

@@ -1,20 +1,24 @@
 #pragma once
 
-#include "PixelariumImageView.hpp"
+#include "PixelariumImageViewDefault.hpp"
+#include "rendering/IPixelariumImageView.hpp"
 #include "resources/resource.hpp"
+#include "utilities/ILog.hpp"
 namespace pixelarium::render
 {
 class ImageViewFactory
 {
     using Image = imaging::IPixelariumImage;
     using Pool = resources::ImageResourcePool;
+    using Log = utils::log::ILog;
 
    public:
-    explicit ImageViewFactory(Pool& pool) : image_pool_(pool) {}
+    explicit ImageViewFactory(Pool& pool, const Log& log) : image_pool_(pool), log_(log) {}
 
-    std::unique_ptr<PixelariumImageView> RenderImage(size_t id);
+    std::unique_ptr<IPixelariumImageView> RenderImage(size_t id);
 
    private:
     Pool& image_pool_;
+    const Log& log_;
 };
 }  // namespace pixelarium::render

lib/rendering/PixelariumImageView.hpp

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "imaging/IPixelariumImage.hpp"
-#include "imgui.h"
-#include "rendering/CvMatRender.hpp"
-
-namespace pixelarium::render
-{
-class PixelariumImageView
-{
-    using Image = imaging::IPixelariumImage;
-    using Render = render::CvMatRender;
-
-   public:
-    explicit PixelariumImageView(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:
-    std::shared_ptr<Image> img_;
-    std::optional<std::unique_ptr<cv::Mat>> cached_image_ {};
-    Render render_;
-    bool open_p{true};
-    ImVec2 curr_dim_{};
-};
-}  // namespace pixelarium::render

lib/rendering/PixelariumImageViewDefault.cpp

@@ -1,4 +1,4 @@
-#include "PixelariumImageView.hpp"
+#include "PixelariumImageViewDefault.hpp"
 
 #include <format>
 
@@ -39,14 +39,15 @@ ImVec2 aspect_const_dimensions(const ImVec2& raw_dim, const ImVec2& curr_dim)
 /// 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()
+void pixelarium::render::PixelariumImageViewDefault::ShowImage()
 {
-    if (!this->cached_image_.has_value())
+    if (!this->cached_image_ || this->is_dirty_)
     {
         this->cached_image_ = this->img_->TryGetImage();
+        this->is_dirty_ = false;
     }
 
-    if (this->img_->Empty() || this->img_->type_ == imaging::ImageFileType::UNKNOWN || !cached_image_.has_value() || this->img_->Name().empty())
+    if (this->img_->Empty() || this->img_->type_ == imaging::ImageFileType::UNKNOWN || !cached_image_ || this->img_->Name().empty())
     {
         // do nothing
         return;
@@ -63,7 +64,7 @@ void pixelarium::render::PixelariumImageView::ShowImage()
 
     this->curr_dim_ = new_dim;
 
-    ImVec2 dim(cached_image_.value()->cols, cached_image_.value()->rows);
+    ImVec2 dim(cached_image_->cols, cached_image_->rows);
 
     ImGui::Image(reinterpret_cast<ImTextureID>(reinterpret_cast<void*>(texture)),
                  aspect_const_dimensions(dim, new_dim));

lib/rendering/PixelariumImageViewDefault.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <memory>
+
+#include "imaging/IPixelariumImage.hpp"
+#include "imgui.h"
+#include "rendering/CvMatRender.hpp"
+#include "rendering/IPixelariumImageView.hpp"
+
+namespace pixelarium::render
+{
+class PixelariumImageViewDefault : public IPixelariumImageView
+{
+    using Image = imaging::IPixelariumImage;
+    using Render = render::CvMatRender;
+
+   public:
+    explicit PixelariumImageViewDefault(std::shared_ptr<Image> img)
+    {
+        img_ = img;
+        render_ = Render(img_);
+    }
+    PixelariumImageViewDefault() = delete;
+    PixelariumImageViewDefault(PixelariumImageViewDefault&) = delete;
+    PixelariumImageViewDefault(const PixelariumImageViewDefault&) = delete;
+    PixelariumImageViewDefault(PixelariumImageViewDefault&&) = delete;
+    PixelariumImageViewDefault& operator=(PixelariumImageViewDefault&) = delete;
+    PixelariumImageViewDefault& operator=(PixelariumImageViewDefault&&) = delete;
+
+    void ShowImage() override;
+
+   private:
+    ImVec2 curr_dim_{};
+};
+}  // namespace pixelarium::render

lib/rendering/RenderImageManager.cpp

@@ -64,7 +64,6 @@ void pixelarium::render::RenderImageManager::Add(resources::ResourceKey key) noe
                 RenderImageStateWrapper
                 {
                     .view{ std::move(current_view) },
-                    .show_state = current_view->GetStatus(),
                 }
             }
             );

lib/rendering/RenderImageManager.hpp

@@ -5,7 +5,8 @@
 #include <unordered_set>
 
 #include "ImageViewFactory.hpp"
-#include "PixelariumImageView.hpp"
+#include "PixelariumImageViewDefault.hpp"
+#include "rendering/IPixelariumImageView.hpp"
 #include "resources/resource.hpp"
 #include "utilities/ILog.hpp"
 
@@ -13,9 +14,12 @@
 // aggregating views that should be rendered (or not)
 namespace pixelarium::render
 {
+/// @brief Instead of directly using the view, we
+/// proxy it through a wrapper. This allows for arbitrary additional data
+/// to be added in future
 struct RenderImageStateWrapper
 {
-    std::unique_ptr<PixelariumImageView> view;
+    std::unique_ptr<IPixelariumImageView> view;
     const bool* show_state;
 };
 
@@ -25,7 +29,7 @@ class RenderImageManager
 
    public:
     explicit RenderImageManager(Pool& pool, const utils::log::ILog& log)
-        : view_factory_(std::make_unique<ImageViewFactory>(pool)), log_(log)
+        : view_factory_(std::make_unique<ImageViewFactory>(pool, log)), log_(log)
     {
     }