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 <map>
#include <vapor/common.h>
#include <vapor/ParamsBase.h>
#include <vapor/MapperFunction.h>
#include <vapor/Box.h>
#include <vapor/ColorbarPbase.h>
#include <vapor/Transform.h>
#include <vapor/DataMgr.h>
 
namespace VAPoR {
 
class PARAMS_API RenderParams : public ParamsBase {
public:
    RenderParams(DataMgr *dataMgr, ParamsBase::StateSave *ssave, const string &classname, int maxdim = 3);
 
    RenderParams(DataMgr *dataMgr, ParamsBase::StateSave *ssave, XmlNode *node, int maxdim = 3);
 
    RenderParams(const RenderParams &rhs);
 
    RenderParams &operator=(const RenderParams &rhs);
 
    virtual ~RenderParams();
 
    //
    virtual int Initialize();
    
    int ResetUserExtentsToDataExents(string var="");
 
    virtual bool IsEnabled() const { return ((bool)GetValueLong(_EnabledTag, (int)false)); }
 
    virtual void SetEnabled(bool val);
 
    virtual void SetVariableName(string varName);
 
    string GetVariableName() const;
 
    virtual void SetAuxVariableNames(vector<string> varName);
 
    vector<string> GetAuxVariableNames() const;
 
    bool UseAuxVariable() const
    {
        vector<string> names = GetAuxVariableNames();
        for (int i = 0; i < names.size(); i++) {
            if (GetVariableName() == names[i]) return true;
        }
        return false;
    }
 
    //
    string GetFirstVariableName() const;
 
    //
    virtual void SetFieldVariableNames(vector<string> varNames);
 
    //
    void SetXFieldVariableName(std::string varName);
 
    //
    void SetYFieldVariableName(std::string varName);
 
    //
    void SetZFieldVariableName(std::string varName);
 
    vector<string> GetFieldVariableNames() const;
 
    //
    std::string GetXFieldVariableName() const;
 
    //
    std::string GetYFieldVariableName() const;
 
    //
    std::string GetZFieldVariableName() const;
 
    vector<string> GetDistribVariableNames() const { return (GetValueStringVec(_distribVariableNamesTag)); }
 
    virtual void SetRefinementLevel(int numrefinements);
 
    virtual int GetRefinementLevel() const;
 
    virtual int GetCompressionLevel() const;
 
    virtual void SetCompressionLevel(int val);
 
    void SetHistoStretch(float factor);
 
    float GetHistoStretch() const;
 
    virtual ColorbarPbase *GetColorbarPbase() const { return _Colorbar; }
 
    virtual void SetColorbarPbase(ColorbarPbase *pb);
 
    //
    virtual MapperFunction *GetMapperFunc(string varname);
 
    //
    virtual void RemoveMapperFunc(string varname);
 
    //
    virtual void SetMapperFunc(string varname, MapperFunction *tf);
 
    //
    virtual Box *GetBox() const { return (_Box); }
 
    void SetCursorCoords(const float coords[2]);
 
    void GetCursorCoords(float coords[2]) const;
 
    virtual void SetHeightVariableName(string varname);
 
    virtual string GetHeightVariableName() const;
 
    bool UseSingleColor() const;
 
    //
    virtual void SetColorMapVariableName(string varname);
 
    virtual string GetColorMapVariableName() const;
 
    virtual string GetActualColorMapVariableName() const = 0;
 
    void SetUseSingleColor(bool val);
 
    //
    void SetConstantColor(const float rgb[3]);
    void SetConstantColor(vector<float> rgb);
 
    //
    void GetConstantColor(float rgb[3]) const;
 
    vector<float> GetConstantColor() const
    {
        float rgb[3];
        GetConstantColor(rgb);
        vector<float> v = {rgb[0], rgb[1], rgb[2]};
        return (v);
    }
 
    void SetConstantOpacity(float o);
 
    //
    float GetConstantOpacity() const;
 
    //
    size_t GetCurrentTimestep() const { return (size_t)GetValueLong(_currentTimestepTag, 0); }
 
    //
    void SetCurrentTimestep(size_t ts) { SetValueLong(_currentTimestepTag, "Set timestep", (long)ts); }
 
    //
    virtual Transform *GetTransform() const { return _transform; }
 
    void initializeBypassFlags();
 
    virtual void SetDefaultVariables(int dim, bool secondaryColormapVariable);
 
    virtual size_t GetRenderDim() const = 0;
 
    virtual bool           HasIsoValues() const { return false; }
    virtual vector<double> GetIsoValues(const string &variable)
    {
        VAssert(0);
        return {};
    }
    virtual void SetIsoValues(const string &variable, const vector<double> &values) { VAssert(0); }
 
    vector<double> GetIsoValues() { return GetIsoValues(GetVariableName()); }
    void           SetIsoValues(const vector<double> &values) { SetIsoValues(GetVariableName(), values); }
 
    virtual bool GetOrientable() const;
 
    vector<double> GetSlicePlaneRotation() const;
 
    vector<double> GetSlicePlaneOrigin() const;
 
    vector<double> GetSlicePlaneNormal() const;
 
    double GetXSlicePlaneOrigin() const;
 
    double GetYSlicePlaneOrigin() const;
 
    double GetZSlicePlaneOrigin() const;
 
    void SetXSlicePlaneOrigin(double xOrigin);
 
    void SetYSlicePlaneOrigin(double yOrigin);
 
    void SetZSlicePlaneOrigin(double zOrigin);
 
    void SetSlicePlaneQuad(const std::vector<CoordType> &quad) { _slicePlaneQuad = quad; }
 
    std::vector<CoordType> GetSlicePlaneQuad() const { return _slicePlaneQuad; }
 
protected:
    DataMgr *_dataMgr;
    int      _maxDim;
 
    bool InitBoxFromVariable(size_t ts, string varName);
 
    virtual bool GetUseSingleColorDefault() const { return false; }
 
private:
    void                   _init();
    void                   _calculateStride(string varName);
    int                    _stride;
    ParamsContainer *      _TFs;
    Box *                  _Box;
    ColorbarPbase *        _Colorbar;
    Transform *            _transform;
    bool                   _classInitialized;    //
    std::vector<CoordType> _slicePlaneQuad;
 
    static const string _EnabledTag;
    static const string _histoScaleTag;
    static const string _editBoundsTag;
    static const string _histoBoundsTag;
    static const string _cursorCoordsTag;
    static const string _terrainMapTag;
    static const string _auxVariableNamesTag;
    static const string _distribVariableNamesTag;
    static const string _transferFunctionsTag;
    static const string _stretchFactorsTag;
    static const string _currentTimestepTag;
 
    string _findVarStartingWithLetter(std::vector<string> searchVars, char letter);
    string _findVarEndingWithLetter(std::vector<string> searchVars, char letter);
 
public:
    static const string _variableNameTag;
    static const string _colorMapVariableNameTag;
    static const string _heightVariableNameTag;
    static const string _useSingleColorTag;
    static const string _constantColorTag;
    static const string _CompressionLevelTag;
    static const string _RefinementLevelTag;
    //    static const string _fieldVariableNamesTag;
    static const string _xFieldVariableNameTag;
    static const string _yFieldVariableNameTag;
    static const string _zFieldVariableNameTag;
    static const string _constantOpacityTag;
    static const string CustomHistogramDataTag;
    static const string CustomHistogramRangeTag;
    static const string LightingEnabledTag;
    static const string UserNameTag;
 
    static const string XSlicePlaneOriginTag;
 
    static const string YSlicePlaneOriginTag;
 
    static const string ZSlicePlaneOriginTag;
 
    static const string XSlicePlaneRotationTag;
 
    static const string YSlicePlaneRotationTag;
 
    static const string ZSlicePlaneRotationTag;
 
    static const string SampleRateTag;
 
    static const string SliceOffsetTag;
 
    static const string SlicePlaneNormalXTag;
 
    static const string SlicePlaneNormalYTag;
 
    static const string SlicePlaneNormalZTag;
 
    static const string SlicePlaneOrientationModeTag;
 
    enum class SlicePlaneOrientationMode {
        Rotation = 0,
        Normal = 1,
    };
};
 
//
// RenParamsFactory Class
//
 
class PARAMS_API RenParamsFactory {
public:
    static RenParamsFactory *Instance()
    {
        static RenParamsFactory instance;
        return &instance;
    }
 
    void RegisterFactoryFunction(string name, function<RenderParams *(DataMgr *, ParamsBase::StateSave *, XmlNode *)> classFactoryFunction)
    {
        // register the class factory function
        _factoryFunctionRegistry[name] = classFactoryFunction;
    }
 
    RenderParams *(CreateInstance(string classType, DataMgr *, ParamsBase::StateSave *, XmlNode *));
 
    vector<string> GetFactoryNames() const;
 
private:
    map<string, function<RenderParams *(DataMgr *, ParamsBase::StateSave *, XmlNode *)>> _factoryFunctionRegistry;
 
    RenParamsFactory() {}
    RenParamsFactory(const RenParamsFactory &) {}
    RenParamsFactory &operator=(const RenParamsFactory &) { return *this; }
};
 
//
// RenParamsRegistrar Class
//
// Register RenParamsBase derived class with:
//
//  static RenParamsRegistrar<RenParamsClass> registrar("myclassname");
//
// where 'RenParamsClass' is a class derived from 'RenderParams', and
// "myclassname" is the name of the class
//
 
template<class T> class RenParamsRegistrar {
public:
    RenParamsRegistrar(string classType)
    {
        // register the class factory function
        //
        RenParamsFactory::Instance()->RegisterFactoryFunction(classType, [](DataMgr *dataMgr, ParamsBase::StateSave *ssave, XmlNode *node) -> RenderParams * {
            if (node)
                return new T(dataMgr, ssave, node);
            else
                return new T(dataMgr, ssave);
        });
    }
};
 
//
// RenParamsContainer Class
//
 
//
// The RenParamsContainer class constructs an XML tree as depicted below,
// where 'Container Name' is the root of XML tree, and is the name
// passed into the constructor as 'myname'; 'Class Name' is the name of
// the derived RenParamBase class used to construct new instances of
// the derived class; and 'ele name x' is the unique name of the element
// contained in the container.
//
/*
            |----------------|
            | Container Name |
            |----------------|
                    |
                   \|/
            |----------------|
            |   Class Name   |
            |----------------|
                    |         \
                   \|/         \
            |----------------|  \ |----------------|
            |   ele name 1   |....|   ele name n   |
            |----------------|    |----------------|
*/
class PARAMS_API RenParamsContainer : public Wasp::MyBase {
public:
    RenParamsContainer(DataMgr *dataMgr, ParamsBase::StateSave *ssave, const string &myname);
 
    RenParamsContainer(DataMgr *dataMgr, ParamsBase::StateSave *ssave, XmlNode *node);
 
    RenParamsContainer(const RenParamsContainer &rhs);
 
    RenParamsContainer &operator=(const RenParamsContainer &rhs);
 
    ~RenParamsContainer();
 
    RenderParams *Insert(const RenderParams *rp, string name);
 
    RenderParams *Create(string classType, string name);
 
    void Remove(string name);
 
    RenderParams *GetParams(string name) const;
 
    vector<string> GetNames() const;
 
    size_t Size() const { return (_elements.size()); }
 
    XmlNode *GetNode() const { return _separator->GetNode(); }
 
    ParamsSeparator *GetSeparator() const { return _separator; }
 
    string const GetName() const { return (_separator->GetName()); }
 
private:
    DataMgr *                   _dataMgr;
    ParamsBase::StateSave *     _ssave;
    ParamsSeparator *           _separator;
    map<string, RenderParams *> _elements;
};
 
};        // End namespace VAPoR
#endif    // RENDERPARAMS_H