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

namespace VAPoR {

#include <vapor/ParamsBase.h>

class PARAMS_API Box : public ParamsBase {
public:
    
    Box();
    virtual ~Box() {}


    int GetUserExtents(double extents[6], size_t timestep);
    int GetUserExtents(vector<double> minExts, vector<double>maxExts, size_t timestep);
    int GetUserExtents(float extents[6], size_t timestep);

    int GetLocalExtents(double extents[6], int timestep = -1);
    int GetLocalExtents(float extents[6], int timestep = -1);
    int GetStretchedLocalExtents(double extents[6], int timestep = -1);
    const vector<double>  GetLocalExtents() {
        const vector<double> localExtents(6,0.);
        return GetValueDoubleVec(_extentsTag,localExtents);
    }
    int SetLocalExtents(const vector<double>& extents, Params* p, int timestep = -1);
    int SetLocalExtents(const double extents[6], Params* p, int timestep = -1);
    int SetLocalExtents(const float extents[6], Params* p, int timestep = -1);
    int SetStretchedLocalExtents(const double extents[6], Params* p, int timestep = -1);

    const vector<double> GetAngles(){
        const vector<double> defaultAngles(3,0.);
        return GetValueDoubleVec(Box::_anglesTag,defaultAngles);
    }
    int GetAngles(double ang[3]){
        const vector<double> defaultAngles(3,0.);
        const vector<double> angles = GetValueDoubleVec(Box::_anglesTag,defaultAngles);
        if (angles.size() != 3) return -1;
        for (int i = 0; i<3;i++) ang[i]=angles[i];
        return 0;
    }
    int GetAngles(float ang[3]){
        const vector<double> defaultAngles(3,0.);
        const vector<double> angles = GetValueDoubleVec(Box::_anglesTag,defaultAngles);
        if (angles.size() != 3) return -1;
        for (int i = 0; i<3;i++) ang[i]=(float)angles[i];
        return 0;
    }
    int SetAngles(const double angles[3], Params* p){
        vector<double> ang;
        for (int i = 0; i<3;i++) ang.push_back(angles[i]);
        return SetValueDouble(_anglesTag, "change box angles",ang,p);
    }
    int SetAngles(const float angles[3], Params* p){
        vector<double> angl;
        for (int i = 0; i<3;i++) angl.push_back((double)angles[i]);
        return SetValueDouble(_anglesTag, "change box angles",angl,p);
    }
    void SetAngles(const vector<double>& vals, Params* p){
        SetValueDouble(_anglesTag, "Change box angles",vals, p);
    }
    const vector<long> GetTimes() { 
        const vector<long> defaultTimes(1,0);
        return( GetValueLongVec(Box::_timesTag,defaultTimes));
    }
    void SetTimes(const vector<long>& times, Params* p) { 
        SetValueLong(Box::_timesTag, "Change box times",times, p);
    }

    void Trim(Params* p,int numTimes = 1);

    bool IsPlanar() {return GetValueLong(Box::_planarTag) != 0;}

    void SetPlanar(bool value, Params* p){
        SetValueLong(Box::_planarTag, "Set box planar value", (long)value, p);
    }
    int GetOrientation(){
        return GetValueLong(Box::_orientationTag);
    }
    void SetOrientation(long value, Params* p){
        SetValueLong(Box::_orientationTag, "Set box orientation", (long)value, p);
    }


    static ParamsBase* CreateDefaultInstance() {return new Box();}
    
    void calcContainingBoxExtents(double extents[6], bool rotated = false) {
        if (!rotated) GetLocalExtents(extents,-1);
        else calcRotatedBoxExtents(extents);
    }
    void calcContainingStretchedBoxExtents(double extents[6], bool rotated = false) {
        if (!rotated) GetStretchedLocalExtents(extents,-1);
        else calcRotatedStretchedBoxExtents(extents);
    }

    void calcRotatedBoxExtents(double extents[6]);

    void calcRotatedStretchedBoxExtents(double extents[6]);


    //Used only by params with rotated boxes:
    bool cropToBox(const double boxExts[6], Params* p);
    bool intersectRotatedBox(double boxexts[6], double pointFound[3], double probeCoords[2]);
    bool fitToBox(const double boxExts[6], Params* p);
    void setBoxToExtents(const double extents[6], Params* pParams);
    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, Params* p);

#ifndef DOXYGEN_SKIP_THIS
    void buildLocalCoordTransform(double transformMatrix[12], double extraThickness, int timestep, double rotation = 0., int axis= -1);
    void convertThetaPhiPsi(double *newTheta, double* newPhi, double* newPsi, int axis, double rotation);
    //Not part of public API
    void calcLocalBoxCorners(double corners[8][3], float extraThickness, int timestep, double rotation = 0., int axis = -1);
    
    static const string _boxTag;
    static const string _anglesTag;
    static const string _extentsTag;
    static const string _timesTag;
    static const string _planarTag;
    static const string _orientationTag;
#endif //DOXYGEN_SKIP_THIS  
};
};
#endif