regionparams.h

Go to the documentation of this file.

//************************************************************************
//                                                                      *
//           Copyright (C)  2004                                        *
//     University Corporation for Atmospheric Research                  *
//           All Rights Reserved                                        *
//                                                                      *
//************************************************************************/
//
//  File:       regionparams.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       September 2004
//
//  Description:    Defines the RegionParams class.
//      This class supports parameters associted with the
//      region panel, describing the rendering region
//
#ifndef REGIONPARAMS_H
#define REGIONPARAMS_H


#include <vector>
#include <map>
#include <qwidget.h>
#include <vapor/MyBase.h>
#include <vapor/common.h>
#include "params.h"


using namespace VetsUtil;

namespace VAPoR {

class ViewpointParams;
class XmlNode;
class ParamNode;
class PARAMS_API RegionParams : public Params {
    
public: 

    RegionParams(int winnum);

    ~RegionParams();
    
    void getRegionVoxelCoords(int reflevel, int lod, size_t min_dim[3], size_t max_dim[3], int timestep);
    
    int getAvailableVoxelCoords(int reflevel, int* lod, size_t min_dim[3], size_t max_dim[3], 
        size_t timestep, 
        const int* sesVarNums, int numVars, double* regMin = 0, double* regMax = 0);
    

    static int PrepareCoordsForRetrieval(int numxforms, int lod, size_t timestep, const vector<string>& varnames,
        double* regMin, double* regMax, 
        size_t min_dim[3], size_t max_dim[3]);


    static float calcCurrentValue( const string& varname, const double point[3], int numRefinements, int lod, size_t timeStep);
    float fullRegionMBs(int refLevel);

#ifndef DOXYGEN_SKIP_THIS

    virtual Params* deepCopy(ParamNode* n = 0);
    static ParamsBase* CreateDefaultInstance() {return new RegionParams(-1);}
    const std::string& getShortName() {return _shortName;}
    float getLocalRegionMin(int coord, int timestep){ 
        double exts[6];
        myBox->GetLocalExtents(exts, timestep);
        return exts[coord];
    }
    float getLocalRegionMax(int coord, int timestep){ 
        double exts[6];
        myBox->GetLocalExtents(exts, timestep);
        return exts[coord+3];
    }
    void getLocalRegionExtents(double exts[6],int timestep){
        myBox->GetLocalExtents(exts,timestep);
        return;
    }
    float getLocalRegionCenter(int indx, int timestep) {
        return (0.5f*(getLocalRegionMin(indx,timestep)+getLocalRegionMax(indx,timestep)));
    }
    
    
    //Version of DataMgr::GetValidRegion that knows about layered data
    //Callers must supply the full voxel extents, these get reduced depending on what data is available for
    //the specified variable, or (for derived variables) the input variables to the script.
    static int getValidRegion(size_t timestep, const char* varname, int minRefLevel, size_t min_coord[3], size_t max_coord[3]);
    
    //Determine how many megabytes will be needed for one variable at specified
    //refinement level, specified box extents.

    static int getMBStorageNeeded(const double exts[6], int refLevel);
    // Reinitialize due to new Session:
    bool reinit(bool doOverride);
    virtual void restart();
    static void setDefaultPrefs() {}  //No default preferences
    
    ParamNode* buildNode();
    bool elementStartHandler(ExpatParseMgr*, int /* depth*/ , std::string& /*tag*/, const char ** /*attribs*/);
    bool elementEndHandler(ExpatParseMgr*, int /*depth*/ , std::string& /*tag*/);
    //See if the proposed number of transformations is OK.  Return a valid value
    int validateNumTrans(int n, int timestep);

    
    virtual Box* GetBox() {return myBox;}
    //Methods to set the region max and min from a float value.
    //public so accessible from router
    //
    void setLocalRegionMin(int coord, float minval, int timestep, bool checkMax=true);
    void setLocalRegionMax(int coord, float maxval, int timestep, bool checkMin=true);
    void setInfoNumRefinements(int n){infoNumRefinements = n;}
    void setInfoTimeStep(int n) {infoTimeStep = n;}
    void setInfoVarNum(int n) {infoVarNum = n;}
    const vector<double>& GetAllExtents(){ return myBox->GetRootNode()->GetElementDouble(Box::_extentsTag);}
    const vector<long>& GetTimes(){ return myBox->GetRootNode()->GetElementLong(Box::_timesTag);}
    void clearRegionsMap();
    bool extentsAreVarying(){ return myBox->GetTimes().size()>1;}
    //Insert a time in the list.  Return false if it's already there
    bool insertTime(int timestep);
    //Remove a time from the time-varying timesteps.  Return false if unsuccessful
    bool removeTime(int timestep);

protected:
    static const string _shortName;
    static const string _regionMinTag;
    static const string _regionMaxTag;
    static const string _regionCenterTag;
    static const string _regionSizeTag;
    static const string _regionAtTimeTag;
    static const string _regionListTag;
    static const string _maxSizeAttr;
    static const string _numTransAttr;
    static const string _fullHeightAttr;
    static const string _timestepAttr;
    static const string _extentsAttr;
    
    //Methods to make sliders and text valid and consistent for region:

    int infoNumRefinements, infoVarNum, infoTimeStep;

    
    //Full grid height for layered data.  0 otherwise.
    static size_t fullHeight;
    
    Box* myBox;
#endif //DOXYGEN_SKIP_THIS
};

};
#endif //REGIONPARAMS_H