renderparams.h

Go to the documentation of this file.

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

//
#ifndef RENDERPARAMS_H
#define RENDERPARAMS_H

#include <vapor/XmlNode.h>
#include <vapor/ExpatParseMgr.h>
#include <vapor/ParamNode.h>
#include <map>

#include "assert.h"

#include <vapor/common.h>
#include <vapor/ParamsBase.h>
#include <vapor/RegularGrid.h>
#include "Box.h"
#include "params.h"
using namespace VetsUtil;

namespace VAPoR{


class XmlNode;
class ParamNode;
class ViewpointParams;
class DataMgrV3_0;
class Command;
class MapperFunction;


class PARAMS_API RenderParams : public Params {
public: 

    RenderParams(XmlNode *parent, const string &name, int winnum); 

    virtual bool IsEnabled(){
        int enabled = GetValueLong(_EnabledTag);
        return (enabled != 0);
    }
    virtual void SetEnabled(bool val);

    virtual bool usingVariable(const std::string& varname) = 0;

    virtual void SetVariableName(string varName);

    const string GetVariableName();

    const string GetFirstVariableName();

    virtual void SetFieldVariableNames(vector <string> varNames);

    const vector<string> GetFieldVariableNames();

    bool IsTerrainMapped(){
        const vector<long>off(1,0);
        return (0 !=GetValueLong(_terrainMapTag,off));
    }

    int SetTerrainMapped(bool val) {
        int rc = SetValueLong(_terrainMapTag, "Enable terrain-mapping", (long)val);
        setAllBypass(false);
        return rc;
    }

    virtual void SetRendererName(const string& renName);
    virtual const string GetRendererName();
    virtual int SetRefinementLevel(int numrefinements);
    virtual int GetRefinementLevel();
    virtual int GetCompressionLevel();
    virtual int SetCompressionLevel(int val);
    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 int GetFidelityLevel();
    virtual void SetFidelityLevel(int level);
    virtual bool GetIgnoreFidelity();
    virtual void SetIgnoreFidelity(bool val);

    void SetFidelityToDefaults();

    void SetHistoStretch(float factor){
        SetValueDouble(_histoScaleTag,"Set histo stretch",(double)factor);
    }
    float GetHistoStretch(){
        return GetValueDouble(_histoScaleTag);
    }
    double getMinEditBound(){
        return GetRootNode()->GetElementDouble(_editBoundsTag)[0];
    }
    double getMaxEditBound(){
        return GetRootNode()->GetElementDouble(_editBoundsTag)[1];
    }
    void setMinEditBound(double val){
        vector<double>vals = GetValueDoubleVec(_editBoundsTag);
        if (vals.size()<1) vals.push_back(val);
        vals[0]=val;
        SetValueDouble(_editBoundsTag,"change edit min bound",vals);
    }
    void setMaxEditBound(double val){
        vector<double>vals = GetValueDoubleVec(_editBoundsTag);
        while (vals.size()<2) vals.push_back(val);
        vals[1]=val;
        SetValueDouble(_editBoundsTag,"change edit max bound",vals);
    }
    void SetEditBounds(vector<double>bounds){
        SetValueDouble(_editBoundsTag,"set edit bounds",bounds);
    }
    virtual MapperFunction* GetMapperFunc(){
        return 0;
    }
    void SetCursorCoords(const vector<double>& coords){
        SetValueDouble(_cursorCoordsTag,"set cursor coords",coords);
    }
    const vector<double> GetCursorCoords(){
        return (GetValueDoubleVec(_cursorCoordsTag));
    }
    static void InsertParamsInstance(int pType, int winnum, int posn, RenderParams* dp){
        vector<Params*>& instances = _paramsInstances[make_pair(pType,winnum)];
        instances.insert(instances.begin()+posn, dp);
    }
    

    virtual int SetVariables3D(bool val) {
        if (val == VariablesAre3D()) return 0;
        int rc = SetValueLong(_variableDimensionTag,"Set variable dimensions",(long)(val ? 3:2));
        setAllBypass(false);
        return rc;
    }
    virtual bool VariablesAre3D() { return true; }

    const vector<long> GetGrid(){
        const vector<long> defaultGrid(3,1);
        return (GetValueLongVec(_gridTag,defaultGrid));
    }
    int SetGrid(const int grid[3]);

    int AlignGridToData(bool val) {
        if (IsAlignedToData() == val) return 0;
        return SetValueLong(_alignGridTag, "Set barb grid alignment",(val ? 1:0));
    }
    bool IsAlignedToData() {
        const vector<long> notAligned(1,0);
        return (0 != GetValueLong(_alignGridTag,notAligned));
    }
    const vector<long> GetGridAlignStrides(){
        const vector<long> defaultStrides(3,10);
        return GetValueLongVec(_alignGridStridesTag,defaultStrides);
    }
    int SetGridAlignStrides(const vector<long>& strides);

    void getDataAlignment(double rakeExts[6],int rakeGrid[3], size_t timestep);
    
    virtual int SetHeightVariableName(const string& varName); 

    virtual const string GetHeightVariableName();
#ifndef DOXYGEN_SKIP_THIS

    int SetLocal(bool lg){
        assert(lg);
        return false;
    }

    bool IsLocal() {
        return true;
    }
    
    virtual ~RenderParams(){
    }
    
    
    void initializeBypassFlags();
    
protected:
    static const string _EnabledTag;
    static const string _FidelityLevelTag;
    static const string _IgnoreFidelityTag;
    static const string _histoScaleTag;
    static const string _editBoundsTag;
    static const string _histoBoundsTag;
    static const string _RendererNameTag;
    static const string _cursorCoordsTag;
    static const string _heightVariableNameTag;
    static const string _variableDimensionTag;
    static const string _terrainMapTag;
    static const string _variableNameTag;
    static const string _fieldVariableNamesTag;
    static const string _gridTag;
    static const string _alignGridTag;
    static const string _alignGridStridesTag;
    
    vector<int> _bypassFlags;
#endif //DOXYGEN_SKIP_THIS
};

}; //End namespace VAPoR
#endif //RENDERPARAMS_H