isolineparams.h

Go to the documentation of this file.

#ifndef ISOLINEPARAMS_H
#define ISOLINEPARAMS_H

#include "vapor/ParamNode.h"
#include "params.h"
#include "datastatus.h"
#include "mapperfunction.h"
#include "transferfunction.h"

namespace VAPoR {
class PARAMS_API IsolineParams : public RenderParams {
public:
    IsolineParams(XmlNode *parent, int winnum);

    static ParamsBase* CreateDefaultInstance() {
        return new IsolineParams(0, -1);
    }

    const std::string getShortName() {return _shortName;}

    virtual ~IsolineParams();

    virtual void restart();
    
    virtual Box* GetBox() {
        if (VariablesAre3D()){
            ParamNode* pNode = GetRootNode()->GetNode(IsolineParams::_3DBoxTag);
            if (pNode) {
                return (Box*)pNode->GetNode(Box::_boxTag)->GetParamsBase();
            }
            else assert(0);
            return 0;
        } else {
            ParamNode* pNode = GetRootNode()->GetNode(IsolineParams::_2DBoxTag);
            if (pNode) {
                return (Box*)pNode->GetNode(Box::_boxTag)->GetParamsBase();
            }
            else assert(0);
            return 0;
        }
    }

    virtual void Validate(int type);

    virtual bool IsOpaque() {return true;}

    virtual bool usingVariable(const std::string& varname){
        if (GetVariableName() == varname) return true;
        return false;
    }

    void setSelectedPointLocal(const double point[3]){
        for (int i = 0; i<3; i++) _selectPoint[i] = point[i];
    }
    virtual const double* getSelectedPointLocal() {
        return _selectPoint;
    }

    const vector<double> GetIsolineLocalExtents(){
        return (GetBox()->GetLocalExtents());
    }
    void GetLocalExtents(double exts[6]){
        GetBox()->GetLocalExtents(exts);
    }
    void SetLocalExtents(const vector<double>&exts){
        GetBox()->SetLocalExtents(exts, this);
        setAllBypass(false);
    }
    float GetLineThickness(){
        return ((float)GetValueDouble(_lineThicknessTag));
    }
    void SetLineThickness(double val){
        SetValueDouble(_lineThicknessTag, "Set contour line thickness", val);
    }
    float GetPanelLineThickness(){
        return (float)GetValueDouble(_panelLineThicknessTag);
    }
    void SetPanelLineThickness(double val){
        SetValueDouble(_panelLineThicknessTag, "Set line thickness in image", val);
    }
    float GetTextSize(){
        return ((float)GetValueDouble(_textSizeTag));
    }
    void SetTextSize(double val){
        SetValueDouble(_textSizeTag, "Set text size", val);
    }
    float GetTextDensity(){
        return ((float)GetValueDouble(_textDensityTag));
    }
    void SetTextDensity(double val){
        SetValueDouble(_textDensityTag, "Set text density", val);
    }
    bool textEnabled() {
        return (0 != GetValueLong(_textEnabledTag));
    }
    void SetTextEnabled(bool val){
        SetValueLong(_textEnabledTag, "enable/disable isoline text",(long)val);
    }
    bool UseSingleColor() {
        return (0 != GetValueLong(_useSingleColorTag));
    }
    void SetUseSingleColor(bool val) {
        SetValueLong(_useSingleColorTag, "enable/disable use single color", (long)val);
    }
    void SetSingleColor(double clr[3]){
        vector<double> dcolors;
        for (int i = 0; i<3; i++) dcolors.push_back(clr[i]);
        SetValueDouble(_singleColorTag,"Specify single color",dcolors);
    }
    const vector<double> GetSingleColor(){
        return GetValueDoubleVec(_singleColorTag);
    }
    void SetPanelBackgroundColor(const float rgb[3]);

    const vector<double> GetPanelBackgroundColor();

    void getLineColor(int isoNum, float lineColor[3]);
    
    int getNumIsovalues(){
        return GetIsoControl()->getIsoValues().size();
    }

    int GetNumVariables3D();

    int GetNumVariables2D();

    IsoControl* GetIsoControl(){
        vector<string>path;
        if (VariablesAre3D()) path.push_back(_Variables3DTag);
        else path.push_back(_Variables2DTag);
        path.push_back(GetVariableName());
        path.push_back(_IsoControlTag);
        if (!GetRootNode()->GetNode(path)) return 0;
        return (IsoControl*)(GetRootNode()->GetNode(path)->GetParamsBase());
    }

    IsoControl* GetIsoControl(string varname, bool is3D){
        vector<string>path;
        if (is3D) path.push_back(_Variables3DTag);
        else path.push_back(_Variables2DTag);
        path.push_back(varname);
        path.push_back(_IsoControlTag);
        if (!GetRootNode()->GetNode(path)) return 0;
        return (IsoControl*)(GetRootNode()->GetNode(path)->GetParamsBase());
    }

    int SetIsoControl(const string varname, IsoControl* iControl, bool is3D);
    
    virtual MapperFunction* GetMapperFunc(){
        return (MapperFunction*)GetIsoControl();
    }
    vector<double> GetIsovalues(){
        return GetIsoControl()->getIsoValues();
    }
    void SetIsovalues(const vector<double>& values){
        GetIsoControl()->setIsoValues(values);
        setAllBypass(false);
    }
    void SetTextLabelType(int val){
        SetValueLong(_textTypeTag,"set text label type",val);
    }
    int GetTextLabelType(){
        return GetValueLong(_textTypeTag);
    }
    void SetNumDigits(int val){
        SetValueLong(_numDigitsTag,"set display digits",val);
    }
    int GetNumDigits(){
        return GetValueLong(_numDigitsTag);
    }
    void SetHistoBounds(const float bnds[2]){
        IsoControl* isoContr = GetIsoControl();
        if(!isoContr) return;
        if(isoContr->getMinHistoValue() == bnds[0] &&
            isoContr->getMaxHistoValue() == bnds[1]) return;
        isoContr->setMinMaxHistoValue(bnds[0],bnds[1]);
        
        isoContr->setMinMaxMapValue(bnds[0],bnds[1]);
        
        setAllBypass(false);
    }
    void GetHistoBounds(float bounds[2]){
         if (!GetIsoControl()){
             bounds[0] = 0.f;
             bounds[1] = 1.f;
         } else {
            bounds[0]=GetIsoControl()->getMinHistoValue();
            bounds[1]=GetIsoControl()->getMaxHistoValue();
         }
     }
    
    virtual void hookupTF(TransferFunction* , int );
    
    void spaceIsovals(float miniso, float spacing);

#ifndef DOXYGEN_SKIP_THIS
private:
    static const string _shortName;
    static const string _numDigitsTag;
    static const string _panelBackgroundColorTag;
    static const string _isolineExtentsTag;
    static const string _lineThicknessTag;
    static const string _panelLineThicknessTag;
    static const string _textSizeTag;
    static const string _textDensityTag;
    static const string _2DBoxTag;
    static const string _3DBoxTag;
    static const string _editBoundsTag;
    static const string _textEnabledTag;
    static const string _useSingleColorTag;
    static const string _singleColorTag;
    static const string _textTypeTag;

    double _selectPoint[3];
    float _histoBounds[2];
#endif //DOXYGEN_SKIP_THIS
}; //End of Class IsolineParams
};
#endif //ISOLINEPARAMS_H