Compressor.h

Go to the documentation of this file.

//
// $Id$
//
 
#ifndef _Compressor_h_
#define _Compressor_h_
 
#include <vector>
#include "SignificanceMap.h"
#include "MatWaveWavedec.h"
 
namespace VAPoR {
 
//
class WASP_API Compressor : public MatWaveWavedec {
public:
    //
    Compressor(std::vector<size_t> dims, const string &wname, const string &mode);
    Compressor(std::vector<size_t> dims, const string &wname);
 
    virtual ~Compressor();
 
    //
    int Compress(const float *src_arr, float *dst_arr, size_t dst_arr_len, SignificanceMap *sigmap);
    int Compress(const double *src_arr, double *dst_arr, size_t dst_arr_len, SignificanceMap *sigmap);
    int Compress(const int *src_arr, int *dst_arr, size_t dst_arr_len, SignificanceMap *sigmap);
    int Compress(const long *src_arr, long *dst_arr, size_t dst_arr_len, SignificanceMap *sigmap);
 
    //
    int Decompress(const float *src_arr, float *dst_arr, SignificanceMap *sigmap);
    int Decompress(const double *src_arr, double *dst_arr, SignificanceMap *sigmap);
    int Decompress(const int *src_arr, int *dst_arr, SignificanceMap *sigmap);
    int Decompress(const long *src_arr, long *dst_arr, SignificanceMap *sigmap);
 
    //
    int Decompose(const float *src_arr, float *dst_arr, const vector<size_t> &dst_arr_lens, vector<SignificanceMap> &sigmaps);
    int Decompose(const double *src_arr, double *dst_arr, const vector<size_t> &dst_arr_lens, vector<SignificanceMap> &sigmaps);
    int Decompose(const int *src_arr, int *dst_arr, const vector<size_t> &dst_arr_lens, vector<SignificanceMap> &sigmaps);
    int Decompose(const long *src_arr, long *dst_arr, const vector<size_t> &dst_arr_lens, vector<SignificanceMap> &sigmaps);
 
    int Reconstruct(const float *src_arr, float *dst_arr, vector<SignificanceMap> &sigmaps, int l);
    int Reconstruct(const double *src_arr, double *dst_arr, vector<SignificanceMap> &sigmaps, int l);
    int Reconstruct(const int *src_arr, int *dst_arr, vector<SignificanceMap> &sigmaps, int l);
    int Reconstruct(const long *src_arr, long *dst_arr, vector<SignificanceMap> &sigmaps, int l);
 
    // static bool IsCompressible(
    //  std::vector <size_t> dims, const string &wavename, const string &mode
    //);
 
    void GetSigMapShape(std::vector<size_t> &dims) const
    {
        dims.clear();
        dims.push_back(_CLen);
    };
 
    size_t GetNumWaveCoeffs() const { return (_CLen); };
 
    size_t GetSigMapSize(size_t num_entries) const
    {
        std::vector<size_t> dims;
        dims.push_back(GetNumWaveCoeffs());
        return (SignificanceMap::GetMapSize(dims, num_entries));
    };
 
 
    void GetDimension(vector<size_t> &dims, int l) const;
 
    //
    int GetNumLevels() const { return (_nlevels); };
 
    //
    size_t GetMinCompression() const;
 
    bool &KeepAppOnOff() { return (_keepapp); };
 
    bool &ClampMinOnOff() { return (_clamp_min_flag); };
 
    double &ClampMin() { return (_clamp_min); };
 
    bool &ClampMaxOnOff() { return (_clamp_max_flag); };
 
    double &ClampMax() { return (_clamp_max); };
 
    bool &EpsilonOnOff() { return (_epsilon_flag); };
 
    double &Epsilon() { return (_epsilon); };
 
    static bool CompressionInfo(vector<size_t> dims, const string wavename, bool keepapp, size_t &nlevels, size_t &maxcratio);
 
    friend std::ostream &operator<<(std::ostream &o, const Compressor &rhs);
 
private:
    vector<size_t> _dims;        // dimensions of array
    int            _nlevels;     // Number of wavelet transformation levels
    vector<void *> _indexvec;    // used to sort wavelet coefficients
    size_t         _nx;
    size_t         _ny;
    size_t         _nz;
    double *       _C;    // storage for wavelet coefficients
    size_t         _CLen;
    size_t *       _L;    // wavelet coefficient book keeping array
    size_t         _LLen;
    bool           _keepapp;    // if true, approximation coeffs are not used in compression
    bool           _clamp_min_flag;
    bool           _clamp_max_flag;
    bool           _epsilon_flag;
    double         _clamp_min;
    double         _clamp_max;
    double         _epsilon;
 
    void _Compressor(std::vector<size_t> dims);
};
 
}    // namespace VAPoR
 
#endif