WaveletBlock3DRegionReader.h

Go to the documentation of this file.

//
//      $Id$
//


#ifndef _WavletBlock3DRegionReader_h_
#define _WavletBlock3DRegionReader_h_

#include <vapor/MyBase.h>
#include "WaveletBlockIOBase.h"

namespace VAPoR {

//
//
class VDF_API   WaveletBlock3DRegionReader : public WaveletBlockIOBase {

public:

 //
 WaveletBlock3DRegionReader(
    const MetadataVDC &metadata
 );

 //
 WaveletBlock3DRegionReader(
    const string &metafile
 );

 virtual ~WaveletBlock3DRegionReader();


 virtual int    OpenVariableRead(
    size_t timestep,
    const char *varname,
    int reflevel = 0,
    int lod = 0
 );

 virtual int OpenVariableWrite(
    size_t /*timestep*/,
    const char * /*varname*/,
    int /* reflevel */ = 0,
    int = 0
 ) {SetErrMsg("Operation not supported"); return(-1);};


 virtual int    CloseVariable();

 //
 virtual int    ReadRegion(
    const size_t min[3], const size_t max[3], 
    float *region
 );

 virtual int    ReadRegion(
    float *region
 );


 //
 virtual int    BlockReadRegion(
    const size_t bmin[3], const size_t bmax[3], 
    float *region, bool unblock = true
 );

#ifdef  DEAD

 // Read a subregion of gamma (detail) coefficients from disk. The 
 // spatial coordinates of the region (min, max) are given 
 // in **block** units, where 'min' specifies the minimum bounds
 // and 'max' specifies the maximum bound.  The coefficients are stored
 // in the three arrays pointed to by xregion, yregion, and zregion. Each
 // much have enough space to accomodate the X, Y, and Z gamma coefficients
 // respectively. The dimenions of the zregion in block units are nbx*nby*nbz,
 // where nbx == max[0]-min[0]+1, and so on. The dimensions of the 
 // yregion and xregion
 // are nbx*nby*(nbz*2), and nbx*(nby*2)*(nbz*2), respectively (there are 
 // twice as many Y coefficients as Z, and four times as many X coefficients). 
 //
 // The coefficients returned are those needed to forward transform 
 // a volume from level 'level-1', to 'level'. Thus, 'level' must be at least
 // one.
 //
 // The coefficients will be unblocked if the 'unblock' flag is set. Otherwise,
 // they are left in their native blocked-storage order
 //
 int    ReadRegionGamma(
    size_t min[3], size_t max[3], float *xregion, 
    float *yregion, float *zregion, int unblock = 1
 );

#endif

protected:
 void _GetDataRange(float /*range*/[2]) const {};


private:
 float  *lambda_blks_c[MAX_LEVELS];
 float  *gamma_blks_c[MAX_LEVELS];
 float  *_lambda_tiles[MAX_LEVELS];
 float  *_gamma_tiles[MAX_LEVELS];

 size_t _block_size;

 int    row_inv_xform3d(
    const float *lambda_row, 
    unsigned int ljx0, unsigned int ljy0, unsigned int ljz0, 
    unsigned int ljnx, unsigned int j, float *region, 
    const size_t min[3], const size_t max[3], unsigned int level, int unblock
 );
 int    row_inv_xform2d(
    const float *lambda_row,
    unsigned int ljx0, unsigned int ljy0,
    unsigned int ljnx, unsigned int j, float *region,
    const size_t min[2], const size_t max[2], unsigned int level, int untile
 );

 int    my_realloc3d(); 
 int    my_realloc2d(); 
 void   my_free(); 

 int    _ReadRegion3D(
    const size_t min[3], const size_t max[3], 
    float *region, int unblock = 1
 );
 int    _ReadRegion2D(
    const size_t min[2], const size_t max[2], 
    float *region, int unblock = 1
 );

 void   _WaveletBlock3DRegionReader();

};

};

#endif  //  _WavletBlock3DRegionReader_h_