GeoTessProfile.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 PROFILE_OBJECT_H
#define PROFILE_OBJECT_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <vector>
#include <iostream>
#include <string>
#include <fstream>
#include <map>
 
// use standard library objects
using namespace std;
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "GeoTessProfileType.h"
#include "GeoTessData.h"
#include "GeoTessDataArray.h"
 
// **** _BEGIN GEOTESS NAMESPACE_ **********************************************
 
namespace geotess {
 
// **** _FORWARD REFERENCES_ ***************************************************
 
class GeoTessInterpolatorType;
class GeoTessMetaData;
class IFStreamAscii;
class IFStreamBinary;
 
 
// **** _CLASS DEFINITION_ *****************************************************
 
class GEOTESS_EXP_IMP GeoTessProfile
{
private:
 
    static int                      aClassCount;
 
public:
 
    static GeoTessProfile* newProfile(const vector<float>& radii, vector<GeoTessData*>& data);
 
    static GeoTessProfile* newProfile(const vector<float>& radii, vector<vector<double> >& data);
    static GeoTessProfile* newProfile(const vector<float>& radii, vector<vector<float> >& data);
    static GeoTessProfile* newProfile(const vector<float>& radii, vector<vector<LONG_INT> >& data);
    static GeoTessProfile* newProfile(const vector<float>& radii, vector<vector<int> >& data);
    static GeoTessProfile* newProfile(const vector<float>& radii, vector<vector<short> >& data);
    static GeoTessProfile* newProfile(const vector<float>& radii, vector<vector<byte> >& data);
 
    static GeoTessProfile* newProfile(float* radii, const int& nRadii, GeoTessData** data, const int& nData);
 
    static GeoTessProfile* newProfile(float* radii, const int& nRadii, double** values, const int& nNodes, const int& nAttributes)
    {
        if (nNodes < 1 && nRadii == 2)
            return GeoTessProfile::newProfile(radii, nRadii, NULL, 0);
 
        if (nNodes == 1)
        {
            GeoTessData* d[1];
            d[0] = GeoTessData::getData(values[0], nAttributes);
            return GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        }
 
        GeoTessData** d = new GeoTessData*[nNodes];
        for (int i=0; i<nNodes; ++i) d[i] = GeoTessData::getData(values[i], nAttributes);
        GeoTessProfile* profile = GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        delete[] d;
        return profile;
    }
 
    static GeoTessProfile* newProfile(float* radii, const int& nRadii, float** values, const int& nNodes, const int& nAttributes)
    {
        if (nNodes < 1 && nRadii == 2)
            return GeoTessProfile::newProfile(radii, nRadii, NULL, 0);
 
        if (nNodes == 1)
        {
            GeoTessData* d[1];
            d[0] = GeoTessData::getData(values[0], nAttributes);
            return GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        }
 
        GeoTessData** d = new GeoTessData*[nNodes];
        for (int i=0; i<nNodes; ++i) d[i] = GeoTessData::getData(values[i], nAttributes);
        GeoTessProfile* profile = GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        delete[] d;
        return profile;
    }
 
    static GeoTessProfile* newProfile(float* radii, const int& nRadii, LONG_INT** values, const int& nNodes, const int& nAttributes)
    {
        if (nNodes < 1 && nRadii == 2)
            return GeoTessProfile::newProfile(radii, nRadii, NULL, 0);
 
        if (nNodes == 1)
        {
            GeoTessData* d[1];
            d[0] = GeoTessData::getData(values[0], nAttributes);
            return GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        }
 
        GeoTessData** d = new GeoTessData*[nNodes];
        for (int i=0; i<nNodes; ++i) d[i] = GeoTessData::getData(values[i], nAttributes);
        GeoTessProfile* profile = GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        delete[] d;
        return profile;
    }
 
    static GeoTessProfile* newProfile(float* radii, const int& nRadii, int** values, const int& nNodes, const int& nAttributes)
    {
        if (nNodes < 1 && nRadii == 2)
            return GeoTessProfile::newProfile(radii, nRadii, NULL, 0);
 
        if (nNodes == 1)
        {
            GeoTessData* d[1];
            d[0] = GeoTessData::getData(values[0], nAttributes);
            return GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        }
 
        GeoTessData** d = new GeoTessData*[nNodes];
        for (int i=0; i<nNodes; ++i) d[i] = GeoTessData::getData(values[i], nAttributes);
        GeoTessProfile* profile = GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        delete[] d;
        return profile;
    }
 
    static GeoTessProfile* newProfile(float* radii, const int& nRadii, short** values, const int& nNodes, const int& nAttributes)
    {
        if (nNodes < 1 && nRadii == 2)
            return GeoTessProfile::newProfile(radii, nRadii, NULL, 0);
 
        if (nNodes == 1)
        {
            GeoTessData* d[1];
            d[0] = GeoTessData::getData(values[0], nAttributes);
            return GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        }
 
        GeoTessData** d = new GeoTessData*[nNodes];
        for (int i=0; i<nNodes; ++i) d[i] = GeoTessData::getData(values[i], nAttributes);
        GeoTessProfile* profile = GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        delete[] d;
        return profile;
    }
 
    static GeoTessProfile* newProfile(float* radii, const int& nRadii, byte** values, const int& nNodes, const int& nAttributes)
    {
        if (nNodes < 1 && nRadii == 2)
            return GeoTessProfile::newProfile(radii, nRadii, NULL, 0);
 
        if (nNodes == 1)
        {
            GeoTessData* d[1];
            d[0] = GeoTessData::getData(values[0], nAttributes);
            return GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        }
 
        GeoTessData** d = new GeoTessData*[nNodes];
        for (int i=0; i<nNodes; ++i) d[i] = GeoTessData::getData(values[i], nAttributes);
        GeoTessProfile* profile = GeoTessProfile::newProfile(radii, nRadii, d, nNodes);
        delete[] d;
        return profile;
    }
 
    static  string              class_name() { return "Profile"; };
 
    virtual int                 class_size() const { return (int) sizeof(GeoTessProfile); };
 
    virtual LONG_INT getMemory() = ABSTRACT;
 
    static  int                 class_count() { return aClassCount; };
 
    virtual const GeoTessProfileType&   getType() const = ABSTRACT;
 
    virtual bool operator == (const GeoTessProfile& p) const { return (getType() == p.getType()); }
 
    virtual double              getValue(const GeoTessInterpolatorType& rInterpType,
            int attributeIndex, double radius, bool allowRadiusOutOfRange) const   = ABSTRACT;
 
    double  getValue(const vector<int>& nodeIds,
            const vector<double>& coefficients, int attributeIndex) const
    {
        double value = 0;
        for (int i=0; i<(int)nodeIds.size(); ++i)
            value += getValue(attributeIndex, nodeIds[i])*coefficients[i];
        return value;
    }
 
    virtual double getValue(int attributeIndex, int nodeIndex) const  = ABSTRACT;
 
    virtual bool isNaN(int nodeIndex, int attributeIndex) = ABSTRACT;
 
    virtual double            getValueTop(int attributeIndex) const = ABSTRACT;
 
    virtual double            getValueBottom(int attributeIndex) const
    {
        return getValue(attributeIndex, 0);
    }
 
    virtual float               getRadius(int i) const = ABSTRACT;
 
    virtual int                 getNRadii() const = ABSTRACT;
 
    virtual int                 getNData() const = ABSTRACT;
 
    virtual float*              getRadii() = ABSTRACT;
 
    virtual GeoTessData**               getData() = ABSTRACT;
 
    virtual GeoTessData*                getData(int i) = ABSTRACT;
 
    virtual const GeoTessData&          getData(int i) const = ABSTRACT;
 
    virtual void                setData(int index, GeoTessData* data) = ABSTRACT;
 
    virtual void                setData(const vector<GeoTessData*>& inData) = ABSTRACT;
 
    virtual void                setRadii(const vector<float>& newRadii) = ABSTRACT;
 
    virtual void                setRadius(int index, float radius) = ABSTRACT;
 
    virtual float               getRadiusTop() const = ABSTRACT;
 
    virtual const GeoTessData&          getDataTop() const = ABSTRACT;
 
    virtual GeoTessData*                getDataTop() = ABSTRACT;
 
    virtual float               getRadiusBottom() const = ABSTRACT;
 
    virtual const GeoTessData&          getDataBottom() const = ABSTRACT;
 
    virtual GeoTessData*                getDataBottom() = ABSTRACT;
 
    double                      getThickness() { return getRadiusTop() - getRadiusBottom(); }
 
    int                         getRadiusIndex(double radius) const
    { return getRadiusIndex(radius, -1); }
 
    virtual int                 getRadiusIndex(double radius, int jlo) const
    {
        // note that ProfileNPoint will override this method.
        return 0;
    }
 
    virtual double getInterpolationCoefficient(int i, double radius,
            bool allowOutOfRange) const
    {
        if (!allowOutOfRange && (radius < getRadiusBottom() || radius > getRadiusTop()))
            return NaN_DOUBLE;
 
        // note that ProfileNPoint will override this method.
        return 1.;
    }
 
    virtual int                 getPointIndex(int nodeIndex) const = ABSTRACT;
 
    virtual int                 findClosestRadiusIndex(double radius) const = ABSTRACT;
 
 
    virtual void getWeights(map<int, double>& weights,
            double dkm, double radius, double hcoefficient) const
    {
        // get the point index of the one-and-only node.
 
        int index = getPointIndex(0);
 
        // find the current weight of the point, if it exists.
        // either set the weight of pointIndex (if it does not already exist),
        // or add the new weight to the existing weight.
 
        map<int, double>::iterator it = weights.find(index);
        if (it == weights.end())
            weights[index] = dkm * hcoefficient;
        else
            it->second += dkm * hcoefficient;
    }
 
    virtual void                getCoefficients(map<int, double>& coefficients, double radius,
            double horizontalCoefficient) const
    {
        // this works for Profile types Constant, Thin and Surface since they only have a single node
        // in the profile.  It does not work for ProfileNPoint and ProfileEmpty so they override this method.
 
        coefficients[getPointIndex(0)] = horizontalCoefficient;
    }
 
    GeoTessProfile() { ++aClassCount; };
 
    virtual                     ~GeoTessProfile() { --aClassCount; };
 
    static GeoTessProfile*              newProfile(IFStreamBinary& ifs, GeoTessMetaData& gtmd);
 
    static GeoTessProfile*              newProfile(IFStreamAscii& ifs, GeoTessMetaData& gtmd);
 
    virtual void                    write(IFStreamBinary& ofs) = ABSTRACT;
 
    virtual void                    write(IFStreamAscii& ofs) = ABSTRACT;
 
    virtual void                    setPointIndex(int nodeIndex, int pointIndex) = ABSTRACT;
 
    virtual void resetPointIndices() = ABSTRACT;
 
    virtual void setInterpolationCoefficients(const GeoTessInterpolatorType& interpType,
            vector<int>& nodeIndexes, vector<double>& coefficients,
            double& radius, bool& allowOutOfRange)
    {
        // this code works for Profiles constant, thin and surface.
        // ProfileNPoint and ProfileEmpty will override it.
        nodeIndexes.push_back(0);
        if (!allowOutOfRange && (radius < getRadiusBottom() || radius > getRadiusTop()))
            coefficients.push_back(NaN_DOUBLE);
        else
            coefficients.push_back(1.);
    }
 
    virtual GeoTessProfile*      copy() = ABSTRACT;
 
 
}; // end class Profile
 
} // end namespace geotess
 
#endif  // PROFILE_OBJECT_H