zviimageitem.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/drivers/zvi/pole_lib.hpp"
#include "slideio/drivers/zvi/zvipixelformat.hpp"
#include "slideio/core/slideio_enums.hpp"
#include <opencv2/opencv.hpp>
 
namespace slideio
{
        class   ZVIImageItem
        {
        public:
            ZVIImageItem() = default;
            void setItemIndex(int itemIndex) { m_ItemIndex = itemIndex; }
            int getZIndex() const { return m_ZIndex; }
            int getCIndex() const { return m_CIndex; }
            int getTIndex() const { return m_TIndex; }
            int getPositionIndex() const { return m_PositionIndex; }
            int getSceneIndex() const { return m_SceneIndex; }
            int getItemIndex() const { return m_ItemIndex; }
            std::streamoff getDataOffset() const { return m_DataPos; }
            std::string getChannelName() const { return m_ChannelName; }
            ZVIPixelFormat getPixelFormat() const { return m_PixelFormat; }
            int getWidth() const { return m_Width; }
            int getHeight() const { return m_Height; }
            int getZSliceCount() const { return m_ZSliceCount; }
            void setZSliceCount(int depth) { m_ZSliceCount = depth; }
            DataType getDataType() const { return m_DataType; }
            int getChannelCount() const { return m_ChannelCount; }
            void readItemInfo(ole::compound_document& doc);
            int getTileIndexX() const { return m_TileIndexX; }
            int getTileIndexY() const { return m_TileIndexY; }
            void readRaster(ole::compound_document& doc, cv::OutputArray raster) const;
            int getValidBits() const { return m_ValidBits; }
            // ACQUISITION_BIT_DEPTH: how many of the stored bits the camera filled.
            // 0 when the item states none. Distinct from getValidBits(), which is
            // the raster header field and doubles as a compression marker.
            int getAcquisitionBitDepth() const { return m_AcquisitionBitDepth; }
            // CAMERA_IMAGE_ACQUISITION_TIME as seconds since the Unix epoch.
            // hasAcquisitionTime() is the test, not a zero epoch: 1970 is a real
            // instant even if no microscope will produce it.
            bool hasAcquisitionTime() const { return m_HasAcquisitionTime; }
            double getAcquisitionTime() const { return m_AcquisitionTime; }
            // The scene renumbers the item coordinates densely once it knows
            // which items the document really holds; see
            // ZVIScene::computeSceneDimensions().
            void setCIndex(int cIndex) { m_CIndex = cIndex; }
            void setZIndex(int zIndex) { m_ZIndex = zIndex; }
            void setTIndex(int tIndex) { m_TIndex = tIndex; }
            // Likewise for the tile position: ZVIScene::computeTiles() resolves
            // an unknown one against the grid. It has to be written back to the
            // item, because ZVITile::addItem() reads the position from the item
            // rather than from the caller.
            void setTileIndexX(int index) { m_TileIndexX = index; }
            void setTileIndexY(int index) { m_TileIndexY = index; }
 
            // Per-channel display hints carried by the per-item tag stream.
            // Multichannel Colour is a Windows-style packed BGR int
            // (0x00BBGGRR); 0 means the file did not assign a color. Wavelength
            // values are in nanometers; 0 means absent. Reflector is the
            // microscope filter cube label (e.g. "49 DAPI").
            int getMultichannelColour() const { return m_MultichannelColour; }
            double getEmissionWavelength() const { return m_EmissionWavelength; }
            double getExcitationWavelength() const { return m_ExcitationWavelength; }
            std::string getReflector() const { return m_Reflector; }
        private:
            void setWidth(int width) { m_Width = width; }
            void setHeight(int height) { m_Height = height; }
            void setPixelFormat(ZVIPixelFormat pixelFormat);
            void setPositionIndex(int positionIndex) { m_PositionIndex = positionIndex; }
            void setSceneIndex(int sceneIndex) { m_SceneIndex = sceneIndex; }
            void setDataOffset(std::streamoff pos) { m_DataPos = pos; }
            void setChannelName(const std::string& name) { m_ChannelName = name; }
            void readContents(ole::compound_document& doc);
            void readTags(ole::compound_document& doc);
            void setValidBits(int bits) { m_ValidBits = bits; }
        private:
            int m_ChannelCount = 0;
            int m_Width = 0;
            int m_Height = 0;
            int m_ItemIndex = -1;
            int m_ZIndex = -1;
            int m_CIndex = -1;
            int m_TIndex = -1;
            int m_PositionIndex = -1;
            int m_SceneIndex = -1;
            // -1 means "the tag stream did not say". ZVIScene::computeTiles()
            // resolves that to (0,0) only when the image is a single tile;
            // guessing a position on a mosaic serves the wrong pixels.
            int m_TileIndexX = -1;
            int m_TileIndexY = -1;
            int m_ValidBits = 0;
            int m_AcquisitionBitDepth = 0;
            bool m_HasAcquisitionTime = false;
            double m_AcquisitionTime = 0.;
            std::streamoff m_DataPos = 0;
            std::string m_ChannelName;
            ZVIPixelFormat m_PixelFormat = ZVIPixelFormat::PF_UNKNOWN;
            int m_ZSliceCount = 1;
            DataType m_DataType = DataType::DT_Unknown;
            int m_MultichannelColour = 0;
            double m_EmissionWavelength = 0.0;
            double m_ExcitationWavelength = 0.0;
            std::string m_Reflector;
        };
 
}