sharp 0.25.4 → 0.26.0

package/src/libvips/cplusplus/VImage.cpp

@@ -5,7 +5,7 @@
  * 10/6/16
  * 	- missing implementation of VImage::write()
  * 11/6/16
- * 	- added arithmetic assignment overloads, += etc. 
+ * 	- added arithmetic assignment overloads, += etc.
  */
 
 /*
@@ -51,7 +51,7 @@
 
 VIPS_NAMESPACE_START
 
-std::vector<double> 
+std::vector<double>
 to_vectorv( int n, ... )
 {
 	std::vector<double> vector( n );
@@ -65,13 +65,13 @@ to_vectorv( int n, ... )
 	return( vector );
 }
 
-std::vector<double> 
+std::vector<double>
 to_vector( double value )
 {
 	return( to_vectorv( 1, value ) );
 }
 
-std::vector<double> 
+std::vector<double>
 to_vector( int n, double array[] )
 {
 	std::vector<double> vector( n );
@@ -82,10 +82,10 @@ to_vector( int n, double array[] )
 	return( vector );
 }
 
-std::vector<double> 
+std::vector<double>
 negate( std::vector<double> vector )
 {
-	std::vector<double> new_vector( vector.size() ); 
+	std::vector<double> new_vector( vector.size() );
 
 	for( unsigned int i = 0; i < vector.size(); i++ )
 		new_vector[i] = vector[i] * -1;
@@ -93,7 +93,7 @@ negate( std::vector<double> vector )
 	return( new_vector );
 }
 
-std::vector<double> 
+std::vector<double>
 invert( std::vector<double> vector )
 {
 	std::vector<double> new_vector( vector.size() );
@@ -108,7 +108,7 @@ VOption::~VOption()
 {
 	std::list<Pair *>::iterator i;
 
-	for( i = options.begin(); i != options.end(); ++i ) 
+	for( i = options.begin(); i != options.end(); ++i )
 		delete *i;
 }
 
@@ -140,7 +140,7 @@ VOption::set( const char *name, int value )
 	return( this );
 }
 
-// input double 
+// input double
 VOption *
 VOption::set( const char *name, double value )
 {
@@ -188,17 +188,17 @@ VOption::set( const char *name, std::vector<double> value )
 	Pair *pair = new Pair( name );
 
 	double *array;
-	unsigned int i; 
+	unsigned int i;
 
 	pair->input = true;
 
 	g_value_init( &pair->value, VIPS_TYPE_ARRAY_DOUBLE );
 	vips_value_set_array_double( &pair->value, NULL,
 		static_cast< int >( value.size() ) );
-	array = vips_value_get_array_double( &pair->value, NULL ); 
+	array = vips_value_get_array_double( &pair->value, NULL );
 
-	for( i = 0; i < value.size(); i++ )  
-		array[i] = value[i]; 
+	for( i = 0; i < value.size(); i++ ) 
+		array[i] = value[i];
 
 	options.push_back( pair );
 
@@ -212,17 +212,17 @@ VOption::set( const char *name, std::vector<int> value )
 	Pair *pair = new Pair( name );
 
 	int *array;
-	unsigned int i; 
+	unsigned int i;
 
 	pair->input = true;
 
 	g_value_init( &pair->value, VIPS_TYPE_ARRAY_INT );
 	vips_value_set_array_int( &pair->value, NULL,
 		static_cast< int >( value.size() ) );
-	array = vips_value_get_array_int( &pair->value, NULL ); 
+	array = vips_value_get_array_int( &pair->value, NULL );
 
-	for( i = 0; i < value.size(); i++ )  
-		array[i] = value[i]; 
+	for( i = 0; i < value.size(); i++ ) 
+		array[i] = value[i];
 
 	options.push_back( pair );
 
@@ -236,7 +236,7 @@ VOption::set( const char *name, std::vector<VImage> value )
 	Pair *pair = new Pair( name );
 
 	VipsImage **array;
-	unsigned int i; 
+	unsigned int i;
 
 	pair->input = true;
 
@@ -245,11 +245,11 @@ VOption::set( const char *name, std::vector<VImage> value )
 		static_cast< int >( value.size() ) );
 	array = vips_value_get_array_image( &pair->value, NULL );
 
-	for( i = 0; i < value.size(); i++ ) { 
+	for( i = 0; i < value.size(); i++ ) {
 		VipsImage *vips_image = value[i].get_image();
 
-		array[i] = vips_image; 
-		g_object_ref( vips_image );  
+		array[i] = vips_image;
+		g_object_ref( vips_image ); 
 	}
 
 	options.push_back( pair );
@@ -279,7 +279,7 @@ VOption::set( const char *name, bool *value )
 
 	pair->input = false;
 	pair->vbool = value;
-	g_value_init( &pair->value, G_TYPE_BOOLEAN ); 
+	g_value_init( &pair->value, G_TYPE_BOOLEAN );
 
 	options.push_back( pair );
 
@@ -294,7 +294,7 @@ VOption::set( const char *name, int *value )
 
 	pair->input = false;
 	pair->vint = value;
-	g_value_init( &pair->value, G_TYPE_INT ); 
+	g_value_init( &pair->value, G_TYPE_INT );
 
 	options.push_back( pair );
 
@@ -309,7 +309,7 @@ VOption::set( const char *name, double *value )
 
 	pair->input = false;
 	pair->vdouble = value;
-	g_value_init( &pair->value, G_TYPE_DOUBLE ); 
+	g_value_init( &pair->value, G_TYPE_DOUBLE );
 
 	options.push_back( pair );
 
@@ -339,7 +339,7 @@ VOption::set( const char *name, std::vector<double> *value )
 
 	pair->input = false;
 	pair->vvector = value;
-	g_value_init( &pair->value, VIPS_TYPE_ARRAY_DOUBLE ); 
+	g_value_init( &pair->value, VIPS_TYPE_ARRAY_DOUBLE );
 
 	options.push_back( pair );
 
@@ -354,7 +354,7 @@ VOption::set( const char *name, VipsBlob **value )
 
 	pair->input = false;
 	pair->vblob = value;
-	g_value_init( &pair->value, VIPS_TYPE_BLOB ); 
+	g_value_init( &pair->value, VIPS_TYPE_BLOB );
 
 	options.push_back( pair );
 
@@ -362,7 +362,7 @@ VOption::set( const char *name, VipsBlob **value )
 }
 
 // just g_object_set_property(), except we allow set enum from string
-static void 
+static void
 set_property( VipsObject *object, const char *name, const GValue *value )
 {
 	VipsObjectClass *object_class = VIPS_OBJECT_GET_CLASS( object );
@@ -372,7 +372,7 @@ set_property( VipsObject *object, const char *name, const GValue *value )
 	VipsArgumentClass *argument_class;
 	VipsArgumentInstance *argument_instance;
 
-	if( vips_object_get_argument( object, name, 
+	if( vips_object_get_argument( object, name,
 		&pspec, &argument_class, &argument_instance ) ) {
 		g_warning( "%s", vips_error_buffer() );
 		vips_error_clear();
@@ -384,17 +384,17 @@ set_property( VipsObject *object, const char *name, const GValue *value )
 		GType pspec_type = G_PARAM_SPEC_VALUE_TYPE( pspec );
 
 		int enum_value;
-		GValue value2 = { 0 }; 
+		GValue value2 = { 0 };
 
-		if( (enum_value = vips_enum_from_nick( object_class->nickname, 
+		if( (enum_value = vips_enum_from_nick( object_class->nickname,
 			pspec_type, g_value_get_string( value ) )) < 0 ) {
 			g_warning( "%s", vips_error_buffer() );
 			vips_error_clear();
 			return;
 		}
 
-		g_value_init( &value2, pspec_type ); 
-		g_value_set_enum( &value2, enum_value ); 
+		g_value_init( &value2, pspec_type );
+		g_value_set_enum( &value2, enum_value );
 		g_object_set_property( G_OBJECT( object ), name, &value2 );
 		g_value_unset( &value2 );
 	}
@@ -402,18 +402,19 @@ set_property( VipsObject *object, const char *name, const GValue *value )
 		g_object_set_property( G_OBJECT( object ), name, value );
 }
 
-// walk the options and set props on the operation 
-void 
+// walk the options and set props on the operation
+void
 VOption::set_operation( VipsOperation *operation )
 {
 	std::list<Pair *>::iterator i;
 
-	for( i = options.begin(); i != options.end(); ++i ) 
+	for( i = options.begin(); i != options.end(); ++i )
 		if( (*i)->input ) {
 #ifdef VIPS_DEBUG_VERBOSE
 			printf( "set_operation: " );
 			vips_object_print_name( VIPS_OBJECT( operation ) );
-			char *str_value = g_strdup_value_contents( &(*i)->value );
+			char *str_value =
+				g_strdup_value_contents( &(*i)->value );
 			printf( ".%s = %s\n", (*i)->name, str_value );
 			g_free( str_value );
 #endif /*VIPS_DEBUG_VERBOSE*/
@@ -424,12 +425,12 @@ VOption::set_operation( VipsOperation *operation )
 }
 
 // walk the options and fetch any requested outputs
-void 
+void
 VOption::get_operation( VipsOperation *operation )
 {
 	std::list<Pair *>::iterator i;
 
-	for( i = options.begin(); i != options.end(); ++i ) 
+	for( i = options.begin(); i != options.end(); ++i )
 		if( ! (*i)->input ) {
 			const char *name = (*i)->name;
 
@@ -439,7 +440,7 @@ VOption::get_operation( VipsOperation *operation )
 #ifdef VIPS_DEBUG_VERBOSE
 			printf( "get_operation: " );
 			vips_object_print_name( VIPS_OBJECT( operation ) );
-			char *str_value = g_strdup_value_contents( 
+			char *str_value = g_strdup_value_contents(
 				&(*i)->value );
 			printf( ".%s = %s\n", name, str_value );
 			g_free( str_value );
@@ -450,59 +451,59 @@ VOption::get_operation( VipsOperation *operation )
 
 			if( type == VIPS_TYPE_IMAGE ) {
 				// rebox object
-				VipsImage *image = VIPS_IMAGE( 
-					g_value_get_object( value ) );  
-				*((*i)->vimage) = VImage( image ); 
+				VipsImage *image = VIPS_IMAGE(
+					g_value_get_object( value ) ); 
+				*((*i)->vimage) = VImage( image );
 			}
-			else if( type == G_TYPE_INT ) 
-				*((*i)->vint) = g_value_get_int( value ); 
-			else if( type == G_TYPE_BOOLEAN ) 
-				*((*i)->vbool) = g_value_get_boolean( value ); 
-			else if( type == G_TYPE_DOUBLE ) 
-				*((*i)->vdouble) = g_value_get_double( value ); 
+			else if( type == G_TYPE_INT )
+				*((*i)->vint) = g_value_get_int( value );
+			else if( type == G_TYPE_BOOLEAN )
+				*((*i)->vbool) = g_value_get_boolean( value );
+			else if( type == G_TYPE_DOUBLE )
+				*((*i)->vdouble) = g_value_get_double( value );
 			else if( type == VIPS_TYPE_ARRAY_DOUBLE ) {
 				int length;
-				double *array = 
-					vips_value_get_array_double( value, 
+				double *array =
+					vips_value_get_array_double( value,
 					&length );
 				int j;
 
-				((*i)->vvector)->resize( length ); 
+				((*i)->vvector)->resize( length );
 				for( j = 0; j < length; j++ )
 					(*((*i)->vvector))[j] = array[j];
 			}
 			else if( type == VIPS_TYPE_BLOB ) {
 				// our caller gets a reference
-				*((*i)->vblob) = 
+				*((*i)->vblob) =
 					(VipsBlob *) g_value_dup_boxed( value );
 			}
 		}
 }
 
-void 
-VImage::call_option_string( const char *operation_name, 
-	const char *option_string, VOption *options ) 
+void
+VImage::call_option_string( const char *operation_name,
+	const char *option_string, VOption *options )
 {
 	VipsOperation *operation;
 
-	VIPS_DEBUG_MSG( "call_option_string: starting for %s ...\n", 
+	VIPS_DEBUG_MSG( "call_option_string: starting for %s ...\n",
 		operation_name );
 
 	if( !(operation = vips_operation_new( operation_name )) ) {
 		delete options;
-		throw( VError() ); 
+		throw( VError() );
 	}
 
-	/* Set str options before vargs options, so the user can't 
+	/* Set str options before vargs options, so the user can't
 	 * override things we set deliberately.
 	 */
 	if( option_string &&
-		vips_object_set_from_string( VIPS_OBJECT( operation ), 
+		vips_object_set_from_string( VIPS_OBJECT( operation ),
 			option_string ) ) {
 		vips_object_unref_outputs( VIPS_OBJECT( operation ) );
-		g_object_unref( operation ); 
-		delete options; 
-		throw( VError() ); 
+		g_object_unref( operation );
+		delete options;
+		throw( VError() );
 	}
 
 	if( options )
@@ -512,9 +513,9 @@ VImage::call_option_string( const char *operation_name,
 	 */
 	if( vips_cache_operation_buildp( &operation ) ) {
 		vips_object_unref_outputs( VIPS_OBJECT( operation ) );
-		g_object_unref( operation ); 
-		delete options; 
-		throw( VError() ); 
+		g_object_unref( operation );
+		delete options;
+		throw( VError() );
 	}
 
 	/* Walk args again, writing output.
@@ -524,46 +525,46 @@ VImage::call_option_string( const char *operation_name,
 
 	/* We're done with options!
 	 */
-	delete options; 
+	delete options;
 
-	/* The operation we have built should now have been reffed by 
-	 * one of its arguments or have finished its work. Either 
+	/* The operation we have built should now have been reffed by
+	 * one of its arguments or have finished its work. Either
 	 * way, we can unref.
 	 */
 	g_object_unref( operation );
 }
 
-void 
-VImage::call( const char *operation_name, VOption *options ) 
+void
+VImage::call( const char *operation_name, VOption *options )
 {
-	call_option_string( operation_name, NULL, options ); 
+	call_option_string( operation_name, NULL, options );
 }
 
-VImage 
+VImage
 VImage::new_from_file( const char *name, VOption *options )
 {
 	char filename[VIPS_PATH_MAX];
 	char option_string[VIPS_PATH_MAX];
 	const char *operation_name;
 
-	VImage out; 
+	VImage out;
 
 	vips__filename_split8( name, filename, option_string );
 	if( !(operation_name = vips_foreign_find_load( filename )) ) {
-		delete options; 
-		throw VError(); 
+		delete options;
+		throw VError();
 	}
 
 	call_option_string( operation_name, option_string,
-		(options ? options : VImage::option())-> 
+		(options ? options : VImage::option())->
 			set( "filename", filename )->
 			set( "out", &out ) );
 
-	return( out ); 
+	return( out );
 }
 
-VImage 
-VImage::new_from_buffer( const void *buf, size_t len, const char *option_string, 
+VImage
+VImage::new_from_buffer( const void *buf, size_t len, const char *option_string,
 	VOption *options )
 {
 	const char *operation_name;
@@ -571,87 +572,87 @@ VImage::new_from_buffer( const void *buf, size_t len, const char *option_string,
 	VImage out;
 
 	if( !(operation_name = vips_foreign_find_load_buffer( buf, len )) ) {
-		delete options; 
-		throw( VError() ); 
+		delete options;
+		throw( VError() );
 	}
 
 	/* We don't take a copy of the data or free it.
 	 */
 	blob = vips_blob_new( NULL, buf, len );
-	options = (options ? options : VImage::option())-> 
+	options = (options ? options : VImage::option())->
 		set( "buffer", blob )->
 		set( "out", &out );
 	vips_area_unref( VIPS_AREA( blob ) );
 
-	call_option_string( operation_name, option_string, options ); 
+	call_option_string( operation_name, option_string, options );
 
 	return( out );
 }
 
-VImage 
-VImage::new_from_buffer( const std::string &buf, const char *option_string, 
+VImage
+VImage::new_from_buffer( const std::string &buf, const char *option_string,
 	VOption *options )
 {
-	return( new_from_buffer( buf.c_str(), buf.size(), 
+	return( new_from_buffer( buf.c_str(), buf.size(),
 		option_string, options ) );
 }
 
-VImage 
-VImage::new_from_source( VSource source, const char *option_string, 
+VImage
+VImage::new_from_source( VSource source, const char *option_string,
 	VOption *options )
 {
 	const char *operation_name;
 	VImage out;
 
-	if( !(operation_name = vips_foreign_find_load_source( 
+	if( !(operation_name = vips_foreign_find_load_source(
 		source.get_source() )) ) {
-		delete options; 
-		throw( VError() ); 
+		delete options;
+		throw( VError() );
 	}
 
-	options = (options ? options : VImage::option())-> 
+	options = (options ? options : VImage::option())->
 		set( "source", source )->
 		set( "out", &out );
 
-	call_option_string( operation_name, option_string, options ); 
+	call_option_string( operation_name, option_string, options );
 
 	return( out );
 }
 
-VImage 
-VImage::new_matrix( int width, int height ) 
+VImage
+VImage::new_matrix( int width, int height )
 {
-	return( VImage( vips_image_new_matrix( width, height ) ) ); 
+	return( VImage( vips_image_new_matrix( width, height ) ) );
 }
 
-VImage 
+VImage
 VImage::new_matrixv( int width, int height, ... )
 {
 	VImage matrix = new_matrix( width, height );
-	VipsImage *vips_matrix = matrix.get_image(); 
+	VipsImage *vips_matrix = matrix.get_image();
 
 	va_list ap;
 
 	va_start( ap, height );
 	for( int y = 0; y < height; y++ )
 		for( int x = 0; x < width; x++ )
-			*VIPS_MATRIX( vips_matrix, x, y ) = 
+			*VIPS_MATRIX( vips_matrix, x, y ) =
 				va_arg( ap, double );
 	va_end( ap );
 
-	return( matrix ); 
+	return( matrix );
 }
 
 VImage
 VImage::write( VImage out ) const
 {
 	if( vips_image_write( this->get_image(), out.get_image() ) )
-		throw VError(); 
+		throw VError();
 
-	return( out ); 
+	return( out );
 }
 
-void 
+void
 VImage::write_to_file( const char *name, VOption *options ) const
 {
 	char filename[VIPS_PATH_MAX];
@@ -660,18 +661,18 @@ VImage::write_to_file( const char *name, VOption *options ) const
 
 	vips__filename_split8( name, filename, option_string );
 	if( !(operation_name = vips_foreign_find_save( filename )) ) {
-		delete options; 
-		throw VError(); 
+		delete options;
+		throw VError();
 	}
 
-	call_option_string( operation_name, option_string, 
-		(options ? options : VImage::option())-> 
+	call_option_string( operation_name, option_string,
+		(options ? options : VImage::option())->
 			set( "in", *this )->
 			set( "filename", filename ) );
 }
 
-void 
-VImage::write_to_buffer( const char *suffix, void **buf, size_t *size, 
+void
+VImage::write_to_buffer( const char *suffix, void **buf, size_t *size,
 	VOption *options ) const
 {
 	char filename[VIPS_PATH_MAX];
@@ -681,16 +682,16 @@ VImage::write_to_buffer( const char *suffix, void **buf, size_t *size,
 
 	vips__filename_split8( suffix, filename, option_string );
 	if( !(operation_name = vips_foreign_find_save_buffer( filename )) ) {
-		delete options; 
-		throw VError(); 
+		delete options;
+		throw VError();
 	}
 
-	call_option_string( operation_name, option_string, 
-		(options ? options : VImage::option())-> 
+	call_option_string( operation_name, option_string,
+		(options ? options : VImage::option())->
 			set( "in", *this )->
 			set( "buffer", &blob ) );
 
-	if( blob ) { 
+	if( blob ) {
 		if( buf ) {
 			*buf = VIPS_AREA( blob )->data;
 			VIPS_AREA( blob )->free_fn = NULL;
@@ -702,8 +703,8 @@ VImage::write_to_buffer( const char *suffix, void **buf, size_t *size,
 	}
 }
 
-void 
-VImage::write_to_target( const char *suffix, VTarget target, 
+void
+VImage::write_to_target( const char *suffix, VTarget target,
 	VOption *options ) const
 {
 	char filename[VIPS_PATH_MAX];
@@ -712,755 +713,755 @@ VImage::write_to_target( const char *suffix, VTarget target,
 
 	vips__filename_split8( suffix, filename, option_string );
 	if( !(operation_name = vips_foreign_find_save_target( filename )) ) {
-		delete options; 
-		throw VError(); 
+		delete options;
+		throw VError();
 	}
 
-	call_option_string( operation_name, option_string, 
-		(options ? options : VImage::option())-> 
+	call_option_string( operation_name, option_string,
+		(options ? options : VImage::option())->
 			set( "in", *this )->
 			set( "target", target ) );
 }
 
 #include "vips-operators.cpp"
 
-std::vector<VImage> 
+std::vector<VImage>
 VImage::bandsplit( VOption *options ) const
 {
-	std::vector<VImage> b; 
+	std::vector<VImage> b;
 
 	for( int i = 0; i < bands(); i++ )
-		b.push_back( extract_band( i ) ); 
+		b.push_back( extract_band( i ) );
 
-	return( b ); 
+	return( b );
 }
 
-VImage 
+VImage
 VImage::bandjoin( VImage other, VOption *options ) const
 {
-	VImage v[2] = { *this, other }; 
+	VImage v[2] = { *this, other };
 	std::vector<VImage> vec( v, v + VIPS_NUMBER( v ) );
 
-	return( bandjoin( vec, options ) ); 
+	return( bandjoin( vec, options ) );
 }
 
-VImage 
+VImage
 VImage::composite( VImage other, VipsBlendMode mode, VOption *options ) const
 {
-	VImage v[2] = { *this, other }; 
+	VImage v[2] = { *this, other };
 	std::vector<VImage> ivec( v, v + VIPS_NUMBER( v ) );
-	int m[1] = { static_cast<int>( mode ) }; 
+	int m[1] = { static_cast<int>( mode ) };
 	std::vector<int> mvec( m, m + VIPS_NUMBER( m ) );
 
-	return( composite( ivec, mvec, options ) ); 
+	return( composite( ivec, mvec, options ) );
 }
 
-std::complex<double> 
+std::complex<double>
 VImage::minpos( VOption *options ) const
 {
 	double x, y;
 
-	(void) min( 
+	(void) min(
 		(options ? options : VImage::option()) ->
 			set( "x", &x ) ->
 			set( "y", &y ) );
 
-	return( std::complex<double>( x, y ) ); 
+	return( std::complex<double>( x, y ) );
 }
 
-std::complex<double> 
+std::complex<double>
 VImage::maxpos( VOption *options ) const
 {
 	double x, y;
 
-	(void) max( 
+	(void) max(
 		(options ? options : VImage::option()) ->
 			set( "x", &x ) ->
 			set( "y", &y ) );
 
-	return( std::complex<double>( x, y ) ); 
+	return( std::complex<double>( x, y ) );
 }
 
 // Operator overloads
 
-VImage 
+VImage
 VImage::operator[]( int index ) const
 {
-	return( this->extract_band( index ) ); 
+	return( this->extract_band( index ) );
 }
 
-std::vector<double> 
+std::vector<double>
 VImage::operator()( int x, int y ) const
 {
-	return( this->getpoint( x, y ) ); 
+	return( this->getpoint( x, y ) );
 }
 
-VImage 
+VImage
 operator+( const VImage a, const VImage b )
 {
 	return( a.add( b ) );
 }
 
-VImage 
-operator+( double a, const VImage b ) 
+VImage
+operator+( double a, const VImage b )
 {
-	return( b.linear( 1.0, a ) ); 
+	return( b.linear( 1.0, a ) );
 }
 
-VImage 
-operator+( const VImage a, double b ) 
-{ 
-	return( a.linear( 1.0, b ) ); 
+VImage
+operator+( const VImage a, double b )
+{
+	return( a.linear( 1.0, b ) );
 }
 
-VImage 
-operator+( const std::vector<double> a, const VImage b ) 
+VImage
+operator+( const std::vector<double> a, const VImage b )
 {
-	return( b.linear( 1.0, a ) ); 
+	return( b.linear( 1.0, a ) );
 }
 
-VImage 
-operator+( const VImage a, const std::vector<double> b ) 
-{ 
-	return( a.linear( 1.0, b ) ); 
+VImage
+operator+( const VImage a, const std::vector<double> b )
+{
+	return( a.linear( 1.0, b ) );
 }
 
-VImage & 
+VImage &
 operator+=( VImage &a, const VImage b )
 {
-	return( a = a + b ); 
+	return( a = a + b );
 }
 
-VImage & 
+VImage &
 operator+=( VImage &a, const double b )
 {
-	return( a = a + b ); 
+	return( a = a + b );
 }
 
-VImage & 
+VImage &
 operator+=( VImage &a, const std::vector<double> b )
 {
-	return( a = a + b ); 
+	return( a = a + b );
 }
 
-VImage 
-operator-( const VImage a, const VImage b ) 
+VImage
+operator-( const VImage a, const VImage b )
 {
 	return( a.subtract( b ) );
 }
 
-VImage 
-operator-( double a, const VImage b ) 
+VImage
+operator-( double a, const VImage b )
 {
-	return( b.linear( -1.0, a ) ); 
+	return( b.linear( -1.0, a ) );
 }
 
-VImage 
-operator-( const VImage a, double b ) 
-{ 
-	return( a.linear( 1.0, -b ) ); 
+VImage
+operator-( const VImage a, double b )
+{
+	return( a.linear( 1.0, -b ) );
 }
 
-VImage 
-operator-( const std::vector<double> a, const VImage b ) 
+VImage
+operator-( const std::vector<double> a, const VImage b )
 {
-	return( b.linear( -1.0, a ) ); 
+	return( b.linear( -1.0, a ) );
 }
 
-VImage 
-operator-( const VImage a, const std::vector<double> b ) 
-{ 
-	return( a.linear( 1.0, vips::negate( b ) ) ); 
+VImage
+operator-( const VImage a, const std::vector<double> b )
+{
+	return( a.linear( 1.0, vips::negate( b ) ) );
 }
 
-VImage & 
+VImage &
 operator-=( VImage &a, const VImage b )
 {
-	return( a = a - b ); 
+	return( a = a - b );
 }
 
-VImage & 
+VImage &
 operator-=( VImage &a, const double b )
 {
-	return( a = a - b ); 
+	return( a = a - b );
 }
 
-VImage & 
+VImage &
 operator-=( VImage &a, const std::vector<double> b )
 {
-	return( a = a - b ); 
+	return( a = a - b );
 }
 
-VImage 
-operator-( const VImage a ) 
-{ 
+VImage
+operator-( const VImage a )
+{
 	return( a * -1 );
 }
 
-VImage 
-operator*( const VImage a, const VImage b ) 
+VImage
+operator*( const VImage a, const VImage b )
 {
 	return( a.multiply( b ) );
 }
 
-VImage 
-operator*( double a, const VImage b ) 
+VImage
+operator*( double a, const VImage b )
 {
-	return( b.linear( a, 0.0 ) ); 
+	return( b.linear( a, 0.0 ) );
 }
 
-VImage 
-operator*( const VImage a, double b ) 
-{ 
-	return( a.linear( b, 0.0 ) ); 
+VImage
+operator*( const VImage a, double b )
+{
+	return( a.linear( b, 0.0 ) );
 }
 
-VImage 
-operator*( const std::vector<double> a, const VImage b ) 
+VImage
+operator*( const std::vector<double> a, const VImage b )
 {
-	return( b.linear( a, 0.0 ) ); 
+	return( b.linear( a, 0.0 ) );
 }
 
-VImage 
-operator*( const VImage a, const std::vector<double> b ) 
-{ 
-	return( a.linear( b, 0.0 ) ); 
+VImage
+operator*( const VImage a, const std::vector<double> b )
+{
+	return( a.linear( b, 0.0 ) );
 }
 
-VImage & 
+VImage &
 operator*=( VImage &a, const VImage b )
 {
-	return( a = a * b ); 
+	return( a = a * b );
 }
 
-VImage & 
+VImage &
 operator*=( VImage &a, const double b )
 {
-	return( a = a * b ); 
+	return( a = a * b );
 }
 
-VImage & 
+VImage &
 operator*=( VImage &a, const std::vector<double> b )
 {
-	return( a = a * b ); 
+	return( a = a * b );
 }
 
-VImage 
-operator/( const VImage a, const VImage b ) 
+VImage
+operator/( const VImage a, const VImage b )
 {
 	return( a.divide( b ) );
 }
 
-VImage 
-operator/( double a, const VImage b ) 
+VImage
+operator/( double a, const VImage b )
 {
-	return( b.pow( -1.0 ).linear( a, 0.0 ) ); 
+	return( b.pow( -1.0 ).linear( a, 0.0 ) );
 }
 
-VImage 
-operator/( const VImage a, double b ) 
-{ 
-	return( a.linear( 1.0 / b, 0.0 ) ); 
+VImage
+operator/( const VImage a, double b )
+{
+	return( a.linear( 1.0 / b, 0.0 ) );
 }
 
-VImage 
-operator/( const std::vector<double> a, const VImage b ) 
+VImage
+operator/( const std::vector<double> a, const VImage b )
 {
-	return( b.pow( -1.0 ).linear( a, 0.0 ) ); 
+	return( b.pow( -1.0 ).linear( a, 0.0 ) );
 }
 
-VImage 
-operator/( const VImage a, const std::vector<double> b ) 
-{ 
-	return( a.linear( vips::invert( b ), 0.0 ) ); 
+VImage
+operator/( const VImage a, const std::vector<double> b )
+{
+	return( a.linear( vips::invert( b ), 0.0 ) );
 }
 
-VImage & 
+VImage &
 operator/=( VImage &a, const VImage b )
 {
-	return( a = a / b ); 
+	return( a = a / b );
 }
 
-VImage & 
+VImage &
 operator/=( VImage &a, const double b )
 {
-	return( a = a / b ); 
+	return( a = a / b );
 }
 
-VImage & 
+VImage &
 operator/=( VImage &a, const std::vector<double> b )
 {
-	return( a = a / b ); 
+	return( a = a / b );
 }
 
-VImage 
-operator%( const VImage a, const VImage b ) 
+VImage
+operator%( const VImage a, const VImage b )
 {
 	return( a.remainder( b ) );
 }
 
-VImage 
-operator%( const VImage a, const double b ) 
-{ 
-	return( a.remainder_const( to_vector( b ) ) ); 
+VImage
+operator%( const VImage a, const double b )
+{
+	return( a.remainder_const( to_vector( b ) ) );
 }
 
-VImage 
-operator%( const VImage a, const std::vector<double> b ) 
-{ 
-	return( a.remainder_const( b ) ); 
+VImage
+operator%( const VImage a, const std::vector<double> b )
+{
+	return( a.remainder_const( b ) );
 }
 
-VImage & 
+VImage &
 operator%=( VImage &a, const VImage b )
 {
-	return( a = a % b ); 
+	return( a = a % b );
 }
 
-VImage & 
+VImage &
 operator%=( VImage &a, const double b )
 {
-	return( a = a % b ); 
+	return( a = a % b );
 }
 
-VImage & 
+VImage &
 operator%=( VImage &a, const std::vector<double> b )
 {
-	return( a = a % b ); 
+	return( a = a % b );
 }
 
-VImage 
-operator<( const VImage a, const VImage b ) 
+VImage
+operator<( const VImage a, const VImage b )
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESS ) );
 }
 
-VImage 
-operator<( const double a, const VImage b ) 
+VImage
+operator<( const double a, const VImage b )
 {
-	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MORE, 
-		to_vector( a ) ) ); 
+	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
+		to_vector( a ) ) );
 }
 
-VImage 
-operator<( const VImage a, const double b ) 
-{ 
-	return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESS, 
-		to_vector( b ) ) );  
+VImage
+operator<( const VImage a, const double b )
+{
+	return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
+		to_vector( b ) ) ); 
 }
 
-VImage 
-operator<( const std::vector<double> a, const VImage b ) 
+VImage
+operator<( const std::vector<double> a, const VImage b )
 {
-	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MORE, 
-		a ) );  
+	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
+		a ) ); 
 }
 
-VImage 
-operator<( const VImage a, const std::vector<double> b ) 
-{ 
-	return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESS, 
-		b ) ); 
+VImage
+operator<( const VImage a, const std::vector<double> b )
+{
+	return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
+		b ) );
 }
 
-VImage 
-operator<=( const VImage a, const VImage b ) 
+VImage
+operator<=( const VImage a, const VImage b )
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESSEQ ) );
 }
 
-VImage 
-operator<=( const double a, const VImage b ) 
+VImage
+operator<=( const double a, const VImage b )
 {
-	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ, 
-		to_vector( a ) ) );  
+	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
+		to_vector( a ) ) ); 
 }
 
-VImage 
-operator<=( const VImage a, const double b ) 
-{ 
-	return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ, 
-		to_vector( b ) ) );  
+VImage
+operator<=( const VImage a, const double b )
+{
+	return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
+		to_vector( b ) ) ); 
 }
 
-VImage 
-operator<=( const std::vector<double> a, const VImage b ) 
+VImage
+operator<=( const std::vector<double> a, const VImage b )
 {
-	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ, 
+	return( b.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
 		a ) );
 }
 
-VImage 
-operator<=( const VImage a, const std::vector<double> b ) 
-{ 
+VImage
+operator<=( const VImage a, const std::vector<double> b )
+{
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
 		b ) );
 }
 
-VImage 
-operator>( const VImage a, const VImage b ) 
+VImage
+operator>( const VImage a, const VImage b )
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_MORE ) );
 }
 
-VImage 
-operator>( const double a, const VImage b ) 
+VImage
+operator>( const double a, const VImage b )
 {
-	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESS, 
-		to_vector( a ) ) ); 
+	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
+		to_vector( a ) ) );
 }
 
-VImage 
-operator>( const VImage a, const double b ) 
-{ 
-	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MORE, 
+VImage
+operator>( const VImage a, const double b )
+{
+	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
 		to_vector( b ) ) );
 }
 
-VImage 
-operator>( const std::vector<double> a, const VImage b ) 
+VImage
+operator>( const std::vector<double> a, const VImage b )
 {
-	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESS, 
+	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
 		a ) );
 }
 
-VImage 
-operator>( const VImage a, const std::vector<double> b ) 
-{ 
-	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MORE, 
+VImage
+operator>( const VImage a, const std::vector<double> b )
+{
+	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
 		b ) );
 }
 
-VImage 
-operator>=( const VImage a, const VImage b ) 
+VImage
+operator>=( const VImage a, const VImage b )
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_MOREEQ ) );
 }
 
-VImage 
-operator>=( const double a, const VImage b ) 
+VImage
+operator>=( const double a, const VImage b )
 {
-	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ, 
-		to_vector( a ) ) );  
+	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
+		to_vector( a ) ) ); 
 }
 
-VImage 
-operator>=( const VImage a, const double b ) 
-{ 
-	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ, 
-		to_vector( b ) ) ); 
+VImage
+operator>=( const VImage a, const double b )
+{
+	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
+		to_vector( b ) ) );
 }
 
-VImage 
-operator>=( const std::vector<double> a, const VImage b ) 
+VImage
+operator>=( const std::vector<double> a, const VImage b )
 {
-	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ, 
+	return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
 		a ) );
 }
 
-VImage 
-operator>=( const VImage a, const std::vector<double> b ) 
-{ 
-	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ, 
+VImage
+operator>=( const VImage a, const std::vector<double> b )
+{
+	return( a.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
 		b ) );
 }
 
-VImage 
-operator==( const VImage a, const VImage b ) 
+VImage
+operator==( const VImage a, const VImage b )
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_EQUAL ) );
 }
 
-VImage 
-operator==( const double a, const VImage b ) 
+VImage
+operator==( const double a, const VImage b )
 {
-	return( b.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL, 
+	return( b.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
 		to_vector( a ) ) );
 }
 
-VImage 
-operator==( const VImage a, const double b ) 
-{ 
-	return( a.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL, 
+VImage
+operator==( const VImage a, const double b )
+{
+	return( a.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
 		to_vector( b ) ) );
 }
 
-VImage 
-operator==( const std::vector<double> a, const VImage b ) 
+VImage
+operator==( const std::vector<double> a, const VImage b )
 {
-	return( b.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL, 
+	return( b.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
 		a ) );
 }
 
-VImage 
-operator==( const VImage a, const std::vector<double> b ) 
-{ 
-	return( a.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL, 
+VImage
+operator==( const VImage a, const std::vector<double> b )
+{
+	return( a.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
 		b ) );
 }
 
-VImage 
-operator!=( const VImage a, const VImage b ) 
+VImage
+operator!=( const VImage a, const VImage b )
 {
 	return( a.relational( b, VIPS_OPERATION_RELATIONAL_NOTEQ ) );
 }
 
-VImage 
-operator!=( const double a, const VImage b ) 
+VImage
+operator!=( const double a, const VImage b )
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
-		to_vector( a ) ) );  
+		to_vector( a ) ) ); 
 }
 
-VImage 
-operator!=( const VImage a, const double b ) 
-{ 
-	return( a.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ, 
+VImage
+operator!=( const VImage a, const double b )
+{
+	return( a.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
 		to_vector( b ) ) );
 }
 
-VImage 
-operator!=( const std::vector<double> a, const VImage b ) 
+VImage
+operator!=( const std::vector<double> a, const VImage b )
 {
 	return( b.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
 		a ) );
 }
 
-VImage 
-operator!=( const VImage a, const std::vector<double> b ) 
-{ 
+VImage
+operator!=( const VImage a, const std::vector<double> b )
+{
 	return( a.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
 		b ) );
 }
 
-VImage 
-operator&( const VImage a, const VImage b ) 
+VImage
+operator&( const VImage a, const VImage b )
 {
 	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_AND ) );
 }
 
-VImage 
-operator&( const double a, const VImage b ) 
+VImage
+operator&( const double a, const VImage b )
 {
-	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_AND, 
-		to_vector( a ) ) );  
+	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_AND,
+		to_vector( a ) ) ); 
 }
 
-VImage 
-operator&( const VImage a, const double b ) 
-{ 
-	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_AND, 
+VImage
+operator&( const VImage a, const double b )
+{
+	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_AND,
 		to_vector( b ) ) );
 }
 
-VImage 
-operator&( const std::vector<double> a, const VImage b ) 
+VImage
+operator&( const std::vector<double> a, const VImage b )
 {
 	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_AND, a ) );
 }
 
-VImage 
-operator&( const VImage a, const std::vector<double> b ) 
-{ 
+VImage
+operator&( const VImage a, const std::vector<double> b )
+{
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_AND, b ) );
 }
 
-VImage & 
+VImage &
 operator&=( VImage &a, const VImage b )
 {
-	return( a = a & b ); 
+	return( a = a & b );
 }
 
-VImage & 
+VImage &
 operator&=( VImage &a, const double b )
 {
-	return( a = a & b ); 
+	return( a = a & b );
 }
 
-VImage & 
+VImage &
 operator&=( VImage &a, const std::vector<double> b )
 {
-	return( a = a & b ); 
+	return( a = a & b );
 }
 
-VImage 
-operator|( const VImage a, const VImage b ) 
+VImage
+operator|( const VImage a, const VImage b )
 {
 	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_OR ) );
 }
 
-VImage 
-operator|( const double a, const VImage b ) 
+VImage
+operator|( const double a, const VImage b )
 {
-	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_OR, 
-		to_vector( a ) ) ); 
+	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
+		to_vector( a ) ) );
 }
 
-VImage 
-operator|( const VImage a, const double b ) 
-{ 
-	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_OR, 
+VImage
+operator|( const VImage a, const double b )
+{
+	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
 		to_vector( b ) ) );
 }
 
-VImage 
-operator|( const std::vector<double> a, const VImage b ) 
+VImage
+operator|( const std::vector<double> a, const VImage b )
 {
-	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_OR, 
+	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
 		a ) );
 }
 
-VImage 
-operator|( const VImage a, const std::vector<double> b ) 
-{ 
-	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_OR, 
+VImage
+operator|( const VImage a, const std::vector<double> b )
+{
+	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
 		b ) );
 }
 
-VImage & 
+VImage &
 operator|=( VImage &a, const VImage b )
 {
-	return( a = a | b ); 
+	return( a = a | b );
 }
 
-VImage & 
+VImage &
 operator|=( VImage &a, const double b )
 {
-	return( a = a | b ); 
+	return( a = a | b );
 }
 
-VImage & 
+VImage &
 operator|=( VImage &a, const std::vector<double> b )
 {
-	return( a = a | b ); 
+	return( a = a | b );
 }
 
-VImage 
-operator^( const VImage a, const VImage b ) 
+VImage
+operator^( const VImage a, const VImage b )
 {
 	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_EOR ) );
 }
 
-VImage 
-operator^( const double a, const VImage b ) 
+VImage
+operator^( const double a, const VImage b )
 {
-	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_EOR, 
-		to_vector( a ) ) ); 
+	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
+		to_vector( a ) ) );
 }
 
-VImage 
-operator^( const VImage a, const double b ) 
-{ 
-	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_EOR, 
-		to_vector( b ) ) ); 
+VImage
+operator^( const VImage a, const double b )
+{
+	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
+		to_vector( b ) ) );
 }
 
-VImage 
-operator^( const std::vector<double> a, const VImage b ) 
+VImage
+operator^( const std::vector<double> a, const VImage b )
 {
 	return( b.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
 		a ) );
 }
 
-VImage 
-operator^( const VImage a, const std::vector<double> b ) 
-{ 
+VImage
+operator^( const VImage a, const std::vector<double> b )
+{
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
 		b ) );
 }
 
-VImage & 
+VImage &
 operator^=( VImage &a, const VImage b )
 {
-	return( a = a ^ b ); 
+	return( a = a ^ b );
 }
 
-VImage & 
+VImage &
 operator^=( VImage &a, const double b )
 {
-	return( a = a ^ b ); 
+	return( a = a ^ b );
 }
 
-VImage & 
+VImage &
 operator^=( VImage &a, const std::vector<double> b )
 {
-	return( a = a ^ b ); 
+	return( a = a ^ b );
 }
 
-VImage 
-operator<<( const VImage a, const VImage b ) 
+VImage
+operator<<( const VImage a, const VImage b )
 {
 	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_LSHIFT ) );
 }
 
-VImage 
-operator<<( const VImage a, const double b ) 
-{ 
-	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_LSHIFT, 
-		to_vector( b ) ) ); 
+VImage
+operator<<( const VImage a, const double b )
+{
+	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_LSHIFT,
+		to_vector( b ) ) );
 }
 
-VImage 
-operator<<( const VImage a, const std::vector<double> b ) 
-{ 
-	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_LSHIFT, 
-		b ) ); 
+VImage
+operator<<( const VImage a, const std::vector<double> b )
+{
+	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_LSHIFT,
+		b ) );
 }
 
-VImage & 
+VImage &
 operator<<=( VImage &a, const VImage b )
 {
-	return( a = a << b ); 
+	return( a = a << b );
 }
 
-VImage & 
+VImage &
 operator<<=( VImage &a, const double b )
 {
-	return( a = a << b ); 
+	return( a = a << b );
 }
 
-VImage & 
+VImage &
 operator<<=( VImage &a, const std::vector<double> b )
 {
-	return( a = a << b ); 
+	return( a = a << b );
 }
 
-VImage 
-operator>>( const VImage a, const VImage b ) 
+VImage
+operator>>( const VImage a, const VImage b )
 {
 	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_RSHIFT ) );
 }
 
-VImage 
-operator>>( const VImage a, const double b ) 
-{ 
-	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_RSHIFT, 
-		to_vector( b ) ) );  
+VImage
+operator>>( const VImage a, const double b )
+{
+	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_RSHIFT,
+		to_vector( b ) ) ); 
 }
 
-VImage 
-operator>>( const VImage a, const std::vector<double> b ) 
-{ 
+VImage
+operator>>( const VImage a, const std::vector<double> b )
+{
 	return( a.boolean_const( VIPS_OPERATION_BOOLEAN_RSHIFT,
-		b ) ); 
+		b ) );
 }
 
-VImage & 
+VImage &
 operator>>=( VImage &a, const VImage b )
 {
-	return( a = a << b ); 
+	return( a = a << b );
 }
 
-VImage & 
+VImage &
 operator>>=( VImage &a, const double b )
 {
-	return( a = a << b ); 
+	return( a = a << b );
 }
 
-VImage & 
+VImage &
 operator>>=( VImage &a, const std::vector<double> b )
 {
-	return( a = a << b ); 
+	return( a = a << b );
 }
 
 VIPS_NAMESPACE_END