libCZI_Pixels.h

// SPDX-FileCopyrightText: 2017-2022 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <cstdint>
#include <memory>
#include <algorithm>
#include <ostream>
#include <utility>
 
namespace libCZI
{
    struct IntRect
    {
        int x;  
        int y;  
        int w;  
        int h;  
 
        void Invalidate() { this->w = this->h = -1; }
 
        bool IsValid() const { return this->w >= 0 && this->h >= 0; }
 
        bool IsNonEmpty() const { return this->w > 0 && this->h > 0; }
 
        bool IntersectsWith(const IntRect& r) const
        {
            const IntRect is = this->Intersect(r);
            if (is.w <= 0 || is.h <= 0)
            {
                return false;
            }
 
            return true;
        }
 
        IntRect Intersect(const IntRect& r) const
        {
            return IntRect::Intersect(*this, r);
        }
 
        static IntRect Intersect(const IntRect& a, const IntRect& b)
        {
            const int x1 = (std::max)(a.x, b.x);
            const int x2 = (std::min)(a.x + a.w, b.x + b.w);
            const int y1 = (std::max)(a.y, b.y);
            const int y2 = (std::min)(a.y + a.h, b.y + b.h);
            if (x2 >= x1 && y2 >= y1)
            {
                return IntRect{ x1, y1, x2 - x1, y2 - y1 };
            }
 
            return IntRect{ 0,0,0,0 };
        }
    };
 
    struct DblRect
    {
        double x;   
        double y;   
        double w;   
        double h;   
 
        void Invalidate() { this->w = this->h = -1; }
    };
 
    struct IntSize
    {
        std::uint32_t w;    
        std::uint32_t h;    
    };
 
    struct Rgb8Color
    {
        std::uint8_t r; 
        std::uint8_t g; 
        std::uint8_t b; 
    };
 
    struct RgbFloatColor
    {
        float r; 
        float g; 
        float b; 
    };
 
    enum class PixelType : std::uint8_t
    {
        Invalid = 0xff,             
        Gray8 = 0,                  
        Gray16 = 1,                 
        Gray32Float = 2,            
        Bgr24 = 3,                  
        Bgr48 = 4,                  
        Bgr96Float = 8,             
        Bgra32 = 9,                 
        Gray64ComplexFloat = 10,    
        Bgr192ComplexFloat = 11,    
        Gray32 = 12,                
        Gray64Float = 13,           
    };
 
    enum class CompressionMode : std::uint8_t
    {
        Invalid = 0xff,     
        UnCompressed = 0,   
        Jpg = 1,            
        JpgXr = 4,          
        Zstd0 = 5,          
        Zstd1 = 6           
    };
 
    enum class SubBlockPyramidType : std::uint8_t
    {
        Invalid = 0xff,     
        None = 0,           
        SingleSubBlock= 1,  
        MultiSubBlock = 2   
    };
 
    struct BitmapLockInfo
    {
        void* ptrData;              
        void* ptrDataRoi;           
        std::uint32_t   stride;     
        std::uint64_t   size;       
    };
 
    class IBitmapData
    {
    public:
 
        virtual PixelType       GetPixelType() const = 0;
 
        virtual IntSize         GetSize() const = 0;
 
        virtual BitmapLockInfo  Lock() = 0;
 
        virtual void            Unlock() = 0;
 
        virtual ~IBitmapData() {}
 
        std::uint32_t GetWidth() const { return this->GetSize().w; }
 
        std::uint32_t GetHeight() const { return this->GetSize().h; }
    };
 
    template <typename tBitmap>
    class ScopedBitmapLocker : public BitmapLockInfo
    {
    private:
        tBitmap bmData;
    public:
        ScopedBitmapLocker() = delete;
 
        explicit ScopedBitmapLocker(tBitmap bmData) : bmData(bmData)
        {
            auto lockInfo = bmData->Lock();
            this->ptrData = lockInfo.ptrData;
            this->ptrDataRoi = lockInfo.ptrDataRoi;
            this->stride = lockInfo.stride;
            this->size = lockInfo.size;
        }
 
        ScopedBitmapLocker(const ScopedBitmapLocker<tBitmap>& other) : bmData(other.bmData)
        {
            auto lockInfo = other.bmData->Lock();
            this->ptrData = lockInfo.ptrData;
            this->ptrDataRoi = lockInfo.ptrDataRoi;
            this->stride = lockInfo.stride;
            this->size = lockInfo.size;
        }
 
        ScopedBitmapLocker(ScopedBitmapLocker<tBitmap>&& other) noexcept : bmData(tBitmap())
        {
            *this = std::move(other);
        }
 
        ScopedBitmapLocker<tBitmap>& operator=(ScopedBitmapLocker<tBitmap>&& other) noexcept
        {
            if (this != &other)
            {
                if (this->bmData)
                {
                    this->bmData->Unlock();
                }
 
                this->bmData = std::move(other.bmData);
                this->ptrData = other.ptrData;
                this->ptrDataRoi = other.ptrDataRoi;
                this->stride = other.stride;
                this->size = other.size;
                other.ptrData = other.ptrDataRoi = nullptr;
                other.bmData = tBitmap();
            }
 
            return *this;
        }
 
        ~ScopedBitmapLocker()
        {
            if (this->bmData)
            {
                this->bmData->Unlock();
            }
        }
    };
 
    typedef ScopedBitmapLocker<IBitmapData*> ScopedBitmapLockerP;
 
    typedef ScopedBitmapLocker<std::shared_ptr<IBitmapData>> ScopedBitmapLockerSP;
 
    //-------------------------------------------------------------------------
 
    inline std::ostream& operator<<(std::ostream& os, const IntRect& rect)
    {
        os << "(" << rect.x << "," << rect.y << "," << rect.w << "," << rect.h << ")";
        return os;
    }
 
    inline std::ostream& operator<<(std::ostream& os, const IntSize& size)
    {
        os << "(" << size.w << "," << size.h << ")";
        return os;
    }
}