cvscene.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.
#ifndef OPENCV_slideio_scene_HPP
#define OPENCV_slideio_scene_HPP
 
#include "slideio/core/slideio_core_def.hpp"
#include "slideio/base/resolution.hpp"
#include "slideio/base/slideio_enums.hpp"
#include <opencv2/core.hpp>
#include <vector>
#include <string>
#include <list>
#include "refcounter.hpp"
#include <mutex>
 
#include "levelinfo.hpp"
 
#if defined(_MSC_VER)
#pragma warning( push )
#pragma warning(disable: 4251)
#endif
 
namespace slideio
{
    class SLIDEIO_CORE_EXPORTS CVScene : public RefCounter
    {
    public:
        virtual ~CVScene() = default;
        virtual std::string getFilePath() const = 0;
        virtual std::string getName() const = 0;
        virtual cv::Rect getRect() const = 0;
        virtual int getNumChannels() const = 0;
        virtual int getNumZSlices() const {return 1;}
        virtual int getNumTFrames() const {return 1;}
        virtual slideio::DataType getChannelDataType(int channel) const = 0;
        virtual std::string getChannelName(int channel) const;
        virtual Resolution  getResolution() const = 0;
        virtual double getZSliceResolution() const {return 0;}
        virtual double getTFrameResolution() const {return 0;}
        virtual double getMagnification() const = 0;
        virtual Compression getCompression() const = 0;
        virtual void readBlock(const cv::Rect& blockRect, cv::OutputArray output);
        virtual void readBlockChannels(const cv::Rect& blockRect, const std::vector<int>& channelIndices, cv::OutputArray output);
        virtual void readResampledBlock(const cv::Rect& blockRect, const cv::Size& blockSize, cv::OutputArray output);
        virtual void readResampledBlockChannels(const cv::Rect& blockRect, const cv::Size& blockSize, const std::vector<int>& channelIndices, cv::OutputArray output);
        virtual void read4DBlock(const cv::Rect& blockRect, const cv::Range& zSliceRange, const cv::Range& timeFrameRange, cv::OutputArray output);
        virtual void read4DBlockChannels(const cv::Rect& blockRect, const std::vector<int>& channelIndices, const cv::Range& zSliceRange, const cv::Range& timeFrameRange, cv::OutputArray output);
        virtual void readResampled4DBlock(const cv::Rect& blockRect, const cv::Size& blockSize, const cv::Range& zSliceRange, const cv::Range& timeFrameRange, cv::OutputArray output);
        virtual void readResampled4DBlockChannels(const cv::Rect& blockRect, const cv::Size& blockSize, const std::vector<int>& channelIndices, const cv::Range& zSliceRange, const cv::Range& timeFrameRange, cv::OutputArray output);
        virtual const std::list<std::string>& getAuxImageNames() const {
            return m_auxNames;
        }
        virtual int getNumAuxImages() const {
            return static_cast<int>(m_auxNames.size());
        }
        virtual std::shared_ptr<CVScene> getAuxImage(const std::string& imageName) const;
        virtual std::string getRawMetadata() const { return m_rawMetadata; }
        virtual void readResampledBlockChannelsEx(const cv::Rect& blockRect, const cv::Size& blockSize,
            const std::vector<int>& componentIndices, int zSliceIndex, int tFrameIndex, cv::OutputArray output) = 0;
        virtual int getNumZoomLevels() const;
        virtual const LevelInfo* getZoomLevelInfo(int level) const;
        std::string toString() const;
        virtual MetadataFormat getMetadataFormat() const { return m_metadataFormat; }
        virtual int defineChannelAttribute(const std::string& attributeName);
        virtual int getChannelAttributeIndex(const std::string& attributeName) const;
        virtual void setChannelAttribute(int channelIndex, const std::string& attributeName, const std::string& attributeValues);
        virtual std::string getChannelAttributeValue(int channelIndex, const std::string& attributeName) const;
        virtual const std::string& getChannelAttributeValue(int channelIndex, int attributeIndex) const;
        virtual const std::string& getChannelAttributeName(int index) const;
        virtual int getNumChannelAttributes() const {
            return static_cast<int>(m_channelAttributeNames.size());
        }
    protected:
        std::vector<int> getValidChannelIndices(const std::vector<int>& channelIndices);
        void initializeSceneBlock(const cv::Size& blockSize, const std::vector<int>& channelIndices,
                                  cv::OutputArray output) const;
 
    protected:
        std::list<std::string> m_auxNames;
        std::vector<LevelInfo> m_levels;
        mutable std::mutex m_readBlockMutex;
        std::string m_rawMetadata;
        MetadataFormat m_metadataFormat = MetadataFormat::None;
        std::vector<std::string> m_channelAttributeNames;
        std::vector<std::vector<std::string>> m_channelAttributes;
    };
}
 
#define CVScenePtr std::shared_ptr<slideio::CVScene>
 
#if defined(_MSC_VER)
#pragma warning( pop )
#endif
 
#endif