libCZI.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 "ImportExport.h"

#include "priv_guiddef.h"
#include "libCZI_exceptions.h"
#include "libCZI_DimCoordinate.h"
#include "libCZI_Pixels.h"
#include "libCZI_Metadata.h"
#include "libCZI_Metadata2.h"
#include "libCZI_Utilities.h"
#include "libCZI_Compositor.h"
#include "libCZI_Site.h"

#include <functional>
#include <memory>
#include <map>
#include <limits>

// virtual d'tor -> https://isocpp.org/wiki/faq/virtual-functions#virtual-dtors

namespace libCZI
{
    enum class SiteObjectType
    {
        Default,        
        WithJxrDecoder  
#if defined(_WIN32)
        , WithWICDecoder
#endif
    };

    class ISite;

    LIBCZI_API ISite* GetDefaultSiteObject(libCZI::SiteObjectType type);

    LIBCZI_API void SetSiteObject(libCZI::ISite* pSite);

    class ICZIReader;
    class IStream;
    class ISubBlock;
    class IMetadataSegment;
    class ISubBlockRepository;
    class IAttachment;

    struct BuildInformation
    {
        std::string compilerIdentification;

        std::string repositoryUrl;

        std::string repositoryBranch;

        std::string repositoryTag;
    };

    LIBCZI_API void GetLibCZIVersion(int* pMajor, int* pMinor);

    LIBCZI_API void GetLibCZIBuildInformation(BuildInformation& info);

    LIBCZI_API std::shared_ptr<ICZIReader> CreateCZIReader();

    LIBCZI_API std::shared_ptr<IBitmapData>  CreateBitmapFromSubBlock(ISubBlock* subBlk);

    LIBCZI_API std::shared_ptr<ICziMetadata> CreateMetaFromMetadataSegment(IMetadataSegment* metadataSegment);

    LIBCZI_API std::shared_ptr<IAccessor> CreateAccesor(std::shared_ptr<ISubBlockRepository> repository, AccessorType accessorType);

    LIBCZI_API std::shared_ptr<IStream> CreateStreamFromFile(const wchar_t* szFilename);

    LIBCZI_API std::shared_ptr<IStream> CreateStreamFromMemory(std::shared_ptr<const void> ptr, size_t dataSize);

    LIBCZI_API std::shared_ptr<IStream> CreateStreamFromMemory(IAttachment* attachment);



    class IStream
    {
    public:
        virtual void Read(std::uint64_t offset, void *pv, std::uint64_t size, std::uint64_t* ptrBytesRead) = 0;

        virtual ~IStream() {}
    };

    struct SubBlockInfo
    {
        CompressionMode         mode;
        PixelType               pixelType;
        libCZI::CDimCoordinate  coordinate;
        libCZI::IntRect         logicalRect;
        libCZI::IntSize         physicalSize;
        int                     mIndex;

        double                  GetZoom() const
        {
            if (this->physicalSize.w > this->physicalSize.h)
            {
                return double(this->physicalSize.w) / this->logicalRect.w;
            }

            return double(this->physicalSize.h) / this->logicalRect.h;
        }
    };

    class ISubBlock
    {
    public:
        enum MemBlkType
        {
            Metadata,   
            Data,       
            Attachment  
        };

        virtual const SubBlockInfo& GetSubBlockInfo() const = 0;

        virtual void DangerousGetRawData(MemBlkType type, const void*& ptr, size_t& size) const = 0;

        virtual std::shared_ptr<const void> GetRawData(MemBlkType type, size_t* ptrSize) = 0;

        virtual std::shared_ptr<IBitmapData> CreateBitmap() = 0;

        virtual ~ISubBlock() {};

        template <class Q>
        void DangerousGetRawData(MemBlkType type, const Q*& ptr, size_t& size) const
        {
            const void* p;
            this->DangerousGetRawData(type, p, size);
            ptr = static_cast<Q*>(p);
        }
    };

    struct AttachmentInfo
    {
        GUID        contentGuid;            
        char        contentFileType[9];     
        std::string name;                   
    };

    class IAttachment
    {
    public:
        virtual const AttachmentInfo& GetAttachmentInfo() const = 0;

        virtual void DangerousGetRawData(const void*& ptr, size_t& size) const = 0;

        virtual std::shared_ptr<const void> GetRawData(size_t* ptrSize) = 0;

        virtual ~IAttachment() {};

        template <class Q>
        void DangerousGetRawData(const Q*& ptr, size_t& size) const
        {
            const void* p;
            this->DangerousGetRawData(p, size);
            ptr = (Q*)p;
        }
    };

    class IMetadataSegment
    {
    public:
        enum MemBlkType
        {
            XmlMetadata,    
            Attachment      
        };

        virtual std::shared_ptr<const void> GetRawData(MemBlkType type, size_t* ptrSize) = 0;

        virtual void DangerousGetRawData(MemBlkType type, const void*& ptr, size_t& size) const = 0;

        virtual ~IMetadataSegment() {}

        std::shared_ptr<ICziMetadata> CreateMetaFromMetadataSegment() { return libCZI::CreateMetaFromMetadataSegment(this); }
    };

    struct BoundingBoxes
    {
        IntRect boundingBox;

        IntRect boundingBoxLayer0;
    };

    struct SubBlockStatistics
    {
        int subBlockCount;

        int minMindex;

        int maxMindex;

        IntRect boundingBox;

        IntRect boundingBoxLayer0Only;

        CDimBounds dimBounds;

        std::map<int, BoundingBoxes> sceneBoundingBoxes;

        bool IsMIndexValid() const
        {
            return this->minMindex <= this->maxMindex ? true : false;
        }

        void Invalidate()
        {
            this->subBlockCount = -1;
            this->boundingBox.Invalidate();
            this->boundingBoxLayer0Only.Invalidate();
            this->dimBounds.Clear();
            this->sceneBoundingBoxes.clear();
            this->minMindex = (std::numeric_limits<int>::max)();
            this->maxMindex = (std::numeric_limits<int>::min)();
        }
    };

    struct PyramidStatistics
    {
        struct PyramidLayerInfo
        {
            std::uint8_t minificationFactor;    
            std::uint8_t pyramidLayerNo;        

            bool IsLayer0() const { return this->minificationFactor == 0 && this->pyramidLayerNo == 0; }

            bool IsNotIdentifiedAsPyramidLayer() const { return this->minificationFactor == 0xff && this->pyramidLayerNo == 0xff; }
        };
    
        struct PyramidLayerStatistics
        {
            PyramidLayerInfo    layerInfo;  
            int                 count;      
        };

        std::map<int, std::vector<PyramidLayerStatistics>> scenePyramidStatistics;
    };

    class LIBCZI_API ISubBlockRepository
    {
    public:
        virtual void EnumerateSubBlocks(std::function<bool(int index, const SubBlockInfo& info)> funcEnum) = 0;

        virtual void EnumSubset(const IDimCoordinate* planeCoordinate, const IntRect* roi, bool onlyLayer0, std::function<bool(int index, const SubBlockInfo& info)> funcEnum) = 0;

        virtual std::shared_ptr<ISubBlock> ReadSubBlock(int index) = 0;

        virtual bool TryGetSubBlockInfoOfArbitrarySubBlockInChannel(int channelIndex, SubBlockInfo& info) = 0;

        virtual SubBlockStatistics GetStatistics() = 0;

        virtual PyramidStatistics GetPyramidStatistics() = 0;

        virtual ~ISubBlockRepository() {}
    };

    class LIBCZI_API IAttachmentRepository
    {
    public:

        virtual void EnumerateAttachments(std::function<bool(int index, const AttachmentInfo& info)> funcEnum) = 0;

        virtual void EnumerateSubset(const char* contentFileType, const char* name, std::function<bool(int index, const AttachmentInfo& infi)> funcEnum) = 0;

        virtual ~IAttachmentRepository() {};

        virtual std::shared_ptr<IAttachment> ReadAttachment(int index) = 0;
    };

    struct FileHeaderInfo
    {
        GUID fileGuid;      
        int majorVersion;   
        int minorVersion;   
    };

    class ICZIReader : public ISubBlockRepository, public IAttachmentRepository
    {
    public:
        virtual void Open(std::shared_ptr<IStream> stream) = 0;

        virtual FileHeaderInfo GetFileHeaderInfo() = 0;

        virtual std::shared_ptr<IMetadataSegment> ReadMetadataSegment() = 0;

        virtual std::shared_ptr<IAccessor> CreateAccessor(AccessorType accessorType) = 0;

        virtual void Close() = 0;
    public:
        std::shared_ptr<ISingleChannelTileAccessor>  CreateSingleChannelTileAccessor()
        {
            return std::dynamic_pointer_cast<ISingleChannelTileAccessor, IAccessor>(this->CreateAccessor(libCZI::AccessorType::SingleChannelTileAccessor));
        }

        std::shared_ptr<ISingleChannelPyramidLayerTileAccessor>  CreateSingleChannelPyramidLayerTileAccessor()
        {
            return std::dynamic_pointer_cast<ISingleChannelPyramidLayerTileAccessor, IAccessor>(this->CreateAccessor(libCZI::AccessorType::SingleChannelPyramidLayerTileAccessor));
        }

        std::shared_ptr<ISingleChannelScalingTileAccessor> CreateSingleChannelScalingTileAccessor()
        {
            return std::dynamic_pointer_cast<ISingleChannelScalingTileAccessor, IAccessor>(this->CreateAccessor(libCZI::AccessorType::SingleChannelScalingTileAccessor));
        }
    };
}

#include "libCZI_Query.h"
#include "libCZI_Helpers.h"