libCZI_Pixels.h

//******************************************************************************
// 
// libCZI is a reader for the CZI fileformat written in C++
// Copyright (C) 2017  Zeiss Microscopy GmbH
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// 
// To obtain a commercial version please contact Zeiss Microscopy GmbH.
// 
//******************************************************************************

#pragma once

#include <cstdint>
#include <memory>
#include <algorithm>
#include <ostream>

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 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)
        {
            int x1 = (std::max)(a.x, b.x);
            int x2 = (std::min)(a.x + a.w, b.x + b.w);
            int y1 = (std::max)(a.y, b.y);
            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           
    };

    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;
    }
}