SignificanceMap.h

Go to the documentation of this file.

//
// $Id: SignificanceMap.h,v 1.5 2012/02/28 18:15:58 ypolius Exp $
//
 
#ifndef _SignificanceMap_h_
#define _SignificanceMap_h_
 
#include <vector>
#include "vapor/VAssert.h"
#include <vapor/MyBase.h>
#include <algorithm>
 
// using namespace std;
 
//#include "MyBase.h"
 
#ifndef BITSPERBYTE
    #define BITSPERBYTE 8
#endif
 
namespace VAPoR {
 
//
 
class WASP_API SignificanceMap : public Wasp::MyBase {
public:
    SignificanceMap();
 
    SignificanceMap(size_t nx, size_t ny = 1, size_t nz = 1, size_t nt = 1);
    SignificanceMap(std::vector<size_t> dims);
 
    //
    //
    SignificanceMap(const unsigned char *map, size_t nx, size_t ny = 1, size_t nz = 1, size_t nt = 1);
    SignificanceMap(const unsigned char *map, std::vector<size_t> dims);
 
    SignificanceMap(const SignificanceMap &);
 
    ~SignificanceMap();
 
    int Reshape(std::vector<size_t> dims);
    int Reshape(size_t nx, size_t ny = 1, size_t nz = 1, size_t nt = 1);
 
    void GetShape(std::vector<size_t> &dims) const { dims = _dimsVec; };
 
    int Set(size_t idx);
    int SetXYZT(size_t x, size_t y = 0, size_t z = 0, size_t t = 0);
 
    bool inline Test(size_t idx) const;
    bool inline TestXYZT(size_t x, size_t y = 0, size_t z = 0, size_t t = 0) const;
 
    int Clear(size_t idx);
    int ClearXYZT(size_t x, size_t y = 0, size_t z = 0, size_t t = 0);
 
    void Clear();
 
    size_t GetNumSignificant() const { return (_sigMapVec.size()); };
 
    //
    int GetCoordinatesXYZT(size_t i, size_t *x, size_t *y = NULL, size_t *z = NULL, size_t *t = NULL) const;
    int GetCoordinates(size_t i, size_t *idx) const;
 
    //
    void GetNextEntryRestart();
 
    //
    //
    int GetNextEntry(size_t *idx);
    int GetNextEntryXYZT(size_t *x, size_t *y, size_t *z, size_t *t);
 
    //
    static size_t GetMapSize(vector<size_t> dims, size_t num_entries);
 
    //
    size_t GetMapSize(size_t num_entries) const;
 
    //
    size_t GetMapSize() const { return (GetMapSize(GetNumSignificant())); };
 
    //
    void GetMap(const unsigned char **map, size_t *maplen);
 
    //
    void GetMap(unsigned char *map);
 
    //
    //
    int SetMap(const unsigned char *map);
 
    //
    int Append(const SignificanceMap &smap);
 
    //
    void Invert();
 
    //
    void Sort();
 
    SignificanceMap &operator=(const SignificanceMap &map);
 
    friend std::ostream &operator<<(std::ostream &o, const SignificanceMap &sigmap);
 
private:
    static const int HEADER_SIZE = 64;
    static const int VDF_VERSION = 2;
    size_t           _nx;
    size_t           _ny;
    size_t           _nz;
    size_t           _nt;    // dimensions of map (when # dims < 5)
 
    bool _sorted;    // true if the map is sorted in ascending order
 
    std::vector<size_t> _dimsVec;       // Map dimensions
    size_t              _sigMapSize;    // product of dimensions (max coordinate index)
    std::vector<size_t> _sigMapVec;     // The signficance map
 
    int            _bits_per_idx;        // # bits needed to encode a coordinate
    unsigned char *_sigMapEncode;        // compactly encoded version of _sigMapVec
    size_t         _sigMapEncodeSize;    // size of _sigMapEncode in bytes
 
    size_t _idxentry;    // Counter for sequential access to sig. map
 
    int _SignificanceMap(std::vector<size_t> dims);
    int _SignificanceMap(const unsigned char *map, std::vector<size_t> dims);
 
    static size_t _GetBitsPerIdx(vector<size_t> dims);
};
 
bool inline SignificanceMap::Test(size_t idx) const
{
    if (idx > _sigMapSize) return (0);    // Invalid coordinate
 
    if (_sorted) { return (binary_search(_sigMapVec.begin(), _sigMapVec.end(), idx)); }
 
    for (size_t i = 0; i < _sigMapVec.size(); i++) {
        if (_sigMapVec[i] == idx) return (1);
    }
    return (0);
}
 
bool inline SignificanceMap::TestXYZT(size_t x, size_t y, size_t z, size_t t) const
{
    size_t idx = (t * _nz * _ny * _nx) + (z * _ny * _nx) + (y * _nx) + x;
 
    return (this->Test(idx));
}
 
}    // namespace VAPoR
 
#endif