GeoTessProfileConstant.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 PROFILECONSTANT_OBJECT_H
#define PROFILECONSTANT_OBJECT_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <iostream>
#include <string>
#include <fstream>
 
// 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 GeoTessProfileConstant : virtual public GeoTessProfile
{
  private:
 
        float                                   radiusBottom;
 
        float                                   radiusTop;
 
        GeoTessData*                            data;
 
        int                                     pointIndex;
 
                                                    GeoTessProfileConstant() : GeoTessProfile(), radiusBottom(0.0), radiusTop(0.0),
                                                                                        data(NULL), pointIndex(-1) {};
 
    public:
 
                                                    GeoTessProfileConstant(float radBot, float radTop, GeoTessData* dat) :
                                                                    GeoTessProfile(), radiusBottom(radBot), radiusTop(radTop),
                                                                    data(dat), pointIndex(-1) {};
 
        static  string              class_name() { return "ProfileConstant"; };
 
        virtual int                     class_size() const
                                                    { return (int) sizeof(GeoTessProfileConstant); };
 
        virtual LONG_INT getMemory() { return (LONG_INT)(sizeof(GeoTessProfileConstant) + data->getMemory()); };
 
        virtual const GeoTessProfileType&       getType() const
                                                    { return GeoTessProfileType::CONSTANT; };
 
        virtual bool                    operator == (const GeoTessProfile& p) const
                                                    {   return (GeoTessProfile::operator==(p) &&
                                                                        (radiusBottom == p.getRadiusBottom()) &&
                                                                        (radiusTop == p.getRadiusTop()) &&
                                                                        (*data == p.getData(0)));
                                                    }
 
        virtual float                   getRadius(int i) const
                                                    { return i == 0 ? radiusBottom : radiusTop; };
 
        virtual int                     getNRadii() const { return 2; };
 
        virtual int                     getNData() const { return 1; };
 
        virtual float*              getRadii()
        { float* fa = new float [2]; fa[0] = radiusBottom; fa[1] = radiusTop; 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          setData(int index, GeoTessData* inData)
                                                    { delete data; data = inData; }
 
        virtual double getValue(int attributeIndex, int nodeIndex) const
        { return nodeIndex <= 1 ? data->getDouble(attributeIndex) : NaN_DOUBLE; }
 
        virtual double getValue(const GeoTessInterpolatorType& rInterpType,
                int attributeIndex, double radius, bool allowRadiusOutOfRange) const
        {
            if (!allowRadiusOutOfRange &&
                    ((radius < getRadiusBottom()) || (radius > 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 void                    setRadii(const vector<float>& newRadii)
        { radiusBottom = newRadii[0]; radiusTop = newRadii[1]; }
 
        virtual void setRadius(int index, float radius)
        {
            switch (index)
            {
            case 0:
                radiusBottom = radius;
                break;
            case 1:
                radiusTop = radius;
                break;
            }
        }
 
        virtual float                   getRadiusTop() const { return radiusTop; };
 
        virtual const GeoTessData&      getDataTop() const { return *data; };
 
        virtual GeoTessData*                    getDataTop() { return data; };
 
        virtual float                   getRadiusBottom() const { return radiusBottom; };
 
        virtual const GeoTessData&      getDataBottom() const { return *data; };
 
        virtual GeoTessData*                    getDataBottom() { return data; };
 
 
                                                    GeoTessProfileConstant(IFStreamBinary& ifs, GeoTessMetaData& gtmd) : GeoTessProfile()
                                                    { radiusBottom = ifs.readFloat(); radiusTop = ifs.readFloat();
                                                        data = GeoTessData::getData(ifs, gtmd); };
 
                                                    GeoTessProfileConstant(IFStreamAscii& ifs, GeoTessMetaData& gtmd) : GeoTessProfile()
                                                    { radiusBottom = ifs.readFloat();
                                                        radiusTop = ifs.readFloat();
                                                        data = GeoTessData::getData(ifs, gtmd); };
 
        virtual                             ~GeoTessProfileConstant() { if (data != NULL) delete data; };
 
        virtual void                    write(IFStreamBinary& ofs)
                                                    {
                                                        ofs.writeByte((byte) GeoTessProfileType::CONSTANT.ordinal());
                                                        ofs.writeFloat(radiusBottom);
                                                        ofs.writeFloat(radiusTop);
                                                        data->write(ofs);
                                                    };
 
        virtual void                    write(IFStreamAscii& ofs)
                                                    { ofs.writeInt(GeoTessProfileType::CONSTANT.ordinal());
                                                        ofs.writeString(" ");
                                                        ofs.writeFloat(radiusBottom);
                                                        ofs.writeString(" ");
                                                        ofs.writeFloat(radiusTop);
                                                        data->write(ofs);
                                                        ofs.writeNL();
                                                    };
 
        virtual int                     findClosestRadiusIndex(double radius) const
        {   return abs(radiusTop - radius) < abs(radiusBottom - radius) ? 1 : 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 GeoTessProfileConstant(radiusBottom, radiusTop, data->copy());
        }
 
 
}; // end class ProfileConstant
 
} // end namespace geotess
 
#endif  // PROFILECONSTANT_OBJECT_H