LibCorr3D.h

Go to the documentation of this file.

//- ****************************************************************************
//- 
//- Copyright 2009 Sandia Corporation. Under the terms of Contract
//- DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
//- retains certain rights in this software.
//- 
//- BSD Open Source License.
//- All rights reserved.
//- 
//- Redistribution and use in source and binary forms, with or without
//- modification, are permitted provided that the following conditions are met:
//- 
//-    * Redistributions of source code must retain the above copyright notice,
//-      this list of conditions and the following disclaimer.
//-    * Redistributions in binary form must reproduce the above copyright
//-      notice, this list of conditions and the following disclaimer in the
//-      documentation and/or other materials provided with the distribution.
//-    * Neither the name of Sandia National Laboratories nor the names of its
//-      contributors may be used to endorse or promote products derived from
//-      this software without specific prior written permission.
//- 
//- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
//- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//- POSSIBILITY OF SUCH DAMAGE.
//-
//- ****************************************************************************
 
#ifndef LIBCORR3D_OBJECT_H
#define LIBCORR3D_OBJECT_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <map>
 
// use standard library objects
using namespace std;
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "CPPUtils.h"
#include "GeoTessUtils.h"
#include "GeoTessException.h"
#include "GeoTessModel.h"
#include "GeoTessPosition.h"
#include "GeoTessOptimizationType.h"
 
// **** _BEGIN GEOTESS NAMESPACE_ **********************************************
 
namespace geotess
{
 
// **** _FORWARD REFERENCES_ ***************************************************
 
class GeoTessPosition;
class LibCorr3DModel;
class GeoTessMetaData;
class IFStreamBinary;
class GeoTessInterpolatorType;
 
// **** _CLASS DEFINITION_ *****************************************************
 
class GEOTESS_EXP_IMP LibCorr3D
{
private:
 
        double lc3dCurrIntrpVector[3];
 
        double lc3dCurrIntrpRadius;
 
        double lc3dCurrIntrpTime;
 
        string lc3dGTRootPath;
 
        string lc3dOldRootPath;
 
        string lc3dGTRelGridPath;
 
        string lc3dOldRelTessPath;
 
        vector<string> lc3dModelFileName;
 
        map<string, int> lc3dModelMap;
 
        vector<LibCorr3DModel*> lc3dModelList;
 
        map<string, GeoTessPosition*> lc3dPositionMap;
 
        vector<GeoTessPosition*> lc3dPositionList;
 
        int lc3dCurrErrCode;
 
        string lc3dCurrErrMsg;
 
        void checkPath(const string& fname, string& pth, string& relGrid);
 
        GeoTessInterpolatorType const* geographicInterpolatorType;
 
        GeoTessInterpolatorType const* radialInterpolatorType;
 
public:
 
        LibCorr3D(const string& rootPath);
 
        LibCorr3D(const string& newRootPath, const string& oldRootPath);
 
        LibCorr3D(const string& newRootPath, const string& newRelGridPath,
                        const string& oldRootPath, const string& oldRelGridPath);
 
        virtual ~LibCorr3D();
 
        static string getVersion() { return "1.2.8"; };
 
        // version 1.2.5    2015-08-19
        // Fixed a bug discovered at AFTAC, in method
        // LibCorr3DModel::interpolate2DModelUncertainty
        // that resulted in incorrect model uncertainty values
        // when distance was out of range.
        //
        // version 1.2.4        2015-01-22
        // Added getMemory() functions to GeoTess and Libcorr3D.
        //
        // version 1.2.2        2014-05-01
        // Changes to GeoTessCPP to improve the performance of
        // the natural neighbor algorithm. GeoTessCPP version
        // is now 2.2.0.  No changes to the LibCorr3D code.
        //
        // version 1,2,1  10/07/2013
        // Fixed a bug where GeoTessPosition objects were not being deleted
        // properly in LibCorr3d::removeModel(handle).
        //
        // version 1.1.0  11/21/2012:
        // - multiple models can be supported by a single GeoTessPosition object.
        // - can specify geographic and radial interpolators independently.
        // - can specify interpolation location using unit vector and radius
        //       in addition to specification using lat, lon, depth.
        // - can specify OptimizationType in loadModel() method
 
        LONG_INT getMemory();
 
        int loadModel(const string& fname, const GeoTessOptimizationType& optimizationType = GeoTessOptimizationType::SPEED)
        {
                // call the other loadModel() method with attributeFilter that is empty, which means
                // it will be ignored and all attributes will be loaded.
                vector<int> attributeFilter;
                return loadModel(fname, attributeFilter, optimizationType);
        }
 
        int loadModel(const string& fname, vector<int>& attributeFilter,
                        const GeoTessOptimizationType& optimizationType = GeoTessOptimizationType::SPEED);
 
        void removeModel(int handle);
 
        const double* getCurrentInterpolationLocation() const
        {
                return lc3dCurrIntrpVector;
        }
 
        double getCurrentInterpolationLat()
        {
                return GeoTessUtils::getLatDegrees(lc3dCurrIntrpVector);
        }
 
        double getCurrentInterpolationLon()
        {
                return GeoTessUtils::getLonDegrees(lc3dCurrIntrpVector);
        }
 
        double getCurrentInterpolationRadius()
        {
                return lc3dCurrIntrpRadius;
        }
 
        double getCurrentInterpolationDepth()
        {
                return GeoTessUtils::getEarthRadius(lc3dCurrIntrpVector)-lc3dCurrIntrpRadius;
        }
 
        double getCurrentInterpolationTime()
        {
                return lc3dCurrIntrpTime;
        }
 
        string getCurrentInterpolationLocation()
        {
                ostringstream os;
                os << fixed << setprecision(5);
                os << setw(11) << getCurrentInterpolationLon();
                os << " " << setw(10) << getCurrentInterpolationLat();
                os << fixed << setprecision(3);
                os << " " << setw(7) << getCurrentInterpolationDepth();
                os << " " << setw(7) << getCurrentInterpolationTime();
                return os.str();
        }
 
        LibCorr3D* setInterpolationLocation(double lon, double lat, double depth = 0.0, double time =
                        NA_VALUE)
        {
                if (lat < -90 || lat > 90)
                {
                        ostringstream os;
                        os << fixed << setprecision(6);
                        os << endl << "ERROR in LibCorr3D::setInterpolationLocation" << endl
                                        << "latitude (" << lat << ") is out of range" << endl;
                        throw GeoTessException(os, __FILE__, __LINE__, 109);
                }
 
                GeoTessUtils::getVectorDegrees(lat, lon, lc3dCurrIntrpVector);
                lc3dCurrIntrpRadius = GeoTessUtils::getEarthRadius(lc3dCurrIntrpVector)-depth;
                lc3dCurrIntrpTime = time;
                return this;
        }
 
        LibCorr3D* setInterpolationLocation(double* unitVector, double radius = -1., double time =
                        NA_VALUE)
        {
                lc3dCurrIntrpVector[0] = unitVector[0];
                lc3dCurrIntrpVector[1] = unitVector[1];
                lc3dCurrIntrpVector[2] = unitVector[2];
                lc3dCurrIntrpRadius = radius < 0. ? GeoTessUtils::getEarthRadius(unitVector) : radius;
                lc3dCurrIntrpTime = time;
                return this;
        }
 
        void setInterpolator(GeoTessInterpolatorType const* intrpGeographic, GeoTessInterpolatorType const* intrpRadial);
 
        const GeoTessInterpolatorType& getGeographicInterpolatorType() const
        {
                return *geographicInterpolatorType;
        }
 
        const GeoTessInterpolatorType& getRadialInterpolatorType() const
        {
                return *radialInterpolatorType;
        }
 
        LibCorr3DModel* getModel(int handle);
 
        bool getModelResult(int handle, double& modelValue, double& modelUncertainty);
 
        const string& getRootPath() const
        {
                return lc3dGTRootPath;
        }
 
        const string& getOldRootPath() const
        {
                return lc3dOldRootPath;
        }
 
        const string& getRelGridPath() const
        {
                return lc3dGTRelGridPath;
        }
 
        const string& getOldRelGridPath() const
        {
                return lc3dOldRelTessPath;
        }
 
        int getCurrentErrorCode() const
        {
                return lc3dCurrErrCode;
        }
 
        const string& getCurrentErrorMessage() const
        {
                return lc3dCurrErrMsg;
        }
 
};
 
// end class LibCorr3D
 
}// end namespace geotess
 
#endif // LIBCORR3D_OBJECT_H