datastatus.h

Go to the documentation of this file.

//************************************************************************
//                                                                  *   
//           Copyright (C)  2004                                        *
//     University Corporation for Atmospheric Research                  *
//           All Rights Reserved                                        *
//                                                                      *
//************************************************************************/
//
//  File:       datastatus.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       February 2006
//
//  Description:    Defines the DataStatus class.  
//  This class maintains information about the data that is currently
//  loaded.  Maintained and accessed mostly through the Session
#ifndef DATASTATUS_H
#define DATASTATUS_H


#include <vector>
#include <string>
#include <map>
#include <vapor/common.h>
#include <vapor/DataMgrV3_0.h>
#include <vapor/MetadataVDC.h>
#include "regionparams.h" 
#include "vizfeatureparams.h"

namespace VAPoR {
class PARAMS_API DataStatus{
public:
    
    static DataStatus* getInstance() {
        if (!_dataStatus) _dataStatus = new DataStatus;
        return _dataStatus;
    }

    static const double* getLocalExtents() { return _extents; }

    static const double* getFullSizes() {return _fullSizes;}

    static const double* getFullStretchedSizes() {return _fullStretchedSizes;}

    static const double* getStretchedLocalExtents() {return _stretchedExtents;}

    static size_t getMinTimestep() {return _minTimeStep;}

    static size_t getMaxTimestep() {return _maxTimeStep;}

    static int getNumTimesteps() {return _numTimesteps;}

    static int getActiveVarNum(int dim, string varname);

    static double getVoxelSize(size_t timestep, string varname, int refLevel, int dir);

    static int getNumActiveVariables3D() {return _dataMgr->GetDataVarNames(3,true).size();}
    static int getNumActiveVariables2D() {return _dataMgr->GetDataVarNames(2,true).size();}
    static int getNumActiveVariables() {return getNumActiveVariables3D()+getNumActiveVariables2D();}

    float getDefaultDataMax(string vname);

    float getDefaultDataMin(string vname);

    static float getDefaultLODFidelity2D(){return _defaultLODFidelity2D;}

    static float getDefaultRefinementFidelity2D(){return _defaultRefFidelity2D;}

    static float getDefaultLODFidelity3D(){return _defaultLODFidelity3D;}

    static float getDefaultRefinementFidelity3D(){return _defaultRefFidelity3D;}

    static void setDefaultLODFidelity2D(float q) {_defaultLODFidelity2D = q;}

    static void setDefaultLODFidelity3D(float q) {_defaultLODFidelity3D = q;}

    static void setDefaultRefinementFidelity2D(float q){_defaultRefFidelity2D = q;}

    static void setDefaultRefinementFidelity3D(float q){_defaultRefFidelity3D = q;}

    static int getDefaultFidelitySettings(int dim, vector<int>&lods, vector<int>&refs){
        if (dim == 2) {lods = _fidelity2DLODs; refs = _fidelity2DRefs;}
        else  {lods = _fidelity3DLODs; refs = _fidelity3DRefs;}
        return _defaultFidelity[dim-2];
    }

    static void setFidelityDefault(RenderParams* rp);
    
    static bool convertToLonLat(double coords[], int npoints = 1);
    static bool convertFromLonLat(double coords[], int npoints = 1);
    static bool convertLocalToLonLat(int timestep, double coords[], int npoints = 1);
    static bool convertLocalFromLonLat(int timestep,double coords[], int npoints = 1);
    
    void mapBoxToVox(Box* box, int refLevel, int lod, int timestep, size_t voxExts[6]);

    static int GetExtents(size_t timestep, vector<double>& minExts, vector<double>& maxExts);

    static const vector<double> getStretchFactors() {
        return ((VizFeatureParams*)Params::GetDefaultParams(Params::_visualizerFeaturesParamsTag))->GetStretchFactors();
    }

    static void stretchCoords(vector<double>& coords){
        vector<double>stretchFactors = getStretchFactors();
        for (int i = 0; i<3; i++) coords[i] = coords[i]*stretchFactors[i];
    }
    static void stretchCoords(double coords[3]){
        vector<double>stretchFactors = getStretchFactors();
        for (int i = 0; i<3; i++) coords[i] = coords[i]*stretchFactors[i];
    }
    static double getMaxStretchedSize(){
        return (Max(_fullStretchedSizes[0],Max(_fullStretchedSizes[1],_fullStretchedSizes[2])));
    }
    static void localToStretched(const double fromCoords[3], double toCoords[3]);
    static int maxXFormPresent(string varname, size_t timestep);
    static int maxLODPresent(string varname, size_t timestep);
    static bool useLowerAccuracy() {return _useLowerAccuracy;}
    static void setUseLowerAccuracy(bool val){_useLowerAccuracy = val;}
    static bool dataIsPresent(int timestep);
    static int mapVoxToUser(size_t timestep, string varname, const size_t vcoords[3], double uCoords[3], int reflevel);
    static void mapUserToVox(size_t timestep, string varname, const double uCoords[3], size_t vCoords[3], int reflevel);
    

    DataStatus();
    ~DataStatus();

    bool reset(DataMgrV3_0* dm, size_t cachesize);
    
    static void stretchExtents(vector<double> factor){
        vector<double> stretchFactors;
        for (int i = 0; i< 3; i++) {
            _stretchedExtents[i] = _extents[i]*factor[i];
            _stretchedExtents[i+3] = _extents[i+3]*factor[i];
            _fullStretchedSizes[i] = _fullSizes[i]*factor[i];
        }
        
    }
    static size_t getCacheMB() {return _cacheMB;}
    
    
private:
    static void makeFidelitySettings();

#ifndef DOXYGEN_SKIP_THIS
    static DataStatus* _dataStatus;
    static DataMgrV3_0* _dataMgr;
    
    //specify the minimum and max time step that actually have data:
    static size_t _minTimeStep;
    static size_t _maxTimeStep;

    //numTimeSteps may include lots of times that are not used. 
    static int _numTimesteps;

    static float _defaultRefFidelity2D;
    static float _defaultRefFidelity3D;
    static float _defaultLODFidelity2D;
    static float _defaultLODFidelity3D;
    static int _defaultFidelity[2];
    static vector<int> _fidelity2DRefs;
    static vector<int> _fidelity3DRefs;
    static vector<int> _fidelity2DLODs;
    static vector<int> _fidelity3DLODs;
    static double _extents[6];
    static double _stretchedExtents[6];
    static double _fullSizes[3];
    static double _fullStretchedSizes[3];
    //Cache size in megabytes
    static size_t _cacheMB;
    static bool _useLowerAccuracy;
    
#endif //DOXYGEN_SKIP_THIS
};

}; //end VAPoR namespace
#endif //DATASTATUS_H