params.h

Go to the documentation of this file.

//************************************************************************
//                                  *
//           Copyright (C)  2004                *
//     University Corporation for Atmospheric Research          *
//           All Rights Reserved                *
//                                  *
//************************************************************************/
//
//  File:       params.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       October 2004
//
//  Description:    Defines the Params and the RendererParams classes.
//      This is an abstract class for all the tabbed panel params classes.
//      Supports functionality common to all the tabbed panel params.
//
#ifndef PARAMS_H
#define PARAMS_H

#include <cassert>
#include <qwidget.h>
#include <vapor/XmlNode.h>
#include <vapor/ExpatParseMgr.h>
#include <vapor/ParamNode.h>
#include <vapor/common.h>
#include <vapor/ParamsBase.h>
#include <vapor/RegularGrid.h>
#include "Box.h"

class QWidget;

using namespace VetsUtil;
//Error tolerance for gui parameters:
#define ROUND_OFF 1.e-6f
#define MAXVIZWINS 16
#define OUT_OF_BOUNDS -1.e30f

namespace VAPoR{
enum DirtyBitType {
    RegionBit,
    NavigatingBit,
    LightingBit,
    ProjMatrixBit,
    ViewportBit,
    AnimationBit 
};
class XmlNode;
class ParamNode;
class DummyParams;
class MapperFunction;
class TransferFunction;
class ViewpointParams;
class RegionParams;
class DataMgr;
class Histo;
class PARAMS_API Params : public MyBase, public ParamsBase {
    
public: 
Params(
    XmlNode *parent, const string &name, int winNum
 );
Params(int winNum, const string& name) : ParamsBase(name) {
    vizNum = winNum;
    if(winNum < 0) local = false; else local = true;
    
    previousClass = 0;
}
    
    Params(const Params& p);
    virtual ~Params();

     virtual const std::string& getShortName()=0;

    static int GetCurrentParamsInstanceIndex(int pType, int winnum){
        return currentParamsInstance[make_pair(pType,winnum)];
    }
    static int GetCurrentParamsInstanceIndex(const std::string tag, int winnum){
        return GetCurrentParamsInstanceIndex(GetTypeFromTag(tag),winnum);
    }
     
    static void SetCurrentParamsInstanceIndex(int pType, int winnum, int instance){
        currentParamsInstance[make_pair(pType,winnum)] = instance;
    }
    
    static Params* GetParamsInstance(int pType, int winnum = -1, int instance = -1);

    static Params* GetParamsInstance(const std::string tag, int winnum = -1, int instance = -1){
        return GetParamsInstance(GetTypeFromTag(tag), winnum, instance);
    }

    static Params* GetCurrentParamsInstance(int pType, int winnum){
        Params* p = GetParamsInstance(pType, winnum, -1);
        if (p->isLocal()) return p;
        return GetDefaultParams(pType);
    }
    
    static Params* GetDefaultParams(ParamsBase::ParamsBaseType pType){
        return defaultParamsInstance[pType];
    }

    static Params* GetDefaultParams(const string& tag){
        return defaultParamsInstance[GetTypeFromTag(tag)];
    }

    static void SetDefaultParams(int pType, Params* p) {
        defaultParamsInstance[pType] = p;
    }

    static void SetDefaultParams(const string& tag, Params* p) {
        defaultParamsInstance[GetTypeFromTag(tag)] = p;
    }
    static Params* CreateDefaultParams(int pType){
        Params*p = (Params*)(createDefaultFcnMap[pType])();
        return p;
    }
    
        
    static int GetNumParamsInstances(int pType, int winnum){
        return paramsInstances[make_pair(pType, winnum)].size();
    }

    static int GetNumParamsInstances(const std::string tag, int winnum){
        return GetNumParamsInstances(GetTypeFromTag(tag), winnum);
    }
    
    static void AppendParamsInstance(int pType, int winnum, Params* p){
        paramsInstances[make_pair(pType,winnum)].push_back(p);
    }

    static void AppendParamsInstance(const std::string tag, int winnum, Params* p){
        AppendParamsInstance(GetTypeFromTag(tag),winnum, p);
    }

    static void RemoveParamsInstance(int pType, int winnum, int instance);
    
    static void InsertParamsInstance(int pType, int winnum, int posn, Params* dp){
        vector<Params*>& instances = paramsInstances[make_pair(pType,winnum)];
        instances.insert(instances.begin()+posn, dp);
    }

    static vector<Params*>& GetAllParamsInstances(int pType, int winnum){
        return paramsInstances[make_pair(pType,winnum)];
    }

    static vector<Params*>& GetAllParamsInstances(const std::string tag, int winnum){
        return GetAllParamsInstances(GetTypeFromTag(tag),winnum);
    }

    static map <int, vector<Params*> >* cloneAllParamsInstances(int winnum);

    static vector <Params*>* cloneAllDefaultParams();

    static bool IsRenderingEnabled(int winnum);
    
    virtual bool isRenderParams() {return false;}
    
    virtual Params* deepCopy(ParamNode* nd = 0);

    virtual void restart() = 0;
    
    virtual int getVizNum() {return vizNum;}

    virtual void setLocal(bool lg){ if (lg) {
        local = true;
    }
        else local = false;
    }

    bool isLocal() {return local;}
    
    virtual void setVizNum(int vnum){vizNum = vnum;}
    
    virtual void SetVisualizerNum(int viznum);
    virtual int GetVisualizerNum();
//
    virtual bool reinit(bool) {return false;}
    virtual Box* GetBox() {return 0;}
    virtual int getOrientation() { assert(0); return -1;}


    virtual void calcContainingStretchedBoxExtentsInCube(float extents[6], bool rotated = false) 
        {if (!rotated) calcStretchedBoxExtentsInCube(extents, -1);
        else calcRotatedStretchedBoxExtentsInCube(extents);}

    void calcRotatedStretchedBoxExtentsInCube(float extents[6]);

    virtual bool isDomainConstrained() {return true;}

    //Following methods, while public, are not part of extensibility API
    
#ifndef DOXYGEN_SKIP_THIS
    void setLocalBox(const float boxMin[3], const float boxMax[3], int timestep = -1 ) {
        double extents[6];
        for (int i = 0; i<3; i++){
            extents[i] = boxMin[i];
            extents[i+3] = boxMax[i];
        }
        GetBox()->SetLocalExtents(extents,timestep);
    }
    void setLocalBox(const double boxMin[3], const double boxMax[3], int timestep = -1 ) {
        double extents[6];
        for (int i = 0; i<3; i++){
            extents[i] = boxMin[i];
            extents[i+3] = boxMax[i];
        }
        GetBox()->SetLocalExtents(extents,timestep);
    }
    //Map min/max corners of box to voxels
    void mapBoxToVox(DataMgr* dataMgr, double bxmin[3], double bxmax[3], int refLevel, int lod, size_t timestep, size_t voxExts[6]);
    void setTheta(float th) {
        double angles[3];
        GetBox()->GetAngles(angles);
        angles[0]=th;
        GetBox()->SetAngles(angles);
    }
    void setPhi(float ph) {
        double angles[3];
        GetBox()->GetAngles(angles);
        angles[1]=ph;
        GetBox()->SetAngles(angles);
    }
    void setPsi(float ps) {
        double angles[3];
        GetBox()->GetAngles(angles);
        angles[2]=ps;
        GetBox()->SetAngles(angles);
    }
    
    void getLocalBox(float boxMin[3], float boxMax[3], int timestep = -1) {
        double extents[6];
        GetBox()->GetLocalExtents(extents, timestep);
        for (int i = 0; i<3; i++){
            boxMin[i] = extents[i];
            boxMax[i] = extents[i+3];
        }
    }
    void getLocalBox(double boxMin[3], double boxMax[3], int timestep = -1) {
        double extents[6];
        GetBox()->GetLocalExtents(extents, timestep);
        for (int i = 0; i<3; i++){
            boxMin[i] = extents[i];
            boxMax[i] = extents[i+3];
        }
    }
    
    float getPhi() {
        if (GetBox()->GetAngles().size() < 2) return 0.f;
        return((float)GetBox()->GetAngles()[1]);
    }
    float getTheta() {
        if (GetBox()->GetAngles().size() < 1) return 0.f;
        return((float)GetBox()->GetAngles()[0]);
    }
    float getPsi() {
        if (GetBox()->GetAngles().size() < 3) return 0.f;
        return((float)GetBox()->GetAngles()[2]);
    }

    static Params* CreateDummyParams(std::string tag);
    static void BailOut (const char *errstr, const char *fname, int lineno);

    static int getNumDummyClasses(){return dummyParamsInstances.size();}
    static Params* getDummyParamsInstance(int i) {return dummyParamsInstances[i];}
    static void addDummyParamsInstance(Params*const & p ) {dummyParamsInstances.push_back(p);}

    static void clearDummyParamsInstances();
    static const std::string& paramName(ParamsBaseType t);
    static const string _dvrParamsTag;
    static const string _isoParamsTag;
    
    static const string _probeParamsTag;
    static const string _twoDParamsTag;
    static const string _twoDDataParamsTag;
    static const string _twoDImageParamsTag;
    static const string _regionParamsTag;
    static const string _viewpointParamsTag;
    static const string _animationParamsTag;
    static const string _flowParamsTag;
    static const string _RefinementLevelTag;
    static const string _CompressionLevelTag;
    static const string _FidelityLevelTag;
    static const string _IgnoreFidelityTag;
    static const string _VariableNameTag;
    static const string _VariableNamesTag;
    static const string _VisualizerNumTag;
    static const string _VariablesTag;
    static const string _Variables2DTag;
    static const string _Variables3DTag;

    static const string _vizNumAttr;
    static const string _localAttr;
    static const string _numVariablesAttr;
    static const string _variableTag;
    static const string _leftEditBoundAttr;
    static const string _rightEditBoundAttr;
    static const string _variableNumAttr;
    static const string _variableNameAttr;
    static const string _opacityScaleAttr;
    static const string _numTransformsAttr;
    static const string _useTimestepSampleListAttr;
    static const string _timestepSampleListAttr;


    void setStretchedBox(const float[3], const float[3], int);
    void getStretchedBox(float boxmin[3], float boxmax[3], int timestep);
    //Determine the box extents in the unit cube.
    void calcStretchedBoxExtentsInCube(float extents[6], int timestep);

    void calcStretchedBoxExtents(float* extents, int timestep);
    void calcBoxExtents(float* extents, int timestep);
    //Calculate the box in local coords, using any theta or phi
    virtual void calcLocalBoxCorners(float corners[8][3], float extraThickness, int timestep, float rotation = 0.f, int axis = -1);
    
    // Construct transformation as a mapping of [-1,1]^3 into volume array
    // coordinates at current resolution
    void buildLocalCoordTransform(float transformMatrix[12], float extraThickness, int timestep, float rotation = 0.f, int axis = -1);
    void buildLocalCoordTransform(double transformMatrix[12], double extraThickness, int timestep, float rotation = 0.f, int axis = -1);

    //Construct transform of form (x,y)-> a[0]x+b[0],a[1]y+b[1],
    //Mapping [-1,1]X[-1,1] into local 3D volume coordinates.
    void buildLocal2DTransform(int dataOrientation, float a[2],float b[2], float* constVal, int mappedDims[3]);

    //Method indicates if the geometry is contstrained to fit in a plane (e.g. for manips)
    //Default is false;
    virtual bool isPlanar() {return false;}

    //Helper function for testing distances,
    //testing whether a point is inside or outside of cube 
    //Return is positive if point is outside.  Arguments are outward pointing
    //unit normal vectors and associated points (corners) of probe faces.
    static float distanceToCube(const float point[3],const float faceNormals[6][3], const float faceCorners[6][3]);
    //Modifiction of above that provides x,y,z components of distances outside, when point is outside.
    //This is useful if the box is highly nonuniform in x,y,z
    static float distancesToCube(const float point[3],const float faceNormals[6][3], const float faceCorners[6][3], float maxDist[3]);

    
    //
    // Parse command line arguements 
    //
    static bool searchCmdLine(const char *flag);
    static const char* parseCmdLine(const char *flag);

    //Determine a new value of theta and phi when the probe is rotated around either the
    //x-, y-, or z- axis.  axis is 0,1,or 1. rotation is in degrees.
    void convertThetaPhiPsi(float *newTheta, float* newPhi, float* newPsi, int axis, float rotation);
    static int getGrids(size_t ts, const vector<string>& varnames, double extents[6], int* refLevel, int* lod, RegularGrid** grids);
    
    
protected:
    bool local;
    
    //Keep track of which window number corresp to this.  -1 for global or default parameters.
    //
    int vizNum;
    double savedBoxExts[6];
    int savedBoxVoxExts[6];
    int savedRefLevel;
    
    //Params instances are vectors of Params*, one per instance, indexed by paramsBaseType, winNum
    static map<pair<int,int>,vector<Params*> > paramsInstances;
    //CurrentRenderParams indexed by paramsBaseType, winNum
    static map<pair<int,int>, int> currentParamsInstance;
    //Dummy params are those that are found in a session file but not 
    //available in the current code.
    //default params instances indexed by paramsBaseType
    static map<int, Params*> defaultParamsInstance;
    static vector<Params*> dummyParamsInstances;
#endif //DOXYGEN_SKIP_THIS
};

class PARAMS_API RenderParams : public Params {
public: 
    
    RenderParams(XmlNode *parent, const string &name, int winnum); 
    
        
    bool isEnabled(){return enabled;}

    virtual void setEnabled(bool value) {enabled = value; stopFlag = false;}

    virtual bool usingVariable(const std::string& varname) = 0;
    virtual void SetRefinementLevel(int level){
        GetRootNode()->SetElementLong(_RefinementLevelTag, level);
        setAllBypass(false);
    }
    virtual int GetRefinementLevel(){
        const vector<long>defaultRefinement(1,0);
        return (GetRootNode()->GetElementLong(_RefinementLevelTag,defaultRefinement)[0]);
    }
    virtual int GetCompressionLevel();
    virtual int GetFidelityLevel();
    virtual void SetFidelityLevel(int level);
    virtual bool GetIgnoreFidelity();
    virtual void SetIgnoreFidelity(bool val);
    virtual void SetCompressionLevel(int val);

    virtual const float* getSelectedPointLocal() {
        return 0;
    }

    // \param[in] ViewpointParams* vpp Current applicable ViewpointParams instance
    // \param[in] const float extents[6] Box extents in world coordinates.
    // \retval float distance from camera to box
    static float getCameraDistance(ViewpointParams* vpp, const double exts[6]);

    // Pure virtual method indicates whether or not the geometry is opaque.
    // \retval true if it is opaque.
    virtual bool IsOpaque()=0;

    void setBypass(int timestep) {bypassFlags[timestep] = 2;}

    void setPartialBypass(int timestep) {bypassFlags[timestep] = 1;}

    void setAllBypass(bool val);

    bool doBypass(int ts) {return ((ts < bypassFlags.size()) && bypassFlags[ts]);}

    bool doAlwaysBypass(int ts) {return ((ts < bypassFlags.size()) && bypassFlags[ts]>1);}

    
    virtual bool UsesMapperFunction() {return false;}

#ifndef DOXYGEN_SKIP_THIS
    //Following methods are deprecated, used by some built-in renderparams classes
    
    // \param[in] vpp Current applicable ViewpointParams instance
    // \param[in] rp  Current applicable RegionParams instance
    // \param[in] timestep Current applicable time step
    // \retval float distance from camera
    virtual float getCameraDistance(ViewpointParams* vpp, RegionParams* rp, int timestep);
    
    //Deprecated constructor used by some built-in classes
    RenderParams(int winNum, const string& name) : Params(winNum, name) {
        
        local = true;
        
        previousClass = 0;
        minColorEditBounds = 0;
        maxColorEditBounds = 0;
        minOpacEditBounds = 0;
        maxOpacEditBounds = 0;
        
    }
    virtual ~RenderParams(){
        if (minColorEditBounds) delete [] minColorEditBounds;
        if (maxColorEditBounds) delete [] maxColorEditBounds;
        if (minOpacEditBounds) delete [] minOpacEditBounds;
        if (maxOpacEditBounds) delete [] maxOpacEditBounds;

    }
    
    virtual Params* deepCopy(ParamNode* nd = 0);
    virtual bool isRenderParams() {return true;}

    //following does nothing for renderParams
    virtual void setLocal(bool ){ assert(0);}

    virtual int getSessionVarNum(){assert(0); return -1;}  //needed for transfer functions
    virtual float GetHistoStretch() { assert(0); return 1.f;}
    virtual bool getEditMode() {assert(0); return true;}
    virtual const float* getCurrentDatarange(){assert(0); return(0);}
    virtual void hookupTF(TransferFunction* , int ) {assert(0);}

    
    //The following may be redefined by some renderer params.  Parent version should never be invoked
    virtual void setMinColorMapBound(float) {assert(0);}
    virtual void setMaxColorMapBound(float){assert(0);}
    virtual void setMinOpacMapBound(float){assert(0);}
    virtual void setMaxOpacMapBound(float){assert(0);}


    float getMinColorMapBound();    
    float getMaxColorMapBound(); 
    
    virtual void setMinColorEditBound(float val, int var) {
        minColorEditBounds[var] = val;
    }
    virtual void setMaxColorEditBound(float val, int var) {
        maxColorEditBounds[var] = val;
    }
    virtual float getMinColorEditBound(int var) {
        return minColorEditBounds[var];
    }
    virtual float getMaxColorEditBound(int var) {
        return maxColorEditBounds[var];
    }
    //And opacity:
    
    virtual float getMinOpacMapBound(); 
    virtual float getMaxOpacMapBound(); 
    

    virtual void setMinOpacEditBound(float val, int var) {
        minOpacEditBounds[var] = val;
    }
    virtual void setMaxOpacEditBound(float val, int var) {
        maxOpacEditBounds[var] = val;
    }
    virtual float getMinOpacEditBound(int var) {
        return minOpacEditBounds[var];
    }
    virtual float getMaxOpacEditBound(int var) {
        return maxOpacEditBounds[var];
    }

    virtual MapperFunction* GetMapperFunc() {return 0;}
    
    void setStopFlag(bool val = true) {stopFlag = val;}
    bool getStopFlag() {return stopFlag;}
    int getBypassValue(int i) {return bypassFlags[i];} //only used for debugging
    
    void initializeBypassFlags();
    //Used only by params with rotated boxes:
    bool cropToBox(const double boxExts[6]);
    bool intersectRotatedBox(double boxexts[6], double pointFound[3], double probeCoords[2]);
    bool fitToBox(const double boxExts[6]);
    int interceptBox(const double boxExts[6], double intercept[6][3]);
    //change box dimensions after a rotation so that it appears to be the same size:
    void rotateAndRenormalizeBox(int axis, float rotVal);
    //Obtain region that contains rotated box
    void getLocalContainingRegion(float regMin[3], float regMax[3]);
    void getRotatedVoxelExtents(float voxdims[2]);
    //Calculate a histogram of a slice of 3d variables
    void calcSliceHistogram(int ts, Histo* histo);
    //Used for rendering texture of variable. Default is linear:
    virtual int getInterpolationOrder() {return 1;}

protected:
    
    // The enabled flag is only used by renderer params
    //
    bool enabled;
    bool stopFlag;  //Indicates if user asked to stop (only with flow calc now)
    //Needed for renderer params:
    float* minColorEditBounds;
    float* maxColorEditBounds;
    float* minOpacEditBounds;
    float* maxOpacEditBounds;
    
    vector<int> bypassFlags;
#endif //DOXYGEN_SKIP_THIS
};
#ifndef DOXYGEN_SKIP_THIS
class DummyParams : public Params {
    public:
        DummyParams(XmlNode *parent, const std::string tag, int winnum);
    virtual ~DummyParams(){}
    virtual void restart(){}
    virtual int GetRefinementLevel() {
        return 0;
    }

    virtual int GetCompressionLevel() {return 0;}
    
    virtual void SetCompressionLevel(int){}
    
    virtual bool reinit(bool){return false;}
    
    virtual bool IsOpaque() {return true;}
    
    virtual bool usingVariable(const std::string& ){
        return false;
    }
    const std::string &getShortName(){return myTag;}

    std::string myTag;

};

class PARAMS_API Point4{
public:
    Point4() {point[0]=point[1]=point[2]=point[3]=0.f;}
    Point4(const float data[4]){setVal(data);}
    void setVal(const float sourceData[4]){
        for (int i = 0; i< 4; i++) point[i] = sourceData[i];
    }
    void set3Val(const float sourceData[3]){
        for (int i = 0; i< 3; i++) point[i] = sourceData[i];
    }
    void set1Val(int index, float sourceData){
        point[index] = sourceData;
    }
    float getVal(int i){return point[i];}
    void copy3Vals(float* dest) {dest[0]=point[0];dest[1]=point[1];dest[2]=point[2];}
protected:
    float point[4];
};
#endif //DOXYGEN_SKIP_THIS
}; //End namespace VAPoR
#endif //PARAMS_H