393 lines
8.8 KiB
C++
393 lines
8.8 KiB
C++
/* Test +/-* overloads with every combination of vector, image and double.
|
|
* This isn't a full test suite, look in the Python area for that.
|
|
*
|
|
* compile with:
|
|
*
|
|
* g++ -g -Wall test_overloads.cpp `pkg-config vips-cpp --cflags --libs`
|
|
*
|
|
* run with:
|
|
*
|
|
* valgrind --leak-check=yes ./a.out ~/pics/k2.jpg ~/pics/shark.jpg
|
|
*
|
|
*/
|
|
|
|
/*
|
|
#define VIPS_DEBUG
|
|
#define VIPS_DEBUG_VERBOSE
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <vips/vips8>
|
|
|
|
using namespace vips;
|
|
|
|
bool
|
|
equal_vector( std::vector<double> a, std::vector<double> b )
|
|
{
|
|
for( unsigned int i = 0; i < a.size(); i++ )
|
|
if( fabs( a[i] - b[i] ) > 0.001 ) {
|
|
printf( "vectors differ at %u: should be [", i );
|
|
for( unsigned int i = 0; i < a.size(); i++ ) {
|
|
if( i > 0 )
|
|
printf( ", " );
|
|
printf( "%g", a[i] );
|
|
}
|
|
printf( "], is [" );
|
|
for( unsigned int i = 0; i < a.size(); i++ ) {
|
|
if( i > 0 )
|
|
printf( ", " );
|
|
printf( "%g", a[i] );
|
|
}
|
|
printf( "]\n" );
|
|
|
|
return( false );
|
|
}
|
|
|
|
return( true );
|
|
}
|
|
|
|
bool
|
|
equal_double( double a, double b )
|
|
{
|
|
if( fabs( a - b ) > 0.001 ) {
|
|
printf( "doubles differ: should be %g, is %g\n", a, b );
|
|
return( false );
|
|
}
|
|
|
|
return( true );
|
|
}
|
|
|
|
/* We can't do this with a template, I think we'd need partially-parameterised
|
|
* template, which is C++11 only.
|
|
*/
|
|
|
|
/* Only test a few points and only test uchar: we are just testing the C++
|
|
* overloads, we rely on the python test suite for testing the underlying
|
|
* vips operators.
|
|
*/
|
|
#define TEST_BINARY( OPERATOR ) \
|
|
void \
|
|
test_binary_##OPERATOR( VImage left, VImage right ) \
|
|
{ \
|
|
for( int x = 10; x < 30; x += 10 ) { \
|
|
std::vector<double> p_left = left.getpoint( x, x ); \
|
|
std::vector<double> p_right = right.getpoint( x, x ); \
|
|
std::vector<double> p_result = \
|
|
OPERATOR<std::vector<double>, \
|
|
std::vector<double>, \
|
|
std::vector<double> >(p_left, p_right ); \
|
|
\
|
|
VImage im_result; \
|
|
std::vector<double> p_im_result; \
|
|
\
|
|
/* test: image = image OP image \
|
|
*/ \
|
|
im_result = OPERATOR<VImage, VImage, VImage>( left, right ); \
|
|
p_im_result = im_result.getpoint( x, x ); \
|
|
\
|
|
if( !equal_vector( p_result, p_im_result ) ) { \
|
|
printf( #OPERATOR \
|
|
"(VImage, VImage) failed at (%d, %d)\n", \
|
|
x, x ); \
|
|
abort(); \
|
|
} \
|
|
\
|
|
/* test: image = image OP vec \
|
|
*/ \
|
|
im_result = \
|
|
OPERATOR<VImage, \
|
|
VImage, std::vector<double> >( left, p_right );\
|
|
p_im_result = im_result.getpoint( x, x ); \
|
|
\
|
|
if( !equal_vector( p_result, p_im_result ) ) { \
|
|
printf( #OPERATOR \
|
|
"(VImage, vector) failed at (%d, %d)\n", \
|
|
x, x ); \
|
|
abort(); \
|
|
} \
|
|
\
|
|
/* test: image = vec OP image \
|
|
*/ \
|
|
im_result = \
|
|
OPERATOR<VImage, std::vector<double>, \
|
|
VImage>( p_left, right ); \
|
|
p_im_result = im_result.getpoint( x, x ); \
|
|
\
|
|
if( !equal_vector( p_result, p_im_result ) ) { \
|
|
printf( #OPERATOR \
|
|
"(vector, VImage) failed at (%d, %d)\n", \
|
|
x, x ); \
|
|
abort(); \
|
|
} \
|
|
\
|
|
/* test: image = image OP double \
|
|
*/ \
|
|
for( unsigned int i = 0; i < p_right.size(); i++ ) { \
|
|
im_result = \
|
|
OPERATOR<VImage, \
|
|
VImage, double>( left, p_right[i] ); \
|
|
p_im_result = im_result.getpoint( x, x ); \
|
|
\
|
|
if( !equal_double( p_result[i], p_im_result[i] ) ) { \
|
|
printf( #OPERATOR \
|
|
"(VImage, double) failed at " \
|
|
"(%d, %d)\n", \
|
|
x, x ); \
|
|
abort(); \
|
|
} \
|
|
} \
|
|
\
|
|
/* test: image = double OP image \
|
|
*/ \
|
|
for( unsigned int i = 0; i < p_left.size(); i++ ) { \
|
|
im_result = \
|
|
OPERATOR<VImage, \
|
|
double, VImage>( p_left[i], right ); \
|
|
p_im_result = im_result.getpoint( x, x ); \
|
|
\
|
|
if( !equal_double( p_result[i], p_im_result[i] ) ) { \
|
|
printf( #OPERATOR \
|
|
"(double, VImage) failed at " \
|
|
"(%d, %d)\n", \
|
|
x, x ); \
|
|
abort(); \
|
|
} \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
// eg. double = double + double
|
|
// or image = double + image
|
|
template <typename A, typename B, typename C>
|
|
A test_add( B left, C right )
|
|
{
|
|
return( left + right );
|
|
}
|
|
|
|
template <typename T>
|
|
std::vector<T> operator+( std::vector<T> &v1, const std::vector<T> &v2 )
|
|
{
|
|
std::vector<T> result( v1.size() );
|
|
|
|
for( unsigned int i = 0; i < v1.size(); i++ )
|
|
result[i] = v1[i] + v2[i];
|
|
|
|
return( result );
|
|
}
|
|
|
|
TEST_BINARY( test_add );
|
|
|
|
template <typename A, typename B, typename C>
|
|
A test_subtract( B left, C right )
|
|
{
|
|
return( left - right );
|
|
}
|
|
|
|
template <typename T>
|
|
std::vector<T> operator-( std::vector<T> &v1, const std::vector<T> &v2 )
|
|
{
|
|
std::vector<T> result( v1.size() );
|
|
|
|
for( unsigned int i = 0; i < v1.size(); i++ )
|
|
result[i] = v1[i] - v2[i];
|
|
|
|
return( result );
|
|
}
|
|
|
|
TEST_BINARY( test_subtract );
|
|
|
|
template <typename A, typename B, typename C>
|
|
A test_multiply( B left, C right )
|
|
{
|
|
return( left * right );
|
|
}
|
|
|
|
template <typename T>
|
|
std::vector<T> operator*( std::vector<T> &v1, const std::vector<T> &v2 )
|
|
{
|
|
std::vector<T> result( v1.size() );
|
|
|
|
for( unsigned int i = 0; i < v1.size(); i++ )
|
|
result[i] = v1[i] * v2[i];
|
|
|
|
return( result );
|
|
}
|
|
|
|
TEST_BINARY( test_multiply );
|
|
|
|
template <typename A, typename B, typename C>
|
|
A test_divide( B left, C right )
|
|
{
|
|
return( left / right );
|
|
}
|
|
|
|
template <typename T>
|
|
std::vector<T> operator/( std::vector<T> &v1, const std::vector<T> &v2 )
|
|
{
|
|
std::vector<T> result( v1.size() );
|
|
|
|
for( unsigned int i = 0; i < v1.size(); i++ )
|
|
result[i] = v1[i] / v2[i];
|
|
|
|
return( result );
|
|
}
|
|
|
|
TEST_BINARY( test_divide );
|
|
|
|
/* We can't test remainder easily, vips does not support constant % image.
|
|
*/
|
|
|
|
/* We'd need an int version to test the bool operators, C++ does not like
|
|
* double & double.
|
|
*/
|
|
|
|
/* Only test a few points and only test uchar: we are just testing the C++
|
|
* overloads, we rely on the python test suite for testing the underlying
|
|
* vips operators.
|
|
*/
|
|
#define TEST_ASSIGNMENT( OPERATOR ) \
|
|
void \
|
|
test_assignment_##OPERATOR( VImage left, VImage right ) \
|
|
{ \
|
|
for( int x = 10; x < 30; x += 10 ) { \
|
|
std::vector<double> p_left = left.getpoint( x, x ); \
|
|
std::vector<double> p_right = right.getpoint( x, x ); \
|
|
std::vector<double> p_result = p_left; \
|
|
OPERATOR<std::vector<double>, \
|
|
std::vector<double> >( p_result, p_right ); \
|
|
\
|
|
/* test: image OP= image \
|
|
*/ \
|
|
VImage im_result = left; \
|
|
OPERATOR<VImage, VImage>( im_result, right ); \
|
|
std::vector<double> p_im_result = im_result.getpoint( x, x ); \
|
|
\
|
|
if( !equal_vector( p_result, p_im_result ) ) { \
|
|
printf( #OPERATOR \
|
|
"(VImage, VImage) failed at (%d, %d)\n", \
|
|
x, x ); \
|
|
abort(); \
|
|
} \
|
|
\
|
|
/* test: image OP= vec \
|
|
*/ \
|
|
im_result = left; \
|
|
OPERATOR<VImage, std::vector<double> >( im_result, p_right ); \
|
|
p_im_result = im_result.getpoint( x, x ); \
|
|
\
|
|
if( !equal_vector( p_result, p_im_result ) ) { \
|
|
printf( #OPERATOR \
|
|
"(VImage, vector) failed at (%d, %d)\n", \
|
|
x, x ); \
|
|
abort(); \
|
|
} \
|
|
\
|
|
\
|
|
/* test: image OP= double \
|
|
*/ \
|
|
for( unsigned int i = 0; i < p_left.size(); i++ ) { \
|
|
im_result = left; \
|
|
OPERATOR<VImage, double>( im_result, p_right[i] ); \
|
|
p_im_result = im_result.getpoint( x, x ); \
|
|
\
|
|
if( !equal_double( p_result[i], p_im_result[i] ) ) { \
|
|
printf( #OPERATOR \
|
|
"(VImage, double) failed at " \
|
|
"(%d, %d)\n", \
|
|
x, x ); \
|
|
abort(); \
|
|
} \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
template <typename T>
|
|
std::vector<T> & operator+=( std::vector<T> & a, std::vector<T> b )
|
|
{
|
|
return( a = a + b );
|
|
}
|
|
|
|
template <typename A, typename B>
|
|
void test_plusequals( A &left, B right )
|
|
{
|
|
left += right;
|
|
}
|
|
|
|
TEST_ASSIGNMENT( test_plusequals );
|
|
|
|
template <typename T>
|
|
std::vector<T> & operator-=( std::vector<T> & a, std::vector<T> b )
|
|
{
|
|
return( a = a - b );
|
|
}
|
|
|
|
template <typename A, typename B>
|
|
void test_minusequals( A &left, B right )
|
|
{
|
|
left -= right;
|
|
}
|
|
|
|
TEST_ASSIGNMENT( test_minusequals );
|
|
|
|
template <typename T>
|
|
std::vector<T> & operator*=( std::vector<T> & a, std::vector<T> b )
|
|
{
|
|
return( a = a * b );
|
|
}
|
|
|
|
template <typename A, typename B>
|
|
void test_timesequals( A &left, B right )
|
|
{
|
|
left *= right;
|
|
}
|
|
|
|
TEST_ASSIGNMENT( test_timesequals );
|
|
|
|
template <typename T>
|
|
std::vector<T> & operator/=( std::vector<T> & a, std::vector<T> b )
|
|
{
|
|
return( a = a / b );
|
|
}
|
|
|
|
template <typename A, typename B>
|
|
void test_divideequals( A &left, B right )
|
|
{
|
|
left /= right;
|
|
}
|
|
|
|
TEST_ASSIGNMENT( test_divideequals );
|
|
|
|
/* We can't test remainder easily, vips does not support constant % image.
|
|
*/
|
|
|
|
/* We'd need an int version to test the bool operators.
|
|
*/
|
|
|
|
int
|
|
main( int argc, char **argv )
|
|
{
|
|
if( VIPS_INIT( argv[0] ) )
|
|
vips_error_exit( NULL );
|
|
|
|
VImage left = VImage::new_from_file( argv[1] );
|
|
VImage right = VImage::new_from_file( argv[2] );
|
|
|
|
VImage band_one = left[1];
|
|
std::vector<double> point = left(0, 0);
|
|
|
|
test_binary_test_add( left, right );
|
|
test_binary_test_subtract( left, right );
|
|
test_binary_test_multiply( left, right );
|
|
test_binary_test_divide( left, right );
|
|
|
|
test_assignment_test_plusequals( left, right );
|
|
test_assignment_test_minusequals( left, right );
|
|
test_assignment_test_timesequals( left, right );
|
|
test_assignment_test_divideequals( left, right );
|
|
|
|
vips_shutdown();
|
|
|
|
return( 0 );
|
|
}
|