ossimDblGrid Class Reference

#include <ossimDblGrid.h>

Public Types
enum	InterpType { BILINEAR }
enum	DomainType { CONTINUOUS = 0, SAWTOOTH_90 = 1, WRAP_180 = 2, WRAP_360 = 3 }

Public Member Functions
	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)
void	deallocate ()
void	fill (double fill_value)
void	clear ()
void	setNode (const ossimIpt &p, const double &value)
void	setNode (int x, int y, const double &value)
double	getNode (const ossimIpt &p) const
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)
void	setInterpolationType (InterpType interp)
void	setDomainType (DomainType dt)
double	operator() (const ossimDpt &uv_point) const
double	value (const ossimDpt &uv_point) const
double	operator() (const double &u, const double &v) const
double	value (const double &u, const double &v) const
const ossimDblGrid &	operator= (const ossimDblGrid &grid)
double	minValue () const
double	maxValue () const
double	nullValue () const
double	meanValue ()
double	meanStdDev ()
void	setMinValue (double value)
void	setMaxValue (double value)
void	setNullValue (double value)
const ossimIpt &	size () const
const ossimDpt &	origin () const
const ossimDpt &	spacing () const
unsigned long	getSizeInBytes () const
bool	isInside (const ossimDpt &p) const
bool	isInside (const double &u, const double &v) const
bool	save (std::ostream &os, const char *descr) const
bool	load (std::istream &is)

Private Member Functions
void	computeMean ()
double	interpolate (double x, double y) const
	Interpolates given non-integral point x, y. More...
double	extrapolate (double x, double y) const
void	constrain (double &value) const
	Constrains the value to the numerical domain specified in theDomainType. More...
ossim_uint32	index (int x, int y) const

Private Attributes
double *	theGridData
ossimIpt	theSize
ossimDpt	theOrigin
ossimDpt	theSpacing
double	theMinValue
double	theMaxValue
double	theNullValue
double	theMeanValue
double	theDeviation
bool	theMeanIsComputed
bool	theExtrapIsEnabled
DomainType	theDomainType

Friends
std::ostream &	operator<< (std::ostream &os, const ossimDblGrid &grid)

Detailed Description

---

CLASS: ossimDblGrid

Definition at line 44 of file ossimDblGrid.h.

Member Enumeration Documentation

DomainType

enum ossimDblGrid::DomainType

Enumerator
CONTINUOUS
SAWTOOTH_90
WRAP_180
WRAP_360

Definition at line 149 of file ossimDblGrid.h.

   {
      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)
   };

InterpType

enum ossimDblGrid::InterpType

Interpolate between grid nodes given arbitrary u/v coord system:

Enumerator
BILINEAR

Definition at line 143 of file ossimDblGrid.h.

   {
      BILINEAR
   };

Constructor & Destructor Documentation

ossimDblGrid() [1/4]

ossimDblGrid::ossimDblGrid

(

)

Default Constructor.

---

DEFAULT CONSTRUCTOR: ossimDblGrid

Definition at line 40 of file ossimDblGrid.cpp.

:
theGridData       (0),
theSize           (0, 0),
theOrigin         (0.0, 0.0),
theSpacing        (0.0, 0.0),
theMinValue       (OSSIM_DEFAULT_MIN_PIX_DOUBLE),
theMaxValue       (OSSIM_DEFAULT_MAX_PIX_DOUBLE),
theNullValue      (OSSIM_DEFAULT_NULL_PIX_DOUBLE),
theMeanValue      (0.0),
theDeviation      (0.0),
theMeanIsComputed (false),
theExtrapIsEnabled (true),
theDomainType     (CONTINUOUS)
{ }

ossimDblGrid() [2/4]

ossimDblGrid::ossimDblGrid

(

const ossimDblGrid &

source

)

Copy Constructor.

---

COPY CONSTRUCTOR: ossimDblGrid

Allocate mem for the grid, and initialize:

Definition at line 61 of file ossimDblGrid.cpp.

:
theGridData   (0),
theMinValue   (OSSIM_DEFAULT_MIN_PIX_DOUBLE),
theMaxValue   (OSSIM_DEFAULT_MAX_PIX_DOUBLE),
theExtrapIsEnabled (true),
theDomainType (CONTINUOUS)
{
   static const char MODULE[] = "ossimDblGrid Constructor";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";

   *this = source;
   //    int buflen = theSize.x * theSize.y;
   //    theGridData = new double [buflen];

   //    for (int i=0; i<buflen; i++)
   //       theGridData[i] = source.theGridData[i];

   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
}

ossimDblGrid() [3/4]

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

Constructs given a U/V origin and spacing, and a grid size.

---

CONSTRUCTOR: ossimDblGrid

Definition at line 89 of file ossimDblGrid.cpp.

                           :
theGridData   (0),
theMinValue   (OSSIM_DEFAULT_MIN_PIX_DOUBLE),
theMaxValue   (OSSIM_DEFAULT_MAX_PIX_DOUBLE),
theExtrapIsEnabled (true),
theDomainType (CONTINUOUS)
{
   static const char MODULE[] = "ossimDblGrid Constructor";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";

   initialize(size, origin, spacing, null_value);

   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
}

ossimDblGrid() [4/4]

ossimDblGrid::ossimDblGrid	(	const ossimDrect &	rect,
		const ossimDpt &	spacing,
		double	null_value = OSSIM_DEFAULT_NULL_PIX_DOUBLE
	)

Constructs given a rectangle in U/V space and grid spacing. The origin is taken as the upper-left corner of the rectangle. The lower-rightmost grid point may not coincide with the rectangles LR corner if the side is not evenly divisible by the corresponding spacing.

---

CONSTRUCTOR: ossimDblGrid

Definition at line 112 of file ossimDblGrid.cpp.

                           :
theGridData   (0),
theMinValue   (OSSIM_DEFAULT_MIN_PIX_DOUBLE),
theMaxValue   (OSSIM_DEFAULT_MAX_PIX_DOUBLE),
theExtrapIsEnabled (true),
theDomainType (CONTINUOUS)
{
   static const char MODULE[] = "ossimDblGrid Constructor";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";

   ossimIpt size ((int) (rect.width()/spacing.x)  + 1,
      (int) (rect.height()/spacing.y) + 1);

   initialize(size, rect.ul(), spacing, null_value);

   if (traceExec())  ossimNotify(ossimNotifyLevel_WARN) << MODULE << " returning...\n";
}

~ossimDblGrid()

ossimDblGrid::~ossimDblGrid

(

)

Definition at line 137 of file ossimDblGrid.cpp.

References theGridData.

{
   if(theGridData)
   {
      delete [] theGridData;
      theGridData = NULL;
   }
}

Member Function Documentation

clear()

void ossimDblGrid::clear ( )

inline

Fills the current grid with null values.

Definition at line 102 of file ossimDblGrid.h.

{ fill(theNullValue); }

computeMean()

void ossimDblGrid::computeMean ( )

private

---

METHOD: ossimDblGrid::computeMean()

Loop to compute mean:

Loop again to compute deviation:

Definition at line 606 of file ossimDblGrid.cpp.

References theGridData.

{
   static const char MODULE[] = "ossimDblGrid::meanStdDev()";
   if(!theGridData) return;
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << "entering...\n";

   if (!theMeanIsComputed)
   {
      double accum = 0.0;
      double num_samples = 0.0;

      for (int i=0; i<(theSize.x*theSize.y); i++)
      {
         if (theGridData[i] != theNullValue)
         {
            accum += theGridData[i];
            num_samples += 1.0;
         }
      }
      theMeanValue = accum/num_samples;

      accum = 0.0;
      double diff;
      for (int i=0; i<(theSize.x*theSize.y); i++)
      {
         if (theGridData[i] != theNullValue)
         {
            diff = theMeanValue - theGridData[i];
            accum += diff*diff;
         }
      }
      theDeviation = sqrt(accum/num_samples);

      theMeanIsComputed = true;
   }

   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
   return;
}

constrain()

void ossimDblGrid::constrain ( double &  value ) const

private

Constrains the value to the numerical domain specified in theDomainType.

Definition at line 1178 of file ossimDblGrid.cpp.

References CONTINUOUS, theDomainType, theNullValue, value(), WRAP_180, and WRAP_360.

Referenced by extrapolate(), interpolate(), setNearestNode(), and setNode().

{
   if ((theDomainType == CONTINUOUS) || (value == theNullValue))
      return;
      
   // Consider again the domain to verify the value is within allowable range:
   if (theDomainType == WRAP_180) 
   {
      if (value <= -180.0)
         value += 360.0;
      else if (value > 180.0) 
         value -= 360.0;
   }
   else if (theDomainType == WRAP_360)
   {
      if (value < 0.0) 
         value += 360.0;
      else if (value >= 360.0) 
         value -= 360.0;
   }
   //else if (theDomainType == SAWTOOTH_90)
   //{
   //   // Any adjustment here corrupts the data value since it is clipped:
   //   if (value < -90.0) 
   //      value = -90.0;
   //   else if (value > 90.0) 
   //      value = 90.0;
   //}
}

deallocate()

void ossimDblGrid::deallocate

(

)

Definition at line 219 of file ossimDblGrid.cpp.

References theGridData, and theSize.

{
   if(theGridData)
   {
      delete [] theGridData;
      theGridData = 0;
   }
   theSize = ossimIpt(0,0); 
}

enableExtrapolation()

void ossimDblGrid::enableExtrapolation ( bool  arg = true )

inline

Enables/disables extrapolation functionality. If extrapolation is enabled, then calls to operator() will handle points outside of the grid.

Definition at line 91 of file ossimDblGrid.h.

Referenced by ossimH5GridModel::initializeModelParams().

{ theExtrapIsEnabled = arg;}

extrapolate()

double ossimDblGrid::extrapolate ( double  x, double  y  ) const

private

Definition at line 419 of file ossimDblGrid.cpp.

References constrain(), getNode(), interpolate(), theDomainType, theGridData, theNullValue, theSize, WRAP_180, ossimIpt::x, x, ossimIpt::y, and y.

Referenced by operator()().

{
   if(!theGridData) 
      return theNullValue;


   // Decide which extra-grid region contains the input point:
   double dx=0, dy=0, dR_dx=0, dR_dy=0, R0;
   if (y < 0)
   {
      // The point is above the top edge of grid space:
      dy = y;
      if (x < 0)
      {
         // The point is in the top-left region. Use UL corner alone as reference, and compute first
         // and second partials:
         R0 = getNode(0, 0);
         dx = x;
         dR_dx = getNode(1, 0) - R0;
         dR_dy = getNode(0, 1) - R0;
      }
      else if (x <= theSize.x-1)
      {
         // The point directly above the grid, use the dR_dy of the edge pixel:
         R0 = interpolate(x, 0);
         dR_dy = interpolate(x, 1.0) - R0;
      }
      else
      {
         // The point is in the top-right region:
         R0 = getNode(theSize.x - 1, 0);
         dx = x - theSize.x + 1;
         dR_dx = R0 - getNode(theSize.x-2, 0);
         dR_dy = getNode(theSize.x-1, 1) - R0;
      }
   }
   else if (y <= theSize.y-1)
   {
      // The point is either to the left, the right, or inside of the grid:
      if (x < 0)
      {
         // The point is directly to the left of the grid:
         R0 = interpolate(0, y);
         dx = x;
         dR_dx = interpolate(1.0, y) - R0;
      }
      else if (x <= theSize.x-1)
      {
         // The point is inside the grid. This should never happen, but handle just in case:
         return interpolate(x, y);
      }
      else 
      {
         // The point directly to the right of the grid:
         R0 = interpolate((double)theSize.x-1, y);
         dx = x - theSize.x + 1;
         dR_dx = R0 - interpolate((double)theSize.x-2, y);
      }
   }
   else
   {
      // The point is below the bottom edge of grid space:
      dy = y - theSize.y + 1;
      if (x < 0)
      {
         // The point is in the bottom-left region:
         R0 = getNode(0, theSize.y-1);
         dx = x;
         dR_dx = getNode(1, theSize.y-1) - R0;
         dR_dy = R0 - getNode(0, theSize.y-2);
      }
      else if (x < theSize.x-1)
      {
         // The point directly below the grid:
         R0 = interpolate(x, (double)theSize.y-1);
         dR_dy = R0 - interpolate(x, (double)theSize.y-2);
      }
      else
      {
         // The point is in the bottom-right region:
         R0 = getNode(theSize.x - 1, theSize.y-1);
         dx = x - theSize.x + 1;
         dR_dx = R0 - getNode(theSize.x-2, theSize.y-1);
         dR_dy = R0 - getNode(theSize.x-1, theSize.y-2);
      }
   }

   // Consider the numerical domain and adjust potential wrap conditions in the differences:
   if (theDomainType >= WRAP_180)
   {
      if (dR_dx > 180.0) dR_dx -= 360.0;
      else if (dR_dx < -180.0) dR_dx += 360.0;

      if (dR_dy > 180.0) dR_dy -= 360.0;
      else if (dR_dy < -180.0) dR_dy += 360.0;
   }

   double R = R0 + dR_dx*dx + dR_dy*dy;
   constrain(R);
   return R;
}

fill()

void ossimDblGrid::fill

(

double

fill_value

)

Fills the current grid with the value specified.

Definition at line 1161 of file ossimDblGrid.cpp.

References size(), theGridData, theSize, ossimIpt::x, and ossimIpt::y.

Referenced by ossimEnviCgModel::loadEnviGeocFile().

{
   if (!theGridData)
   {
      return;
   }

   int size = theSize.x * theSize.y;
   for (int i=0; i<size; i++)
      theGridData[i] = fill_value;

   return;
}

filter()

void ossimDblGrid::filter	(	int	size_x,
		int	size_y,
		double *	kernel
	)

Passes the grid data through a convolution filter given the kernel array. The grid must not contain any NULL nodes as these are treated as valid quantities. The kernel sizes should be odd numbers. To avoid shrinking the grid by the kernel radius, the edge nodes outside of the filter's reach are computed by extrapolation. X is the contiguous axis in the kernel array, i.e., kernel(x,y) = kernel[y*size_x + x].

Definition at line 1093 of file ossimDblGrid.cpp.

{
   static const char MODULE[] = "ossimDblGrid::filter()";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << "entering...\n";
   if(!theGridData) return;

   int      rx      = (size_x - 1)/2;     // kernel radii
   int      ry      = (size_y - 1)/2;     
   int      start_x = rx;                 // indexes to start sampling grid
   int      start_y = ry;
   int      end_x   = theSize.x - rx;     // indexes to end buffer sampling
   int      end_y   = theSize.y - ry;
   int      knl_ctr = ry*size_x + rx;     // offset to center of kernel buffer
   double   node_value, kernel_value;
   int      resample_node_idx;
   
   // The resampled data is accumulated and stored in a temporary ossimDblGrid object so that we
   // can take advantage of the extrapolation feature later in this method.
   ossimIpt resample_grid_size(end_x-start_x, end_y-start_y);
   ossimDpt resample_grid_origin(start_x, start_y);
   ossimDpt resample_grid_spacing(1,1);
   ossimDblGrid resample_grid(resample_grid_size, resample_grid_origin, resample_grid_spacing);
   resample_grid.enableExtrapolation();
   resample_grid.fill(0.0);

   // Loop over the entire grid to resample all NULL nodes:
   for (int y=start_y; y<end_y; y++)
   {
      for (int x=start_x; x<end_x; x++)
      {
         resample_node_idx = resample_grid.index(x-start_x, y-start_y);
      
         // Fetch samples for each kernel element, apply gain, then accumulate
         // in output buffer:
         for (int ky=-ry; ky<=ry; ky++)
         {
            for (int kx=-rx; kx<=rx; kx++)
            {
               node_value = theGridData[index(x+kx, y+ky)];
               kernel_value = kernel[knl_ctr + ky*size_x + kx];
               resample_grid.theGridData[resample_node_idx] += kernel_value*node_value;
            }
         }
      }
   }
   
   // Copy the resampled data to the original grid.
   // Note: the grid margin has unfiltered data due to the kernel radius. Use the resample_grid's
   // inherent extrapolator to fill in these unfiltered border nodes:
   for (int y=0; y<theSize.y; y++)
   {
      for (int x=0; x<theSize.x; x++)
      {
         theGridData[index(x, y)] = resample_grid(x, y); // automatically extrapolates if necessary
      }
   }

   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
   return;
}

getNode() [1/2]

double ossimDblGrid::getNode ( const ossimIpt &  p ) const

inline

Definition at line 111 of file ossimDblGrid.h.

References getNode(), ossimIpt::x, and ossimIpt::y.

Referenced by ossimHdf5GridModel::crossesDateline(), extrapolate(), getNode(), ossimH5GridModel::initializeModelParams(), ossimCoarseGridModel::initializeModelParams(), operator<<(), ossimCoarseGridModel::print(), and ossimH5GridModel::setGridNodes().

{ return getNode(p.x, p.y); }

getNode() [2/2]

double ossimDblGrid::getNode	(	int	x,
		int	y
	)		const

---

METHOD: ossimDblGrid::getNode(x, y) CONST

This method is used to return the grid data values.

Definition at line 304 of file ossimDblGrid.cpp.

References index(), theGridData, theNullValue, theSize, ossimIpt::x, x, ossimIpt::y, and y.

{
   if(!theGridData) return theNullValue;
   if ((x>=0)&&(x<theSize.x)&&(y>=0)&&(y<theSize.y))
   {
      ossim_uint32 i = index(x, y);
      double val = theGridData[i];
      return val;
   }
   return theNullValue;
}

getSizeInBytes()

unsigned long ossimDblGrid::getSizeInBytes ( ) const

inline

Definition at line 190 of file ossimDblGrid.h.

{ return theSize.x*theSize.y*sizeof(double); }

index()

ossim_uint32 ossimDblGrid::index ( int  x, int  y  ) const

inlineprivate

Definition at line 215 of file ossimDblGrid.h.

References x, and y.

Referenced by getNode(), and setNode().

{ return y*theSize.x + x; }

initialize() [1/2]

void ossimDblGrid::initialize	(	const ossimIpt &	size,
		const ossimDpt &	origin,
		const ossimDpt &	spacing,
		double	null_value = OSSIM_DEFAULT_NULL_PIX_DOUBLE
	)

When constructed with default, permits initialization afterward.

Allocate mem for the grid, and initialize:

Definition at line 152 of file ossimDblGrid.cpp.

Referenced by ossimHdf5GridModel::initialize(), ossimQuadProjection::initializeGrids(), ossimEnviCgModel::loadEnviGeocFile(), ossimTiledElevationDatabase::mapRegion(), and ossimH5GridModel::setGridNodes().

{
   static const char MODULE[] = "ossimDblGrid::initialize()";
   if (traceExec())  ossimNotify(ossimNotifyLevel_WARN) << MODULE << " entering...\n";

   //***
   // Delete any existing grid:
   //***
   if (theGridData)
   {
      delete [] theGridData;
      theGridData = 0;
   }

   //***
   // Initialize data members:
   //***
   theSize           = size;
   theOrigin         = origin;
   theSpacing        = spacing;
   theNullValue      = null_value;
   theMinValue       = OSSIM_DEFAULT_MIN_PIX_DOUBLE;
   theMaxValue       = OSSIM_DEFAULT_MAX_PIX_DOUBLE;
   theMeanIsComputed = false;

   ossim_uint32 buflen = theSize.x * theSize.y;
   if(buflen > 0)
   {
      theGridData = new double [buflen];

      for (ossim_uint32 i=0; i<buflen; i++)
         theGridData[i] = theNullValue;
   }   
   if (traceExec())  ossimNotify(ossimNotifyLevel_WARN) << MODULE << " returning...\n";

   return;
}

initialize() [2/2]

void ossimDblGrid::initialize	(	const ossimDrect &	uv_rect,
		const ossimDpt &	spacing,
		double	null_value = OSSIM_DEFAULT_NULL_PIX_DOUBLE
	)

Definition at line 202 of file ossimDblGrid.cpp.

{
   static const char MODULE[] = "ossimDblGrid::initialize()";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";

   ossimIpt size ((int) (uv_rect.width()/spacing.x)  + 1,
      (int) (uv_rect.height()/spacing.y) + 1);

   initialize(size, uv_rect.ul(), spacing, null_value);

   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
   return;
}

interpolate()

double ossimDblGrid::interpolate ( double  x, double  y  ) const

private

Interpolates given non-integral point x, y.

Definition at line 342 of file ossimDblGrid.cpp.

References constrain(), if(), ossim::nan(), theDomainType, theGridData, theNullValue, theSize, value(), WRAP_180, ossimIpt::x, and ossimIpt::y.

Referenced by extrapolate(), and operator()().

{
   if(!theGridData) 
      return theNullValue;

   // Establish the grid cell origin indices:
   int x0 = (int) xi;
   int y0 = (int) yi;

   // Compute bilinear interpolation weights:
   double wx1 = xi - x0;
   double wy1 = yi - y0;
   double wx0 = 1.0 - wx1;
   double wy0 = 1.0 - wy1;
   double w00 = wx0 * wy0;
   double w01 = wx0 * wy1;
   double w10 = wx1 * wy0;
   double w11 = wx1 * wy1;

   // Establish grid indices for 4 surrounding points:
   int index00  = theSize.x*y0 + x0;
   int index10 = index00;
   int index11 = index00;
   int index01 = index00;

   if (x0 < (theSize.x-1)) index10 = index00 + 1;
   if (y0 < (theSize.y-1)) index01 = index00 + theSize.x;
   if (y0 < (theSize.y-1)) index01 = index00 + theSize.x;
   if (x0 < (theSize.x-1)) index11 = index01 + 1;

   // Safety check:
   int max_idx = theSize.x * theSize.y;
   if ((index00 > max_idx) || (index10 > max_idx) || (index11 > max_idx) || (index01 > max_idx))
      return ossim::nan();

   // Extract the four data points:
   double p00 = theGridData[index00];
   double p01 = theGridData[index01];
   double p10 = theGridData[index10];
   double p11 = theGridData[index11];

   // Consider the numerical domain to catch any wrap condition:
   if (theDomainType >= WRAP_180)
   {
      double dp01_00 = p01 - p00;
      double dp10_00 = p10 - p00;
      double dp11_00 = p11 - p00;

      if (dp01_00 > 180.0)
         p01 -= 360.0;
      else if (dp01_00 < -180.0)
         p01 += 360.0;

      if (dp10_00 > 180.0)
         p10 -= 360.0;
      else if (dp10_00 < -180.0)
         p10 += 360.0;

      if (dp11_00 > 180.0)
         p11 -= 360.0;
      else if (dp11_00 < -180.0)
         p11 += 360.0;
   }

   // Perform interpolation:
   double value = (p00*w00 + p01*w01 + p10*w10 + p11*w11) / (w00 + w01 + w10 + w11);
   constrain(value);

   return value;
}

interpolateNullValuedNodes()

void ossimDblGrid::interpolateNullValuedNodes

(

const double &

decay_rate = 10.0

)

This method performs a resampling of the defined grid nodes in order to compute interpolated values for those uninitialized nodes. This is necessary when only a subset of nodes are available for initializing the grid.

Definition at line 912 of file ossimDblGrid.cpp.

{
   static const char MODULE[] = "ossimDblGrid::interpolateNullValuedNodes()";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";
   if(!theGridData) return;

   //***
   // Allocate buffer to store resampled nodes:
   //***
   int buf_size = theSize.x*theSize.y;

   //---
   // Note: Changed resampled_grid from double* to vector<double> to fix
   // coverity scan uninitialized error. This calls the fill constructor.
   // drb - 20150527
   //---
   std::vector<double> resampled_grid( buf_size, 0.0 );

   double min_weight_needed = 4.0/decay_rate;

   int      start_x, start_y, end_x, end_y;
   int      diameter;
   double   sum_weights;
   double   accumulator;
   double   weight;
   double   sample;
   double   node_value;
   bool     sample_found;
   int      node_idx;
   double   adj_delta;
   int      dx, dy;
   bool     blocked[16];

   //***
   // Loop over the entire grid to resample all NULL nodes:
   //***
   for (int y=0; y<theSize.y; ++y)
   {
      for (int x=0; x<theSize.x; ++x)
      {
         //***
         // Only resample those nodes that contain NULL:
         //***
         node_idx = index(x, y);
         node_value = theGridData[node_idx];
         if (node_value != theNullValue)
         {
            //***
            // This node had a value. Simply copy it into the resample_grid:
            //***
            resampled_grid[node_idx] = node_value;
         }

         else
         {
            //***
            // Resampling is necessary. Initialize quantities used:
            //***
            start_x = x;
            start_y = y;
            diameter = 0;
            sum_weights = 0;
            accumulator = 0;
            weight = 1.0;
            sample_found = true;

            for (int i=0; i<16; i++)
               blocked[i] = false;

            //***
            // Loop collecting contributions from non-null neighbors. Begin with
            // a small kernel size (diameter) and successively grow until a
            // sufficient number of contributors is found:
            //***
            while ((sum_weights < min_weight_needed) && sample_found)
            {
               diameter += 2;
               start_x -= 1;
               start_y -= 1;
               weight *= decay_rate;
               sample_found = false;

               //***
               // Loop over each pixel in kernel and sum in it's contribution:
               //***
               end_y = start_y + diameter;
               end_x = start_x + diameter;

               for (int yn=start_y; yn<=end_y; ++yn)
               {
                  if ((yn == start_y) || (yn == end_y))
                  {
                     //***
                     // This is the top edge or bottom edge, need samples from
                     // each x along kernel edge:
                     //***
                     for (int xn=start_x; xn<=end_x; ++xn)
                     {
                        sample_found = sample_found || isInside(xn, yn);
                        sample = getNode(xn, yn);
                        if (sample != theNullValue)
                        {
                           dx = x - xn; dy = y - yn;
                           if (!isBlocked(blocked, dx, dy))
                           {
                              adj_delta = weight*sqrt((double)(dx*dx + dy*dy));
                              accumulator += sample/adj_delta;
                              sum_weights += 1.0/adj_delta;
                              blockDirection(blocked, dx, dy);
                           }
                        }
                     }
                  }
                  else
                  {
                     //***
                     // For the left/right edge of the kernel, need to sample
                     // only the first (start_x) and last (end_x):
                     //***
                     sample_found = sample_found || isInside(start_x, yn);
                     sample = getNode(start_x, yn);
                     if (sample != theNullValue)
                     {
                        dx = x - start_x; dy = y - yn;
                        if (!isBlocked(blocked, dx, dy))
                        {
                           adj_delta = weight*sqrt((double)(dx*dx + dy*dy));
                           accumulator += sample/adj_delta;
                           sum_weights += 1.0/adj_delta;
                           blockDirection(blocked, dx, dy);
                        }
                     }

                     sample_found = sample_found || isInside(end_x, yn);
                     sample = getNode(end_x, yn);
                     if (sample != theNullValue)
                     {
                        dx = x - end_x; dy = y - yn;
                        if (!isBlocked(blocked, dx, dy))
                        {
                           adj_delta = weight*sqrt((double)(dx*dx + dy*dy));
                           accumulator += sample/adj_delta;
                           sum_weights += 1.0/adj_delta;
                           blockDirection(blocked, dx, dy);
                        }
                     }
                  } // end else
               } // end for loop over all rows in kernel
            } // end while loop inflating kernel size

            //***
            // Finished collecting sample contributions for this node. compute
            // convolution and save in buffer:
            //***
            if (sum_weights != 0)
               resampled_grid[node_idx] = accumulator/sum_weights;
            else
               resampled_grid[node_idx] = theNullValue;

         } // end else (if input node is NULL)
      } // end for loop over all columns in grid
   } // end for loop over all lines in grid

   //***
   // Now copy the resampled grid back into the original buffer:
   //***
   for (node_idx=0; node_idx<buf_size; node_idx++)
      theGridData[node_idx] = resampled_grid[node_idx];

   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
   return;
}

isInside() [1/2]

bool ossimDblGrid::isInside ( const ossimDpt &  p ) const

inline

Returns true if double point lies within world space coverage:

Definition at line 195 of file ossimDblGrid.h.

References isInside(), ossimDpt::u, and ossimDpt::v.

Referenced by isInside().

{return isInside(p.u, p.v);}

isInside() [2/2]

bool ossimDblGrid::isInside	(	const double &	u,
		const double &	v
	)		const

---

INLINE METHOD: ossimDblGrid::isInside(const ossimDpt& pt) const

Definition at line 655 of file ossimDblGrid.cpp.

References theOrigin, theSize, theSpacing, ossimDpt::u, ossimDpt::v, ossimIpt::x, ossimDpt::x, ossimIpt::y, and ossimDpt::y.

{
   double xi = (u - theOrigin.u)/theSpacing.x;
   double yi = (v - theOrigin.v)/theSpacing.y;
   return ((xi >= 0.0) && (xi <= ((double)theSize.x - 1.0)) &&
      (yi >= 0.0) && (yi <= ((double)theSize.y - 1.0)));
   //return ((xi >= 0.0) && (xi < ((double)theSize.x)) &&
   //        (yi >= 0.0) && (yi < ((double)theSize.y)));
}

load()

bool ossimDblGrid::load

(

std::istream &

is

)

Definition at line 736 of file ossimDblGrid.cpp.

{
   static const char MODULE[] = "ossimDblGrid::load()";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";

   ossimString strbuf;

   //***
   // Read magic number tag to insure it is an ossimDblGrid record:
   //***
   getline(is, strbuf);
   if (!strbuf.contains(MAGIC_NUMBER))
   {
      ossimNotify(ossimNotifyLevel_FATAL) << MODULE << "Error reading OSSIM_DBL_GRID magic number from stream. "
         << "Aborting...\n";
      return false;
   }

   theSize           = ossimDpt(0,0);
   theOrigin         = ossimDpt(0,0);
   theSpacing        = ossimDpt(0,0);
   theMinValue       = OSSIM_DEFAULT_MAX_PIX_DOUBLE;
   theMaxValue       =  OSSIM_DEFAULT_MIN_PIX_DOUBLE;
  // theNullValue      = theNullValue;
   theMeanIsComputed = false;

   //***
   // Read the grid size, origin, and spacing:
   //***
   ossimIpt size;
   ossimDpt origin, spacing;
   double null_value;
   getline(is, strbuf);
   vector<ossimString> items =  strbuf.split(" ", true);
   if (items.size() < 7)
   {
      ossimNotify(ossimNotifyLevel_FATAL) << MODULE << "Error reading OSSIM_DBL_GRID parameters. "
         << "Aborting...\n";
      return false;
   }
   size.x = items[0].toInt();
   size.y = items[1].toInt();
   origin.u = items[2].toDouble();
   origin.v = items[3].toDouble();
   spacing.u = items[4].toDouble();
   spacing.v = items[5].toDouble();
   null_value = items[6].toDouble();

   // Check for possible domain type 7th parameter (Added Sep 2016 OLK)
   if ((items.size() > 7))
      theDomainType = (DomainType) items[7].toInt();

   initialize(size, origin, spacing, null_value);

   //***
   // Loop to read grid points:
   //***
   int max_index = theSize.x*theSize.y;
   for (int i=0; i<max_index; i++)
   {
      is >> theGridData[i];
   }
   getline(is, strbuf);

   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";

   return true;
}

maxValue()

double ossimDblGrid::maxValue ( ) const

inline

Definition at line 176 of file ossimDblGrid.h.

Referenced by ossimHdf5GridModel::initialize().

{ return theMaxValue; }

meanStdDev()

double ossimDblGrid::meanStdDev

(

)

---

METHOD: ossimDblGrid::meanStdDev()

Definition at line 590 of file ossimDblGrid.cpp.

{
   static const char MODULE[] = "ossimDblGrid::meanStdDev()";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";

   if (!theMeanIsComputed)
      computeMean();

   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";;
   return theDeviation;
}

meanValue()

double ossimDblGrid::meanValue

(

)

---

METHOD: ossimDblGrid::meanValue()

Definition at line 572 of file ossimDblGrid.cpp.

Referenced by ossimIntensityAdjustmentFilter::getTile().

{
   static const char MODULE[] = "ossimDblGrid::meanValue()";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";

   if (!theMeanIsComputed)
   {
      computeMean();
   }

   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
   return theMeanValue;
}

minValue()

double ossimDblGrid::minValue ( ) const

inline

Statistics methods:

Definition at line 175 of file ossimDblGrid.h.

Referenced by ossimHdf5GridModel::initialize().

{ return theMinValue; }

nullValue()

double ossimDblGrid::nullValue ( ) const

inline

Definition at line 177 of file ossimDblGrid.h.

{ return theNullValue; }

operator()() [1/2]

double ossimDblGrid::operator() ( const ossimDpt &  uv_point ) const

inline

Access an interpolated value in the U/V (output) coordinate system.

Definition at line 161 of file ossimDblGrid.h.

References ossimDpt::u, and ossimDpt::v.

{return (*this)(uv_point.u, uv_point.v);}

operator()() [2/2]

double ossimDblGrid::operator()	(	const double &	u,
		const double &	v
	)		const

---

METHOD: ossimDblGrid::operator(double, double)

This method interpolates between grid points given a fractional location in UV (external) world space.

Definition at line 323 of file ossimDblGrid.cpp.

References extrapolate(), interpolate(), theExtrapIsEnabled, theGridData, theNullValue, theOrigin, theSize, theSpacing, ossimDpt::u, ossimDpt::v, ossimIpt::x, ossimDpt::x, ossimIpt::y, and ossimDpt::y.

{
   if(!theGridData) return theNullValue;

   double xi = (u - theOrigin.u)/theSpacing.x;
   double yi = (v - theOrigin.v)/theSpacing.y;

   if ((xi >= 0.0) && (xi <= (double)theSize.x-1) && (yi >= 0.0) && (yi <= (double)theSize.y-1))
      return interpolate(xi, yi);

   else if (theExtrapIsEnabled)
      return extrapolate(xi, yi);

   return theNullValue;
}

operator=()

const ossimDblGrid & ossimDblGrid::operator=

(

const ossimDblGrid &

grid

)

operator for initializing this grid with another.

Definition at line 525 of file ossimDblGrid.cpp.

References theDeviation, theDomainType, theExtrapIsEnabled, theGridData, theMaxValue, theMeanIsComputed, theMeanValue, theMinValue, theNullValue, theOrigin, theSize, theSpacing, ossimIpt::x, and ossimIpt::y.

{
   if(&source == this) return *this;

   if (theGridData)
   {
      delete [] theGridData;
      theGridData = 0;
   }

   //***
   // Assign data members:
   //***
   theSize           = source.theSize;
   theOrigin         = source.theOrigin;
   theSpacing        = source.theSpacing;
   theMinValue       = source.theMinValue;
   theMaxValue       = source.theMaxValue;
   theNullValue      = source.theNullValue;
   theMeanValue      = source.theMeanValue;
   theDeviation      = source.theDeviation;
   theMeanIsComputed = source.theMeanIsComputed;
   theDomainType     = source.theDomainType;
   theExtrapIsEnabled = source.theExtrapIsEnabled;

   //***
   // Allocate mem for the grid, and initialize:
   //***
   int buflen = theSize.x * theSize.y;
   if(buflen>0)
   {
      theGridData = new double [buflen];

      for (int i=0; i<buflen; i++)
      {
         theGridData[i] = source.theGridData[i];
      }
   }

   return *this;
}

origin()

const ossimDpt& ossimDblGrid::origin ( ) const

inline

Definition at line 188 of file ossimDblGrid.h.

Referenced by ossimHdf5GridModel::initialize().

{ return theOrigin; }

save()

bool ossimDblGrid::save	(	std::ostream &	os,
		const char *	descr
	)		const

Loads and saves the grid from/to a stream. Returns TRUE if successful.

Definition at line 673 of file ossimDblGrid.cpp.

{
   static const char MODULE[] = "ossimDblGrid::save()";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";

   //***
   // Preserve the stream's settings:
   //***
   ios::fmtflags new_options = ios::scientific|ios::dec;
   //ios::streamsize new_precision = 12;
   int new_precision = 12;

   ios::fmtflags old_options = os.flags(new_options);
   int old_precision = os.precision(new_precision);

   //***
   // Verify the description string is not too long:
   //***
   char descr_buf[81];
   std::strncpy(descr_buf, descr, 80);
   descr_buf[80] = '\0';

   //***
   // write magic number tag and the grid size X, Y, num params:
   //***
   os << MAGIC_NUMBER << " " << descr_buf << "\n"
      << theSize.x << "  "
      << theSize.y << "  "
      << theOrigin.u << "  "
      << theOrigin.v << "  "
      << theSpacing.u << "  "
      << theSpacing.v << "  "
      << theNullValue << "  "
      << (int) theDomainType << "\n";

   if(theGridData)
   {
      //***
      // Loop to write grid points:
      //***
      int max_index = theSize.x*theSize.y;
      for (int i=0; i<max_index; i++)
         os << theGridData[i] << "  ";
   }
   os << "\n";

   //***
   // Restore the stream's state:
   //***
   os.flags(old_options);
   os.precision(old_precision);

   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
   return true;
}

setDomainType()

void ossimDblGrid::setDomainType ( DomainType  dt )

inline

Definition at line 156 of file ossimDblGrid.h.

Referenced by ossimHdf5GridModel::crossesDateline(), ossimEnviCgModel::loadEnviGeocFile(), ossimH5GridModel::ossimH5GridModel(), ossimHdf5GridModel::ossimHdf5GridModel(), and ossimH5GridModel::setGridNodes().

{ theDomainType = dt; }

setInterpolationType()

void ossimDblGrid::setInterpolationType

(

InterpType

interp

)

setMaxValue()

void ossimDblGrid::setMaxValue ( double  value )

inline

Definition at line 182 of file ossimDblGrid.h.

{theMaxValue = value;}

setMinValue()

void ossimDblGrid::setMinValue ( double  value )

inline

Definition at line 181 of file ossimDblGrid.h.

{theMinValue = value;}

setNearestNode()

void ossimDblGrid::setNearestNode	(	const ossimDpt &	uv_point,
		const double &	input
	)

Sets the node nearest the U,V point specified to the value given. This is different from setNode() in that the UV coordinate system is used to address a node instead of an XY grid point.

---

METHOD: ossimDblGrid::setNearestNode(uv)

Sets the node nearest the U,V point specified to the value given. This is different from setNode() in that the UV coordinate system is used to address a node instead of an XY grid point.

Definition at line 269 of file ossimDblGrid.cpp.

References constrain(), setNode(), theGridData, theOrigin, theSize, theSpacing, ossimDpt::u, ossimDpt::v, value(), ossimIpt::x, ossimDpt::x, ossimIpt::y, and ossimDpt::y.

Referenced by ossimIntensityAdjustmentFilter::createAndPopulateGrid().

{
   if(!theGridData) return;
   
   // Insure the value passed in is allowed:
   double value = input;
   constrain(value);

   //***
   // Establish the grid indexes:
   //***
   int xi = ossim::round<int>((uv_point.u - theOrigin.u)/theSpacing.x);
   int yi = ossim::round<int>((uv_point.v - theOrigin.v)/theSpacing.y);

   if (xi < 0)
      xi = 0;
   if (xi >= theSize.x)
      xi = theSize.x - 1;
   if (yi < 0)
      yi = 0;
   if (yi >= theSize.y)
      yi = theSize.y - 1;

   setNode (xi, yi, value);

   return;
}

setNode() [1/2]

void ossimDblGrid::setNode ( const ossimIpt &  p, const double &  value  )

inline

Access individual node value by node index in the X/Y (grid) coord system.

Definition at line 107 of file ossimDblGrid.h.

References ossimIpt::x, and ossimIpt::y.

Referenced by ossimTiledElevationDatabase::fillGrid(), ossimQuadProjection::initializeGrids(), ossimEnviCgModel::loadEnviGeocFile(), ossimH5GridModel::setGridNodes(), and setNearestNode().

                                                { setNode(p.x, p.y, value); }

setNode() [2/2]

void ossimDblGrid::setNode	(	int	x,
		int	y,
		const double &	input
	)

---

METHOD: ossimDblGrid::setNode(x, y) NON-CONST

This method is used to assign the grid data values.

Definition at line 235 of file ossimDblGrid.cpp.

References constrain(), index(), theGridData, theMaxValue, theMeanIsComputed, theMinValue, theNullValue, theSize, value(), ossimIpt::x, x, ossimIpt::y, and y.

{
   if(!theGridData) return;

   // Insure the value passed in is allowed:
   double value = input;
   constrain(value);

   if ((x>=0)&&(x<theSize.x)&&(y>=0)&&(y<theSize.y))
   {
      theGridData[index(x, y)] = value;

      if (value != theNullValue)
      {
         if (value < theMinValue)
            theMinValue = value;
         if (value > theMaxValue)
            theMaxValue = value;
      }

      theMeanIsComputed = false;
   }

   return;
}

setNullValue()

void ossimDblGrid::setNullValue ( double  value )

inline

Definition at line 183 of file ossimDblGrid.h.

Referenced by ossimQuadProjection::initializeGrids(), and ossimH5GridModel::setGridNodes().

{theNullValue = value;}

size()

const ossimIpt& ossimDblGrid::size ( ) const

inline

Other member access methods:

Definition at line 187 of file ossimDblGrid.h.

Referenced by ossimHdf5GridModel::crossesDateline(), fill(), ossimHdf5GridModel::initialize(), ossimH5GridModel::initializeModelParams(), ossimCoarseGridModel::initializeModelParams(), and ossimCoarseGridModel::print().

{ return theSize; }

spacing()

const ossimDpt& ossimDblGrid::spacing ( ) const

inline

Definition at line 189 of file ossimDblGrid.h.

Referenced by ossimHdf5GridModel::initialize(), ossimH5GridModel::initializeModelParams(), ossimCoarseGridModel::initializeModelParams(), and ossimCoarseGridModel::print().

{ return theSpacing; }

value() [1/2]

double ossimDblGrid::value ( const ossimDpt &  uv_point ) const

inline

Definition at line 162 of file ossimDblGrid.h.

References ossimDpt::u, and ossimDpt::v.

Referenced by constrain(), interpolate(), setNearestNode(), and setNode().

{return (*this)(uv_point.u, uv_point.v);}

value() [2/2]

double ossimDblGrid::value ( const double &  u, const double &  v  ) const

inline

Definition at line 165 of file ossimDblGrid.h.

{return (*this)(u,v);}

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  os, const ossimDblGrid &  grid  )

friend

Member Data Documentation

theDeviation

double ossimDblGrid::theDeviation

private

Definition at line 225 of file ossimDblGrid.h.

Referenced by operator<<(), and operator=().

theDomainType

DomainType ossimDblGrid::theDomainType

private

Definition at line 228 of file ossimDblGrid.h.

Referenced by constrain(), extrapolate(), interpolate(), and operator=().

theExtrapIsEnabled

bool ossimDblGrid::theExtrapIsEnabled

private

Definition at line 227 of file ossimDblGrid.h.

Referenced by operator()(), and operator=().

theGridData

double* ossimDblGrid::theGridData

private

Definition at line 217 of file ossimDblGrid.h.

Referenced by computeMean(), deallocate(), extrapolate(), fill(), getNode(), interpolate(), operator()(), operator<<(), operator=(), setNearestNode(), setNode(), and ~ossimDblGrid().

theMaxValue

double ossimDblGrid::theMaxValue

private

Definition at line 222 of file ossimDblGrid.h.

Referenced by operator<<(), operator=(), and setNode().

theMeanIsComputed

bool ossimDblGrid::theMeanIsComputed

private

Definition at line 226 of file ossimDblGrid.h.

Referenced by operator<<(), operator=(), and setNode().

theMeanValue

double ossimDblGrid::theMeanValue

private

Definition at line 224 of file ossimDblGrid.h.

Referenced by operator<<(), and operator=().

theMinValue

double ossimDblGrid::theMinValue

private

Definition at line 221 of file ossimDblGrid.h.

Referenced by operator<<(), operator=(), and setNode().

theNullValue

double ossimDblGrid::theNullValue

private

Definition at line 223 of file ossimDblGrid.h.

Referenced by constrain(), extrapolate(), getNode(), interpolate(), operator()(), operator<<(), operator=(), and setNode().

theOrigin

ossimDpt ossimDblGrid::theOrigin

private

Definition at line 219 of file ossimDblGrid.h.

Referenced by isInside(), operator()(), operator<<(), operator=(), and setNearestNode().

theSize

ossimIpt ossimDblGrid::theSize

private

Definition at line 218 of file ossimDblGrid.h.

Referenced by deallocate(), extrapolate(), fill(), getNode(), interpolate(), isInside(), operator()(), operator<<(), operator=(), setNearestNode(), and setNode().

theSpacing

ossimDpt ossimDblGrid::theSpacing

private

Definition at line 220 of file ossimDblGrid.h.

Referenced by isInside(), operator()(), operator<<(), operator=(), and setNearestNode().

---

The documentation for this class was generated from the following files:

• ossimDblGrid.h
• ossimDblGrid.cpp