ossimDblGrid.h

Go to the documentation of this file.

//*****************************************************************************
//                                   O S S I M
//
// FILE: ossimDblGrid.h
//
// License:  See top level LICENSE.txt file.
//
// AUTHOR:  Oscar Kramer
//
// DESCRIPTION:
//   Contains declaration of class ossimDblGrid. This object class maintains
//   a regular grid of floating point (double) values. Access methods to the
//   grid include interpolation between grid nodes. Capability is included
//   to address the grid in an arbitrary, floating-point u, v coordinate
//   system which is related to the integer grid x, y system by scale and
//   offset:
//
//          u = Sx*(x + Xo),   v = Sy*(y + Y0)
//
//   where Xo, Yo is the origin of the U/V cood system. Sx, Sy are the scale
//   relations. For example, if the grid is being used to hold a grid of
//   elevation posts, then the origin will be the SW corner post ground point,
//   and the scale will be derived from the post spacing. Both origin and
//   spacing are specified to the constructor.
//
//*****************************************************************************
//  $Id: ossimDblGrid.h 20044 2011-09-06 15:02:43Z oscarkramer $

#ifndef ossimDblGrid_HEADER
#define ossimDblGrid_HEADER

#include <ossim/base/ossimDpt.h>
#include <ossim/base/ossimIpt.h>
#include <ossim/base/ossimDrect.h>
#include <ossim/base/ossimCommon.h>

class ossimDrect;

/*!****************************************************************************
 *
 * CLASS:  ossimDblGrid
 *
 *****************************************************************************/
class OSSIMDLLEXPORT ossimDblGrid 
{
public:
   ossimDblGrid ();

   ossimDblGrid (const ossimDblGrid& source_to_copy);

   ossimDblGrid (const ossimIpt&  size, 
                 const ossimDpt&  origin,
                 const ossimDpt&  spacing,
                 double null_value = OSSIM_DEFAULT_NULL_PIX_DOUBLE);

   ossimDblGrid (const ossimDrect&  uv_rect, 
                 const ossimDpt&    spacing,
                 double null_value = OSSIM_DEFAULT_NULL_PIX_DOUBLE);

   ~ossimDblGrid ();

   void         initialize(const ossimIpt&  size, 
                           const ossimDpt&  origin,
                           const ossimDpt&  spacing,
                           double null_value = OSSIM_DEFAULT_NULL_PIX_DOUBLE );
   void         initialize(const ossimDrect&  uv_rect, 
                           const ossimDpt&    spacing,
                           double null_value = OSSIM_DEFAULT_NULL_PIX_DOUBLE);
   void enableExtrapolation(bool arg=true) { theExtrapIsEnabled = arg;}

   void deallocate();
   void         fill(double fill_value);

   void         clear() { fill(theNullValue); }
   
   void         setNode (const ossimIpt& p,
                         const double& value)   { setNode(p.x, p.y, value); }
   void         setNode (int x, int y, const double&  value);

   double       getNode (const ossimIpt& p) const { return getNode(p.x, p.y); }
   double       getNode (int x, int y) const;

   void         setNearestNode(const ossimDpt& uv_point,
                               const double&   value);
   
   void interpolateNullValuedNodes(const double& decay_rate=10.0);

   void filter(int size_x, int size_y, double* kernel);
   
   enum InterpType
   {
      BILINEAR
   };
   void  setInterpolationType (InterpType interp);

   enum DomainType
   {
      CONTINUOUS = 0, // Default continuous grid with no limits on values
      SAWTOOTH_90= 1, // For angles between -90 and 90 deg such as latitude
      WRAP_180   = 2, // For angles between -180 and 180 with discontinuity at limits (typically used for longitude)
      WRAP_360   = 3  // For angles between 0 and 360 with discontinuity at limits (typically used for rotations)
   };
   void setDomainType(DomainType dt) { theDomainType = dt; }

   double operator() (const ossimDpt& uv_point) const {return (*this)(uv_point.u, uv_point.v);}
   double value      (const ossimDpt& uv_point) const {return (*this)(uv_point.u, uv_point.v);}

   double operator() (const double& u, const double& v) const;
   double value (const double& u, const double& v) const {return (*this)(u,v);}

   const ossimDblGrid& operator = (const ossimDblGrid& grid);
   
   double minValue()   const { return theMinValue; }
   double maxValue()   const { return theMaxValue; }
   double nullValue()  const { return theNullValue; }
   double meanValue();
   double meanStdDev();

   void setMinValue(double value) {theMinValue = value;}
   void setMaxValue(double value) {theMaxValue = value;}
   void setNullValue(double value) {theNullValue = value;}
   const ossimIpt& size()    const { return theSize; }
   const ossimDpt& origin()  const { return theOrigin; }
   const ossimDpt& spacing() const { return theSpacing; }
   unsigned long   getSizeInBytes() const { return theSize.x*theSize.y*sizeof(double); }
   
   bool  isInside(const ossimDpt& p) const {return isInside(p.u, p.v);}
   bool  isInside(const double& u, const double& v) const;

   bool  save(std::ostream& os, const char* descr) const;
   bool  load(std::istream& is);
   
   friend std::ostream& operator << (std::ostream& os, const ossimDblGrid& grid);
   
private:
   
   void  computeMean();
   double interpolate(double x, double y) const;
   double extrapolate(double x, double y) const;

   void constrain(double& value) const;

   ossim_uint32   index(int x, int y) const { return y*theSize.x + x; }
   
   double*      theGridData;
   ossimIpt     theSize;
   ossimDpt     theOrigin;
   ossimDpt     theSpacing;
   double       theMinValue;
   double       theMaxValue;
   double       theNullValue;
   double       theMeanValue;
   double       theDeviation;
   bool         theMeanIsComputed;
   bool         theExtrapIsEnabled;
   DomainType   theDomainType;
   
};

#endif