GeoTessProfileSurface.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 PROFILESURFACE_OBJECT_H
#define PROFILESURFACE_OBJECT_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <iostream>
#include <string>
#include <fstream>
 
// use standard library objects
using namespace std;
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "GeoTessUtils.h"
#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 GeoTessProfileSurface: virtual public GeoTessProfile
{
  private:
 
        GeoTessData*                        data;
 
        int                                         pointIndex;
 
                                                        GeoTessProfileSurface() : GeoTessProfile(), data(NULL),
                                                                                             pointIndex(-1) {};
 
    public:
 
                                                        GeoTessProfileSurface(GeoTessData* dat) : GeoTessProfile(), data(dat),
                                                                                                                pointIndex(-1) {};
 
        static  string                  class_name() { return "ProfileSurface"; };
 
        virtual int                         class_size() const
                                                        { return (int) sizeof(GeoTessProfileSurface); };
 
        virtual LONG_INT getMemory()
        { return (LONG_INT)(sizeof(GeoTessProfileSurface) + data->getMemory()); }
 
        virtual const GeoTessProfileType&   getType() const
                                                        { return GeoTessProfileType::SURFACE; };
 
        virtual bool                        operator == (const GeoTessProfile& p) const
                                                        {   return (GeoTessProfile::operator==(p) &&
                                                                (*data == p.getData(0)));
                                                        }
 
        virtual double getValue(int attributeIndex, int nodeIndex) const
        {
            return nodeIndex == 0 ? data->getDouble(attributeIndex) : NaN_DOUBLE;
        }
 
        virtual double getValueTop(int attributeIndex) const
        {   return data->getDouble(attributeIndex); }
 
        virtual bool isNaN(int nodeIndex, int attributeIndex)
        {
            return nodeIndex != 0 || data->isNaN(attributeIndex);
        }
 
        virtual double                  getValue(const GeoTessInterpolatorType& rInterpType,
                                                                         int attributeIndex, double radius,
                                                                         bool allowRadiusOutOfRange) const
        {
            return getData(0).getDouble(attributeIndex);
        }
 
        virtual float                       getRadius(int i) const
                                                        { return NaN_FLOAT; };
 
        virtual int                         getNRadii() const { return 0; };
 
        virtual int                         getNData() const { return 1; };
 
        virtual float*                  getRadii() { return NULL; };
 
        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; }
 
        // TODO: added by sb 9/27/2012
        virtual void                    setRadii(const vector<float>& newRadii)
        { /* do nothing */ };
 
        virtual void setRadius(int index, float radius)
        {  /* do nothing */  }
 
        virtual float                       getRadiusTop() const
                                                        { return NaN_FLOAT; };
 
        virtual const GeoTessData&          getDataTop() const { return *data; };
 
        virtual GeoTessData*                        getDataTop() { return data; };
 
        virtual float                       getRadiusBottom() const
                                                        { return NaN_FLOAT; };
 
        virtual const GeoTessData&          getDataBottom() const { return *data; };
 
        virtual GeoTessData*                        getDataBottom() { return data; };
 
 
                                                        GeoTessProfileSurface(IFStreamBinary& ifs, GeoTessMetaData& gtmd) : GeoTessProfile(),
                                                                                     data(NULL), pointIndex(-1)
                                                        { data = GeoTessData::getData(ifs, gtmd); };
 
                                                        GeoTessProfileSurface(IFStreamAscii& ifs, GeoTessMetaData& gtmd) : GeoTessProfile(),
                                                                                     data(NULL), pointIndex(-1)
                                                        { data = GeoTessData::getData(ifs, gtmd); };
 
        virtual                                 ~GeoTessProfileSurface() { if (data != NULL) delete data; };
 
        virtual void                        write(IFStreamBinary& ofs)
                                                        { ofs.writeByte((byte) GeoTessProfileType::SURFACE.ordinal());
                                                            data->write(ofs); };
 
        virtual void                        write(IFStreamAscii& ofs)
                                                        { ofs.writeInt(GeoTessProfileType::SURFACE.ordinal());
                                                            data->write(ofs);
                                                            ofs.writeNL(); };
 
        // *** TODO added 7/20/2012
        virtual int                         findClosestRadiusIndex(double radius) const
                                                        {   return -1; }
 
        // *** TODO added 7/20/2012
        virtual void                        setPointIndex(int nodeIndex, int pntIndex)
                                                        {   pointIndex = pntIndex; }
 
        // *** TODO added 10/14/2012
        virtual void resetPointIndices() { pointIndex = -1; }
 
        // *** TODO added 7/20/2012
        virtual int                         getPointIndex(int nodeIndex) const
                                                        {   return pointIndex; }
 
        // *** TODO added 8/20/2012
        virtual GeoTessProfile*      copy()
        {
            return new GeoTessProfileSurface(data->copy());
        }
 
 
}; // end class ProfileSurface
 
} // end namespace geotess
 
#endif  // PROFILESURFACE_OBJECT_H