mlDataCompressor.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_DATA_COMPRESSOR_H
#define ML_DATA_COMPRESSOR_H
 
 
// Resolve platform dependencies.
#include "MLDataCompressorSystem.h"
 
#include <mlBase.h>
 
#include <cstring>
 
 
ML_UTILS_START_NAMESPACE
 
  class CompressionRegisterEntry;
 
  // -------------------------------------------------------------------
  // -------------------------------------------------------------------
  class MLDATA_COMPRESSOR_EXPORT DataCompressor : public Base
  {
  public:
 
    //--------------------------------------------------------------------------------
    //--------------------------------------------------------------------------------
 
    enum { MaxHints = 10 };
 
    enum HintType {
      Unused     = 0,  
      IsDouble   = 1,  
      IsInt      = 2,  
      IsBool     = 3,  
      IsString   = 4,  
      IsDataType = 5   
    };
 
 
    //--------------------------------------------------------------------------------
    //--------------------------------------------------------------------------------
 
    DataCompressor();
 
    ~DataCompressor() override;
 
 
    //--------------------------------------------------------------------------------
    //--------------------------------------------------------------------------------
 
    virtual std::string           getTypeName()     const = 0;
 
    virtual std::string           getVersion()      const = 0;
 
    virtual bool                  isSupportedVersion(const std::string &ver) const = 0;
 
    virtual std::string           getVendor()       const { return "";           }
 
    virtual std::string           getSuffix()       const { return "";           }
 
    virtual bool                  isLossy()         const { return false;        }
 
 
    //--------------------------------------------------------------------------------
    //--------------------------------------------------------------------------------
 
    virtual MLDataType            getDataType()        const  { return _dataType; }
 
    virtual void                  setDataType(MLDataType dt)  { _dataType = dt;   }
 
 
    virtual size_t                getVoxelSize()        const { return _voxelSize; }
 
    virtual void                  setVoxelSize(size_t vSize)  { _voxelSize = vSize;}
 
 
    virtual void                  getImageExtent(MLint ext[6]) const { memcpy(ext, _ext, sizeof(MLint)*6); }
 
    virtual void                  setImageExtent(const MLint ext[6]) { memcpy(_ext, ext, sizeof(MLint)*6); }
 
 
    virtual MLuint8               numUsedHints()       const  { return 0;          }
 
    virtual void                  getHint(MLuint8     hintIdx  ,
                                          HintType    &hintType,
                                          std::string &strVal  ,
                                          std::string &hintName,
                                          double      &rangeMin,
                                          double      &rangeMax)   const;
 
    virtual MLErrorCode           setHint(MLuint8           hintIdx,
                                          const std::string value);
 
    virtual MLErrorCode           setHint(const std::string &hintName,
                                          const std::string &value);
 
    virtual int                   findHint(const std::string &hintName);
 
 
 
    //--------------------------------------------------------------------------------
    //--------------------------------------------------------------------------------
 
    [[nodiscard]]
    virtual MLErrorCode           compress(const  void *srcMem,
                                           size_t       srcSize,
                                           void       *&dstMem,
                                           MLint       &dstNum) const = 0;
 
    [[nodiscard]]
    virtual MLErrorCode           decompress(const  void *srcMem,
                                             size_t       srcSize,
                                             void       *&dstMem,
                                             MLint64     &resSize) const = 0;
 
 
  protected:
 
    MLDataType  _dataType;
 
    size_t      _voxelSize;
 
    MLint       _ext[6];
 
 
    HintType    _hintType[MaxHints];
 
    std::string _strHints[MaxHints];
 
    std::string _hintName[MaxHints];
 
    double      _rangeMin[MaxHints];
 
    double      _rangeMax[MaxHints];
 
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    static  int  reorderBytePlanes(void *data, size_t dataSize, size_t voxSize);
 
    static  int  unReorderBytePlanes(void *data, size_t dataSize, size_t voxSize);
 
    static  void diffCodeData  (void *data, size_t dataSize, size_t voxSize=1);
 
    static  void undiffCodeData(void *data, size_t dataSize, size_t voxSize=1);
 
    static int reorderDataTraversal(void *data, size_t dataSize, size_t voxSize, const MLint64 imgExt[6]);
 
    static int unReorderDataTraversal(void *data, size_t dataSize, size_t voxSize, const MLint64 imgExt[6]);
 
    static void packMLints(const MLint vec[6], unsigned char packedBuffer[55]);
 
    static void unpackMLints(const unsigned char packedBuffer[55], MLint vec[6]);
 
 
  private:
 
    static std::vector<CompressionRegisterEntry>::iterator findCompressorType(const std::string &typeName);
 
    static std::vector<CompressionRegisterEntry>::iterator findCompressorType(const RuntimeType &rtType);
 
    static std::vector<CompressionRegisterEntry> _dataCompressorTypes;
 
    ML_ABSTRACT_CLASS_HEADER(DataCompressor)
  };
 
ML_UTILS_END_NAMESPACE
 
#endif // __mlDataCompressor_H