ossimDiscreteConvolutionKernel Class Reference

#include <ossimDiscreteConvolutionKernel.h>

Inheritance diagram for ossimDiscreteConvolutionKernel:

Public Member Functions
	ossimDiscreteConvolutionKernel (long width, long height, bool doWeightedAverage=true)
	ossimDiscreteConvolutionKernel (const NEWMAT::Matrix &kernel, bool doWeightedAverage=true)
virtual	~ossimDiscreteConvolutionKernel ()
virtual void	setKernel (const NEWMAT::Matrix &kernel)
virtual void	convolve (const float *data, double &result, float nullPixel=OSSIM_DEFAULT_NULL_PIX_FLOAT) const
virtual void	convolveSubImage (const float *data, long dataWidth, double &result, float nullPixel=OSSIM_DEFAULT_NULL_PIX_FLOAT) const
virtual void	convolve (const double *data, double &result, double nullPixel=OSSIM_DEFAULT_NULL_PIX_DOUBLE) const
virtual void	convolveSubImage (const double *data, long dataWidth, double &result, double nullPixel=OSSIM_DEFAULT_NULL_PIX_DOUBLE) const
virtual void	convolve (const short *data, double &result, ossim_sint16 nullPixel=OSSIM_DEFAULT_NULL_PIX_SINT16) const
virtual void	convolveSubImage (const short *data, long dataWidth, double &result, ossim_sint16 nullPixel=OSSIM_DEFAULT_NULL_PIX_SINT16) const
virtual void	convolve (const unsigned short *data, double &result, ossim_uint16 nullPixel=OSSIM_DEFAULT_NULL_PIX_UINT16) const
virtual void	convolveSubImage (const unsigned short *data, long dataWidth, double &result, ossim_uint16 nullPixel=OSSIM_DEFAULT_NULL_PIX_UINT16) const
virtual void	convolve (const unsigned char *data, double &result, ossim_uint8 nullPixel=OSSIM_DEFAULT_NULL_PIX_UINT8) const
virtual void	convolveSubImage (const unsigned char *data, long dataWidth, double &result, ossim_uint8 nullPixel=OSSIM_DEFAULT_NULL_PIX_UINT8) const
virtual void	buildConvolution (double, double)
virtual long	getWidth () const
virtual long	getHeight () const
const NEWMAT::Matrix &	getKernel () const

Static Public Member Functions
static void	buildSymmetric (const std::vector< float > &coefficients, NEWMAT::Matrix &result)
static void	buildSymmetric (float *coefficients, long size, NEWMAT::Matrix &result)

Protected Attributes
NEWMAT::Matrix *	theKernel
long	theWidth
long	theHeight
bool	theComputeWeightedAverageFlag

Detailed Description

Definition at line 19 of file ossimDiscreteConvolutionKernel.h.

Constructor & Destructor Documentation

ossimDiscreteConvolutionKernel() [1/2]

ossimDiscreteConvolutionKernel::ossimDiscreteConvolutionKernel	(	long	width,
		long	height,
		bool	doWeightedAverage = true
	)

Definition at line 12 of file ossimDiscreteConvolutionKernel.cpp.

References theHeight, theKernel, and theWidth.

   : theKernel(0),
     theWidth(width),
     theHeight(height),
     theComputeWeightedAverageFlag(doWeightedAverage)
{
   theWidth  = theWidth <0?1:theWidth;
   theHeight = theHeight <0?1:theHeight;
   
   theKernel = new NEWMAT::Matrix(theHeight, theWidth);
   *theKernel = (1.0/(theHeight*theWidth));
}

ossimDiscreteConvolutionKernel() [2/2]

ossimDiscreteConvolutionKernel::ossimDiscreteConvolutionKernel	(	const NEWMAT::Matrix &	kernel,
		bool	doWeightedAverage = true
	)

Definition at line 27 of file ossimDiscreteConvolutionKernel.cpp.

References theHeight, theKernel, and theWidth.

   :theKernel(new NEWMAT::Matrix(kernel)),
   theComputeWeightedAverageFlag(doWeightedAverage)
{
   theWidth  = theKernel->Ncols();
   theHeight = theKernel->Nrows();
}

~ossimDiscreteConvolutionKernel()

ossimDiscreteConvolutionKernel::~ossimDiscreteConvolutionKernel ( )

virtual

Definition at line 36 of file ossimDiscreteConvolutionKernel.cpp.

References theKernel.

{
   if(theKernel)
   {
      delete theKernel;
      theKernel = 0;
   }
}

Member Function Documentation

buildConvolution()

virtual void ossimDiscreteConvolutionKernel::buildConvolution ( double  , double    )

inlinevirtual

This is used to allow me to continually adjust a convolution kernel based on where it center lies on a pixel. The xLocation and yLocation are all from the center of pixel. If I am convolving at full resolution then xLocation and yLocation should both be 0. Let's pretend that we contract an image by .5 scale factor or zooming out by a factor of 2. Then we actually of it .5 off from cneter of pixel in both the x and y direction. This information can be used to allow a kernel to adjust it's waits accordingly.

Typically if the xLocation and yLocation is directly on the center indicated by 0 vor both then the kernel defaults to 1 in the middle and all other weights are zero.

Reimplemented in ossimDiscreteNearestNeighbor, and ossimDiscrete3x3HatFilter.

Definition at line 113 of file ossimDiscreteConvolutionKernel.h.

      {}

buildSymmetric() [1/2]

void ossimDiscreteConvolutionKernel::buildSymmetric ( const std::vector< float > &  coefficients, NEWMAT::Matrix &  result  )

static

Definition at line 45 of file ossimDiscreteConvolutionKernel.cpp.

References size.

{
   ossim_uint32 size = (ossim_uint32)coefficients.size();
   if(size > 0)
   {

      NEWMAT::RowVector row(size);
      NEWMAT::ColumnVector col(size);
      for(ossim_uint32 index = 0; index < size; ++index)
      {
         row[index] = coefficients[index];
         col[index] = coefficients[index];
      }
      result = col*row;
   }
}

buildSymmetric() [2/2]

void ossimDiscreteConvolutionKernel::buildSymmetric ( float *  coefficients, long  size, NEWMAT::Matrix &  result  )

static

Definition at line 63 of file ossimDiscreteConvolutionKernel.cpp.

References size.

{
   if(size > 0)
   {
      NEWMAT::RowVector    row(size);
      NEWMAT::ColumnVector col(size);
      for(long index = 0; index < size; ++index)
      {
         row[index] = coefficients[index];
         col[index] = coefficients[index];
      }
      result = col*row;
   }
}

convolve() [1/5]

void ossimDiscreteConvolutionKernel::convolve ( const float *  data, double &  result, float  nullPixel = OSSIM_DEFAULT_NULL_PIX_FLOAT  ) const

virtual

Will expect a data buffer of size width*height and is row ordered.

Reimplemented in ossimDiscrete3x3HatFilter.

Definition at line 91 of file ossimDiscreteConvolutionKernel.cpp.

References theComputeWeightedAverageFlag, theHeight, and theWidth.

{
   result = 0;

   if(theComputeWeightedAverageFlag)
   {
      double divisor = 0.0;
      for(long row=0; row < theHeight; ++row)
      {
         for(long col=0; col < theWidth; ++col)
         {
            if(*data != nullPixel)
            {
               divisor += (*theKernel)[row][col];
               result  += ((*theKernel)[row][col] * (*data));
            }
            ++data;
         }
      }
      if(divisor > 0)
      {
         result /= divisor;
      }
   }
   else
   {
      for(long row=0; row < theHeight; ++row)
      {
         for(long col=0; col < theWidth; ++col)
         {
            if(*data != nullPixel)
            {
               result  += ((*theKernel)[row][col] * (*data));
            }
            ++data;
         }
      }
   }
}

convolve() [2/5]

void ossimDiscreteConvolutionKernel::convolve ( const double *  data, double &  result, double  nullPixel = OSSIM_DEFAULT_NULL_PIX_DOUBLE  ) const

virtual

Will expect a data buffer of size width*height and is row ordered.

Definition at line 453 of file ossimDiscreteConvolutionKernel.cpp.

References theComputeWeightedAverageFlag, theHeight, and theWidth.

{
   result = 0;

   if(theComputeWeightedAverageFlag)
   {
      double divisor = 0.0;
      for(long row=0; row < theHeight; ++row)
      {
         for(long col=0; col < theWidth; ++col)
         {
            if(*data != nullPixel)
            {
               divisor += (*theKernel)[row][col];
               result  += ((*theKernel)[row][col] * (*data));
            }
            ++data;
         }
      }
      if(divisor > 0)
      {
         result /= divisor;
      }
   }
   else
   {
      for(long row=0; row < theHeight; ++row)
      {
         for(long col=0; col < theWidth; ++col)
         {
            if(*data != nullPixel)
            {
               result  += ((*theKernel)[row][col] * (*data));
            }
            ++data;
         }
      }
   }
}

convolve() [3/5]

void ossimDiscreteConvolutionKernel::convolve ( const short *  data, double &  result, ossim_sint16  nullPixel = OSSIM_DEFAULT_NULL_PIX_SINT16  ) const

virtual

Will expect a data buffer of size width*height and is row ordered.

Definition at line 362 of file ossimDiscreteConvolutionKernel.cpp.

References theComputeWeightedAverageFlag, theHeight, and theWidth.

{
   result = 0;

   if(theComputeWeightedAverageFlag)
   {
      double divisor = 0.0;
      for(long row=0; row < theHeight; ++row)
      {
         for(long col=0; col < theWidth; ++col)
         {
            if(*data != nullPixel)
            {
               divisor += (*theKernel)[row][col];
               result  += ((*theKernel)[row][col] * (*data));
            }
            ++data;
         }
      }
      if(divisor > 0)
      {
         result /= divisor;
      }
   }
   else
   {
      for(long row=0; row < theHeight; ++row)
      {
         for(long col=0; col < theWidth; ++col)
         {
            if(*data != nullPixel)
            {
               result  += ((*theKernel)[row][col] * (*data));
            }
            ++data;
         }
      }
   }
}

convolve() [4/5]

void ossimDiscreteConvolutionKernel::convolve ( const unsigned short *  data, double &  result, ossim_uint16  nullPixel = OSSIM_DEFAULT_NULL_PIX_UINT16  ) const

virtual

Will expect a data buffer of size width*height and is row ordered.

Definition at line 272 of file ossimDiscreteConvolutionKernel.cpp.

References theComputeWeightedAverageFlag, theHeight, and theWidth.

{
   result = 0;

   if(theComputeWeightedAverageFlag)
   {
      double divisor = 0.0;
      for(long row=0; row < theHeight; ++row)
      {
         for(long col=0; col < theWidth; ++col)
         {
            if(*data != nullPixel)
            {
               divisor += (*theKernel)[row][col];
               result  += ((*theKernel)[row][col] * (*data));
            }
            ++data;
         }
      }
      if(divisor > 0)
      {
         result /= divisor;
      }
   }
   else
   {
      for(long row=0; row < theHeight; ++row)
      {
         for(long col=0; col < theWidth; ++col)
         {
            if(*data != nullPixel)
            {
               result  += ((*theKernel)[row][col] * (*data));
            }
            ++data;
         }
      }
   }
}

convolve() [5/5]

void ossimDiscreteConvolutionKernel::convolve ( const unsigned char *  data, double &  result, ossim_uint8  nullPixel = OSSIM_DEFAULT_NULL_PIX_UINT8  ) const

virtual

Reimplemented in ossimDiscrete3x3HatFilter.

Definition at line 181 of file ossimDiscreteConvolutionKernel.cpp.

References theComputeWeightedAverageFlag, theHeight, and theWidth.

{
   result = 0;

   if(theComputeWeightedAverageFlag)
   {
      double divisor = 0.0;
      for(long row=0; row < theHeight; ++row)
      {
         for(long col=0; col < theWidth; ++col)
         {
            if(*data != nullPixel)
            {
               divisor += (*theKernel)[row][col];
               result  += ((*theKernel)[row][col] * (*data));
            }
            ++data;
         }
      }
      if(divisor > 0)
      {
         result /= divisor;
      }
   }
   else
   {
      for(long row=0; row < theHeight; ++row)
      {
         for(long col=0; col < theWidth; ++col)
         {
            if(*data != nullPixel)
            {
               result  += ((*theKernel)[row][col] * (*data));
            }
            ++data;
         }
      }
   }
}

convolveSubImage() [1/5]

void ossimDiscreteConvolutionKernel::convolveSubImage ( const float *  data, long  dataWidth, double &  result, float  nullPixel = OSSIM_DEFAULT_NULL_PIX_FLOAT  ) const

virtual

Reimplemented in ossimDiscrete3x3HatFilter.

Definition at line 133 of file ossimDiscreteConvolutionKernel.cpp.

References theComputeWeightedAverageFlag, theHeight, and theWidth.

Referenced by ossimConvolutionSource::convolve(), and ossimTilePatch::fillTileTemplate().

{
   const float* dataStart = 0;
   result = 0;
   
   if(theComputeWeightedAverageFlag)
   {
      double divisor = 0.0;
      for(long row=0; row < theHeight; ++row)
      {
         dataStart=data;
         for(long col=0; col < theWidth; ++col)
         {
            if(*dataStart != nullPixel)
            {
               divisor += (*theKernel)[row][col];
               result  += ((*theKernel)[row][col] * (*dataStart));
            }
            ++dataStart;
         }
         data+=dataWidth;
      }
      if(divisor > 0)
      {
         result /= divisor;
      }
   }
   else
   {
      for(long row=0; row < theHeight; ++row)
      {
         dataStart=data;
         for(long col=0; col < theWidth; ++col)
         {
            if(*dataStart != nullPixel)
            {
               result  += ((*theKernel)[row][col] * (*dataStart));
            }
            ++dataStart;
         }
         data+=dataWidth;
      }
   }
}

convolveSubImage() [2/5]

void ossimDiscreteConvolutionKernel::convolveSubImage ( const double *  data, long  dataWidth, double &  result, double  nullPixel = OSSIM_DEFAULT_NULL_PIX_DOUBLE  ) const

virtual

Definition at line 495 of file ossimDiscreteConvolutionKernel.cpp.

References theComputeWeightedAverageFlag, theHeight, and theWidth.

{
   const double* dataStart = 0;
   result = 0;
   
   if(theComputeWeightedAverageFlag)
   {
      double divisor = 0.0;
      for(long row=0; row < theHeight; ++row)
      {
         dataStart=data;
         for(long col=0; col < theWidth; ++col)
         {
            if(*dataStart != nullPixel)
            {
               divisor += (*theKernel)[row][col];
               result  += ((*theKernel)[row][col] * (*dataStart));
            }
            ++dataStart;
         }
         data+=dataWidth;
      }
      if(divisor > 0)
      {
         result /= divisor;
      }
   }
   else
   {
      for(long row=0; row < theHeight; ++row)
      {
         dataStart=data;
         for(long col=0; col < theWidth; ++col)
         {
            if(*dataStart != nullPixel)
            {
               result  += ((*theKernel)[row][col] * (*dataStart));
            }
            ++dataStart;
         }
         data+=dataWidth;
      }
   }
}

convolveSubImage() [3/5]

void ossimDiscreteConvolutionKernel::convolveSubImage ( const short *  data, long  dataWidth, double &  result, ossim_sint16  nullPixel = OSSIM_DEFAULT_NULL_PIX_SINT16  ) const

virtual

Definition at line 404 of file ossimDiscreteConvolutionKernel.cpp.

References theComputeWeightedAverageFlag, theHeight, and theWidth.

{
   const ossim_sint16* dataStart = 0;
   result = 0;
   
   if(theComputeWeightedAverageFlag)
   {
      double divisor = 0.0;
      for(long row=0; row < theHeight; ++row)
      {
         dataStart=data;
         for(long col=0; col < theWidth; ++col)
         {
            if(*dataStart != nullPixel)
            {
               divisor += (*theKernel)[row][col];
               result  += ((*theKernel)[row][col] * (*dataStart));
            }
            ++dataStart;
         }
         data+=dataWidth;
      }
      if(divisor > 0)
      {
         result /= divisor;
      }
   }
   else
   {
      for(long row=0; row < theHeight; ++row)
      {
         dataStart=data;
         for(long col=0; col < theWidth; ++col)
         {
            if(*dataStart != nullPixel)
            {
               result  += ((*theKernel)[row][col] * (*dataStart));
            }
            ++dataStart;
         }
         data+=dataWidth;
      }
   }
}

convolveSubImage() [4/5]

void ossimDiscreteConvolutionKernel::convolveSubImage ( const unsigned short *  data, long  dataWidth, double &  result, ossim_uint16  nullPixel = OSSIM_DEFAULT_NULL_PIX_UINT16  ) const

virtual

Definition at line 314 of file ossimDiscreteConvolutionKernel.cpp.

References theComputeWeightedAverageFlag, theHeight, and theWidth.

{
   const ossim_uint16* dataStart = 0;
   result = 0;
   
   if(theComputeWeightedAverageFlag)
   {
      double divisor = 0.0;
      for(long row=0; row < theHeight; ++row)
      {
         dataStart=data;
         for(long col=0; col < theWidth; ++col)
         {
            if(*dataStart != nullPixel)
            {
               divisor += (*theKernel)[row][col];
               result  += ((*theKernel)[row][col] * (*dataStart));
            }
            ++dataStart;
         }
         data+=dataWidth;
      }
      if(divisor > 0)
      {
         result /= divisor;
      }
   }
   else
   {
      for(long row=0; row < theHeight; ++row)
      {
         dataStart=data;
         for(long col=0; col < theWidth; ++col)
         {
            if(*dataStart != nullPixel)
            {
               result  += ((*theKernel)[row][col] * (*dataStart));
            }
            ++dataStart;
         }
         data+=dataWidth;
      }
   }
}

convolveSubImage() [5/5]

void ossimDiscreteConvolutionKernel::convolveSubImage ( const unsigned char *  data, long  dataWidth, double &  result, ossim_uint8  nullPixel = OSSIM_DEFAULT_NULL_PIX_UINT8  ) const

virtual

this allows you to pass a subImage to the convolution engine. It needs to know the width of the buffer so it can increment to the next element.

Reimplemented in ossimDiscrete3x3HatFilter.

Definition at line 223 of file ossimDiscreteConvolutionKernel.cpp.

References theComputeWeightedAverageFlag, theHeight, and theWidth.

{
   const ossim_uint8* dataStart = 0;
   result = 0;
   
   if(theComputeWeightedAverageFlag)
   {
      double divisor = 0.0;
      for(long row=0; row < theHeight; ++row)
      {
         dataStart=data;
         for(long col=0; col < theWidth; ++col)
         {
            if(*dataStart != nullPixel)
            {
               divisor += (*theKernel)[row][col];
               result  += ((*theKernel)[row][col] * (*dataStart));
            }
            ++dataStart;
         }
         data+=dataWidth;
      }
      if(divisor > 0)
      {
         result /= divisor;
      }
   }
   else
   {
      for(long row=0; row < theHeight; ++row)
      {
         dataStart=data;
         for(long col=0; col < theWidth; ++col)
         {
            if(*dataStart != nullPixel)
            {
               result  += ((*theKernel)[row][col] * (*dataStart));
            }
            ++dataStart;
         }
         data+=dataWidth;
      }
   }
}

getHeight()

virtual long ossimDiscreteConvolutionKernel::getHeight ( ) const

inlinevirtual

Definition at line 120 of file ossimDiscreteConvolutionKernel.h.

References theHeight.

Referenced by ossimConvolutionSource::convolve(), ossimTilePatch::convolve(), and ossimTilePatch::fillTileTemplate().

      {
         return theHeight;
      }

getKernel()

const NEWMAT::Matrix& ossimDiscreteConvolutionKernel::getKernel ( ) const

inline

Definition at line 124 of file ossimDiscreteConvolutionKernel.h.

References theKernel.

      {
         return *theKernel;
      }

getWidth()

virtual long ossimDiscreteConvolutionKernel::getWidth ( ) const

inlinevirtual

Definition at line 116 of file ossimDiscreteConvolutionKernel.h.

References theWidth.

Referenced by ossimConvolutionSource::convolve(), ossimTilePatch::convolve(), and ossimTilePatch::fillTileTemplate().

      {
         return theWidth;
      }

setKernel()

void ossimDiscreteConvolutionKernel::setKernel ( const NEWMAT::Matrix &  kernel )

virtual

Definition at line 80 of file ossimDiscreteConvolutionKernel.cpp.

References theHeight, theKernel, and theWidth.

{
   if(theKernel)
   {
      theKernel = new NEWMAT::Matrix;
   }
   *theKernel = kernel;
   theWidth  = theKernel->Ncols();
   theHeight = theKernel->Nrows();   
}

Member Data Documentation

theComputeWeightedAverageFlag

bool ossimDiscreteConvolutionKernel::theComputeWeightedAverageFlag

protected

Definition at line 132 of file ossimDiscreteConvolutionKernel.h.

Referenced by convolve(), and convolveSubImage().

theHeight

long ossimDiscreteConvolutionKernel::theHeight

protected

Definition at line 131 of file ossimDiscreteConvolutionKernel.h.

Referenced by convolve(), convolveSubImage(), getHeight(), ossimDiscreteConvolutionKernel(), and setKernel().

theKernel

NEWMAT::Matrix* ossimDiscreteConvolutionKernel::theKernel

protected

Definition at line 129 of file ossimDiscreteConvolutionKernel.h.

Referenced by getKernel(), ossimDiscreteConvolutionKernel(), setKernel(), and ~ossimDiscreteConvolutionKernel().

theWidth

long ossimDiscreteConvolutionKernel::theWidth

protected

Definition at line 130 of file ossimDiscreteConvolutionKernel.h.

Referenced by convolve(), convolveSubImage(), getWidth(), ossimDiscreteConvolutionKernel(), and setKernel().

---

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

• ossimDiscreteConvolutionKernel.h
• ossimDiscreteConvolutionKernel.cpp