diff --git a/Code/BasicFilters/otbBCOInterpolateImageFunction.h b/Code/BasicFilters/otbBCOInterpolateImageFunction.h
index b717ea2cb297232777ff96dc2bf63383bd6ea0c8..e985904fd2292287a1060cd6ad1580c332a316be 100644
--- a/Code/BasicFilters/otbBCOInterpolateImageFunction.h
+++ b/Code/BasicFilters/otbBCOInterpolateImageFunction.h
@@ -21,44 +21,31 @@
#include "itkInterpolateImageFunction.h"
#include "vnl/vnl_vector.h"
+
+#include "otbVectorImage.h"
+
namespace otb
{
-
/** \class
- * \brief
+ * \brief
*
- *
- *
- *
- *
- *
- *
- *
- * \warning
- *
+ *
*
* \sa
- *
- * \ingroup ImageFunctions ImageInterpolators
+ * \sa
+ * \sa
*/
-template <
- class TInputImage,
- class TCoordRep = double>
-class ITK_EXPORT BCOInterpolateImageFunction :
- public itk::InterpolateImageFunction<TInputImage,TCoordRep>
+template< class TInputImage, class TCoordRep = double >
+class ITK_EXPORT BCOInterpolateImageFunctionBase :
+ public itk::InterpolateImageFunction<TInputImage,TCoordRep>
{
public:
/** Standard class typedefs. */
- typedef BCOInterpolateImageFunction Self;
+ typedef BCOInterpolateImageFunctionBase Self;
typedef itk::InterpolateImageFunction<TInputImage,TCoordRep> Superclass;
- typedef itk::SmartPointer<Self> Pointer;
- typedef itk::SmartPointer<const Self> ConstPointer;
/** Run-time type information (and related methods). */
- itkTypeMacro(BCOInterpolateImageFunction, InterpolateImageFunction);
-
- /** Method for creation through the object factory. */
- itkNewMacro(Self);
+ itkTypeMacro(BCOInterpolateImageFunctionBase, InterpolateImageFunction);
/** OutputType typedef support. */
typedef typename Superclass::OutputType OutputType;
@@ -70,9 +57,8 @@ public:
typedef typename Superclass::InputPixelType InputPixelType;
/** RealType typedef support. */
- //typedef typename Superclass::RealType RealType;
- typedef typename itk::NumericTraits<typename TInputImage::PixelType>::RealType RealType;
-
+ typedef typename Superclass::RealType RealType;
+
/** Dimension underlying input image. */
itkStaticConstMacro(ImageDimension, unsigned int,Superclass::ImageDimension);
@@ -89,36 +75,6 @@ public:
/** Coeficients container type.*/
typedef vnl_vector<double> CoefContainerType;
- /** Interpolate the image at a point position
- *
- * Returns the interpolated image intensity at a
- * specified point position. No bounds checking is done.
- * The point is assume to lie within the image buffer.
- *
- * ImageFunction::IsInsideBuffer() can be used to check bounds before
- * calling the method. */
- //virtual OutputType Evaluate( const PointType& point ) const;//////////////////////////////////////////////////
-
- /** Evaluate the function at a ContinuousIndex position
- *
- * Returns the linearly interpolated image intensity at a
- * specified point position. No bounds checking is done.
- * The point is assume to lie within the image buffer.
- *
- * ImageFunction::IsInsideBuffer() can be used to check bounds before
- * calling the method. */
- virtual OutputType EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const;/////////////////////
-
- /** Interpolate the image at an index position.
- *
- * Simply returns the image value at the
- * specified index position. No bounds checking is done.
- * The point is assume to lie within the image buffer.
- *
- * ImageFunction::IsInsideBuffer() can be used to check bounds before
- * calling the method. */
- //virtual OutputType EvaluateAtIndex( const IndexType & index ) const;//////////////////////////////////////////
-
/** Set/Get the window radius */
virtual void SetRadius(unsigned int radius);
virtual unsigned int GetRadius() const;
@@ -127,16 +83,27 @@ public:
virtual void SetAlpha(double alpha);
virtual double GetAlpha() const;
- /** Compute the BCO coefficients. */
- void EvaluateCoef();
+ /** Evaluate the function at a ContinuousIndex position
+ *
+ * Returns the linearly interpolated image intensity at a
+ * specified point position. No bounds checking is done.
+ * The point is assume to lie within the image buffer.
+ *
+ * ImageFunction::IsInsideBuffer() can be used to check bounds before
+ * calling the method. */
+ //virtual OutputType EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const = 0;
protected:
- BCOInterpolateImageFunction();
- ~BCOInterpolateImageFunction();
+ BCOInterpolateImageFunctionBase();
+ ~BCOInterpolateImageFunctionBase();
void PrintSelf(std::ostream& os, itk::Indent indent) const;
+ /** Compute the BCO coefficients. */
+ virtual void EvaluateCoef();
+ virtual double GetBCOCoef(unsigned int idx) const;
+
private:
- BCOInterpolateImageFunction( const Self& ); //purposely not implemented
+ BCOInterpolateImageFunctionBase( const Self& ); //purposely not implemented
void operator=( const Self& ); //purposely not implemented
/** Used radius for the BCO */
@@ -148,6 +115,82 @@ private:
};
+template < class TInputImage, class TCoordRep = double >
+class ITK_EXPORT BCOInterpolateImageFunction :
+ public otb::BCOInterpolateImageFunctionBase< TInputImage, TCoordRep >
+{
+public:
+ /** Standard class typedefs. */
+ typedef BCOInterpolateImageFunction Self;
+ typedef BCOInterpolateImageFunctionBase<TInputImage,TCoordRep> Superclass;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
+
+ itkTypeMacro(BCOInterpolateImageFunction, BCOInterpolateImageFunctionBase);
+ itkNewMacro(Self);
+ itkStaticConstMacro(ImageDimension, unsigned int,Superclass::ImageDimension);
+
+ typedef typename Superclass::OutputType OutputType;
+ typedef typename Superclass::InputImageType InputImageType;
+ typedef typename Superclass::InputPixelType InputPixelType;
+ typedef typename Superclass::RealType RealType;
+ typedef typename Superclass::IndexType IndexType;
+ typedef typename Superclass::IndexValueType IndexValueType;
+ typedef typename Superclass::PointType PointType;
+ typedef typename Superclass::ContinuousIndexType ContinuousIndexType;
+ typedef typename Superclass::CoefContainerType CoefContainerType;
+
+ virtual OutputType EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const;
+
+protected:
+ BCOInterpolateImageFunction();
+ ~BCOInterpolateImageFunction();
+ void PrintSelf(std::ostream& os, itk::Indent indent) const;
+
+private:
+ BCOInterpolateImageFunction( const Self& ); //purposely not implemented
+ void operator=( const Self& ); //purposely not implemented
+};
+
+
+template < typename TPixel, unsigned int VImageDimension, class TCoordRep >
+class ITK_EXPORT BCOInterpolateImageFunction< otb::VectorImage<TPixel,VImageDimension> , TCoordRep > :
+ public otb::BCOInterpolateImageFunctionBase< otb::VectorImage<TPixel,VImageDimension> , TCoordRep >
+{
+public:
+ /** Standard class typedefs.*/
+ typedef BCOInterpolateImageFunction Self;
+ typedef BCOInterpolateImageFunctionBase
+ < otb::VectorImage<TPixel,VImageDimension>, TCoordRep > Superclass;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
+
+ itkTypeMacro(BCOInterpolateImageFunction, BCOInterpolateImageFunctionBase);
+ itkNewMacro(Self);
+ itkStaticConstMacro(ImageDimension, unsigned int,Superclass::ImageDimension);
+
+ typedef typename Superclass::OutputType OutputType;
+ typedef typename Superclass::InputImageType InputImageType;
+ typedef typename Superclass::InputPixelType InputPixelType;
+ typedef typename Superclass::RealType RealType;
+ typedef typename Superclass::IndexType IndexType;
+ typedef typename Superclass::IndexValueType IndexValueType;
+ typedef typename Superclass::PointType PointType;
+ typedef typename Superclass::ContinuousIndexType ContinuousIndexType;
+ typedef typename Superclass::CoefContainerType CoefContainerType;
+
+ virtual OutputType EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const;
+
+protected:
+ BCOInterpolateImageFunction();
+ ~BCOInterpolateImageFunction();
+ void PrintSelf(std::ostream& os, itk::Indent indent) const;
+
+private:
+ BCOInterpolateImageFunction( const Self& ); //purposely not implemented
+ void operator=( const Self& ); //purposely not implemented
+};
+
} // end namespace otb
#ifndef OTB_MANUAL_INSTANTIATION
diff --git a/Code/BasicFilters/otbBCOInterpolateImageFunction.txx b/Code/BasicFilters/otbBCOInterpolateImageFunction.txx
index 929a50d7503fd3b4812af7a4f971dbdcadf4aa94..20adcf530e23b3dc298d3ef8fcb399c2454b24c1 100644
--- a/Code/BasicFilters/otbBCOInterpolateImageFunction.txx
+++ b/Code/BasicFilters/otbBCOInterpolateImageFunction.txx
@@ -15,8 +15,8 @@
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
-#ifndef __otbProlateInterpolateImageFunction_txx
-#define __otbProlateInterpolateImageFunction_txx
+#ifndef __otbBCOInterpolateImageFunction_txx
+#define __otbBCOInterpolateImageFunction_txx
#include "otbBCOInterpolateImageFunction.h"
@@ -27,19 +27,127 @@ namespace otb
/** Constructor */
template <class TInputImage, class TCoordRep>
-BCOInterpolateImageFunction<TInputImage, TCoordRep>
-::BCOInterpolateImageFunction()
+BCOInterpolateImageFunctionBase<TInputImage, TCoordRep>
+::BCOInterpolateImageFunctionBase()
{
m_Radius = 1;
m_Alpha = -0.5;
+ this->EvaluateCoef();
}
/** Destructor */
template <class TInputImage, class TCoordRep>
+BCOInterpolateImageFunctionBase<TInputImage, TCoordRep>
+::~BCOInterpolateImageFunctionBase()
+{
+}
+
+template <class TInputImage, class TCoordRep>
+void BCOInterpolateImageFunctionBase<TInputImage, TCoordRep>
+::PrintSelf(std::ostream& os, itk::Indent indent) const
+{
+ Superclass::PrintSelf(os, indent);
+}
+
+template <class TInputImage, class TCoordRep>
+void BCOInterpolateImageFunctionBase<TInputImage, TCoordRep>
+::SetRadius(unsigned int radius)
+{
+ if (radius == 0)
+ {
+ itkExceptionMacro(<< "Radius Must Be Strictly Superior to 0");
+ }
+ else
+ {
+ m_Radius = radius;
+ this->EvaluateCoef();
+ }
+}
+
+template <class TInputImage, class TCoordRep>
+unsigned int BCOInterpolateImageFunctionBase<TInputImage, TCoordRep>
+::GetRadius() const
+{
+ return m_Radius;
+}
+
+template <class TInputImage, class TCoordRep>
+void BCOInterpolateImageFunctionBase<TInputImage, TCoordRep>
+::SetAlpha(double alpha)
+{
+ m_Alpha = alpha;
+ this->EvaluateCoef();
+}
+
+template <class TInputImage, class TCoordRep>
+double BCOInterpolateImageFunctionBase<TInputImage, TCoordRep>
+::GetAlpha() const
+{
+ return m_Alpha;
+}
+
+template <class TInputImage, class TCoordRep>
+double BCOInterpolateImageFunctionBase<TInputImage, TCoordRep>
+::GetBCOCoef(unsigned int idx) const
+{
+ return m_BCOCoef[idx];
+}
+
+template<class TInputImage, class TCoordRep>
+void
+BCOInterpolateImageFunctionBase<TInputImage, TCoordRep>
+::EvaluateCoef()
+{
+ // Init BCO coefficient container
+ unsigned int size = 2*m_Radius+1;
+ m_BCOCoef = CoefContainerType(size, 0.);
+ double val = 0.;
+ double step = 1./static_cast<double>(size);
+
+ // Compute BCO coefficients
+ for (unsigned int i = 0; i <= m_Radius; i++)
+ {
+ // Compute the distance according to alpha.
+ double d = val;
+ if( d <= 2. )
+ {
+ if (d <= 1.)
+ {
+ m_BCOCoef[m_Radius+i] = (m_Alpha + 2.)*vcl_abs(vcl_pow(d, 3)) - (m_Alpha + 3.)*vcl_pow(d, 2) + 1;
+ }
+ else
+ {
+ m_BCOCoef[m_Radius+i] = m_Alpha*vcl_abs(vcl_pow(d, 3)) - 5*m_Alpha*vcl_pow(d, 2) + 8*m_Alpha*vcl_abs(d) - 4*m_Alpha;
+ }
+ }
+ else
+ {
+ m_BCOCoef[m_Radius+i] = 0;
+ }
+
+ if(i>0)
+ {
+ // the filter is symteric
+ m_BCOCoef[m_Radius-i] = m_BCOCoef[m_Radius+i];
+ }
+ val = val + step;
+ }
+ }
+
+
+
+/** Constructor */
+template <class TInputImage, class TCoordRep>
BCOInterpolateImageFunction<TInputImage, TCoordRep>
-::~BCOInterpolateImageFunction()
+::BCOInterpolateImageFunction()
{
+}
+/** Destructor */
+template <class TInputImage, class TCoordRep>
+BCOInterpolateImageFunction<TInputImage, TCoordRep>
+::~BCOInterpolateImageFunction()
+{
}
template <class TInputImage, class TCoordRep>
@@ -56,41 +164,26 @@ BCOInterpolateImageFunction<TInputImage, TCoordRep>
::EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const
{
unsigned int dim; // index over dimension
- unsigned int neighborNumber = (2*m_Radius+1) * (2*m_Radius+1);
-
+ unsigned int neighborNumber = (2*this->GetRadius()+1) * (2*this->GetRadius()+1);
+ IndexType baseIndex;
+ IndexType neighIndex;
+ RealType value = itk::NumericTraits<RealType>::Zero;
+ vnl_vector<RealType> lineRes(2*this->GetRadius()+1, 0.);
/**
* Compute base index = closet index below point
- * Compute distance from point to base index
*/
- IndexType baseIndex;
- double distance[ImageDimension];
-
for( dim = 0; dim < ImageDimension; dim++ )
{
baseIndex[dim] = itk::Math::Floor< IndexValueType >( index[dim] );
}
- /*
- std::cout << "index : " << index << std::endl;
- std::cout << "baseIndex : " << baseIndex << std::endl;
- */
-
- RealType value = 0;
-
-
- IndexType neighIndex;
- neighIndex.Fill(0);
-
- vnl_vector<RealType> lineRes(2*m_Radius+1, 0.);
-
for( unsigned int counter = 0; counter < neighborNumber; counter++ )
{
unsigned int upper = counter; // each bit indicates upper/lower neighbour
double BCOCoefIndex; //link beetween counter and BCO Coeff.
-
// get neighbor index
for( dim = 0; dim < ImageDimension; dim++ )
{
@@ -120,104 +213,149 @@ BCOInterpolateImageFunction<TInputImage, TCoordRep>
}
upper >>= 1;
- }
+ }
+ BCOCoefIndex = static_cast<int>(counter - floor(counter/(2*this->GetRadius()+1))*(2*this->GetRadius()+1));
+
// Proceed column
- BCOCoefIndex = static_cast<int>(counter - floor(counter/(2*m_Radius+1))*(2*m_Radius+1));
lineRes[BCOCoefIndex] = lineRes[BCOCoefIndex]
- + static_cast<RealType>( this->GetInputImage()->GetPixel( neighIndex ) ) * m_BCOCoef(BCOCoefIndex) ;
+ + static_cast<RealType>( this->GetInputImage()->GetPixel( neighIndex ) ) * this->GetBCOCoef(BCOCoefIndex) ;
}
-
//Proceed line
for(unsigned int l=0; l<lineRes.size(); l++)
{
- value = value + lineRes[l]*m_BCOCoef(l);
+ value = value + lineRes[l]*this->GetBCOCoef(l);
}
-
- std::cout << "Fin " << value / (2*m_Radius * 2*m_Radius) << std::endl;
- return ( static_cast<OutputType>( value / (2*m_Radius * 2*m_Radius) ) );
+
+ return ( static_cast<OutputType>( value / neighborNumber ) );
}
-template <class TInputImage, class TCoordRep>
-void BCOInterpolateImageFunction<TInputImage, TCoordRep>
-::SetRadius(unsigned int radius)
+/** Constructor */
+template < typename TPixel, unsigned int VImageDimension, class TCoordRep >
+BCOInterpolateImageFunction< otb::VectorImage<TPixel,VImageDimension> , TCoordRep >
+::BCOInterpolateImageFunction()
{
- if (radius == 0)
- {
- itkExceptionMacro(<< "Radius Must Be Strictly Superior to 0");
- }
- else
- {
- m_Radius = radius;
- }
}
-template <class TInputImage, class TCoordRep>
-unsigned int BCOInterpolateImageFunction<TInputImage, TCoordRep>
-::GetRadius() const
+/** Destructor */
+template < typename TPixel, unsigned int VImageDimension, class TCoordRep >
+BCOInterpolateImageFunction< otb::VectorImage<TPixel,VImageDimension> , TCoordRep >
+::~BCOInterpolateImageFunction()
{
- return m_Radius;
}
-template <class TInputImage, class TCoordRep>
-void BCOInterpolateImageFunction<TInputImage, TCoordRep>
-::SetAlpha(double alpha)
+template < typename TPixel, unsigned int VImageDimension, class TCoordRep >
+void BCOInterpolateImageFunction< otb::VectorImage<TPixel,VImageDimension> , TCoordRep >
+::PrintSelf(std::ostream& os, itk::Indent indent) const
{
- m_Alpha = alpha;
+ Superclass::PrintSelf(os, indent);
}
-template <class TInputImage, class TCoordRep>
-double BCOInterpolateImageFunction<TInputImage, TCoordRep>
-::GetAlpha() const
+template < typename TPixel, unsigned int VImageDimension, class TCoordRep >
+typename BCOInterpolateImageFunction< otb::VectorImage<TPixel,VImageDimension> , TCoordRep >
+::OutputType
+BCOInterpolateImageFunction< otb::VectorImage<TPixel,VImageDimension> , TCoordRep >
+::EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const
{
- return m_Alpha;
-}
+ typedef typename itk::NumericTraits<InputPixelType>::ScalarRealType ScalarRealType;
-template<class TInputImage, class TCoordRep>
-void
-BCOInterpolateImageFunction<TInputImage, TCoordRep>
-::EvaluateCoef()
-{
- // Init BCO coefficient container
- unsigned int size = 2*m_Radius+1;
- m_BCOCoef = CoefContainerType(size, 0.);
- double val = 0.;
- //double step = 1./static_cast<double>(m_Radius);
- double step = 1./static_cast<double>(size);
+ unsigned int dim; // index over dimension
+ unsigned int neighborNumber = (2*this->GetRadius()+1) * (2*this->GetRadius()+1);
+ unsigned int componentNumber = this->GetInputImage()->GetNumberOfComponentsPerPixel();
+ IndexType baseIndex;
+ IndexType neighIndex;
+ std::vector< std::vector< ScalarRealType > > lineRes;
+ lineRes.resize(2*this->GetRadius()+1);
+ for( unsigned int i = 0; i<2*this->GetRadius()+1; i++)
+ {
+ lineRes.at(i).resize(componentNumber);
+ for( unsigned int j = 0; j<componentNumber; j++)
+ {
+ lineRes.at(i).at(j) = itk::NumericTraits<ScalarRealType>::Zero;
+ }
+ }
+ std::vector< ScalarRealType > value;
+ value.resize(componentNumber);
+ for( unsigned int j = 0; j<componentNumber; j++)
+ {
+ value.at(j) = itk::NumericTraits<ScalarRealType>::Zero;
+ }
+ OutputType output;
+ output.SetSize(1);
+ /**
+ * Compute base index = closet index below point
+ */
+ for( dim = 0; dim < ImageDimension; dim++ )
+ {
+ baseIndex[dim] = itk::Math::Floor< IndexValueType >( index[dim] );
+ }
+
- // Compute BCO coefficients
- for (unsigned int i = 0; i <= m_Radius; i++)
+ for( unsigned int counter = 0; counter < neighborNumber; counter++ )
{
- // Compute the distance according to alpha.
- double d = val;
- if( d <= 2. )
+
+ unsigned int upper = counter; // each bit indicates upper/lower neighbour
+ double BCOCoefIndex; //link beetween counter and BCO Coeff.
+
+ // get neighbor index
+ for( dim = 0; dim < ImageDimension; dim++ )
{
- if (d <= 1.)
+ if ( upper & 1 )
{
- m_BCOCoef[m_Radius+i] = (m_Alpha + 2.)*vcl_abs(vcl_pow(d, 3)) - (m_Alpha + 3.)*vcl_pow(d, 2) + 1;
+ neighIndex[dim] = baseIndex[dim] + 1;
+#ifdef ITK_USE_CENTERED_PIXEL_COORDINATES_CONSISTENTLY
+ // Take care of the case where the pixel is just
+ // in the outer upper boundary of the image grid.
+ if( neighIndex[dim] > this->m_EndIndex[dim] )
+ {
+ neighIndex[dim] = this->m_EndIndex[dim];
+ }
+#endif
}
else
{
- m_BCOCoef[m_Radius+i] = m_Alpha*vcl_abs(vcl_pow(d, 3)) - 5*m_Alpha*vcl_pow(d, 2) + 8*m_Alpha*vcl_abs(d) - 4*m_Alpha;
- }
+ neighIndex[dim] = baseIndex[dim];
+#ifdef ITK_USE_CENTERED_PIXEL_COORDINATES_CONSISTENTLY
+ // Take care of the case where the pixel is just
+ // in the outer lower boundary of the image grid.
+ if( neighIndex[dim] < this->m_StartIndex[dim] )
+ {
+ neighIndex[dim] = this->m_StartIndex[dim];
+ }
+#endif
+ }
+
+ upper >>= 1;
}
- else
+ BCOCoefIndex = static_cast<int>(counter - floor(counter/(2*this->GetRadius()+1))*(2*this->GetRadius()+1));
+
+ // Proceed column
+ for( unsigned int j = 0; j<componentNumber; j++)
{
- m_BCOCoef[m_Radius+i] = 0;
+ lineRes.at(BCOCoefIndex).at(j) = lineRes.at(BCOCoefIndex).at(j)
+ + this->GetInputImage()->GetPixel( neighIndex ).GetElement(j) * this->GetBCOCoef(BCOCoefIndex);
}
-
- if(i>0)
+ }
+
+ //Proceed line
+ for(unsigned int l=0; l<2*this->GetRadius()+1; l++)
+ {
+ for( unsigned int j = 0; j<componentNumber; j++)
{
- // the filter is symtric
- m_BCOCoef[m_Radius-i] = m_BCOCoef[m_Radius+i];
+ value.at(j) = value.at(j) + lineRes.at(l).at(j)*this->GetBCOCoef(l);
}
- val = val + step;
}
- std::cout << m_BCOCoef << std::endl;
-
- }
+
+ for( unsigned int j = 0; j<componentNumber; j++)
+ {
+ value.at(j) = value.at(j) / neighborNumber;
+ output.SetElement(j, value.at(j));
+ }
+
+ return ( output );
+}
} //namespace otb
diff --git a/Testing/Code/BasicFilters/CMakeLists.txt b/Testing/Code/BasicFilters/CMakeLists.txt
index 339410a01fc696436144b8f6867e0666e4315db0..4e6cead6b437661817e6fb74de0cbdee159b39c2 100644
--- a/Testing/Code/BasicFilters/CMakeLists.txt
+++ b/Testing/Code/BasicFilters/CMakeLists.txt
@@ -673,7 +673,7 @@ ADD_TEST(bfTvProlateInterpolateImageFunction ${BASICFILTERS_TESTS6}
${TEMP}/bfProlateInterpolateImageFunctionCosOutput.tif
${TEMP}/bfProlateInterpolateImageFunctionITKCosOutput.tif
${TEMP}/bfProlateInterpolateImageFunctionProOutput.tif
- 50 # radius
+ 3 # radius
0.5 0.5
127.33 44.9
259.67 21.43
@@ -736,23 +736,59 @@ ADD_TEST(bfTvWindowedSincInterpolateImageHammingFunction ${BASICFILTERS_TESTS6}
# ------- otb::BCOInterpolateImageFunction ------------------------------
ADD_TEST(bfTuBCOInterpolateImageFunctionNew ${BASICFILTERS_TESTS6}
- otbBCOInterpolateImageFunctionNew)
+ otbBCOInterpolateImageFunctionNew
+ )
ADD_TEST(bfTvBCOInterpolateImageFunction ${BASICFILTERS_TESTS6}
- otbBCOInterpolateImageFunction
- ${INPUTDATA}/poupees.tif
- ${TEMP}/bfBCOInterpolateImageFunctionOutput.txt
- 50 # radius
- -0.5 # optimised bicubic
- 0.5 0.5
- 127.33 44.9
- 259.67 21.43
- 12.13 61.79
- 89.5 11
- 128 128
- 127.255 128.73
- -1 -1
- )
+ otbBCOInterpolateImageFunction
+ ${INPUTDATA}/poupees.tif
+ ${TEMP}/bfBCOInterpolateImageFunctionOutput.txt
+ 3 # radius
+ -0.5 # optimised bicubic
+ 0.5 0.5
+ 127.33 44.9
+ 259.67 21.43
+ 12.13 61.79
+ 89.5 11
+ 128 128
+ 127.255 128.73
+ -1 -1
+ )
+
+ADD_TEST(bfTuBCOInterpolateImageFunctionOverVectorImageNew ${BASICFILTERS_TESTS6}
+ otbBCOInterpolateImageFunctionOverVectorImageNew)
+
+ADD_TEST(bfTvBCOInterpolateImageFunctionOverVectorImage ${BASICFILTERS_TESTS6}
+ otbBCOInterpolateImageFunctionOverVectorImage
+ ${INPUTDATA}/poupees.tif
+ ${TEMP}/bfBCOInterpolateImageFunctionOverVectorImageOutput.txt
+ 3 # radius
+ -0.5 # optimised bicubic
+ 0.5 0.5
+ 127.33 44.9
+ 259.67 21.43
+ 12.13 61.79
+ 89.5 11
+ 128 128
+ 127.255 128.73
+ -1 -1
+ )
+
+ADD_TEST(bfTvBCOInterpolateImageFunctionTest ${BASICFILTERS_TESTS6}
+ otbBCOInterpolateImageFunctionTest
+ ${INPUTDATA}/poupees.tif
+ ${TEMP}/bfBCOInterpolateImageFunctionTest.tif
+ 3 # radius
+ -0.5 # optimised bicubic
+ )
+
+ADD_TEST(bfTvBCOInterpolateImageFunctionVectorImageTest ${BASICFILTERS_TESTS6}
+ otbBCOInterpolateImageFunctionVectorImageTest
+ ${INPUTDATA}/poupees.tif
+ ${TEMP}/bfBCOInterpolateImageFunctionVectorImageTest.tif
+ 3 # radius
+ -0.5 # optimised bicubic
+ )
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/Testing/Code/BasicFilters/otbBCOInterpolateImageFunction.cxx b/Testing/Code/BasicFilters/otbBCOInterpolateImageFunction.cxx
index a1ffa9cc88c202c4f476e1b55062827769caa010..1bc84868743914862b82adf719d2674cc8ce5c36 100644
--- a/Testing/Code/BasicFilters/otbBCOInterpolateImageFunction.cxx
+++ b/Testing/Code/BasicFilters/otbBCOInterpolateImageFunction.cxx
@@ -22,11 +22,13 @@
#include "otbImage.h"
#include "otbImageFileReader.h"
#include <fstream>
+#include "otbStreamingImageFileWriter.h"
+#include "otbStreamingResampleImageFilter.h"
int otbBCOInterpolateImageFunctionNew(int argc, char * argv[])
{
typedef otb::Image<double, 2> ImageType;
- typedef otb::BCOInterpolateImageFunction<ImageType, double> InterpolatorType;
+ typedef otb::BCOInterpolateImageFunction<ImageType, double> InterpolatorType;
// Instantiating object
InterpolatorType::Pointer filter = InterpolatorType::New();
@@ -41,8 +43,6 @@ int otbBCOInterpolateImageFunction(int argc, char * argv[])
const unsigned int radius = atoi(argv[3]);
const double alpha = atof(argv[4]);
- //typedef otb::VectorImage<double, 2> ImageType;
-
typedef otb::Image<double, 2> ImageType;
typedef otb::BCOInterpolateImageFunction<ImageType, double> InterpolatorType;
typedef InterpolatorType::ContinuousIndexType ContinuousIndexType;
@@ -79,9 +79,6 @@ int otbBCOInterpolateImageFunction(int argc, char * argv[])
std::cout << "Radius Checking : " << std::endl << filter->GetRadius() << std::endl;
filter->SetRadius(radius);
std::cout << filter->GetRadius() << std::endl;
- std::cout << "Coef Checking : " << std::endl;
- filter->EvaluateCoef();
- std::cout << "Coef Generated ! " << std::endl;
filter->SetInputImage(reader->GetOutput());
@@ -95,6 +92,164 @@ int otbBCOInterpolateImageFunction(int argc, char * argv[])
file.close();
+ return EXIT_SUCCESS;
+}
+
+
+int otbBCOInterpolateImageFunctionOverVectorImageNew(int argc, char * argv[])
+{
+ typedef otb::VectorImage<double, 2> ImageType;
+ typedef otb::BCOInterpolateImageFunction<ImageType, double> InterpolatorType;
+
+ // Instantiating object
+ InterpolatorType::Pointer filter = InterpolatorType::New();
+
+ return EXIT_SUCCESS;
+}
+
+
+int otbBCOInterpolateImageFunctionOverVectorImage(int argc, char * argv[])
+{
+ const char * infname = argv[1];
+ const char * outfname = argv[2];
+ const unsigned int radius = atoi(argv[3]);
+ const double alpha = atof(argv[4]);
+
+ typedef otb::VectorImage<double, 2> ImageType;
+ typedef otb::BCOInterpolateImageFunction<ImageType, double> InterpolatorType;
+ typedef InterpolatorType::ContinuousIndexType ContinuousIndexType;
+ typedef otb::ImageFileReader<ImageType> ReaderType;
+
+ int i = 5;
+
+ std::vector<ContinuousIndexType> indicesList;
+
+ while (i < argc && (i + 1) < argc)
+ {
+ ContinuousIndexType idx;
+
+ idx[0] = atof(argv[i]);
+ idx[1] = atof(argv[i + 1]);
+
+ indicesList.push_back(idx);
+
+ i += 2;
+ }
+
+ // Instantiating object
+ InterpolatorType::Pointer filter = InterpolatorType::New();
+
+ ReaderType::Pointer reader = ReaderType::New();
+ reader->SetFileName(infname);
+ reader->Update();//TODO check if necessary
+
+ std::cout << "Alpha Checking : " << std::endl << filter->GetAlpha() << std::endl;
+ filter->SetAlpha(-1.0);
+ std::cout << filter->GetAlpha() << std::endl;
+ filter->SetAlpha(alpha);
+ std::cout << filter->GetAlpha() << std::endl;
+ std::cout << "Radius Checking : " << std::endl << filter->GetRadius() << std::endl;
+ filter->SetRadius(radius);
+ std::cout << filter->GetRadius() << std::endl;
+
+ filter->SetInputImage(reader->GetOutput());
+
+ std::ofstream file;
+ file.open(outfname);
+
+ for (std::vector<ContinuousIndexType>::iterator it = indicesList.begin(); it != indicesList.end(); ++it)
+ {
+ file << (*it) << " -> " << filter->EvaluateAtContinuousIndex((*it)) << std::endl;
+ }
+
+ file.close();
+
+ return EXIT_SUCCESS;
+}
+
+
+int otbBCOInterpolateImageFunctionTest(int argc, char * argv[])
+{
+
+ const char * infname = argv[1];
+ const char * outfname = argv[2];
+ const unsigned int radius = atoi(argv[3]);
+ const double alpha = atof(argv[4]);
+
+ typedef otb::Image<double, 2> ImageType;
+ typedef otb::ImageFileReader<ImageType> ReaderType;
+ typedef otb::StreamingResampleImageFilter<ImageType,ImageType,double> StreamingResampleImageFilterType;
+ typedef otb::BCOInterpolateImageFunction<ImageType, double> InterpolatorType;
+ typedef otb::StreamingImageFileWriter<ImageType> WriterType;
+
+ // Instantiating objects
+ ReaderType::Pointer reader = ReaderType::New();
+ WriterType::Pointer writer = WriterType::New();
+ StreamingResampleImageFilterType::Pointer resampler = StreamingResampleImageFilterType::New();
+ InterpolatorType::Pointer interpolator = InterpolatorType::New();
+
+ reader->SetFileName(infname);
+ reader->Update();
+
+ interpolator->SetInputImage(reader->GetOutput());
+ interpolator->SetRadius(radius);
+ interpolator->SetAlpha(alpha);
+
+ resampler->SetInput(reader->GetOutput());
+ resampler->SetInterpolator(interpolator);
+ StreamingResampleImageFilterType::SizeType size;
+ size[0] = 256;
+ size[1] = 256;
+ resampler->SetOutputSize(size);
+ resampler->SetOutputSpacing(2);
+ resampler->Update();
+ // Result of resampler is written
+ writer->SetInput(resampler->GetOutput());
+ writer->SetFileName(outfname);
+ writer->Update();
+
+ return EXIT_SUCCESS;
+}
+
+int otbBCOInterpolateImageFunctionVectorImageTest(int argc, char * argv[])
+{
+
+ const char * infname = argv[1];
+ const char * outfname = argv[2];
+ const unsigned int radius = atoi(argv[3]);
+ const double alpha = atof(argv[4]);
+
+ typedef otb::VectorImage<double, 2> ImageType;
+ typedef otb::ImageFileReader<ImageType> ReaderType;
+ typedef otb::StreamingResampleImageFilter<ImageType,ImageType,double> StreamingResampleImageFilterType;
+ typedef otb::BCOInterpolateImageFunction<ImageType, double> InterpolatorType;
+ typedef otb::StreamingImageFileWriter<ImageType> WriterType;
+
+ // Instantiating objects
+ ReaderType::Pointer reader = ReaderType::New();
+ WriterType::Pointer writer = WriterType::New();
+ StreamingResampleImageFilterType::Pointer resampler = StreamingResampleImageFilterType::New();
+ InterpolatorType::Pointer interpolator = InterpolatorType::New();
+
+ reader->SetFileName(infname);
+ reader->Update();
+
+ interpolator->SetInputImage(reader->GetOutput());
+ interpolator->SetRadius(radius);
+ interpolator->SetAlpha(alpha);
+
+ resampler->SetInput(reader->GetOutput());
+ resampler->SetInterpolator(interpolator);
+ StreamingResampleImageFilterType::SizeType size;
+ size[0] = 171;
+ size[1] = 171;
+ resampler->SetOutputSize(size);
+ resampler->SetOutputSpacing(3);
+ resampler->Update();
+ // Result of resampler is written
+ writer->SetInput(resampler->GetOutput());
+ writer->SetFileName(outfname);
+ writer->Update();
return EXIT_SUCCESS;
}
diff --git a/Testing/Code/BasicFilters/otbBasicFiltersTests6.cxx b/Testing/Code/BasicFilters/otbBasicFiltersTests6.cxx
index 3540b7dfd630bee59b4373e7cd25b0787fcfd79a..883fa464bcae9390850f92899e6722d062a15b04 100644
--- a/Testing/Code/BasicFilters/otbBasicFiltersTests6.cxx
+++ b/Testing/Code/BasicFilters/otbBasicFiltersTests6.cxx
@@ -39,4 +39,8 @@ void RegisterTests()
REGISTER_TEST(otbWindowedSincInterpolateImageHammingFunction);
REGISTER_TEST(otbBCOInterpolateImageFunctionNew);
REGISTER_TEST(otbBCOInterpolateImageFunction);
+ REGISTER_TEST(otbBCOInterpolateImageFunctionOverVectorImageNew);
+ REGISTER_TEST(otbBCOInterpolateImageFunctionOverVectorImage);
+ REGISTER_TEST(otbBCOInterpolateImageFunctionTest);
+ REGISTER_TEST(otbBCOInterpolateImageFunctionVectorImageTest);
}