GeoTessProfileThin.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 PROFILETHIN_OBJECT_H
#define PROFILETHIN_OBJECT_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <iostream>
#include <fstream>
#include <string>
 
// use standard library objects
using namespace std;
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "GeoTessData.h"
#include "GeoTessProfile.h"
#include "GeoTessProfileType.h"
#include "IFStreamAscii.h"
#include "IFStreamBinary.h"
 
// **** _BEGIN GEOTESS NAMESPACE_ **********************************************
 
namespace geotess {
 
// **** _FORWARD REFERENCES_ ***************************************************
 
class GeoTessMetaData;
 
// **** _CLASS DEFINITION_ *****************************************************
 
class GEOTESS_EXP_IMP GeoTessProfileThin : virtual public GeoTessProfile
{
private:
 
    float                                   radius;
 
    GeoTessData*                                    data;
 
    int                                         pointIndex;
 
    GeoTessProfileThin() : GeoTessProfile(), radius(0.0), data(NULL),
            pointIndex(-1) {};
 
public:
 
    GeoTessProfileThin(float rad, GeoTessData* dat) :
        GeoTessProfile(), radius(rad), data(dat),
        pointIndex(-1) {};
 
    static  string              class_name() { return "ProfileThin"; };
 
    virtual int                     class_size() const
    { return (int) sizeof(GeoTessProfileThin); };
 
    virtual LONG_INT getMemory() { return (LONG_INT)sizeof(GeoTessProfileThin) + data->getMemory(); }
 
    virtual const GeoTessProfileType&   getType() const
    { return GeoTessProfileType::THIN; };
 
    virtual bool operator == (const GeoTessProfile& p) const
    { return (GeoTessProfile::operator==(p) && (radius == p.getRadius(0)) && (*data == p.getData(0)));  }
 
    virtual double getValue(int attributeIndex, int nodeIndex) const
    { return nodeIndex == 0 ? data->getDouble(attributeIndex) : NaN_DOUBLE; }
 
    virtual double  getValue(const GeoTessInterpolatorType& rInterpType,
            int attributeIndex, double r, bool allowRadiusOutOfRange) const
    {
        if (!allowRadiusOutOfRange &&
                ((r < getRadiusBottom()) || (r > getRadiusTop())))
            return NaN_DOUBLE;
 
        // default behavior is to simply return the data value for the first
        // data object. This works for all the Profile classes that only support
        // a single Data object like ProfileConstant, ProfileSurface, and
        // ProfileThin. Profile classes for which the number of supported
        // Data objects is not equal to 1 must override this method.
 
        return getValue(attributeIndex, 0);
    };
 
    virtual double getValueTop(int attributeIndex) const
    {   return data->getDouble(attributeIndex); }
 
    virtual bool isNaN(int nodeIndex, int attributeIndex)
    {
        return nodeIndex != 0 || data->isNaN(attributeIndex);
    }
 
    virtual float                   getRadius(int i) const { return radius; };
 
    virtual int                     getNRadii() const { return 1; };
 
    virtual int                     getNData() const { return 1; };
 
    virtual float*              getRadii()
    { float* fa = new float [1]; fa[0] = radius; return fa; };
 
    virtual GeoTessData**                   getData()
    { GeoTessData** da = new GeoTessData* [1]; da[0] = data; return da; };
 
    virtual GeoTessData*                    getData(int i) { return data; };
 
    virtual const GeoTessData&      getData(int i) const { return *data; };
 
    virtual void                    setData(const vector<GeoTessData*>& inData)
    { delete data; data = inData[0]; }
 
    virtual void                    setRadii(const vector<float>& newRadii)
    { radius = newRadii[0]; }
 
    virtual void setRadius(int index, float newRadius)
    { if (index == 0) radius = newRadius; }
 
    virtual void          setData(int index, GeoTessData* inData)
    { delete data; data = inData; }
 
    virtual float                   getRadiusTop() const { return radius; };
 
    virtual const GeoTessData&      getDataTop() const { return *data; };
 
    virtual GeoTessData*                    getDataTop() { return data; };
 
    virtual float                   getRadiusBottom() const { return radius; };
 
    virtual const GeoTessData&      getDataBottom() const { return *data; };
 
    virtual GeoTessData*                    getDataBottom() { return data; };
 
 
    GeoTessProfileThin(IFStreamBinary& ifs, GeoTessMetaData& gtmd) : GeoTessProfile(),
            radius(-1.0), data(NULL), pointIndex(-1)
    { radius = ifs.readFloat(); data = GeoTessData::getData(ifs, gtmd); };
 
    GeoTessProfileThin(IFStreamAscii& ifs, GeoTessMetaData& gtmd) : GeoTessProfile(),
            radius(-1.0), data(NULL), pointIndex(-1)
    { radius = ifs.readFloat(); data = GeoTessData::getData(ifs, gtmd); };
 
    virtual                             ~GeoTessProfileThin() { if (data != NULL) delete data; };
 
    virtual void                    write(IFStreamBinary& ofs)
    { ofs.writeByte((byte) GeoTessProfileType::THIN.ordinal());
    ofs.writeFloat(radius); data->write(ofs); };
 
    virtual void                    write(IFStreamAscii& ofs)
    { ofs.writeInt(GeoTessProfileType::THIN.ordinal());
    ofs.writeString(" ");
    ofs.writeFloat(radius);
    data->write(ofs);
    ofs.writeNL(); };
 
    virtual int                         findClosestRadiusIndex(double r) const
    {   return 0; }
 
    virtual void                        setPointIndex(int nodeIndex, int pntIndex)
    {   pointIndex = pntIndex; }
 
    virtual void resetPointIndices() { pointIndex = -1; }
 
    virtual int                         getPointIndex(int nodeIndex) const
    {   return pointIndex; }
 
    virtual GeoTessProfile*      copy()
    {
        return new GeoTessProfileThin(radius, data->copy());
    }
 
 
}; // end class ProfileThin
 
} // end namespace geotess
 
#endif  // PROFILETHIN_OBJECT_H