Box.h

Go to the documentation of this file.

//************************************************************************
//                                  *
//           Copyright (C)  2011                *
//     University Corporation for Atmospheric Research          *
//           All Rights Reserved                *
//                                  *
//************************************************************************/
//
//  File:       Box.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       April 2011
//
//  Description:    Defines the Box class
//      This supports control of a 2D or 3D box-shaped region that can be
//      rotated and changed over time.
//
#ifndef BOX_H
#define BOX_H
 
#include <vapor/ParamsBase.h>
#include <vapor/Grid.h>
 
namespace VAPoR {
 
 
class PARAMS_API Box : public ParamsBase {
public:
    enum Orientation { XY = 0, XZ = 1, YZ = 2, XYZ = 3 };
 
    //
    Box(ParamsBase::StateSave *ssave, string name = Box::GetClassType());
 
    //
    Box(ParamsBase::StateSave *ssave, XmlNode *node);
 
    virtual ~Box();
 
    //
    virtual void SetExtents(const vector<double> &minExt, const vector<double> &maxExt);
    virtual void SetExtents(const VAPoR::CoordType &minExt, const VAPoR::CoordType &maxExt);
 
    //
    void GetExtents(vector<double> &minExt, vector<double> &maxExt) const;
    void GetExtents(VAPoR::CoordType &minExt, VAPoR::CoordType &maxExt) const;
 
    //
    bool IsPlanar() const;
 
    //
    void SetPlanar(bool value);
 
    //
    int GetOrientation() const { return GetValueLong(Box::m_orientationTag, XY); }
 
    //
    void SetOrientation(long value) { SetValueLong(Box::m_orientationTag, "Set box orientation", (long)value); }
 
#if 0
    int GetStretchedLocalExtents(double extents[6], int timestep = -1);
 
    vector<double>  GetLocalExtents() const 
  { 
    const vector<double> localExtents(6, 0);
        return GetValueDoubleVec(_extentsTag, localExtents);
    }
 
    void SetLocalExtents(const vector<double>& extents, int timestep = -1);
 
    void SetLocalExtents(
        const vector<double>& minExt, const vector<double>& maxExt, 
        int timestep = -1
    ) {
        VAssert(minExt.size() == maxExt.size() && minExt.size() == 3);
        vector <double> extents = minExt;
        extents.insert(extents.end(), maxExt.begin(), maxExt.end());
        SetLocalExtents(extents, timestep);
    }
 
    void SetLocalExtents(const double extents[6], int timestep = -1);
 
    void SetLocalExtents(const float extents[6], int timestep = -1);
#endif
 
#if 0
    void SetStretchedLocalExtents(const double extents[6], int timestep = -1);
#endif
 
    vector<double> GetAngles() const
    {
        const vector<double> defaultAngles(3, 0.);
        return GetValueDoubleVec(Box::m_anglesTag, defaultAngles);
    }
 
#if 0
    void GetAngles(double ang[3]){
        const vector<double> angv = GetAngles();
        for (int i=0; i<3; i++) ang[i] = angv[i];
    }
 
    void GetAngles(float ang[3]){
        const vector<double> angv = GetAngles();
        for (int i=0; i<3; i++) ang[i] = angv[i];
    }
#endif
 
    void SetAngles(const double angles[3])
    {
        vector<double> ang;
        for (int i = 0; i < 3; i++) ang.push_back(angles[i]);
        SetValueDoubleVec(m_anglesTag, "change box angles", ang);
    }
 
    void SetAngles(const float angles[3])
    {
        vector<double> angl;
        for (int i = 0; i < 3; i++) angl.push_back((double)angles[i]);
        SetValueDoubleVec(m_anglesTag, "change box angles", angl);
    }
 
    void SetAngles(const vector<double> &vals) { SetValueDoubleVec(m_anglesTag, "Change box angles", vals); }
#if 0
    const vector<long> GetTimes() { 
        return( GetValueLongVec(Box::_timesTag));
    }
    void SetTimes(const vector<long>& times) { 
        SetValueLongVec(Box::_timesTag, "Change box times",times);
    }
 
    void buildLocalCoordTransform(
        double transformMatrix[12], double extraThickness, 
        int timestep, double rotation = 0., int axis= -1
    ) const;
#endif
 
    // Get static string identifier for this params class
    //
    static string GetClassType() { return ("BoxParams"); }
 
private:
#if 0
    void calcContainingBoxExtents(
        double extents[6], bool rotated = false
    ) const {
 
        if (!rotated) GetLocalExtents(extents,-1);
        else calcRotatedBoxExtents(extents);
 
    }
 
    void calcRotatedBoxExtents(double extents[6]) const;
 
    void calcContainingStretchedBoxExtents(
        double extents[6], bool rotated = false
    ) const {
 
        VAssert( ! rotated);
        if (!rotated) GetStretchedLocalExtents(extents,-1);
        //else calcRotatedStretchedBoxExtents(extents);
 
    }
 
 
    void calcRotatedStretchedBoxExtents(
        vector <double> stretchFactors, double extents[6]
    ) const;
 
 
    //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]);
    void setBoxToExtents(const double extents[6]);
    int interceptBox(const double boxExts[6], double intercept[6][3]);
 
    void getRotatedVoxelExtents(string varname, float voxdims[2], int numRefinements);
 
 
    void rotateAndRenormalize(int axis, double rotVal);
 
 
    void convertThetaPhiPsi(
        double *newTheta, double* newPhi, double* newPsi, 
        int axis, double rotation
    ) const;
 
    //Not part of public API
    void calcLocalBoxCorners(
        double corners[8][3], float extraThickness, int timestep, 
        double rotation = 0., int axis = -1
    ) const ;
 
#endif
 
public:
    static const string m_anglesTag;
    static const string m_extentsTag;
    static const string m_planarTag;
    static const string m_orientationTag;
};
};    // namespace VAPoR
#endif