BaseImage.h

// BaseImage.h:
// ------------
//

#ifndef __IPSDKIMAGE_BASEIMAGE_H__
#define __IPSDKIMAGE_BASEIMAGE_H__

// suppression warnings
// warning C4251: 'ipsdk::image::BaseImage::_pIdentifier' : class 'boost::shared_ptr<T>' needs to have dll-interface to be used by clients of class 'ipsdk::image::BaseImage'
#pragma warning (push)
#pragma warning (disable : 4251)

#include <IPSDKImage/IPSDKImageExports.h>
#include <IPSDKImage/Image/ImageTypes.h>
#include <IPSDKImage/Geometry/ImageGeometryTypes.h>
#include <IPSDKImage/Geometry/Component/GeometryComponentTypes.h>
#include <IPSDKBaseData/DataItem/DataItemTypes.h>
#include <IPSDKUtil/BaseCollections.h>
#include <IPSDKUtil/Tools/ProcessingResult.h>
#include <IPSDKSerialization/Engine/BaseObjectWithSkeleton.h>
#include <boost/enable_shared_from_this.hpp>

namespace ipsdk {
namespace image {

struct SubImageExtractor;
struct ImageStripExtractor;
struct ImageTileExtractor;


class IPSDKIMAGE_API BaseImage : public BaseObjectWithSkeleton,
                                 public boost::enable_shared_from_this<BaseImage>
{
    // declare serial class
    IPSDK_DECLARE_ABSTRACT_SERIAL_WITHOUT_COPY(IPSDKImage, BaseImage);

    // friend class for protected members access
    friend struct SubImageExtractor;
    friend struct ImageStripExtractor;
    friend struct ImageTileExtractor;

protected:
    BaseImage();

public:
    virtual ~BaseImage() = 0;
    
// methods
public:
    virtual eImageBaseType              getImageBaseType() const = 0;

    virtual ipBool                      isGpuImage() const = 0;

    virtual ipBool                      isDiskImage() const = 0;

    bool                                isInit() const;

    virtual BoolResult                  init(const BaseImageGeometry& geometry) = 0;

    //------------------------
    //------------------------

    const DataIdentifier&               getIdentifier() const;

    const DataIdentifierConstPtr        getIdentifierPtr() const;

    const Guid&                         getGuid() const;

    const std::string&                  getName() const;

    //--------------------
    //--------------------

    bool                                existsHeaderKey(const std::string& key) const;

    ItemNames                           getHeaderKeys() const;

    const BaseDataItem&                 getHeaderItem(const std::string& key) const;

    DataItemConstPtr                    getHeaderItemPtr(const std::string& key) const;

    DataItemMapConstPtr                 getHeaderPtr() const;

    //-------------------------
    //-------------------------

    bool                                hasGeometricCalibration() const;

    const GeometricCalibration&         getGeometricCalibration() const;

    const GeometricCalibrationConstPtr& getGeometricCalibrationConstPtr() const;

    void                                setGeometricCalibration(const GeometricCalibrationConstPtr& pGeometricCalibration);

    void                                setScaleGeometricCalibration(const ipReal32 scale,
                                                                     const std::string& unitStr = "");
    void                                setScaleGeometricCalibration(const ipReal32 xScale,
                                                                     const ipReal32 yScale,
                                                                     const std::string& unitStr = "");
    void                                setScaleGeometricCalibration(const ipReal32 xScale,
                                                                     const ipReal32 yScale,
                                                                     const ipReal32 zScale,
                                                                     const std::string& unitStr = "");

    void                                setOrigin(const ipReal32 xOrigin, const ipReal32 yOrigin);
    void                                setOrigin(const ipReal32 xOrigin, const ipReal32 yOrigin, const ipReal32 zOrigin);

    //----------------------
    //----------------------

    const BaseImageGeometry&        getGeometry() const;

    ImageGeometryConstPtr           getGeometryPtr() const;

    ipUInt64                        getSizeX() const;

    ipUInt64                        getSizeY() const;

    const VolumeGeometry&           getVolumeGeometry() const;

    const eVolumeGeometryType&      getVolumeGeometryType() const;

    ipUInt64                        getSizeZ() const;

    const ColorGeometry&            getColorGeometry() const;

    const eColorGeometryType&       getColorGeometryType() const;

    ipUInt64                        getSizeC() const;

    const TemporalGeometry&         getTemporalGeometry() const;

    const eTemporalGeometryType&    getTemporalGeometryType() const;

    ipUInt64                        getSizeT() const;

    ipUInt64                        getNbTotPlans() const;

    bool                            isValidPlanIdx(const ipUInt64 zPlanIdx,
                                                   const ipUInt64 cPlanIdx,
                                                   const ipUInt64 tPlanIdx) const;

    bool                            isValidPlanIdx(const PlanIndex& planIdx) const;

    const eImageBufferType&         getBufferType() const;

    const eImageBufferType&         getBufferType(const ipUInt64 tPlanIdx) const;
    
    virtual eImageAccessMode        getAccessMode() const = 0;

    virtual bool                    hasRemoteStorage() const;

    bool                            hasBinary8BitsStorage() const;

    bool                            hasByPlanDataAccess() const;

    PlanStorageConstPtr             getPlanStorage(const PlanIndex& planIndex) const;
    PlanStoragePtr                  getPlanStorage(const PlanIndex& planIndex);
    
    const PlanStorageColl3d&        getPlanStorageColl() const;

    std::string                     getUserPropertiesStr() const;

    void                            setUserPropertiesStr(const std::string& newStrUserProperties);

    std::string                     getChannelName(const ipUInt64 c) const;


    void                            setChannelName(const std::string& strName, const ipUInt64 c);

    bool                            minIsBlack() const;



    //----------------------
    //----------------------

    void                            toGPU(CudaImagePtr pCudaImg) const;

    CudaImagePtr                     toGPU() const;

    ipBool                          containSameData(const BaseImage& otherImage) const;

    void                            setVolumeGeometryType(const eVolumeGeometryType& vType);
    void                            setColorGeometryType(const eColorGeometryType& cType);
    void                            setTemporalGeometryType(const eTemporalGeometryType& tType);
    void                            setBufferType(const eImageBufferType& type);

    void                            clear();

protected:
    BoolResult                      initBase(const DataIdentifierConstPtr& pIdentifier,
                                             const DataItemMapConstPtr& pHeader,
                                             const ImageGeometryPtr& pGeometry,
                                             const PlanStorageColl3d& imagePlans);

    void                            resizeBase(const ImageGeometryPtr& pGeometry,
                                               const PlanStorageColl3d& imagePlans);

    virtual void                    clearDerived() {};

    const PlanStorageColl3d&        accessImagePlans() const;
    PlanStorageColl3d&              accessImagePlans();

    bool                            checkForRemoteStorage() const;

// attributes
private:
    DataIdentifierConstPtr          _pIdentifier;

    DataItemMapConstPtr             _pHeader;

    ImageGeometryPtr                _pGeometry;

    GeometricCalibrationConstPtr    _pGeometricCalibration;

    PlanStorageColl3d               _imagePlans;

    std::string                     _userPropertiesStr;

    bool                            _bInit;
};


inline bool
BaseImage::isInit() const
{
    return _bInit;
}


} // end of namespace image
} // end of namespace ipsdk

#pragma warning (pop)

#endif // __IPSDKIMAGE_BASEIMAGE_H__