libCZI_Compositor.h

// SPDX-FileCopyrightText: 2017-2022 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include "ImportExport.h"
#include <cstring>
#include <limits>
#include <vector>
#include <memory>
#include "libCZI_Pixels.h"
#include "libCZI_Metadata.h"
 
namespace libCZI
{
    class IBitmapData;
    class IDimCoordinate;
 
    enum class AccessorType
    {
        SingleChannelTileAccessor,              
        SingleChannelPyramidLayerTileAccessor,  
        SingleChannelScalingTileAccessor        
    };
 
    class ISubBlockCacheStatistics
    {
    public:
        static constexpr std::uint8_t kMemoryUsage = 1;     
        static constexpr std::uint8_t kElementsCount = 2;   
 
        struct Statistics
        {
            std::uint8_t validityMask;
 
            std::uint64_t memoryUsage;
 
            std::uint32_t elementsCount;
        };
 
        virtual Statistics GetStatistics(std::uint8_t mask) const = 0;
 
        virtual ~ISubBlockCacheStatistics() = default;
 
        ISubBlockCacheStatistics() = default;
        ISubBlockCacheStatistics(const ISubBlockCacheStatistics&) = delete;
        ISubBlockCacheStatistics& operator=(const ISubBlockCacheStatistics&) = delete;
        ISubBlockCacheStatistics(ISubBlockCacheStatistics&&) noexcept = delete;
        ISubBlockCacheStatistics& operator=(ISubBlockCacheStatistics&&) noexcept = delete;
    };
 
    class ISubBlockCacheControl
    {
    public:
        struct PruneOptions
        {
            std::uint64_t   maxMemoryUsage{ (std::numeric_limits<decltype(maxMemoryUsage)>::max)() };
 
            std::uint32_t  maxSubBlockCount{ (std::numeric_limits<decltype(maxSubBlockCount)>::max)() };
        };
 
        virtual void Prune(const PruneOptions& options) = 0;
 
        virtual ~ISubBlockCacheControl() = default;
 
        ISubBlockCacheControl() = default;
        ISubBlockCacheControl(const ISubBlockCacheControl&) = delete;
        ISubBlockCacheControl& operator=(const ISubBlockCacheControl&) = delete;
        ISubBlockCacheControl(ISubBlockCacheControl&&) noexcept = delete;
        ISubBlockCacheControl& operator=(ISubBlockCacheControl&&) noexcept = delete;
    };
 
    class ISubBlockCacheOperation
    {
    public:
        virtual std::shared_ptr<IBitmapData> Get(int subblock_index) = 0;
 
        virtual void Add(int subblock_index, std::shared_ptr<IBitmapData> pBitmap) = 0;
 
        virtual ~ISubBlockCacheOperation() = default;
 
        ISubBlockCacheOperation() = default;
        ISubBlockCacheOperation(const ISubBlockCacheOperation&) = delete;
        ISubBlockCacheOperation& operator=(const ISubBlockCacheOperation&) = delete;
        ISubBlockCacheOperation(ISubBlockCacheOperation&&) noexcept = delete;
        ISubBlockCacheOperation& operator=(ISubBlockCacheOperation&&) noexcept = delete;
    };
 
    class ISubBlockCache : public ISubBlockCacheStatistics, public ISubBlockCacheControl, public ISubBlockCacheOperation
    {
    public:
        ~ISubBlockCache() override = default;
 
        ISubBlockCache() = default;
        ISubBlockCache(const ISubBlockCache&) = delete;
        ISubBlockCache& operator=(const ISubBlockCache&) = delete;
        ISubBlockCache(ISubBlockCache&&) noexcept = delete;
        ISubBlockCache& operator=(ISubBlockCache&&) noexcept = delete;
    };
 
    class IAccessor
    {
    protected:
        virtual ~IAccessor() = default;
    };
 
    class ISingleChannelTileAccessor : public IAccessor
    {
    public:
        struct Options
        {
            RgbFloatColor   backGroundColor;
 
            bool sortByM;
 
            bool useVisibilityCheckOptimization;
 
            bool drawTileBorder;
 
            std::shared_ptr<libCZI::IIndexSet> sceneFilter;
 
            std::shared_ptr<libCZI::ISubBlockCacheOperation> subBlockCache;
 
            bool onlyUseSubBlockCacheForCompressedData;
 
            void Clear()
            {
                this->backGroundColor.r = this->backGroundColor.g = this->backGroundColor.b = std::numeric_limits<float>::quiet_NaN();
                this->sortByM = true;
                this->useVisibilityCheckOptimization = false;
                this->drawTileBorder = false;
                this->sceneFilter.reset();
                this->subBlockCache.reset();
                this->onlyUseSubBlockCacheForCompressedData = true;
            }
        };
 
    public:
        virtual std::shared_ptr<libCZI::IBitmapData> Get(const libCZI::IntRect& roi, const IDimCoordinate* planeCoordinate, const Options* pOptions) = 0;
 
        virtual std::shared_ptr<libCZI::IBitmapData> Get(libCZI::PixelType pixeltype, const libCZI::IntRect& roi, const IDimCoordinate* planeCoordinate, const Options* pOptions) = 0;
 
        virtual void Get(libCZI::IBitmapData* pDest, int xPos, int yPos, const IDimCoordinate* planeCoordinate, const Options* pOptions) = 0;
 
        inline std::shared_ptr<libCZI::IBitmapData> Get(int xPos, int yPos, int width, int height, const IDimCoordinate* planeCoordinate, const Options* pOptions) { return this->Get(libCZI::IntRect{ xPos,yPos,width,height }, planeCoordinate, pOptions); }
 
        inline std::shared_ptr<libCZI::IBitmapData> Get(libCZI::PixelType pixeltype, int xPos, int yPos, int width, int height, const IDimCoordinate* planeCoordinate, const Options* pOptions) { return this->Get(pixeltype, libCZI::IntRect{ xPos,yPos,width,height }, planeCoordinate, pOptions); }
    protected:
        virtual ~ISingleChannelTileAccessor() = default;
    };
 
    class ISingleChannelPyramidLayerTileAccessor : public IAccessor
    {
    public:
        struct Options
        {
            RgbFloatColor   backGroundColor;
 
            bool sortByM;
 
            bool drawTileBorder;
 
            std::shared_ptr<libCZI::IIndexSet> sceneFilter;
 
            std::shared_ptr<libCZI::ISubBlockCacheOperation> subBlockCache;
 
            bool onlyUseSubBlockCacheForCompressedData;
 
            void Clear()
            {
                this->drawTileBorder = false;
                this->sortByM = true;
                this->backGroundColor.r = this->backGroundColor.g = this->backGroundColor.b = std::numeric_limits<float>::quiet_NaN();
                this->sceneFilter.reset();
                this->subBlockCache.reset();
                this->onlyUseSubBlockCacheForCompressedData = true;
            }
        };
 
        struct PyramidLayerInfo
        {
            std::uint8_t minificationFactor;    
            std::uint8_t pyramidLayerNo;        
        };
 
        virtual std::shared_ptr<libCZI::IBitmapData> Get(const libCZI::IntRect& roi, const libCZI::IDimCoordinate* planeCoordinate, const PyramidLayerInfo& pyramidInfo, const libCZI::ISingleChannelPyramidLayerTileAccessor::Options* pOptions) = 0;
 
        virtual std::shared_ptr<libCZI::IBitmapData> Get(libCZI::PixelType pixeltype, const libCZI::IntRect& roi, const libCZI::IDimCoordinate* planeCoordinate, const PyramidLayerInfo& pyramidInfo, const libCZI::ISingleChannelPyramidLayerTileAccessor::Options* pOptions) = 0;
 
        virtual void Get(libCZI::IBitmapData* pDest, int xPos, int yPos, const IDimCoordinate* planeCoordinate, const PyramidLayerInfo& pyramidInfo, const Options* pOptions) = 0;
    };
 
    class ISingleChannelScalingTileAccessor : public IAccessor
    {
    public:
        struct Options
        {
            RgbFloatColor backGroundColor;
 
            bool sortByM;
 
            bool drawTileBorder;
 
            std::shared_ptr<libCZI::IIndexSet> sceneFilter;
 
            bool useVisibilityCheckOptimization;
 
            std::shared_ptr<libCZI::ISubBlockCacheOperation> subBlockCache;
 
            bool onlyUseSubBlockCacheForCompressedData;
 
            void Clear()
            {
                this->drawTileBorder = false;
                this->sortByM = true;
                this->backGroundColor.r = this->backGroundColor.g = this->backGroundColor.b = std::numeric_limits<float>::quiet_NaN();
                this->sceneFilter.reset();
                this->useVisibilityCheckOptimization = false;
                this->subBlockCache.reset();
                this->onlyUseSubBlockCacheForCompressedData = true;
            }
        };
 
        virtual libCZI::IntSize CalcSize(const libCZI::IntRect& roi, float zoom) const = 0;
 
        virtual std::shared_ptr<libCZI::IBitmapData> Get(const libCZI::IntRect& roi, const libCZI::IDimCoordinate* planeCoordinate, float zoom, const libCZI::ISingleChannelScalingTileAccessor::Options* pOptions) = 0;
 
        virtual std::shared_ptr<libCZI::IBitmapData> Get(libCZI::PixelType pixeltype, const libCZI::IntRect& roi, const libCZI::IDimCoordinate* planeCoordinate, float zoom, const libCZI::ISingleChannelScalingTileAccessor::Options* pOptions) = 0;
 
        virtual void Get(libCZI::IBitmapData* pDest, const libCZI::IntRect& roi, const libCZI::IDimCoordinate* planeCoordinate, float zoom, const libCZI::ISingleChannelScalingTileAccessor::Options* pOptions) = 0;
    };
 
    class LIBCZI_API Compositors
    {
    public:
        struct LIBCZI_API ComposeSingleTileOptions
        {
            bool drawTileBorder;
 
            void Clear() { this->drawTileBorder = false; }
        };
 
        static void ComposeSingleChannelTiles(
            const std::function<bool(int index, std::shared_ptr<libCZI::IBitmapData>& src, int& x, int& y)>& getTiles,
            libCZI::IBitmapData* dest,
            int xPos,
            int yPos,
            const ComposeSingleTileOptions* pOptions);
 
        struct TintingColor
        {
            Rgb8Color   color;
        };
 
 
        struct ChannelInfo
        {
            float        weight;
 
            bool         enableTinting;
 
            TintingColor tinting;
 
            float        blackPoint;
 
            float        whitePoint;
 
            int         lookUpTableElementCount;
 
            const std::uint8_t* ptrLookUpTable;
 
            void Clear() { std::memset(this, 0, sizeof(*this)); }
        };
 
        static void ComposeMultiChannel_Bgr24(
            libCZI::IBitmapData* dest,
            int channelCount,
            libCZI::IBitmapData* const* srcBitmaps,
            const ChannelInfo* channelInfos);
 
        static void ComposeMultiChannel_Bgra32(
            libCZI::IBitmapData* dest,
            std::uint8_t alphaVal,
            int channelCount,
            libCZI::IBitmapData* const* srcBitmaps,
            const ChannelInfo* channelInfos);
 
        static std::shared_ptr<IBitmapData> ComposeMultiChannel_Bgr24(
            int channelCount,
            libCZI::IBitmapData* const* srcBitmaps,
            const ChannelInfo* channelInfos);
 
        static std::shared_ptr<IBitmapData> ComposeMultiChannel_Bgra32(
            std::uint8_t alphaVal,
            int channelCount,
            libCZI::IBitmapData* const* srcBitmaps,
            const ChannelInfo* channelInfos);
 
        static std::shared_ptr<IBitmapData> ComposeMultiChannel_Bgr24(
            int channelCount,
            std::vector<std::shared_ptr<libCZI::IBitmapData>>::iterator srcBitmapsIterator,
            const ChannelInfo* channelInfos)
        {
            std::vector<IBitmapData*> vecBm; vecBm.reserve(channelCount);
            for (int i = 0; i < channelCount; ++i)
            {
                vecBm.emplace_back((*srcBitmapsIterator).get());
                ++srcBitmapsIterator;
            }
 
            return ComposeMultiChannel_Bgr24(channelCount, &vecBm[0], channelInfos);
        }
 
        static std::shared_ptr<IBitmapData> ComposeMultiChannel_Bgra32(
            std::uint8_t alphaVal,
            int channelCount,
            std::vector<std::shared_ptr<libCZI::IBitmapData>>::iterator srcBitmapsIterator,
            const ChannelInfo* channelInfos)
        {
            std::vector<IBitmapData*> vecBm; vecBm.reserve(channelCount);
            for (int i = 0; i < channelCount; ++i)
            {
                vecBm.emplace_back((*srcBitmapsIterator).get());
                ++srcBitmapsIterator;
            }
 
            return ComposeMultiChannel_Bgra32(alphaVal, channelCount, &vecBm[0], channelInfos);
        }
    };
}