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 <cassert>
#include <vapor/MyBase.h>
#include <algorithm>

//using namespace std;

//#include "MyBase.h"

#ifndef BITSPERBYTE
#define BITSPERBYTE 8
#endif

namespace VAPoR {

//


class SignificanceMap : public VetsUtil::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));
}


}

#endif