mitkOoCVolume.h

/*=========================================================================

  Program:   3DMed
  Date:      $Date: 2014-02-25 18:30:00 +0800 $
  Version:   $Version: 4.6.0 $
  Copyright: MIPG, Institute of Automation, Chinese Academy of Sciences

=========================================================================*/


#ifndef __mitkOoCVolume_h
#define __mitkOoCVolume_h

#include "mitkVolume.h"

class SliceHeapNode;
class SliceHeap;
class SliceBufferBlockNode;
class SliceBufferFreeQueue;

class mitkThreadDelegate;
class mitkSemaphore;

class mitkOoCVolume;
template <class UserClass> class mitkOoCIODelegate;
typedef mitkOoCIODelegate<mitkOoCVolume> mitkOoCVolumeIODelegate;

class MITK_COMMON_API mitkOoCVolume : public mitkVolume
{
public:
    MITK_TYPE(mitkOoCVolume, mitkVolume)

    virtual void PrintSelf(ostream &os);

    mitkOoCVolume();
    
    virtual int GetDataObjectType() const { return MITK_OOC_VOLUME; }

    virtual void const* GetData() const { return NULL; }

    virtual void* GetData() { return NULL; }

    virtual void FreezeSlice(int sliceIdx);

    virtual void UnFreezeSlice(int sliceIdx);

    virtual void const* GetSliceForRead(int sliceIdx);

    virtual void* GetSliceForWrite(int sliceIdx);

    virtual void* GetSliceForReadWrite(int sliceIdx);

    virtual bool ReadSliceData(int sliceIdx, void *dst);

    virtual bool ReadYZSliceData(int xIdx, void *dst);

    virtual bool ReadXZSliceData(int yIdx, void *dst);

    virtual bool GetArbitrarySlice(int w, int h, double o[3], double ux[3], double uy[3], void *dst);

    virtual bool WriteSliceData(int sliceIdx, void const *src);

    virtual bool ReadSubVolume(int x, int y, int z, int w, int h, int d, int &tw, int &th, int &td, void *dst);

    virtual bool ReadSubVolume(int x, int y, int z, int w, int h, int d,
        int dstx, int dsty, int dstz, int dstw, int dsth, int dstd,
        void *dst, bool zeropad=true);

    virtual bool ReadSubVolume(int x, int y, int z, int w, int h, int d, void *dst, bool zeropad=true);

    virtual bool WriteSubVolume(int x, int y, int z, int w, int h, int d, int &tw, int &th, int &td, void const *src);

    virtual bool Allocate();

    virtual unsigned long long GetActualMemorySize() const;

    virtual void Initialize();

    virtual void ShallowCopy(mitkDataObject *src);

    virtual void DeepCopy(mitkDataObject *src);

    void SetSliceDataModified(int sliceIdx, bool modified = true);

    void SetMemoryBufferSize(size_type s);

    void SetBufferedSliceNum(unsigned int n);

    unsigned int GetBufferedSliceNum() { return m_BufferedSliceNum; }

    void SetPathOfDiskBuffer(char const *path);

    char const* GetPathOfDiskBuffer();

    void SetNamePrefix(char const *prefix);

    char const* GetNamePrefix();

    void SetKeepCacheFiles(bool keep=true) { m_KeepCacheFiles = keep; }

    virtual void PrepareSlicesForRead(int startSliceIdx,int sliceNum=1,bool freeze=false);
    virtual void PrepareSlicesForWrite(int startSliceIdx,int sliceNum=1,bool freeze=false);

protected:
    virtual ~mitkOoCVolume();

    bool _loadSlice(int sliceIdx);
    bool _writeSliceBack(int sliceIdx);
    void _clearDiskCache();
    void _flush();
    SliceBufferBlockNode* _getFreeBufferBlock();
    SliceBufferBlockNode* _getSliceBufferBlock(int sliceIdx);

    void const* _getSliceForRead(int sliceIdx);
    void* _getSliceForWrite(int sliceIdx);
    
    bool _changeBufferSize(unsigned int bufSliceNum);

    void _freezeSlice(int sliceIdx);
    void _unFreezeSlice(int sliceIdx);

    void _prepareSlicesForRead();
    void _prepareSlicesForWrite();

    mitkString *m_DiskPath;
    mitkString *m_NamePrefix;

    size_type m_MemBufSize;
    
    unsigned int m_BufferedSliceNum;

    SliceHeap *m_BufferedSliceHeap;
    SliceHeapNode *m_SliceHeapNodes;

    SliceBufferFreeQueue *m_FreeQueue;
    SliceBufferBlockNode *m_BufferBlockNodes;

    void *m_SliceBuffer;

    bool m_KeepCacheFiles;

    mitkOoCVolumeIODelegate *m_IODelegate;

    int m_IOSliceStartIdx,m_IOSliceNumber;
    bool m_IOFreeze;

private:
    mitkOoCVolume(const mitkOoCVolume&);
    void operator = (const mitkOoCVolume&);

};


//#define DEFINED_mitkOoCVolume



#endif

---