RegularGrid.h

Go to the documentation of this file.

#ifndef _RegularGrid_
#define _RegularGrid_

#include <ostream>
#include <vector>
#include <vapor/common.h>

//
//

namespace VAPoR {
class VDF_API RegularGrid {
public:

 RegularGrid(
    const size_t bs[3],
    const size_t min[3],
    const size_t max[3],
    const double extents[6],
    const bool periodic[3],
    float ** blks
 );

 RegularGrid(
    const size_t bs[3],
    const size_t min[3],
    const size_t max[3],
    const double extents[6],
    const bool periodic[3],
    float ** blks,
    float missing_value
 );

 virtual ~RegularGrid();

 float &AccessIJK(size_t i, size_t j, size_t k) const;

 virtual float GetValue(double x, double y, double z) const;

 virtual void GetUserExtents(double extents[6]) const;

 virtual void GetBoundingBox(
    const size_t min[3], const size_t max[3], double extents[6]
 ) const;
 virtual void GetBoundingBox(
    const std::vector <size_t> &min, const std::vector <size_t> &max,
    std::vector <double> &minu, std::vector <double> &maxu
 ) const; 

 virtual void    GetEnclosingRegion(
    const double minu[3], const double maxu[3], size_t min[3], size_t max[3]
 ) const;

 //
 virtual void GetIJKMinMax(size_t min[3], size_t max[3]) const {
    min[0] = min[1] = min[2] = 0;
    max[0] = _max[0]-_min[0]; max[1] = _max[1]-_min[1]; max[2] = _max[2]-_min[2];
 }

 //
 virtual void GetIJKOrigin(size_t min[3]) const {
    min[0] = _minabs[0]; min[1] = _minabs[1]; min[2] = _minabs[2];
 }

 void GetDimensions(size_t dims[3]) const;

 float GetMissingValue() const {return (_missingValue); };

 void SetMissingValue(float missing_value) {
    _missingValue = missing_value; _hasMissing = true;
 };

 //
 bool HasMissingData() const { return (_hasMissing); };

 virtual int GetInterpolationOrder() const { return _interpolationOrder;};

 virtual void SetInterpolationOrder(int order);

 
 virtual int GetUserCoordinates(
    size_t i, size_t j, size_t k, 
    double *x, double *y, double *z
 ) const;

 
 
 void getBilinearWeights(double x, double y, double z,
                        double &iwgt, double &jwgt) const;

 
 
 double bilinearElevation(size_t i0, size_t i1, size_t j0, size_t j1,
                        size_t k0, double iwgt, double jwgt) const;

 
 double bilinearInterpolation(size_t i0, size_t i1, size_t j0, size_t j1,
                        size_t k0, double iwgt, double jwgt) const;



 double quadraticInterpolation(double x, double y, double z) const;

 
 double verticalLinearInterpolation(double x, double y, double z) const;
 
 virtual void GetIJKIndex(
    double x, double y, double z,
    size_t *i, size_t *j, size_t *k
 ) const;

 virtual void GetIJKIndexFloor(
    double x, double y, double z,
    size_t *i, size_t *j, size_t *k
 ) const;

 virtual void GetRange(float range[2]) const;

 virtual int Reshape(
    const size_t min[3],
    const size_t max[3],
    const bool periodic[3]
 );


 virtual bool InsideGrid(double x, double y, double z) const;


 //
 virtual void HasPeriodic(bool *idim, bool *jdim, bool *kdim) const {
    *idim = _periodic[0]; *jdim = _periodic[1]; *kdim = _periodic[2];
 }

 //
 virtual void SetPeriodic(const bool periodic[3]) {
    _periodic[0] = periodic[0];
    _periodic[1] = periodic[1];
    _periodic[2] = periodic[2];
 }

 void GetBlockSize(size_t bs[3]) const {
    bs[0] = _bs[0]; bs[1] = _bs[1]; bs[2] = _bs[2];
 }

 virtual void GetMinCellExtents(double *x, double *y, double *z) const {
    *x = _delta[0]; *y = _delta[1]; *z = _delta[2];
 };

 //
 virtual int GetRank() {
    int rank = 0;
    for (int i=0; i<3; i++) if (_min[i]!=_max[i]) rank++;
    return(rank);
 }

 virtual double _interpolateVaryingCoord(size_t /*i0*/, size_t /*j0*/,
                size_t /*k0*/, double /*x*/, double /*y*/, double /*z*/) const
                {return 0.0;}; 

 float **GetBlks() const { return(_blks); };

 size_t GetNumBlks() const { return(_nblocks); };

 float Next();

 void ResetItr();

 
 class VDF_API Iterator {
 public:
    Iterator (RegularGrid *rg);
    Iterator ();
    ~Iterator () {}

    inline float &operator*() {return (*_itr);}

    Iterator &operator++(); // ++prefix 
    Iterator operator++(int);   // postfix++

    bool operator==(const Iterator &other);
    bool operator!=(const Iterator &other);

    int GetUserCoordinates(
    double *x, double *y, double *z
    ) const { return(_rg->GetUserCoordinates(
        _x - _rg->_min[0], _y - _rg->_min[1], _z - _rg->_min[2], x,y,z));
    };

 private:
    RegularGrid *_rg;
    size_t _x, _y, _z;  // current index into _rg->_min[3]
    size_t _xb; // x index within a block
    float *_itr;
    bool _end;


 };

 Iterator begin() { return( Iterator(this)); }
 Iterator end() { return(Iterator()); }


 class VDF_API ConstIterator {
 public:
    ConstIterator (const RegularGrid *rg);
    ConstIterator ();
    ~ConstIterator () {}

    inline float &operator*() {return (*_itr);}

    ConstIterator &operator++();    // ++prefix 
    ConstIterator operator++(int);  // postfix++

    bool operator==(const ConstIterator &other);
    bool operator!=(const ConstIterator &other);

    int GetUserCoordinates(
    double *x, double *y, double *z
    ) const { return(_rg->GetUserCoordinates(
        _x - _rg->_min[0], _y - _rg->_min[1], _z - _rg->_min[2], x,y,z));
    };

 private:
    const RegularGrid *_rg;
    size_t _x, _y, _z;  // current index into _rg->_min[3]
    size_t _xb; // x index within a block
    float *_itr;
    bool _end;


 };

 ConstIterator begin() const { return( ConstIterator(this)); }
 ConstIterator end() const { return(ConstIterator()); }




 
 VDF_API friend std::ostream &operator<<(std::ostream &o, const RegularGrid &rg);



protected: 

 float &_AccessIJK(float **blks, size_t i, size_t j, size_t k) const;
 void _ClampCoord(double &x, double &y, double &z) const;
 void _SetExtents(const double extents[6]);
 size_t _min[3];    // ijk offset of first voxel in ROI (relative to ROI)
 size_t _max[3];    // ijk offset of last voxel in ROI (relative to ROI)

private:
    size_t _bs[3];  // dimensions of each block
    size_t _bdims[3];   // dimensions (specified in blocks) of ROI 
    size_t _minabs[3];  // ijk offset of first voxel in ROI (absolute coords)
    size_t _maxabs[3];  // ijk offset of last voxel in ROI (absolute coords)
    double _minu[3];    
    double _maxu[3];    // User coords of first and last voxel
    double _delta[3];   // increment between grid points in user coords
    bool _periodic[3];  // periodicity of boundaries
    float _missingValue;
    bool _hasMissing;
    int _interpolationOrder;    // Order of interpolation 
    size_t _x, _y, _z, _xb;
    bool _end;
    size_t _nblocks; // num blocks allocated to _blks
    float *_itr;
    float **_blks;

    int _RegularGrid(
        const size_t bs[3], const size_t min[3], const size_t max[3],
        const double extents[6], const bool periodic[3], float ** blks
    );
    float _GetValueNearestNeighbor(double x, double y, double z) const;
    float _GetValueLinear(double x, double y, double z) const;

};
};
#endif