ViewpointParams.h

Go to the documentation of this file.

//************************************************************************
//         *
//       Copyright (C)  2004    *
//     University Corporation for Atmospheric Research   *
//       All Rights Reserved    *
//         *
//************************************************************************/
//
// File:  ViewpointParams.h
//
// Author:  Alan Norton
//   National Center for Atmospheric Research
//   PO 3000, Boulder, Colorado
//
// Date:  August 2004
//
// Description: Defines the ViewpointParams class
//  This class contains the parameters associated with viewpoint and lights
//
#ifndef VIEWPOINTPARAMS_H
#define VIEWPOINTPARAMS_H
 
#include <vapor/ParamsBase.h>
#include <vapor/Viewpoint.h>
#include <vapor/Transform.h>
 
#include <memory>
#include <fstream>
 
namespace VAPoR {
 
 
class PARAMS_API ViewpointParams : public ParamsBase {
public:
    ViewpointParams(ParamsBase::StateSave *ssave);
 
    ViewpointParams(ParamsBase::StateSave *ssave, XmlNode *node);
 
    ViewpointParams(const ViewpointParams &rhs);
 
    ViewpointParams &operator=(const ViewpointParams &rhs);
 
    virtual ~ViewpointParams();
 
    void rescale(vector<double> scaleFac);
 
    int getNumLights() const
    {
        size_t n = (size_t)GetValueLong(_numLightsTag, _defaultNumLights);
        if (n > 2) n = 2;
        return (n);
    }
 
    double getExponent() const { return (GetValueDouble(_specularExpTag, _defaultSpecularExp)); }
 
    void setNumLights(size_t nlights)
    {
        if (nlights > 2) nlights = 2;
        SetValueLong(_numLightsTag, "Set number of lights", nlights);
    }
 
    //
    double getLightDirection(int lightNum, int dir) const;
 
    void setLightDirection(int lightNum, int dir, double val);
 
    double getDiffuseCoeff(int lightNum) const;
 
    double getSpecularCoeff(int lightNum) const;
 
    double getAmbientCoeff() const { return GetValueDouble(_ambientCoeffTag, _defaultAmbientCoeff); }
 
    void setDiffuseCoeff(int lightNum, double val);
 
    void setSpecularCoeff(int lightNum, double val);
 
    void setExponent(double val) { SetValueDouble(_specularExpTag, "Set specular lighting", val); }
 
    void setAmbientCoeff(double val) { SetValueDouble(_ambientCoeffTag, "Set ambient lighting", val); }
 
    void SetCurrentViewpoint(Viewpoint *newVP);
 
    void SetWindowSize(size_t width, size_t height);
 
    void GetWindowSize(size_t &width, size_t &height) const;
 
    void   SetFOV(float v);
    double GetFOV() const;
    void   SetOrthoProjectionSize(float f);
    double GetOrthoProjectionSize() const;
 
    enum ProjectionType { Perspective, Orthographic, MapOrthographic };
    void           SetProjectionType(ProjectionType type);
    ProjectionType GetProjectionType() const;
 
    vector<double> GetStretchFactors() const;
 
    void SetStretchFactors(vector<double> factors);
 
    virtual Viewpoint *getCurrentViewpoint() const
    {
        Viewpoint *v = (Viewpoint *)m_VPs->GetParams(_currentViewTag);
        VAssert(v != NULL);
        return (v);
    }
 
    //
    void                GetModelViewMatrix(double m[16]) const { getCurrentViewpoint()->GetModelViewMatrix(m); }
    std::vector<double> GetModelViewMatrix() const
    {
        double m[16];
        getCurrentViewpoint()->GetModelViewMatrix(m);
        vector<double> vec(m, m + sizeof(m) / sizeof(m[0]));
        return (vec);
    }
    void SetModelViewMatrix(const double matrix[16]) { getCurrentViewpoint()->SetModelViewMatrix(matrix); }
    void SetModelViewMatrix(const std::vector<double> mvec)
    {
        VAssert(mvec.size() == 16);
        double m[16];
        for (int i = 0; i < mvec.size(); i++) m[i] = mvec[i];
        getCurrentViewpoint()->SetModelViewMatrix(m);
    }
 
    void GetProjectionMatrix(double m[16]) const { getCurrentViewpoint()->GetProjectionMatrix(m); }
    void SetProjectionMatrix(const double m[16]) { getCurrentViewpoint()->SetProjectionMatrix(m); }
 
    bool ReconstructCamera(const double m[16], double position[3], double upVec[3], double viewDir[3]) const { return (getCurrentViewpoint()->ReconstructCamera(m, position, upVec, viewDir)); }
 
    std::vector<double> GetRotationCenter() const { return (getCurrentViewpoint()->GetRotationCenter()); }
 
    void GetRotationCenter(double c[3]) const
    {
        vector<double> val = GetRotationCenter();
        VAssert(val.size() == 3);
        for (int i = 0; i < val.size(); i++) c[i] = val[i];
    }
 
    void SetRotationCenter(vector<double> c) { getCurrentViewpoint()->SetRotationCenter(c); }
    void SetRotationCenter(const double c[3])
    {
        std::vector<double> vec = {c[0], c[1], c[2]};
        SetRotationCenter(vec);
    }
 
    //
    virtual Transform *GetTransform(string dataSetName);
 
    //
    vector<string> GetTransformNames() const { return (_transforms->GetNames()); }
 
    int SetCameraFromFile(const std::string &path);
    
    int SaveCameraToFile(const std::string &path);
 
#ifdef VAPOR3_0_0_ALPHA
    double GetCurrentViewDiameter(vector<double> stretchFactors) const;
#endif
 
#ifndef DOXYGEN_SKIP_THIS
 
    static const double *getDefaultLightDirection(int lightNum) { return _defaultLightDirection[lightNum]; }
    static double        getDefaultAmbientCoeff() { return _defaultAmbientCoeff; }
    static double        getDefaultSpecularExp() { return _defaultSpecularExp; }
    static int           getDefaultNumLights() { return _defaultNumLights; }
    static const double *getDefaultDiffuseCoeff() { return _defaultDiffuseCoeff; }
    static const double *getDefaultSpecularCoeff() { return _defaultSpecularCoeff; }
    static void          setDefaultLightDirection(int lightNum, double val[3])
    {
        for (int i = 0; i < 3; i++) _defaultLightDirection[lightNum][i] = val[i];
    }
    static void setDefaultSpecularCoeff(double val[3])
    {
        for (int i = 0; i < 3; i++) _defaultSpecularCoeff[i] = val[i];
    }
    static void setDefaultDiffuseCoeff(double val[3])
    {
        for (int i = 0; i < 3; i++) _defaultDiffuseCoeff[i] = val[i];
    }
    static void setDefaultAmbientCoeff(double val) { _defaultAmbientCoeff = val; }
    static void setDefaultSpecularExp(double val) { _defaultSpecularExp = val; }
    static void setDefaultNumLights(int val) { _defaultNumLights = val; }
 
    // Get static string identifier for this params class
    //
    static string GetClassType() { return ("ViewpointParams"); }
 
    static const string UseCustomFramebufferTag;
    static const string CustomFramebufferWidthTag;
    static const string CustomFramebufferHeightTag;
 
private:
    ParamsContainer *m_VPs = nullptr;
    ParamsContainer *_transforms = nullptr;
 
    static const string _viewPointsTag;
    static const string _transformsTag;
    static const string _currentViewTag;
    static const string _lightDirectionsTag;
    static const string _diffuseCoeffTag;
    static const string _specularCoeffTag;
    static const string _specularExpTag;
    static const string _ambientCoeffTag;
    static const string _numLightsTag;
    static const string m_windowSizeTag;
    static const string m_stretchFactorsTag;
    static const string m_fieldOfView;
    static const string _orthoProjectionSizeTag;
    static const string _projectionTypeTag;
 
    // defaults:
    static double _defaultLightDirection[3][4];
    static double _defaultDiffuseCoeff[3];
    static double _defaultSpecularCoeff[3];
    static double _defaultAmbientCoeff;
    static double _defaultSpecularExp;
    static int    _defaultNumLights;
 
    void _init();
 
#endif    // DOXYGEN_SKIP_THIS
};
};        // namespace VAPoR
#endif    // VIEWPOINTPARAMS_H