ossimFilterResampler Class Reference

#include <ossimFilterResampler.h>

Public Types
enum	ossimFilterResamplerType {   ossimFilterResampler_NEAREST_NEIGHBOR = 0, ossimFilterResampler_BOX = 1, ossimFilterResampler_GAUSSIAN = 2, ossimFilterResampler_CUBIC = 3,   ossimFilterResampler_HANNING = 4, ossimFilterResampler_HAMMING = 5, ossimFilterResampler_LANCZOS = 6, ossimFilterResampler_MITCHELL = 7,   ossimFilterResampler_CATROM = 8, ossimFilterResampler_BLACKMAN = 9, ossimFilterResampler_BLACKMAN_SINC = 10, ossimFilterResampler_BLACKMAN_BESSEL = 11,   ossimFilterResampler_QUADRATIC = 12, ossimFilterResampler_TRIANGLE = 13, ossimFilterResampler_BILINEAR = 13, ossimFilterResampler_HERMITE = 14,   ossimFilterResampler_BELL = 15, ossimFilterResampler_BSPLINE = 16, ossimFilterResampler_MAGIC = 17 }

Public Member Functions
	ossimFilterResampler ()
virtual	~ossimFilterResampler ()
virtual void	resample (const ossimRefPtr< ossimImageData > &input, ossimRefPtr< ossimImageData > &output, const ossimDpt &ul, const ossimDpt &ur, const ossimDpt &deltaUl, const ossimDpt &deltaUr, const ossimDpt &length)
virtual void	resample (const ossimRefPtr< ossimImageData > &input, ossimRefPtr< ossimImageData > &output, const ossimIrect &outputSubRect, const ossimDpt &ul, const ossimDpt &ur, const ossimDpt &deltaUl, const ossimDpt &deltaUr, const ossimDpt &length)
void	setFilterType (ossimFilterResamplerType filterType)
void	setFilterType (ossimFilterResamplerType minifyFilterType, ossimFilterResamplerType magnifyFilterType)
void	setFilterType (const ossimString &type)
void	setFilterType (const ossimString &minifyType, const ossimString &magnifyType)
void	setMinifyFilterType (const ossimString &minifyType)
void	setMagnifyFilterType (const ossimString &magnifyType)
void	setMinifyFilterType (ossimFilterResamplerType filterType)
void	setMagnifyFilterType (ossimFilterResamplerType filterType)
ossimString	getMinifyFilterTypeAsString () const
ossimString	getMagnifyFilterTypeAsString () const
void	setScaleFactor (const ossimDpt &scale)
void	setBlurFactor (ossim_float64 blur)
void	setBoundingInputRect (const ossimIrect &rect)
ossimIrect	getBoundingInputRect () const
ossim_float64	getBlurFactor () const
const ossimDpt &	getScaleFactor () const
virtual bool	saveState (ossimKeywordlist &kwl, const char *prefix=0) const
virtual bool	loadState (const ossimKeywordlist &kwl, const char *prefix=0)
virtual void	getKernelSupport (double &x, double &y) const
virtual void	getFilterTypes (std::vector< ossimString > &filterTypes) const

Private Member Functions
const ossimFilter *	getHorizontalFilter () const
const ossimFilter *	getVerticalFilter () const
template<class T >
void	resampleBilinearTile (T dummy, const ossimRefPtr< ossimImageData > &input, ossimRefPtr< ossimImageData > &output, const ossimIrect &outputSubRect, const ossimDpt &inputUl, const ossimDpt &inputUr, const ossimDpt &deltaUl, const ossimDpt &deltaUr, const ossimDpt &outLength)
void	computeTable ()
ossimString	getFilterTypeAsString (ossimFilterResamplerType type) const
ossimFilterResamplerType	getFilterType (const ossimString &type) const
ossimFilter *	createNewFilter (ossimFilterResamplerType filterType, ossimFilterResamplerType &result)

Private Attributes
ossimFilter *	theMinifyFilter
ossimFilter *	theMagnifyFilter
ossimFilterTable	theFilterTable
ossimFilterResamplerType	theMinifyFilterType
ossimFilterResamplerType	theMagnifyFilterType
ossimDpt	theScaleFactor
ossimDpt	theInverseScaleFactor
ossimIrect	theInputRect
ossim_float64	theBlurFactor

Detailed Description

Definition at line 24 of file ossimFilterResampler.h.

Member Enumeration Documentation

ossimFilterResamplerType

enum ossimFilterResampler::ossimFilterResamplerType

Enumerator
ossimFilterResampler_NEAREST_NEIGHBOR
ossimFilterResampler_BOX
ossimFilterResampler_GAUSSIAN
ossimFilterResampler_CUBIC
ossimFilterResampler_HANNING
ossimFilterResampler_HAMMING
ossimFilterResampler_LANCZOS
ossimFilterResampler_MITCHELL
ossimFilterResampler_CATROM
ossimFilterResampler_BLACKMAN
ossimFilterResampler_BLACKMAN_SINC
ossimFilterResampler_BLACKMAN_BESSEL
ossimFilterResampler_QUADRATIC
ossimFilterResampler_TRIANGLE
ossimFilterResampler_BILINEAR
ossimFilterResampler_HERMITE
ossimFilterResampler_BELL
ossimFilterResampler_BSPLINE
ossimFilterResampler_MAGIC

Definition at line 27 of file ossimFilterResampler.h.

   {
      ossimFilterResampler_NEAREST_NEIGHBOR = 0,
      ossimFilterResampler_BOX              = 1,
      ossimFilterResampler_GAUSSIAN         = 2,
      ossimFilterResampler_CUBIC            = 3,
      ossimFilterResampler_HANNING          = 4,
      ossimFilterResampler_HAMMING          = 5,
      ossimFilterResampler_LANCZOS          = 6,
      ossimFilterResampler_MITCHELL         = 7,
      ossimFilterResampler_CATROM           = 8,
      ossimFilterResampler_BLACKMAN         = 9,
      ossimFilterResampler_BLACKMAN_SINC    = 10,
      ossimFilterResampler_BLACKMAN_BESSEL  = 11,
      ossimFilterResampler_QUADRATIC        = 12,
      ossimFilterResampler_TRIANGLE         = 13,
      ossimFilterResampler_BILINEAR         = 13,
      ossimFilterResampler_HERMITE          = 14,
      ossimFilterResampler_BELL             = 15,
      ossimFilterResampler_BSPLINE          = 16,
      ossimFilterResampler_MAGIC            = 17
      
   };

Constructor & Destructor Documentation

ossimFilterResampler()

ossimFilterResampler::ossimFilterResampler

(

)

Definition at line 25 of file ossimFilterResampler.cpp.

References ossimPreferences::instance(), loadState(), and setScaleFactor().

   :theMinifyFilter(new ossimNearestNeighborFilter()),
    theMagnifyFilter(new ossimNearestNeighborFilter()),
    theMinifyFilterType(ossimFilterResampler_NEAREST_NEIGHBOR),
    theMagnifyFilterType(ossimFilterResampler_NEAREST_NEIGHBOR),
    theScaleFactor(1.0, 1.0),
    theInverseScaleFactor(1.0, 1.0),
    theBlurFactor(1.0)
{
   setScaleFactor(ossimDpt(1.0, 1.0));
   loadState(ossimPreferences::instance()->preferencesKWL(),"resampler.");

}

~ossimFilterResampler()

ossimFilterResampler::~ossimFilterResampler ( )

virtual

Definition at line 39 of file ossimFilterResampler.cpp.

References theMagnifyFilter, and theMinifyFilter.

{
   if(theMinifyFilter)
   {
      delete theMinifyFilter;
      theMinifyFilter = NULL;
   }
   if(theMagnifyFilter)
   {
      delete theMagnifyFilter;
      theMagnifyFilter = NULL;
   }
}

Member Function Documentation

computeTable()

void ossimFilterResampler::computeTable ( )

private

Definition at line 945 of file ossimFilterResampler.cpp.

References ossimFilterTable::buildTable(), theFilterTable, and theMagnifyFilter.

Referenced by setFilterType().

{
  theFilterTable.buildTable(32, *theMagnifyFilter);
}

createNewFilter()

ossimFilter * ossimFilterResampler::createNewFilter ( ossimFilterResamplerType  filterType, ossimFilterResamplerType &  result  )

private

Definition at line 213 of file ossimFilterResampler.cpp.

References ossimFilterResampler_BELL, ossimFilterResampler_BLACKMAN, ossimFilterResampler_BLACKMAN_BESSEL, ossimFilterResampler_BLACKMAN_SINC, ossimFilterResampler_BOX, ossimFilterResampler_BSPLINE, ossimFilterResampler_CATROM, ossimFilterResampler_CUBIC, ossimFilterResampler_GAUSSIAN, ossimFilterResampler_HAMMING, ossimFilterResampler_HANNING, ossimFilterResampler_HERMITE, ossimFilterResampler_LANCZOS, ossimFilterResampler_MAGIC, ossimFilterResampler_MITCHELL, ossimFilterResampler_NEAREST_NEIGHBOR, ossimFilterResampler_QUADRATIC, and ossimFilterResampler_TRIANGLE.

Referenced by setFilterType().

{
   switch(filterType)
   {
      case ossimFilterResampler_NEAREST_NEIGHBOR:
      {
         return new ossimNearestNeighborFilter();
      }
      case ossimFilterResampler_BOX:
      {
         return new ossimBoxFilter();
      }
      case ossimFilterResampler_GAUSSIAN:
      {
         return new ossimGaussianFilter();
      }
      case ossimFilterResampler_CUBIC:
      {
         return new ossimCubicFilter();
      }
      case ossimFilterResampler_HANNING:
      {
         return new ossimHanningFilter();
      }
      case ossimFilterResampler_HAMMING:
      {
         return new ossimHammingFilter();
      }
      case ossimFilterResampler_LANCZOS:
      {
         return new ossimLanczosFilter();
      }
      case ossimFilterResampler_CATROM:
      {
         return new ossimCatromFilter();
      }
      case ossimFilterResampler_MITCHELL:
      {
         return new ossimMitchellFilter();
      }
      case ossimFilterResampler_BLACKMAN:
      {
         return new ossimBlackmanFilter();
      }
      case ossimFilterResampler_BLACKMAN_SINC:
      {
         return new ossimBlackmanSincFilter();
      }
      case ossimFilterResampler_BLACKMAN_BESSEL:
      {
         return new ossimBlackmanBesselFilter();
      }
      case ossimFilterResampler_QUADRATIC:
      {
         return new ossimQuadraticFilter();
      }
      case ossimFilterResampler_TRIANGLE:
      {
         return new ossimTriangleFilter();
      }
      case ossimFilterResampler_HERMITE:
      {
         return new ossimHermiteFilter();
      }
      case ossimFilterResampler_BELL:
      {
         return new ossimGaussianFilter();
      }
      case ossimFilterResampler_BSPLINE:
      {
         return new ossimBSplineFilter();
      }
      case ossimFilterResampler_MAGIC:
      {
         return new ossimBSplineFilter();
      }
   }

   result = ossimFilterResampler_NEAREST_NEIGHBOR;
   return new ossimNearestNeighborFilter();
}

getBlurFactor()

ossim_float64 ossimFilterResampler::getBlurFactor

(

)

const

Definition at line 868 of file ossimFilterResampler.cpp.

References theBlurFactor.

{
   return theBlurFactor;
}

getBoundingInputRect()

ossimIrect ossimFilterResampler::getBoundingInputRect ( ) const

inline

Definition at line 90 of file ossimFilterResampler.h.

  {
    return theInputRect;
  }

getFilterType()

ossimFilterResampler::ossimFilterResamplerType ossimFilterResampler::getFilterType ( const ossimString &  type ) const

private

Definition at line 665 of file ossimFilterResampler.cpp.

References ossimString::contains(), ossimFilterResampler_BLACKMAN, ossimFilterResampler_BLACKMAN_BESSEL, ossimFilterResampler_BLACKMAN_SINC, ossimFilterResampler_BOX, ossimFilterResampler_BSPLINE, ossimFilterResampler_CATROM, ossimFilterResampler_CUBIC, ossimFilterResampler_GAUSSIAN, ossimFilterResampler_HAMMING, ossimFilterResampler_HANNING, ossimFilterResampler_HERMITE, ossimFilterResampler_LANCZOS, ossimFilterResampler_MAGIC, ossimFilterResampler_MITCHELL, ossimFilterResampler_NEAREST_NEIGHBOR, ossimFilterResampler_QUADRATIC, ossimFilterResampler_TRIANGLE, and ossimString::upcase().

Referenced by setFilterType(), setMagnifyFilterType(), and setMinifyFilterType().

{
   ossimString typeUpper = type;
   typeUpper = typeUpper.upcase();

   if(typeUpper.contains("BOX"))
   {
      return ossimFilterResampler_BOX;
   }
   else if(typeUpper.contains("NEAREST"))
   {
      return ossimFilterResampler_NEAREST_NEIGHBOR;
   }
   else if(typeUpper.contains("GAUSSIAN"))
   {
      return ossimFilterResampler_GAUSSIAN;
   }
   else if(typeUpper.contains("HANNING"))
   {
      return ossimFilterResampler_HANNING;
   }
   else if(typeUpper.contains("HAMMING"))
   {
      return ossimFilterResampler_HAMMING;
   }
   else if(typeUpper.contains("LANCZOS"))
   {
      return ossimFilterResampler_LANCZOS;
   }
   else if(typeUpper.contains("MITCHELL"))
   {
      return ossimFilterResampler_MITCHELL;
   }
   else if(typeUpper.contains("CATROM"))
   {
      return ossimFilterResampler_CATROM;
   }
   else if(typeUpper.contains("CUBIC"))
   {
      return ossimFilterResampler_CUBIC;
   }
   else if(typeUpper.contains("BESSEL"))
   {
      return ossimFilterResampler_BLACKMAN_BESSEL;
   }
   else if(typeUpper.contains("SINC"))
   {
      return ossimFilterResampler_BLACKMAN_SINC;
   }
   else if(typeUpper.contains("BLACKMAN"))
   {
      return ossimFilterResampler_BLACKMAN;
   }
   else if(typeUpper.contains("QUADRATIC"))
   {
      return ossimFilterResampler_QUADRATIC;
   }
   else if(typeUpper.contains("TRIANGLE"))
   {
      return ossimFilterResampler_TRIANGLE;
   }
   else if(typeUpper.contains("BILINEAR"))
   {
      return ossimFilterResampler_TRIANGLE;
   }
   else if(typeUpper.contains("HERMITE"))
   {
      return ossimFilterResampler_HERMITE;
   }
//    else if(typeUpper.contains("BELL"))
//    {
//       return ossimFilterResampler_BELL;
//    }
   else if(typeUpper.contains("BSPLINE"))
   {
      return ossimFilterResampler_BSPLINE;
   }
   else if(typeUpper.contains("MAGIC"))
   {
      return ossimFilterResampler_MAGIC;
   }
   
   return ossimFilterResampler_NEAREST_NEIGHBOR;
}

getFilterTypeAsString()

ossimString ossimFilterResampler::getFilterTypeAsString ( ossimFilterResamplerType  type ) const

private

Definition at line 561 of file ossimFilterResampler.cpp.

References ossimFilterResampler_BELL, ossimFilterResampler_BLACKMAN, ossimFilterResampler_BLACKMAN_BESSEL, ossimFilterResampler_BLACKMAN_SINC, ossimFilterResampler_BOX, ossimFilterResampler_BSPLINE, ossimFilterResampler_CATROM, ossimFilterResampler_CUBIC, ossimFilterResampler_GAUSSIAN, ossimFilterResampler_HAMMING, ossimFilterResampler_HANNING, ossimFilterResampler_HERMITE, ossimFilterResampler_LANCZOS, ossimFilterResampler_MAGIC, ossimFilterResampler_MITCHELL, ossimFilterResampler_NEAREST_NEIGHBOR, ossimFilterResampler_QUADRATIC, and ossimFilterResampler_TRIANGLE.

Referenced by getMagnifyFilterTypeAsString(), getMinifyFilterTypeAsString(), and saveState().

{
   switch(type)
   {
      case ossimFilterResampler_NEAREST_NEIGHBOR:
      {
         return "nearest neighbor";
      }
      case ossimFilterResampler_BOX:
      {
         return "box";
      }
      case ossimFilterResampler_GAUSSIAN:
      {
         return "gaussian";
      }
      case ossimFilterResampler_CUBIC:
      {
         return "cubic";
      }
      case ossimFilterResampler_HANNING:
      {
         return "hanning";
      }
      case ossimFilterResampler_HAMMING:
      {
         return "hamming";
      }
      case ossimFilterResampler_LANCZOS:
      {
         return "lanczos";
      }
      case ossimFilterResampler_MITCHELL:
      {
         return "mitchell";
      }
      case ossimFilterResampler_CATROM:
      {
         return "catrom";
      }
      case ossimFilterResampler_BLACKMAN:
      {
         return "blackman";
      }
      case ossimFilterResampler_BLACKMAN_SINC:
      {
         return "sinc";
      }
      case ossimFilterResampler_BLACKMAN_BESSEL:
      {
         return "bessel";
      }
      case ossimFilterResampler_QUADRATIC:
      {
         return "quadratic";
      }
      case ossimFilterResampler_TRIANGLE:
      {
         return "bilinear";
      }
      case ossimFilterResampler_HERMITE:
      {
         return "hermite";
      }
      case ossimFilterResampler_BELL:
      {
         return "gaussian";
      }
      case ossimFilterResampler_BSPLINE:
      {
         return "bspline";
      }
      case ossimFilterResampler_MAGIC:
      {
         return "magic";
      }
   }

   return "nearest neighbor";
}

getFilterTypes()

void ossimFilterResampler::getFilterTypes ( std::vector< ossimString > &  filterTypes ) const

virtual

Definition at line 642 of file ossimFilterResampler.cpp.

Referenced by ossimImageRenderer::getProperty(), and ossimInfo::printResamplerFilters().

{
  filterTypes.push_back("nearest neighbor");
  filterTypes.push_back("bilinear");
  filterTypes.push_back("cubic");
//  filterTypes.push_back("bell");
  filterTypes.push_back("bessel");
  filterTypes.push_back("blackman");
  filterTypes.push_back("box");
  filterTypes.push_back("bspline");
  filterTypes.push_back("catrom");
  filterTypes.push_back("gaussian");
  filterTypes.push_back("hanning");
  filterTypes.push_back("hamming");
  filterTypes.push_back("hermite");
  filterTypes.push_back("lanczos");
  filterTypes.push_back("mitchell");
  filterTypes.push_back("quadratic");
  filterTypes.push_back("sinc");
  filterTypes.push_back("magic");
}

getHorizontalFilter()

const ossimFilter * ossimFilterResampler::getHorizontalFilter ( ) const

private

Definition at line 778 of file ossimFilterResampler.cpp.

References theMagnifyFilter, theMinifyFilter, theScaleFactor, and ossimDpt::x.

Referenced by getKernelSupport().

{
   if(theScaleFactor.x < 1)
   {
      return theMinifyFilter;
   }

   return theMagnifyFilter;
}

getKernelSupport()

void ossimFilterResampler::getKernelSupport ( double &  x, double &  y  ) const

virtual

Definition at line 750 of file ossimFilterResampler.cpp.

References getHorizontalFilter(), ossimFilter::getSupport(), getVerticalFilter(), x, and y.

Referenced by ossimImageRenderer::fillTile().

{
   const ossimFilter* horizontalFilter = getHorizontalFilter();
   const ossimFilter* verticalFilter   = getVerticalFilter();

   if(!horizontalFilter)
   {
      x = 0.0;
   }
   else
   {
//       x = theBlurFactor*ossim::max(1.0/theScaleFactor.x, 1.0)*
//           horizontalFilter->getSupport();
      x = horizontalFilter->getSupport();
   }

   if(!verticalFilter)
   {
      y = 0.0;
   }
   else
   {
//       y = theBlurFactor*ossim::max(1.0/theScaleFactor.y, 1.0)*
//           verticalFilter->getSupport();
      y = verticalFilter->getSupport();
   }
}

getMagnifyFilterTypeAsString()

ossimString ossimFilterResampler::getMagnifyFilterTypeAsString

(

)

const

Definition at line 840 of file ossimFilterResampler.cpp.

References getFilterTypeAsString(), and theMagnifyFilterType.

{
   return getFilterTypeAsString(theMagnifyFilterType);
}

getMinifyFilterTypeAsString()

ossimString ossimFilterResampler::getMinifyFilterTypeAsString

(

)

const

Definition at line 835 of file ossimFilterResampler.cpp.

References getFilterTypeAsString(), and theMinifyFilterType.

Referenced by ossimImageRenderer::getProperty().

{
   return getFilterTypeAsString(theMinifyFilterType);
}

getScaleFactor()

const ossimDpt& ossimFilterResampler::getScaleFactor ( ) const

inline

Definition at line 97 of file ossimFilterResampler.h.

  {
    return theScaleFactor;
  }

getVerticalFilter()

const ossimFilter * ossimFilterResampler::getVerticalFilter ( ) const

private

Definition at line 788 of file ossimFilterResampler.cpp.

References theMagnifyFilter, theMinifyFilter, theScaleFactor, and ossimDpt::y.

Referenced by getKernelSupport().

{
   if(theScaleFactor.y < 1)
   {
      return theMinifyFilter;
   }

   return theMagnifyFilter;
}

loadState()

bool ossimFilterResampler::loadState ( const ossimKeywordlist &  kwl, const char *  prefix = 0  )

virtual

Loads the state of this object.

Definition at line 901 of file ossimFilterResampler.cpp.

References ossimKeywordlist::find(), FLT_EPSILON, ossimKeywordNames::SCALE_X_KW, ossimKeywordNames::SCALE_Y_KW, setMagnifyFilterType(), setMinifyFilterType(), theInverseScaleFactor, theScaleFactor, ossimString::toDouble(), ossimDpt::x, and ossimDpt::y.

Referenced by ossimFilterResampler().

{
   const char* lookup = 0;

   lookup = kwl.find(prefix, ossimKeywordNames::SCALE_X_KW);
   if (lookup)
   {
      theScaleFactor.x = ossimString(lookup).toDouble();
   }

   lookup = kwl.find(prefix, ossimKeywordNames::SCALE_Y_KW);
   if (lookup)
   {
      theScaleFactor.y = ossimString(lookup).toDouble();
   }

   lookup = kwl.find(prefix, "minify_type");
   if (lookup)
   {
      setMinifyFilterType(lookup);
   }

   lookup = kwl.find(prefix, "magnify_type");
   if (lookup)
   {
      setMagnifyFilterType(lookup);
   }

   if(fabs(theScaleFactor.x) <= FLT_EPSILON)
   {
      theScaleFactor.x = 1.0;
   }
   if(fabs(theScaleFactor.y) <= FLT_EPSILON)
   {
      theScaleFactor.y = 1.0;
   }

   theInverseScaleFactor.x = 1.0/theScaleFactor.x;
   theInverseScaleFactor.y = 1.0/theScaleFactor.y;
   
   return true;
}

resample() [1/2]

void ossimFilterResampler::resample ( const ossimRefPtr< ossimImageData > &  input, ossimRefPtr< ossimImageData > &  output, const ossimDpt &  ul, const ossimDpt &  ur, const ossimDpt &  deltaUl, const ossimDpt &  deltaUr, const ossimDpt &  length  )

virtual

Definition at line 54 of file ossimFilterResampler.cpp.

References ossimImageData::getImageRectangle().

Referenced by ossimImageCacheTileSource::fillTile(), and ossimImageRenderer::fillTile().

{
   resample(input,
            output,
            output->getImageRectangle(),
            ul,
            ur,
            deltaUl,
            deltaUr,
            length);
}

resample() [2/2]

void ossimFilterResampler::resample ( const ossimRefPtr< ossimImageData > &  input, ossimRefPtr< ossimImageData > &  output, const ossimIrect &  outputSubRect, const ossimDpt &  ul, const ossimDpt &  ur, const ossimDpt &  deltaUl, const ossimDpt &  deltaUr, const ossimDpt &  length  )

virtual

Definition at line 72 of file ossimFilterResampler.cpp.

References ossimImageData::getBuf(), ossimRectilinearDataObject::getScalarType(), OSSIM_FLOAT32, OSSIM_FLOAT64, OSSIM_NORMALIZED_DOUBLE, OSSIM_NORMALIZED_FLOAT, OSSIM_SINT16, OSSIM_SINT32, OSSIM_SINT8, OSSIM_UINT16, OSSIM_UINT32, OSSIM_UINT8, OSSIM_USHORT11, OSSIM_USHORT12, OSSIM_USHORT13, OSSIM_USHORT14, OSSIM_USHORT15, ossimNotify(), ossimNotifyLevel_WARN, resampleBilinearTile(), and ossimRefPtr< T >::valid().

{
   if(!input.valid()   ||
      !output.valid()  ||
      !input->getBuf() ||
      !output->getBuf())
   {
      return;
   }
   
   ossimScalarType scalarType = input->getScalarType();
   switch(scalarType)
   {
      case OSSIM_UINT8:
      {
         resampleBilinearTile(ossim_uint8(0), // dummy template variable
                  input,
                  output,
                  outputSubRect,
                  ul,
                  ur,
                  deltaUl,
                  deltaUr,
                  length);
         break;
      }
      case OSSIM_SINT8:
      {
         resampleBilinearTile(ossim_sint8(0), // dummy template variable
                  input,
                  output,
                  outputSubRect,
                  ul,
                  ur,
                  deltaUl,
                  deltaUr,
                  length);
         break;
      }
      case OSSIM_UINT16:
      case OSSIM_USHORT11:
      case OSSIM_USHORT12:
      case OSSIM_USHORT13:
      case OSSIM_USHORT14:
      case OSSIM_USHORT15:
      {
     resampleBilinearTile(ossim_uint16(0), // dummy template variable
                  input,
                  output,
                  outputSubRect,
                  ul,
                  ur,
                  deltaUl,
                  deltaUr,
                  length);
     break;
      }
      case OSSIM_SINT16:
      {
     resampleBilinearTile(ossim_sint16(0), // dummy template variable
                  input,
                  output,
                  outputSubRect,
                  ul,
                  ur,
                  deltaUl,
                  deltaUr,
                  length);
     break;
      }      
      case OSSIM_UINT32:
      {
     resampleBilinearTile(ossim_uint32(0), // dummy template variable
                  input,
                  output,
                  outputSubRect,
                  ul,
                  ur,
                  deltaUl,
                  deltaUr,
                  length);
     break;
      }      
      case OSSIM_SINT32:
      {
     resampleBilinearTile(ossim_sint32(0), // dummy template variable
                  input,
                  output,
                  outputSubRect,
                  ul,
                  ur,
                  deltaUl,
                  deltaUr,
                  length);
     break;
      }      
      case OSSIM_FLOAT32:
      case OSSIM_NORMALIZED_FLOAT:
      {
     resampleBilinearTile(ossim_float32(0.0), // dummy template variable
                  input,
                  output,
                  outputSubRect,
                  ul,
               ur,
                  deltaUl,
                  deltaUr,
                  length);
     break;
      }
      case OSSIM_FLOAT64:
      case OSSIM_NORMALIZED_DOUBLE:
      {
     resampleBilinearTile(ossim_float64(0.0), // dummy template variable
                  input,
                  output,
                  outputSubRect,
                  ul,
                  ur,
                  deltaUl,
                  deltaUr,
                  length);
         break;
      }
      default:
      {
         ossimNotify(ossimNotifyLevel_WARN)
            << "ossimFilterResampler::resample error: unknown scalar type:  "
            << scalarType << endl;
      }
   }
}

resampleBilinearTile()

template<class T >

void ossimFilterResampler::resampleBilinearTile ( T  dummy, const ossimRefPtr< ossimImageData > &  input, ossimRefPtr< ossimImageData > &  output, const ossimIrect &  outputSubRect, const ossimDpt &  inputUl, const ossimDpt &  inputUr, const ossimDpt &  deltaUl, const ossimDpt &  deltaUr, const ossimDpt &  outLength  )

private

Definition at line 313 of file ossimFilterResampler.cpp.

References FLT_EPSILON, ossimImageData::getBuf(), ossimFilterTable::getClosestWeights(), ossimFilterTable::getHeight(), ossimImageData::getImageRectangle(), ossimImageData::getMaxPix(), ossimImageData::getMinPix(), ossimImageData::getNullPix(), ossimImageData::getNumberOfBands(), ossimImageData::getSizePerBand(), ossimFilterTable::getWidth(), ossimImageData::getWidth(), ossimFilterTable::getXSupport(), ossimFilterTable::getYSupport(), ossimIrect::height(), theFilterTable, ossimIrect::ul(), ossimIrect::width(), ossimIpt::x, ossimDpt::x, ossimIpt::y, and ossimDpt::y.

Referenced by resample().

{
#if 0 /* Please leave for debug. */
   std::cout << "INPUT  = \n" << *input << std::endl
             << "OUTPUT = \n" << *output << std::endl
             << "inputUL= " << inputUl << std::endl
             << "inputUR= " << inputUr << std::endl
             << "deltaUL= " << deltaUl << std::endl
             << "deltaUr= " << deltaUr << std::endl
             << "outlength= " << outLength << std::endl;
#endif
   
   ossim_uint32  band, centerOffset;
   ossim_float64 tmpFlt64, stepSizeWidth;

   if(outLength.x>1) {
      stepSizeWidth  = 1.0/(outLength.x-1.0);
   } else {
      stepSizeWidth   = 1.0;
   }

   // INPUT INFORMATION
   ossim_uint32       inWidth      = input->getWidth();
   ossim_uint32       inBandSize   = input->getSizePerBand();  // fix for out-of-bounds check OLK 06/2005
   ossim_uint32       BANDS        = input->getNumberOfBands();
   ossimIrect         inputRect    = input->getImageRectangle();

   // OUTPUT INFORMATION
   const ossim_float64* NULL_PIX      = output->getNullPix(); 
   const ossim_float64* MIN_PIX       = output->getMinPix(); 
   const ossim_float64* MAX_PIX       = output->getMaxPix(); 
   ossimIrect           outputRect    = output->getImageRectangle();
   ossim_uint32         resultRectH   = outputSubRect.height();
   ossim_uint32         resultRectW   = outputSubRect.width();
   ossim_uint32         outputRectW   = outputRect.width();

   // calculate the offset into the data so we can refer to it at 0 index.
   ossim_uint32 resultOffset=(outputSubRect.ul().y - outputRect.ul().y)*outputRectW +
                             (outputSubRect.ul().x - outputRect.ul().x);

   // make a local copy of the band pointers (at resultOffset)
   ossim_float64 *densityvals=new ossim_float64[BANDS];
   ossim_float64 *pixelvals=new ossim_float64[BANDS];
   const T* *inputBuf  = new const T*[BANDS];
   T* *resultBuf = new T*[BANDS];
   if(!pixelvals||!inputBuf||!resultBuf)
   {
      return;
   }
   
   for(band = 0; band < BANDS; ++band)
   {
      inputBuf[band] = static_cast<const T*>(input->getBuf(band));
      resultBuf[band] = static_cast<T*>(output->getBuf(band))+resultOffset;
   }

   // FILTER INFORMAION
   ossim_uint32 xkernel_width  = theFilterTable.getWidth();;
   ossim_uint32 ykernel_height = theFilterTable.getHeight();
   double xkernel_half_width   = theFilterTable.getXSupport();
   double ykernel_half_height  = theFilterTable.getYSupport();

   double initialx  = inputUl.x-inputRect.ul().x;
   double initialy  = inputUl.y-inputRect.ul().y;
   double terminalx = inputUr.x-inputRect.ul().x;
   double terminaly = inputUr.y-inputRect.ul().y;
   double pointx,pointy,deltaX,deltaY;
   ossim_int32 starty,startx; 

   if(xkernel_width==0 || ykernel_height==0)
   {
      // USING NEAREST NEIGHBOR
      for(ossim_uint32 resultY = 0; resultY < resultRectH; ++resultY)
      {
//          deltaX = (terminalx-initialx) * stepSizeWidth;
//          deltaY = (terminaly-initialy) * stepSizeHeight;
         // this should be stepsize width for both since we are traversing horizontal
         deltaX = (terminalx-initialx) * stepSizeWidth;
         deltaY = (terminaly-initialy) * stepSizeWidth;
         pointx = initialx;
         pointy = initialy;
         for(ossim_uint32 resultX = 0; resultX < resultRectW; ++resultX)
         {
            // just sample center in input space.
            centerOffset = ossim::round<int>(pointy)*inWidth + ossim::round<int>(pointx);
            for(band=0;band<BANDS;++band)
            {
               resultBuf[band][resultX] = inputBuf[band][centerOffset];
            }
            pointy += deltaY;
            pointx += deltaX;
         } // End of loop in x direction.
         
         // increment pointers to where we are now.
         for(band=0;band<BANDS;++band)
         {
            resultBuf[band] += outputRectW;
         }
         initialx += deltaUl.x;
         initialy += deltaUl.y;
         terminalx  += deltaUr.x;
         terminaly  += deltaUr.y;
      } // End of loop in y direction.
      
   }
   else
   {
      // USING A KERNEL
      const double* kernel;
      ossim_uint32 iy,ix,sourceIndex,nullCount;
      for(ossim_uint32 resultY = 0; resultY < resultRectH; ++resultY)
      {
         deltaX = (terminalx-initialx) * stepSizeWidth;
         deltaY = (terminaly-initialy) * stepSizeWidth;
         pointx = initialx;
         pointy = initialy;
         for(ossim_uint32 resultX = 0; resultX < resultRectW; ++resultX)
         {
            starty  = ossim::round<int>(pointy - ykernel_half_height + .5);
            startx  = ossim::round<int>(pointx - xkernel_half_width + .5);
            centerOffset = ossim::round<int>(pointy)*inWidth + ossim::round<int>(pointx);
            sourceIndex = starty*inWidth+startx;

            // look at center pixel, make sure they aren't all null.
            nullCount=0;
            if(centerOffset<inBandSize)
            {
               for (band=0;band<BANDS;++band)
               {
                  if(inputBuf[band][centerOffset]==static_cast<T>(NULL_PIX[band]))
                  {
                     ++nullCount;
                  }
               }
               // the center of the kernel is outside the input space, just set null.
            }
            else
            {
               nullCount=BANDS;
            }

            // make sure we have non-null data and we fit within the inputBuf.
            if ( nullCount==BANDS || (sourceIndex>=inBandSize))
            {
               // we don't need to continue, just assign null!
               for (band=0;band<BANDS;++band)
               {
                  resultBuf[band][resultX] = static_cast<T>(NULL_PIX[band]);
               }
            }
            else
            {  
               kernel = theFilterTable.getClosestWeights(pointx,pointy);
               if(kernel)
               {
                  // reset the pixel/density sums for each band to zero.
                  memset(densityvals,'\0',sizeof(ossim_float64)*BANDS);
                  memset(pixelvals,'\0',sizeof(ossim_float64)*BANDS);

                  // apply kernel to input space.
                  for (iy=0;((iy<ykernel_height)&&(sourceIndex<inBandSize));++iy)
                  {
                     for (ix = 0;((ix<xkernel_width)&&(sourceIndex<inBandSize));++ix)
                     {
                        tmpFlt64=*kernel; // pixel weight;
                        for(band=0;band<BANDS;++band)
                        {
                           if(inputBuf[band][sourceIndex]!=NULL_PIX[band])
                           {
                              densityvals[band] += tmpFlt64;
                              pixelvals[band] += (inputBuf[band][sourceIndex]*tmpFlt64);
                           }
                        }
                        ++sourceIndex;
                        ++kernel;
                        if(sourceIndex>=inBandSize)
                        {
                           break;
                        }
                     }
                     sourceIndex+=(inWidth-xkernel_width);
                  }

                  // actually assign the value to the output
                  for (band = 0; band < BANDS; ++band)
                  {
                     if(densityvals[band]<=FLT_EPSILON)
                     {
                        //---
                        // Setting tempFlt64 to pixelvals[band] causing 0's where -32768
                        // should be when null check was skipped above.
                        // tmpFlt64 = pixelvals[band];
                        //---
                        tmpFlt64 = NULL_PIX[band];
                     }
                     else
                     {
                        // normalize
                        tmpFlt64 = pixelvals[band]/densityvals[band];
                     }
                     
                     // clamp
                     tmpFlt64 = (tmpFlt64>=MIN_PIX[band]?(tmpFlt64<MAX_PIX[band]?tmpFlt64:MAX_PIX[band]):MIN_PIX[band]); 
                     // set resultant pixel value.
                     resultBuf[band][resultX] = static_cast<T>(tmpFlt64);
                  }

                  // we didn't get a filter kernel, just set NULL in this disaster.
               }
               else
               {
                  for (band=0;band<BANDS;++band)
                  {
                     resultBuf[band][resultX] = static_cast<T>(NULL_PIX[band]);
                  }
               }                  
            }
            pointy += deltaY;
            pointx += deltaX;
         } // End of loop in x direction.

         // increment pointers to where we are now.
         for(band=0;band<BANDS;++band)
         {
            resultBuf[band] += outputRectW;
         }
         initialx += deltaUl.x;
         initialy += deltaUl.y;
         terminalx  += deltaUr.x;
         terminaly  += deltaUr.y;
      } // End of loop in y direction.
   } // USING A KERNEL END

   delete [] densityvals;
   delete [] pixelvals;
   delete [] resultBuf;
   delete [] inputBuf;
}

saveState()

bool ossimFilterResampler::saveState ( ossimKeywordlist &  kwl, const char *  prefix = 0  ) const

virtual

Saves the state of this object.

Definition at line 878 of file ossimFilterResampler.cpp.

References ossimKeywordlist::add(), getFilterTypeAsString(), ossimKeywordNames::SCALE_X_KW, ossimKeywordNames::SCALE_Y_KW, theMagnifyFilterType, theMinifyFilterType, theScaleFactor, ossimDpt::x, and ossimDpt::y.

Referenced by ossimImageRenderer::saveState().

{
   kwl.add(prefix,
           ossimKeywordNames::SCALE_X_KW,
           theScaleFactor.x,
           true);
   kwl.add(prefix,
           ossimKeywordNames::SCALE_Y_KW,
           theScaleFactor.y,
           true);
   kwl.add(prefix,
           "minify_type",
           getFilterTypeAsString(theMinifyFilterType),
           true);
   kwl.add(prefix,
           "magnify_type",
           getFilterTypeAsString(theMagnifyFilterType),
           true);

   return true;
}

setBlurFactor()

void ossimFilterResampler::setBlurFactor

(

ossim_float64

blur

)

Definition at line 873 of file ossimFilterResampler.cpp.

References theBlurFactor.

{
   theBlurFactor = blur;
}

setBoundingInputRect()

void ossimFilterResampler::setBoundingInputRect ( const ossimIrect &  rect )

inline

Definition at line 86 of file ossimFilterResampler.h.

Referenced by ossimImageRenderer::fillTile().

  {
    theInputRect = rect;
  }

setFilterType() [1/4]

void ossimFilterResampler::setFilterType

(

ossimFilterResamplerType

filterType

)

Definition at line 803 of file ossimFilterResampler.cpp.

Referenced by ossimKakaduJpipHandler::getTile(), setFilterType(), setMagnifyFilterType(), setMinifyFilterType(), and ossimImageRenderer::setProperty().

{
   setFilterType(filterType, filterType);
}

setFilterType() [2/4]

void ossimFilterResampler::setFilterType	(	ossimFilterResamplerType	minifyFilterType,
		ossimFilterResamplerType	magnifyFilterType
	)

Definition at line 845 of file ossimFilterResampler.cpp.

References computeTable(), createNewFilter(), theMagnifyFilter, theMagnifyFilterType, theMinifyFilter, and theMinifyFilterType.

{
   if(theMinifyFilter)
   {
      delete theMinifyFilter;
      theMinifyFilter = NULL;
   }
   if(theMagnifyFilter)
   {
      delete theMagnifyFilter;
      theMagnifyFilter = NULL;
   }
   
   theMinifyFilterType  = minifyFilterType;
   theMagnifyFilterType = magnifyFilterType;
   
   theMinifyFilter  = createNewFilter(minifyFilterType, theMinifyFilterType);
   theMagnifyFilter = createNewFilter(magnifyFilterType, theMagnifyFilterType);
   computeTable();
}

setFilterType() [3/4]

void ossimFilterResampler::setFilterType

(

const ossimString &

type

)

Definition at line 798 of file ossimFilterResampler.cpp.

References setFilterType().

{
   setFilterType(type, type);
}

setFilterType() [4/4]

void ossimFilterResampler::setFilterType	(	const ossimString &	minifyType,
		const ossimString &	magnifyType
	)

Definition at line 807 of file ossimFilterResampler.cpp.

References getFilterType(), and setFilterType().

{
   setFilterType(getFilterType(minifyType),
                 getFilterType(magnifyType));
}

setMagnifyFilterType() [1/2]

void ossimFilterResampler::setMagnifyFilterType

(

const ossimString &

magnifyType

)

Definition at line 819 of file ossimFilterResampler.cpp.

References getFilterType().

Referenced by loadState().

{
   setMagnifyFilterType(getFilterType(magnifyType));
}

setMagnifyFilterType() [2/2]

void ossimFilterResampler::setMagnifyFilterType

(

ossimFilterResamplerType

filterType

)

Definition at line 830 of file ossimFilterResampler.cpp.

References setFilterType(), and theMinifyFilterType.

{
   setFilterType(theMinifyFilterType,filterType);
}

setMinifyFilterType() [1/2]

void ossimFilterResampler::setMinifyFilterType

(

const ossimString &

minifyType

)

Definition at line 814 of file ossimFilterResampler.cpp.

References getFilterType().

Referenced by loadState().

{
   setMinifyFilterType(getFilterType(minifyType));
}

setMinifyFilterType() [2/2]

void ossimFilterResampler::setMinifyFilterType

(

ossimFilterResamplerType

filterType

)

Definition at line 824 of file ossimFilterResampler.cpp.

References setFilterType(), and theMagnifyFilterType.

{
   setFilterType(filterType,
                 theMagnifyFilterType);
}

setScaleFactor()

void ossimFilterResampler::setScaleFactor

(

const ossimDpt &

scale

)

Definition at line 297 of file ossimFilterResampler.cpp.

References FLT_EPSILON, theInverseScaleFactor, theScaleFactor, ossimDpt::x, and ossimDpt::y.

Referenced by ossimImageRenderer::fillTile(), and ossimFilterResampler().

{
   theScaleFactor = scale;
   if(fabs(theScaleFactor.x) <= FLT_EPSILON)
   {
      theScaleFactor.x = 1.0;
   }
   if(fabs(theScaleFactor.y) <= FLT_EPSILON)
   {
      theScaleFactor.y = 1.0;
   }

   theInverseScaleFactor.x = 1.0/theScaleFactor.x;
   theInverseScaleFactor.y = 1.0/theScaleFactor.y;
}

Member Data Documentation

theBlurFactor

ossim_float64 ossimFilterResampler::theBlurFactor

private

Definition at line 148 of file ossimFilterResampler.h.

Referenced by getBlurFactor(), and setBlurFactor().

theFilterTable

ossimFilterTable ossimFilterResampler::theFilterTable

private

Definition at line 140 of file ossimFilterResampler.h.

Referenced by computeTable(), and resampleBilinearTile().

theInputRect

ossimIrect ossimFilterResampler::theInputRect

private

Definition at line 147 of file ossimFilterResampler.h.

theInverseScaleFactor

ossimDpt ossimFilterResampler::theInverseScaleFactor

private

Definition at line 145 of file ossimFilterResampler.h.

Referenced by loadState(), and setScaleFactor().

theMagnifyFilter

ossimFilter* ossimFilterResampler::theMagnifyFilter

private

Definition at line 139 of file ossimFilterResampler.h.

Referenced by computeTable(), getHorizontalFilter(), getVerticalFilter(), setFilterType(), and ~ossimFilterResampler().

theMagnifyFilterType

ossimFilterResamplerType ossimFilterResampler::theMagnifyFilterType

private

Definition at line 143 of file ossimFilterResampler.h.

Referenced by getMagnifyFilterTypeAsString(), saveState(), setFilterType(), and setMinifyFilterType().

theMinifyFilter

ossimFilter* ossimFilterResampler::theMinifyFilter

private

Definition at line 138 of file ossimFilterResampler.h.

Referenced by getHorizontalFilter(), getVerticalFilter(), setFilterType(), and ~ossimFilterResampler().

theMinifyFilterType

ossimFilterResamplerType ossimFilterResampler::theMinifyFilterType

private

Definition at line 142 of file ossimFilterResampler.h.

Referenced by getMinifyFilterTypeAsString(), saveState(), setFilterType(), and setMagnifyFilterType().

theScaleFactor

ossimDpt ossimFilterResampler::theScaleFactor

private

Definition at line 144 of file ossimFilterResampler.h.

Referenced by getHorizontalFilter(), getVerticalFilter(), loadState(), saveState(), and setScaleFactor().

---

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

• ossimFilterResampler.h
• ossimFilterResampler.cpp