pixelarium/lib/imaging/impl/PixelariumCzi.cpp

#include "PixelariumCzi.hpp"

#include <cstdint>
#include <filesystem>
#include <format>
#include <memory>
#include <stdexcept>
#include <utility>

#include "libCZI.h"
#include "utilities/ILog.hpp"

bool comp_blockinfo_params(const pixelarium::imaging::CziParams& params, const libCZI::SubBlockInfo& info)
{
    bool res{true};

    info.coordinate.EnumValidDimensions(
        [&](libCZI::DimensionIndex dim, int start) -> bool
        {
            if (params.dimension_map.at(dim) == start)
            {
                return true;
            }

            res &= false;
            return true;
        });

    return res;
}

constexpr int try_get_index_match(const pixelarium::imaging::CziParams& params, libCZI::ICZIReader& reader)
{
    int index{-1};
    reader.EnumerateSubBlocks(
        [&](int idx, const libCZI::SubBlockInfo& info) -> bool
        {
            if (comp_blockinfo_params(params, info))
            {
                index = idx;
                // returning false will stop the enumeration
                return false;
            }

            return true;
        });

    return index;
}

std::unique_ptr<cv::Mat> CZISubBlockToCvMat(std::shared_ptr<libCZI::IBitmapData> bitmap, libCZI::PixelType pixeltype,
                                            const pixelarium::utils::log::ILog& log)
{
    size_t pixel_size{0};
    int target_type;
    std::pair<std::string, std::string> pixel_pair;

    switch (pixeltype)
    {
        case libCZI::PixelType::Gray8:
            pixel_pair.first = "Gray8";
            pixel_pair.second = "CV_8U";
            pixel_size = 1;
            target_type = CV_8U;
            break;
        case libCZI::PixelType::Gray16:
            pixel_pair.first = "Gray16";
            pixel_pair.second = "CV_16U";
            pixel_size = 2;
            target_type = CV_16U;
            break;
        case libCZI::PixelType::Bgr24:
            pixel_pair.first = "Bgr24";
            pixel_pair.second = "CV_8UC3";
            pixel_size = 3;
            target_type = CV_8UC3;
            break;
        case libCZI::PixelType::Bgra32:
            pixel_pair.first = "Bgra32";
            pixel_pair.second = "CV_8CU4";
            target_type = CV_8UC4;
        case libCZI::PixelType::Gray32:
            pixel_pair.first = "Gray32";
            pixel_pair.second = "CV_32S";
            target_type = CV_32S;
        case libCZI::PixelType::Gray32Float:
            pixel_pair.first = "Gray32Float";
            pixel_pair.second = "CV_32F";
            target_type = CV_32F;
            pixel_size = 4;
            break;
        default:
            pixel_size = -1;
            break;
    }

    if (pixel_size < 0) return nullptr;

    log.Info(std::format("{}: source pixel type {}, target cv pixel type {}, pixel size {}", __PRETTY_FUNCTION__,
                         pixel_pair.first, pixel_pair.second, pixel_size));

    size_t height{bitmap->GetHeight()};
    size_t width{bitmap->GetWidth()};
    auto fill_mat = std::make_unique<cv::Mat>(height, width, target_type);

    auto bitmap_info = bitmap->Lock();

    for (size_t h{0}; h < height; ++h)
    {
        unsigned char* source_row = ((unsigned char*)bitmap_info.ptrDataRoi) + bitmap_info.stride * h;
        unsigned char* target_row = fill_mat->ptr(h);

        for (size_t w{0}; w < width; ++w)
        {
            switch (pixel_size)
            {
                case 1:
                    target_row[w] = source_row[w];
                    break;
                case 2:
                    reinterpret_cast<unsigned short*>(target_row)[w] = reinterpret_cast<unsigned short*>(source_row)[w];
                    break;
                case 3:
                    target_row[3 * w] = source_row[3 * w];
                    target_row[3 * w + 1] = source_row[3 * w + 1];
                    target_row[3 * w + 2] = source_row[3 * w + 2];
                    break;
                case 4:
                    reinterpret_cast<std::int32_t*>(target_row)[w] = reinterpret_cast<std::int32_t*>(source_row)[w];
                    break;
                default:
                    throw std::runtime_error("Unknown pixel type requested!");
                    break;
            }
        }
    }

    bitmap->Unlock();
    return fill_mat;
}

std::unique_ptr<cv::Mat> pixelarium::imaging::PixelariumCzi::SubblockToCvMat(int index)
{
    log_.Info(std::format("{}: constructing bitmap with index {}", __PRETTY_FUNCTION__, index));
    auto block = this->czi_reader_->ReadSubBlock(index);
    auto bitmap = block->CreateBitmap();
    return CZISubBlockToCvMat(bitmap, block->GetSubBlockInfo().pixelType, log_);
}

pixelarium::imaging::PixelariumCzi::PixelariumCzi(const std::string& uri, const Log& log) : log_(log)
{
    if (!std::filesystem::exists(uri))
    {
        throw std::runtime_error("Render file not found.");
    }

    this->is_empty_ = false;
    this->uri_ = std::filesystem::path(uri);

    auto stream = libCZI::CreateStreamFromFile(this->uri_.wstring().c_str());
    this->czi_reader_ = libCZI::CreateCZIReader();
    this->czi_reader_->Open(stream);
    this->image_statistics_ = this->czi_reader_->GetStatistics();

    this->image_statistics_.dimBounds.EnumValidDimensions(
        [&](libCZI::DimensionIndex dim, int start, int) -> bool
        {
            this->dimension_map_[dim] = start;
            return true;
        });
}

std::unique_ptr<cv::Mat> pixelarium::imaging::PixelariumCzi::TryGetImage() { return SubblockToCvMat(0); }

std::unique_ptr<cv::Mat> pixelarium::imaging::PixelariumCzi::TryGetImage(const IImageQuery& query)
{
    const auto czi_query = static_cast<const CziParams&>(query);
    int index = try_get_index_match(czi_query, *this->czi_reader_);

    if (index < 0)
    {
        return SubblockToCvMat(0);
    }

    return SubblockToCvMat(index);
}