zviscene.hpp

// This file is part of slideio project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://slideio.com/license.html.
#pragma once
 
#include "slideio/core/cvscene.hpp"
#include "slideio/core/tools/tilecomposer.hpp"
#include "slideio/drivers/zvi/zviimageitem.hpp"
#include <pole/storage.hpp>
#include "slideio/drivers/zvi/zvitile.hpp"
#include "slideio/drivers/zvi/zvi_api_def.hpp"
 
#if defined(_MSC_VER)
#pragma warning( push )
#pragma warning(disable: 4251)
#endif
 
namespace slideio
{
    class ZVISlide;
 
    class SLIDEIO_ZVI_EXPORTS ZVIScene : public CVScene, public Tiler
    {
    private:
        struct TilerData
        {
            int zSliceIndex = 0;
        };
    public:
        ZVIScene(const std::string& filePath, const std::string& driverId);
        std::string getFilePath() const override;
        int getSceneIndex() const override {
            return 0;
        }
        const std::string& getDriverId() const override {
            return m_driverId;
        }
        cv::Rect getRect() const override;
        int getNumChannels() const override;
        int getNumZSlices() const override;
        int getNumTFrames() const override;
        double getZSliceResolution() const override;
        double getTFrameResolution() const override;
        void validateChannelIndex(int channel) const;
        DataType getChannelDataType(int channel) const override;
        int getChannelSignificantBits(int channelIndex) const override;
        bool hasPlaneTimestamps() const override { return !m_PlaneTimestamps.empty(); }
        double getPlaneTimestamp(int tFrame, int channel, int zSlice) const override;
        int64_t getAcquisitionTime() const override { return m_AcquisitionTime; }
        std::string getChannelName(int channel) const override;
        Resolution getResolution() const override;
        double getMagnification() const override;
        std::string getName() const override;
        Compression getCompression() const override;
        const std::vector<ZVIImageItem>& getImageItems() const { return m_ImageItems; }
        void readResampledBlockChannelsEx(const cv::Rect& blockRect, const cv::Size& blockSize,
            const std::vector<int>& componentIndices, int zSliceIndex, int tFrameIndex,
            cv::OutputArray output) override;
        // Safe because nothing on the read path holds a cursor: readRaster
        // borrows its stream const and issues one positional read_at, and
        // pole's block loaders read by offset rather than through a shared
        // file cursor. m_Doc is therefore shared by every reader, with two
        // descriptors per document rather than per thread, and no
        // ContextPool -- the CZI and VSI shape, not the NDPI one. See the
        // 2026-09-09 design, section 4.
        bool supportsConcurrentReads() const override { return true; }
    public:
        int getTileCount(void* userData) override;
        bool getTileRect(int tileIndex, cv::Rect& tileRect, void* userData) override;
        bool readTile(int tileIndex, const std::vector<int>& channelIndices, cv::OutputArray tileRaster,
                      void* userData) override;
        void initializeBlock(const cv::Size& blockSize, const std::vector<int>& channelIndices, cv::OutputArray output) override;
    private:
        ZVIPixelFormat getPixelFormat() const;
        void alignChannelInfoToPixelFormat();
        void collectChannelSignificantBits();
        void collectPlaneTimestamps();
        void computeSceneDimensions();
        std::vector<int> findImageItemIndices();
        void readImageItems();
        void init();
        void parseImageTags();
        void parseImageInfo();
        void computeTiles();
    private:
        std::string m_filePath;
        ole::compound_document m_Doc;
        int m_Width = 0;
        int m_Height = 0;
        int m_RawCount = 0;
        ZVIPixelFormat m_PixelFormat = ZVIPixelFormat::PF_UNKNOWN;
        int m_ChannelCount = 0;
        int m_ZSliceCount = 0;
        int m_TFrameCount = 0;
        int m_TileCountX = 1;
        int m_TileCountY = 1;
        std::vector<DataType> m_ChannelDataTypes;
        std::vector<std::string> m_ChannelNames;
        std::vector<ZVIImageItem> m_ImageItems;
        // ACQUISITION_BIT_DEPTH, per channel, 0 where the file states none.
        std::vector<int> m_ChannelSignificantBits;
        // Seconds from getAcquisitionTime(), one per plane, indexed
        // (t * numZ + z) * numC + c. Empty unless every plane states a time.
        std::vector<double> m_PlaneTimestamps;
        int64_t m_AcquisitionTime = 0;
        std::vector<ZVITile> m_Tiles;
        Resolution m_res = {0,0};
        double m_ZSliceRes = 0.;
        std::string m_SceneName;
        Compression m_Compression = Compression::Uncompressed;
        std::string m_driverId;
    };
}
 
 
#if defined(_MSC_VER)
#pragma warning( pop )
#endif