Transition to C++23 (#11)

* enum field renaming

* renderer cleanups

* compiling for C++23

* version bump

* fix build

CMakeLists.txt

@@ -1,9 +1,9 @@
 cmake_minimum_required(VERSION 3.23)
 
-project(pixelarium VERSION 0.0.4)
+project(pixelarium VERSION 0.0.5)
 
 set(CMAKE_VERBOSE_MAKEFILE ON)
-set(CXX_STANDARD 20)
+set(CXX_STANDARD 23)
 set(CXX_STANDARD_REQUIRED true)
 
 # setting global module directories
@@ -28,13 +28,13 @@ option(PIXELARIUM_BUILD_DOCS      "Generate Documentation" ON)
 if(WIN32)
   set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
   if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    set(CMAKE_CXX_FLAGS "/std:c++20 /Zi /EHsc")
+    set(CMAKE_CXX_FLAGS "/std:c++23 /Zi /EHsc")
   else()
-    set(CMAKE_CXX_FLAGS "-Wall -Wextra -g --std=c++20")
+    set(CMAKE_CXX_FLAGS "-Wall -Wextra -g --std=c++23")
   endif()
 endif()
 if(UNIX)
-  set(CMAKE_CXX_FLAGS "-Wall -Wextra -g --std=c++20")
+  set(CMAKE_CXX_FLAGS "-Wall -Wextra -g --std=c++23")
 endif()
 
 string(TOUPPER "${CMAKE_PROJECT_NAME}" PIXELARIUM_TITLE)

doc/versions.md

@@ -2,6 +2,7 @@
 
 | Version | Description                                                             |
 |:-------:|:------------------------------------------------------------------------|
+|   0.0.5 | Compile for C++23 and code style adaptions                              |
 |   0.0.4 | Fix MSVC build, some cosmetics, explicit initial window size for images |
 |   0.0.3 | Fetch subblocks based on the dimension selection sliders                |
 |   0.0.2 | Add Dimension selector sliders to CZI image view                        |

lib/imaging/IPixelariumImage.hpp

@@ -14,15 +14,15 @@ using ImageQueryFunctor = std::function<void(const std::string&, void*, int*)>;
 enum class ImageFileType
 {
     /// @brief Represents an unknown or unsupported file type.
-    UNKNOWN = -10,
+    kUnknown = -10,
     /// @brief Represents an abstract image type (e.g., a placeholder).
-    ABSTRACT = 0,
+    kAbstract = 0,
     /// @brief Represents a PNG image file.
-    PNG = 1,
+    kPng = 1,
     /// @brief Represents a JPG image file.
-    JPG = 2,
+    kJpg = 2,
     /// @brief Represents a CZI image file.
-    CZI = 3,
+    kCzi = 3,
 };
 
 /// @brief An abstract interface to define a semantic query
@@ -83,7 +83,7 @@ class IPixelariumImage
     }
 
    public:
-    const static ImageFileType type_{ImageFileType::ABSTRACT};
+    const static ImageFileType type_{ImageFileType::kAbstract};
 
    protected:
     std::filesystem::path uri_;

lib/imaging/PixelariumImageFactory.cpp

@@ -16,19 +16,19 @@ pixelarium::imaging::PixelariumImageFactory::CreateImage(const std::string& uri,
 
     switch (target_type)
     {
-        case ImageFileType::UNKNOWN:
+        case ImageFileType::kUnknown:
             return {};
             break;
-        case ImageFileType::ABSTRACT:
+        case ImageFileType::kAbstract:
             return {};
             break;
-        case ImageFileType::PNG:
+        case ImageFileType::kPng:
             return std::make_unique<PixelariumPng>(uri);
             break;
-        case ImageFileType::JPG:
+        case ImageFileType::kJpg:
             return std::make_unique<PixelariumJpg>(uri);
             break;
-        case ImageFileType::CZI:
+        case ImageFileType::kCzi:
             return std::make_unique<PixelariumCzi>(uri, log);
             break;
     }

lib/imaging/PixelariumImageFactory.hpp

@@ -13,18 +13,18 @@ constexpr pixelarium::imaging::ImageFileType ExtensionToType(const std::string&
 
     if (lower_ext == ".jpg" || lower_ext == ".jpeg")
     {
-        return pixelarium::imaging::ImageFileType::JPG;
+        return pixelarium::imaging::ImageFileType::kJpg;
     }
     if (lower_ext == ".png")
     {
-        return pixelarium::imaging::ImageFileType::PNG;
+        return pixelarium::imaging::ImageFileType::kPng;
     }
     if (lower_ext == ".czi")
     {
-        return pixelarium::imaging::ImageFileType::CZI;
+        return pixelarium::imaging::ImageFileType::kCzi;
     }
 
-    return pixelarium::imaging::ImageFileType::UNKNOWN;
+    return pixelarium::imaging::ImageFileType::kUnknown;
 }
 
 /// @brief Factory for instantiating implementations of IPixelariumImage based on the given file type.

lib/imaging/impl/PixelariumCzi.hpp

@@ -46,7 +46,7 @@ class PixelariumCzi : public IPixelariumImage
     const libCZI::SubBlockStatistics& GetStatistics() const { return this->image_statistics_; }
 
    public:
-    const static ImageFileType type_{ImageFileType::CZI};
+    const static ImageFileType type_{ImageFileType::kCzi};
 
    private:
     std::unique_ptr<cv::Mat> SubblockToCvMat(int index);

lib/imaging/impl/PixelariumJpg.hpp

@@ -32,7 +32,7 @@ class PixelariumJpg : public IPixelariumImage
     bool Empty() const noexcept override { return this->is_empty_; }
 
    public:
-    const static ImageFileType type_{ImageFileType::JPG};
+    const static ImageFileType type_{ImageFileType::kJpg};
 
    private:
     // this should be set by each image getter

lib/imaging/impl/PixelariumPng.hpp

@@ -32,7 +32,7 @@ class PixelariumPng : public IPixelariumImage
     bool Empty() const noexcept override { return this->is_empty_; }
 
    public:
-    const static ImageFileType type_{ImageFileType::PNG};
+    const static ImageFileType type_{ImageFileType::kPng};
 
    private:
     // this should be set by each image getter

lib/rendering/CvMatRender.cpp

@@ -55,21 +55,25 @@ GLuint pixelarium::render::CvMatRender::uploadTexture()
 
     const int width = img_.cols;
     const int height = img_.rows;
-
+    // see
-    switch (img_.type()) {
+    // https://stackoverflow.com/questions/10167534/how-to-find-out-what-type-of-a-mat-object-is-with-mattype-in-opencv
+    // for pixel a pixel type table
+    switch (img_.type())
+    {
+        case CV_8U:
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_BYTE, img_.data);
+            break;
         case CV_16U:
         case CV_16UC3:
-        case 26:
+        case CV_16UC4:
-            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 CV_32F:
-        case 29:
+        case CV_32FC4:
-            glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT,
-            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_FLOAT, img_.data);
+                         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;
     }

lib/rendering/ImageViewFactory.cpp

@@ -33,15 +33,15 @@ std::unique_ptr<pixelarium::render::IPixelariumImageView> pixelarium::render::Im
 
     switch (type)
     {
-        case imaging::ImageFileType::UNKNOWN:
+        case imaging::ImageFileType::kUnknown:
-        case imaging::ImageFileType::ABSTRACT:
+        case imaging::ImageFileType::kAbstract:
             return {};
-        case imaging::ImageFileType::PNG:
+        case imaging::ImageFileType::kPng:
-        case imaging::ImageFileType::JPG:
+        case imaging::ImageFileType::kJpg:
             log_.Info(std::format("{}: Creating a Default View", __PRETTY_FUNCTION__));
             // beware: here we copy the actual image resource over to the new image
             return std::make_unique<PixelariumImageViewDefault>(img);
-        case imaging::ImageFileType::CZI:
+        case imaging::ImageFileType::kCzi:
             log_.Info(std::format("{}: Creating a CZI View", __PRETTY_FUNCTION__));
             // beware: here we copy the actual image resource over to the new image
             return std::make_unique<PixelariumImageViewCzi>(img, log_);

lib/rendering/PixelariumImageViewCzi.cpp

@@ -51,7 +51,7 @@ void pixelarium::render::PixelariumImageViewCzi::ShowImage()
         this->is_dirty_ = false;
     }
 
-    if (czi_img->Empty() || this->img_->type_ == imaging::ImageFileType::UNKNOWN || !cached_image_ ||
+    if (czi_img->Empty() || this->img_->type_ == imaging::ImageFileType::kUnknown || !cached_image_ ||
         czi_img->Name().empty())
     {
         // do nothing

lib/rendering/PixelariumImageViewDefault.cpp

@@ -18,7 +18,7 @@ void pixelarium::render::PixelariumImageViewDefault::ShowImage()
         this->is_dirty_ = false;
     }
 
-    if (this->img_->Empty() || this->img_->type_ == imaging::ImageFileType::UNKNOWN || !cached_image_ ||
+    if (this->img_->Empty() || this->img_->type_ == imaging::ImageFileType::kUnknown || !cached_image_ ||
         this->img_->Name().empty())
     {
         // do nothing

lib/utilities/ILog.hpp

@@ -10,11 +10,11 @@ namespace pixelarium::utils::log
 {
 enum class LogLevel
 {
-    Trace = 1 << 0,
+    kTrace = 1 << 0,
-    Debug = 1 << 1,
+    kDebug = 1 << 1,
-    Info = 1 << 2,
+    kInfo = 1 << 2,
-    Warn = 1 << 3,
+    kWarn = 1 << 3,
-    Error = 1 << 4,
+    kError = 1 << 4,
 };
 /// @brief Interface for logging implementations.
 class ILog

lib/utilities/SpdLogger.cpp

@@ -30,15 +30,15 @@ void SpdLogger::ChangeLevel(LogLevel lvl) const
     {
         switch (l)
         {
-            case LogLevel::Trace:
+            case LogLevel::kTrace:
                 return "Trace";
-            case LogLevel::Debug:
+            case LogLevel::kDebug:
                 return "Debug";
-            case LogLevel::Info:
+            case LogLevel::kInfo:
                 return "Info";
-            case LogLevel::Warn:
+            case LogLevel::kWarn:
                 return "Warn";
-            case LogLevel::Error:
+            case LogLevel::kError:
                 return "Error";
             default:
                 return "Not Found";
@@ -47,23 +47,23 @@ void SpdLogger::ChangeLevel(LogLevel lvl) const
 
     switch (lvl)
     {
-        case LogLevel::Trace:
+        case LogLevel::kTrace:
             this->logger_->set_level(spdlog::level::trace);
             spdlog::flush_on(spdlog::level::trace);
             break;
-        case LogLevel::Info:
+        case LogLevel::kInfo:
             this->logger_->set_level(spdlog::level::info);
             spdlog::flush_on(spdlog::level::info);
             break;
-        case LogLevel::Warn:
+        case LogLevel::kWarn:
             this->logger_->set_level(spdlog::level::warn);
             spdlog::flush_on(spdlog::level::warn);
             break;
-        case LogLevel::Error:
+        case LogLevel::kError:
             this->logger_->set_level(spdlog::level::err);
             spdlog::flush_on(spdlog::level::err);
             break;
-        case LogLevel::Debug:
+        case LogLevel::kDebug:
         default:
             this->logger_->set_level(spdlog::level::debug);
             spdlog::flush_on(spdlog::level::debug);

src/main.cpp

@@ -17,7 +17,7 @@ int main(int argc, char** argv)
 #endif
     logger->Info(std::format("{}: Starting Application {}", __FUNCTION__, "Pixelarium"));
 
-    logger->ChangeLevel(utils::log::LogLevel::Debug);
+    logger->ChangeLevel(utils::log::LogLevel::kDebug);
     auto image_pool{std::make_unique<resources::ImageResourcePool>()};
 
     pixelarium::ui::DefaultApp app = pixelarium::ui::DefaultApp(*logger, *image_pool);