2be0b97dce
we had vips_warn() and vips_info(), but they are a bit crappy ... switch to g_warning() and g_info() instead see https://github.com/jcupitt/libvips/issues/544
1405 lines
26 KiB
C++
1405 lines
26 KiB
C++
/* Object part of VImage class
|
|
*
|
|
* 30/12/14
|
|
* - allow set enum value from string
|
|
* 10/6/16
|
|
* - missing implementation of VImage::write()
|
|
* 11/6/16
|
|
* - added arithmetic assignment overloads, += etc.
|
|
*/
|
|
|
|
/*
|
|
|
|
Copyright (C) 1991-2001 The National Gallery
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk
|
|
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif /*HAVE_CONFIG_H*/
|
|
#include <vips/intl.h>
|
|
|
|
#include <vips/vips8>
|
|
|
|
#include <vips/debug.h>
|
|
|
|
/*
|
|
#define VIPS_DEBUG
|
|
#define VIPS_DEBUG_VERBOSE
|
|
*/
|
|
|
|
VIPS_NAMESPACE_START
|
|
|
|
std::vector<double>
|
|
to_vectorv( int n, ... )
|
|
{
|
|
std::vector<double> vector( n );
|
|
va_list ap;
|
|
|
|
va_start( ap, n );
|
|
for( int i = 0; i < n; i++ )
|
|
vector[i] = va_arg( ap, double );
|
|
va_end( ap );
|
|
|
|
return( vector );
|
|
}
|
|
|
|
std::vector<double>
|
|
to_vector( double value )
|
|
{
|
|
return( to_vectorv( 1, value ) );
|
|
}
|
|
|
|
std::vector<double>
|
|
to_vector( int n, double array[] )
|
|
{
|
|
std::vector<double> vector( n );
|
|
|
|
for( int i = 0; i < n; i++ )
|
|
vector[i] = array[i];
|
|
|
|
return( vector );
|
|
}
|
|
|
|
std::vector<double>
|
|
negate( std::vector<double> vector )
|
|
{
|
|
std::vector<double> new_vector( vector.size() );
|
|
|
|
for( unsigned int i = 0; i < vector.size(); i++ )
|
|
new_vector[i] = vector[i] * -1;
|
|
|
|
return( new_vector );
|
|
}
|
|
|
|
std::vector<double>
|
|
invert( std::vector<double> vector )
|
|
{
|
|
std::vector<double> new_vector( vector.size() );
|
|
|
|
for( unsigned int i = 0; i < vector.size(); i++ )
|
|
new_vector[i] = 1.0 / vector[i];
|
|
|
|
return( new_vector );
|
|
}
|
|
|
|
VOption::~VOption()
|
|
{
|
|
std::list<Pair *>::iterator i;
|
|
|
|
for( i = options.begin(); i != options.end(); ++i )
|
|
delete *i;
|
|
}
|
|
|
|
// input bool
|
|
VOption *
|
|
VOption::set( const char *name, bool value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = true;
|
|
g_value_init( &pair->value, G_TYPE_BOOLEAN );
|
|
g_value_set_boolean( &pair->value, value );
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// input int ... this path is used for enums as well
|
|
VOption *
|
|
VOption::set( const char *name, int value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = true;
|
|
g_value_init( &pair->value, G_TYPE_INT );
|
|
g_value_set_int( &pair->value, value );
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// input double
|
|
VOption *
|
|
VOption::set( const char *name, double value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = true;
|
|
g_value_init( &pair->value, G_TYPE_DOUBLE );
|
|
g_value_set_double( &pair->value, value );
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
VOption *
|
|
VOption::set( const char *name, const char *value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = true;
|
|
g_value_init( &pair->value, G_TYPE_STRING );
|
|
g_value_set_string( &pair->value, value );
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// input image
|
|
VOption *
|
|
VOption::set( const char *name, VImage value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = true;
|
|
g_value_init( &pair->value, VIPS_TYPE_IMAGE );
|
|
g_value_set_object( &pair->value, value.get_image() );
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// input double array
|
|
VOption *
|
|
VOption::set( const char *name, std::vector<double> value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
double *array;
|
|
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 );
|
|
|
|
for( i = 0; i < value.size(); i++ )
|
|
array[i] = value[i];
|
|
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// input image array
|
|
VOption *
|
|
VOption::set( const char *name, std::vector<VImage> value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
VipsImage **array;
|
|
unsigned int i;
|
|
|
|
pair->input = true;
|
|
|
|
g_value_init( &pair->value, VIPS_TYPE_ARRAY_IMAGE );
|
|
vips_value_set_array_image( &pair->value,
|
|
static_cast< int >( value.size() ) );
|
|
array = vips_value_get_array_image( &pair->value, NULL );
|
|
|
|
for( i = 0; i < value.size(); i++ ) {
|
|
VipsImage *vips_image = value[i].get_image();
|
|
|
|
array[i] = vips_image;
|
|
g_object_ref( vips_image );
|
|
}
|
|
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// input blob
|
|
VOption *
|
|
VOption::set( const char *name, VipsBlob *value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = true;
|
|
g_value_init( &pair->value, VIPS_TYPE_BLOB );
|
|
g_value_set_boxed( &pair->value, value );
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// output bool
|
|
VOption *
|
|
VOption::set( const char *name, bool *value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = false;
|
|
pair->vbool = value;
|
|
g_value_init( &pair->value, G_TYPE_BOOLEAN );
|
|
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// output int
|
|
VOption *
|
|
VOption::set( const char *name, int *value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = false;
|
|
pair->vint = value;
|
|
g_value_init( &pair->value, G_TYPE_INT );
|
|
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// output double
|
|
VOption *
|
|
VOption::set( const char *name, double *value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = false;
|
|
pair->vdouble = value;
|
|
g_value_init( &pair->value, G_TYPE_DOUBLE );
|
|
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// output image
|
|
VOption *
|
|
VOption::set( const char *name, VImage *value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = false;
|
|
pair->vimage = value;
|
|
g_value_init( &pair->value, VIPS_TYPE_IMAGE );
|
|
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// output doublearray
|
|
VOption *
|
|
VOption::set( const char *name, std::vector<double> *value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = false;
|
|
pair->vvector = value;
|
|
g_value_init( &pair->value, VIPS_TYPE_ARRAY_DOUBLE );
|
|
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// output blob
|
|
VOption *
|
|
VOption::set( const char *name, VipsBlob **value )
|
|
{
|
|
Pair *pair = new Pair( name );
|
|
|
|
pair->input = false;
|
|
pair->vblob = value;
|
|
g_value_init( &pair->value, VIPS_TYPE_BLOB );
|
|
|
|
options.push_back( pair );
|
|
|
|
return( this );
|
|
}
|
|
|
|
// just g_object_set_property(), except we allow set enum from string
|
|
static void
|
|
set_property( VipsObject *object, const char *name, const GValue *value )
|
|
{
|
|
VipsObjectClass *object_class = VIPS_OBJECT_GET_CLASS( object );
|
|
GType type = G_VALUE_TYPE( value );
|
|
|
|
GParamSpec *pspec;
|
|
VipsArgumentClass *argument_class;
|
|
VipsArgumentInstance *argument_instance;
|
|
|
|
if( vips_object_get_argument( object, name,
|
|
&pspec, &argument_class, &argument_instance ) ) {
|
|
g_warning( "%s", vips_error_buffer() );
|
|
vips_error_clear();
|
|
return;
|
|
}
|
|
|
|
if( G_IS_PARAM_SPEC_ENUM( pspec ) &&
|
|
type == G_TYPE_STRING ) {
|
|
GType pspec_type = G_PARAM_SPEC_VALUE_TYPE( pspec );
|
|
|
|
int enum_value;
|
|
GValue value2 = { 0 };
|
|
|
|
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_object_set_property( G_OBJECT( object ), name, &value2 );
|
|
g_value_unset( &value2 );
|
|
}
|
|
else
|
|
g_object_set_property( G_OBJECT( object ), name, value );
|
|
}
|
|
|
|
// 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 )
|
|
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 );
|
|
printf( ".%s = %s\n", (*i)->name, str_value );
|
|
g_free( str_value );
|
|
#endif /*VIPS_DEBUG_VERBOSE*/
|
|
|
|
set_property( VIPS_OBJECT( operation ),
|
|
(*i)->name, &(*i)->value );
|
|
}
|
|
}
|
|
|
|
// walk the options and fetch any requested outputs
|
|
void
|
|
VOption::get_operation( VipsOperation *operation )
|
|
{
|
|
std::list<Pair *>::iterator i;
|
|
|
|
for( i = options.begin(); i != options.end(); ++i )
|
|
if( ! (*i)->input ) {
|
|
const char *name = (*i)->name;
|
|
|
|
g_object_get_property( G_OBJECT( operation ),
|
|
name, &(*i)->value );
|
|
|
|
#ifdef VIPS_DEBUG_VERBOSE
|
|
printf( "get_operation: " );
|
|
vips_object_print_name( VIPS_OBJECT( operation ) );
|
|
char *str_value = g_strdup_value_contents(
|
|
&(*i)->value );
|
|
printf( ".%s = %s\n", name, str_value );
|
|
g_free( str_value );
|
|
#endif /*VIPS_DEBUG_VERBOSE*/
|
|
|
|
GValue *value = &(*i)->value;
|
|
GType type = G_VALUE_TYPE( value );
|
|
|
|
if( type == VIPS_TYPE_IMAGE ) {
|
|
// rebox object
|
|
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 == VIPS_TYPE_ARRAY_DOUBLE ) {
|
|
int length;
|
|
double *array =
|
|
vips_value_get_array_double( value,
|
|
&length );
|
|
int j;
|
|
|
|
((*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) =
|
|
(VipsBlob *) g_value_dup_boxed( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
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",
|
|
operation_name );
|
|
|
|
if( !(operation = vips_operation_new( operation_name )) ) {
|
|
if( options )
|
|
delete options;
|
|
throw( VError() );
|
|
}
|
|
|
|
/* 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 ),
|
|
option_string ) ) {
|
|
vips_object_unref_outputs( VIPS_OBJECT( operation ) );
|
|
g_object_unref( operation );
|
|
delete options;
|
|
throw( VError() );
|
|
}
|
|
|
|
if( options )
|
|
options->set_operation( operation );
|
|
|
|
/* Build from cache.
|
|
*/
|
|
if( vips_cache_operation_buildp( &operation ) ) {
|
|
vips_object_unref_outputs( VIPS_OBJECT( operation ) );
|
|
g_object_unref( operation );
|
|
delete options;
|
|
throw( VError() );
|
|
}
|
|
|
|
/* Walk args again, writing output.
|
|
*/
|
|
if( options )
|
|
options->get_operation( operation );
|
|
|
|
/* We're done with options!
|
|
*/
|
|
delete options;
|
|
|
|
/* 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 )
|
|
{
|
|
call_option_string( operation_name, NULL, options );
|
|
}
|
|
|
|
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;
|
|
|
|
vips__filename_split8( name, filename, option_string );
|
|
if( !(operation_name = vips_foreign_find_load( filename )) ) {
|
|
delete options;
|
|
throw VError();
|
|
}
|
|
|
|
call_option_string( operation_name, option_string,
|
|
(options ? options : VImage::option())->
|
|
set( "filename", filename )->
|
|
set( "out", &out ) );
|
|
|
|
return( out );
|
|
}
|
|
|
|
VImage
|
|
VImage::new_from_buffer( void *buf, size_t len, const char *option_string,
|
|
VOption *options )
|
|
{
|
|
const char *operation_name;
|
|
VipsBlob *blob;
|
|
VImage out;
|
|
|
|
if( !(operation_name = vips_foreign_find_load_buffer( buf, len )) ) {
|
|
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())->
|
|
set( "buffer", blob )->
|
|
set( "out", &out );
|
|
vips_area_unref( VIPS_AREA( blob ) );
|
|
|
|
call_option_string( operation_name, option_string, options );
|
|
|
|
return( out );
|
|
}
|
|
|
|
VImage
|
|
VImage::new_from_image( std::vector<double> pixel )
|
|
{
|
|
VImage onepx = VImage::black( 1, 1,
|
|
VImage::option()->set( "bands", bands() ) );
|
|
|
|
onepx = (onepx + pixel).cast( format() );
|
|
|
|
VImage big = onepx.embed( 0, 0, width(), height(),
|
|
VImage::option()->set( "extend", VIPS_EXTEND_COPY ) );
|
|
|
|
big = big.copy(
|
|
VImage::option()->
|
|
set( "interpretation", interpretation() )->
|
|
set( "xres", xres() )->
|
|
set( "yres", yres() )->
|
|
set( "xoffset", xres() )->
|
|
set( "yoffset", yres() ) );
|
|
|
|
return( big );
|
|
}
|
|
|
|
VImage
|
|
VImage::new_from_image( double pixel )
|
|
{
|
|
return( new_from_image( to_vectorv( 1, pixel ) ) );
|
|
}
|
|
|
|
VImage
|
|
VImage::new_matrix( int width, int height )
|
|
{
|
|
return( VImage( vips_image_new_matrix( width, height ) ) );
|
|
}
|
|
|
|
VImage
|
|
VImage::new_matrixv( int width, int height, ... )
|
|
{
|
|
VImage matrix = new_matrix( width, height );
|
|
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 ) =
|
|
va_arg( ap, double );
|
|
va_end( ap );
|
|
|
|
return( matrix );
|
|
}
|
|
|
|
VImage
|
|
VImage::write( VImage out )
|
|
{
|
|
if( vips_image_write( this->get_image(), out.get_image() ) )
|
|
throw VError();
|
|
|
|
return( out );
|
|
}
|
|
|
|
void
|
|
VImage::write_to_file( const char *name, VOption *options )
|
|
{
|
|
char filename[VIPS_PATH_MAX];
|
|
char option_string[VIPS_PATH_MAX];
|
|
const char *operation_name;
|
|
|
|
vips__filename_split8( name, filename, option_string );
|
|
if( !(operation_name = vips_foreign_find_save( filename )) ) {
|
|
delete options;
|
|
throw VError();
|
|
}
|
|
|
|
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,
|
|
VOption *options )
|
|
{
|
|
char filename[VIPS_PATH_MAX];
|
|
char option_string[VIPS_PATH_MAX];
|
|
const char *operation_name;
|
|
VipsBlob *blob;
|
|
|
|
vips__filename_split8( suffix, filename, option_string );
|
|
if( !(operation_name = vips_foreign_find_save_buffer( filename )) ) {
|
|
delete options;
|
|
throw VError();
|
|
}
|
|
|
|
call_option_string( operation_name, option_string,
|
|
(options ? options : VImage::option())->
|
|
set( "in", *this )->
|
|
set( "buffer", &blob ) );
|
|
|
|
if( blob ) {
|
|
if( buf ) {
|
|
*buf = VIPS_AREA( blob )->data;
|
|
VIPS_AREA( blob )->free_fn = NULL;
|
|
}
|
|
if( size )
|
|
*size = VIPS_AREA( blob )->length;
|
|
|
|
vips_area_unref( VIPS_AREA( blob ) );
|
|
}
|
|
}
|
|
|
|
#include "vips-operators.cpp"
|
|
|
|
std::vector<VImage>
|
|
VImage::bandsplit( VOption *options )
|
|
{
|
|
std::vector<VImage> b;
|
|
|
|
for( int i = 0; i < bands(); i++ )
|
|
b.push_back( extract_band( i ) );
|
|
|
|
return( b );
|
|
}
|
|
|
|
VImage
|
|
VImage::bandjoin( VImage other, VOption *options )
|
|
{
|
|
VImage v[2] = { *this, other };
|
|
std::vector<VImage> vec( v, v + VIPS_NUMBER( v ) );
|
|
|
|
return( bandjoin( vec, options ) );
|
|
}
|
|
|
|
std::complex<double>
|
|
VImage::minpos( VOption *options )
|
|
{
|
|
double x, y;
|
|
|
|
(void) min(
|
|
(options ? options : VImage::option()) ->
|
|
set( "x", &x ) ->
|
|
set( "y", &y ) );
|
|
|
|
return( std::complex<double>( x, y ) );
|
|
}
|
|
|
|
std::complex<double>
|
|
VImage::maxpos( VOption *options )
|
|
{
|
|
double x, y;
|
|
|
|
(void) max(
|
|
(options ? options : VImage::option()) ->
|
|
set( "x", &x ) ->
|
|
set( "y", &y ) );
|
|
|
|
return( std::complex<double>( x, y ) );
|
|
}
|
|
|
|
// Operator overloads
|
|
|
|
VImage
|
|
VImage::operator[]( int index )
|
|
{
|
|
return( this->extract_band( index ) );
|
|
}
|
|
|
|
std::vector<double>
|
|
VImage::operator()( int x, int y )
|
|
{
|
|
return( this->getpoint( x, y ) );
|
|
}
|
|
|
|
VImage
|
|
operator+( VImage a, VImage b )
|
|
{
|
|
return( a.add( b ) );
|
|
}
|
|
|
|
VImage
|
|
operator+( double a, VImage b )
|
|
{
|
|
return( b.linear( 1.0, a ) );
|
|
}
|
|
|
|
VImage
|
|
operator+( VImage a, double b )
|
|
{
|
|
return( a.linear( 1.0, b ) );
|
|
}
|
|
|
|
VImage
|
|
operator+( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.linear( 1.0, a ) );
|
|
}
|
|
|
|
VImage
|
|
operator+( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.linear( 1.0, b ) );
|
|
}
|
|
|
|
VImage &
|
|
operator+=( VImage a, const VImage b )
|
|
{
|
|
return( a = a + b );
|
|
}
|
|
|
|
VImage &
|
|
operator+=( VImage a, const double b )
|
|
{
|
|
return( a = a + b );
|
|
}
|
|
|
|
VImage &
|
|
operator+=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a = a + b );
|
|
}
|
|
|
|
VImage
|
|
operator-( VImage a, VImage b )
|
|
{
|
|
return( a.subtract( b ) );
|
|
}
|
|
|
|
VImage
|
|
operator-( double a, VImage b )
|
|
{
|
|
return( b.linear( -1.0, a ) );
|
|
}
|
|
|
|
VImage
|
|
operator-( VImage a, double b )
|
|
{
|
|
return( a.linear( 1.0, -b ) );
|
|
}
|
|
|
|
VImage
|
|
operator-( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.linear( -1.0, a ) );
|
|
}
|
|
|
|
VImage
|
|
operator-( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.linear( 1.0, vips::negate( b ) ) );
|
|
}
|
|
|
|
VImage &
|
|
operator-=( VImage a, const VImage b )
|
|
{
|
|
return( a = a - b );
|
|
}
|
|
|
|
VImage &
|
|
operator-=( VImage a, const double b )
|
|
{
|
|
return( a = a - b );
|
|
}
|
|
|
|
VImage &
|
|
operator-=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a = a - b );
|
|
}
|
|
|
|
VImage
|
|
operator-( VImage a )
|
|
{
|
|
return( a * -1 );
|
|
}
|
|
|
|
VImage
|
|
operator*( VImage a, VImage b )
|
|
{
|
|
return( a.multiply( b ) );
|
|
}
|
|
|
|
VImage
|
|
operator*( double a, VImage b )
|
|
{
|
|
return( b.linear( a, 0.0 ) );
|
|
}
|
|
|
|
VImage
|
|
operator*( VImage a, double b )
|
|
{
|
|
return( a.linear( b, 0.0 ) );
|
|
}
|
|
|
|
VImage
|
|
operator*( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.linear( a, 0.0 ) );
|
|
}
|
|
|
|
VImage
|
|
operator*( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.linear( b, 0.0 ) );
|
|
}
|
|
|
|
VImage &
|
|
operator*=( VImage a, const VImage b )
|
|
{
|
|
return( a = a * b );
|
|
}
|
|
|
|
VImage &
|
|
operator*=( VImage a, const double b )
|
|
{
|
|
return( a = a * b );
|
|
}
|
|
|
|
VImage &
|
|
operator*=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a = a * b );
|
|
}
|
|
|
|
VImage
|
|
operator/( VImage a, VImage b )
|
|
{
|
|
return( a.divide( b ) );
|
|
}
|
|
|
|
VImage
|
|
operator/( double a, VImage b )
|
|
{
|
|
return( b.pow( -1.0 ).linear( a, 0.0 ) );
|
|
}
|
|
|
|
VImage
|
|
operator/( VImage a, double b )
|
|
{
|
|
return( a.linear( 1.0 / b, 0.0 ) );
|
|
}
|
|
|
|
VImage
|
|
operator/( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.pow( -1.0 ).linear( a, 0.0 ) );
|
|
}
|
|
|
|
VImage
|
|
operator/( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.linear( vips::invert( b ), 0.0 ) );
|
|
}
|
|
|
|
VImage &
|
|
operator/=( VImage a, const VImage b )
|
|
{
|
|
return( a = a / b );
|
|
}
|
|
|
|
VImage &
|
|
operator/=( VImage a, const double b )
|
|
{
|
|
return( a = a / b );
|
|
}
|
|
|
|
VImage &
|
|
operator/=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a = a / b );
|
|
}
|
|
|
|
VImage
|
|
operator%( VImage a, VImage b )
|
|
{
|
|
return( a.remainder( b ) );
|
|
}
|
|
|
|
VImage
|
|
operator%( VImage a, double b )
|
|
{
|
|
return( a.remainder_const( to_vector( b ) ) );
|
|
}
|
|
|
|
VImage
|
|
operator%( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.remainder_const( b ) );
|
|
}
|
|
|
|
VImage &
|
|
operator%=( VImage a, const VImage b )
|
|
{
|
|
return( a = a % b );
|
|
}
|
|
|
|
VImage &
|
|
operator%=( VImage a, const double b )
|
|
{
|
|
return( a = a % b );
|
|
}
|
|
|
|
VImage &
|
|
operator%=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a = a % b );
|
|
}
|
|
|
|
VImage
|
|
operator<( VImage a, VImage b )
|
|
{
|
|
return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESS ) );
|
|
}
|
|
|
|
VImage
|
|
operator<( double a, VImage b )
|
|
{
|
|
return( b.relational_const( to_vector( a ),
|
|
VIPS_OPERATION_RELATIONAL_MORE ) );
|
|
}
|
|
|
|
VImage
|
|
operator<( VImage a, double b )
|
|
{
|
|
return( a.relational_const( to_vector( b ),
|
|
VIPS_OPERATION_RELATIONAL_LESS ) );
|
|
}
|
|
|
|
VImage
|
|
operator<( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.relational_const( a,
|
|
VIPS_OPERATION_RELATIONAL_MORE ) );
|
|
}
|
|
|
|
VImage
|
|
operator<( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.relational_const( b,
|
|
VIPS_OPERATION_RELATIONAL_LESS ) );
|
|
}
|
|
|
|
VImage
|
|
operator<=( VImage a, VImage b )
|
|
{
|
|
return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESSEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator<=( double a, VImage b )
|
|
{
|
|
return( b.relational_const( to_vector( a ),
|
|
VIPS_OPERATION_RELATIONAL_MOREEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator<=( VImage a, double b )
|
|
{
|
|
return( a.relational_const( to_vector( b ),
|
|
VIPS_OPERATION_RELATIONAL_LESSEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator<=( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.relational_const( a,
|
|
VIPS_OPERATION_RELATIONAL_MOREEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator<=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.relational_const( b,
|
|
VIPS_OPERATION_RELATIONAL_LESSEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator>( VImage a, VImage b )
|
|
{
|
|
return( a.relational( b, VIPS_OPERATION_RELATIONAL_MORE ) );
|
|
}
|
|
|
|
VImage
|
|
operator>( double a, VImage b )
|
|
{
|
|
return( b.relational_const( to_vector( a ),
|
|
VIPS_OPERATION_RELATIONAL_LESS ) );
|
|
}
|
|
|
|
VImage
|
|
operator>( VImage a, double b )
|
|
{
|
|
return( a.relational_const( to_vector( b ),
|
|
VIPS_OPERATION_RELATIONAL_MORE ) );
|
|
}
|
|
|
|
VImage
|
|
operator>( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.relational_const( a,
|
|
VIPS_OPERATION_RELATIONAL_LESS ) );
|
|
}
|
|
|
|
VImage
|
|
operator>( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.relational_const( b,
|
|
VIPS_OPERATION_RELATIONAL_MORE ) );
|
|
}
|
|
|
|
VImage
|
|
operator>=( VImage a, VImage b )
|
|
{
|
|
return( a.relational( b, VIPS_OPERATION_RELATIONAL_MOREEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator>=( double a, VImage b )
|
|
{
|
|
return( b.relational_const( to_vector( a ),
|
|
VIPS_OPERATION_RELATIONAL_LESSEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator>=( VImage a, double b )
|
|
{
|
|
return( a.relational_const( to_vector( b ),
|
|
VIPS_OPERATION_RELATIONAL_MOREEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator>=( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.relational_const( a,
|
|
VIPS_OPERATION_RELATIONAL_LESSEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator>=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.relational_const( b,
|
|
VIPS_OPERATION_RELATIONAL_MOREEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator==( VImage a, VImage b )
|
|
{
|
|
return( a.relational( b, VIPS_OPERATION_RELATIONAL_EQUAL ) );
|
|
}
|
|
|
|
VImage
|
|
operator==( double a, VImage b )
|
|
{
|
|
return( b.relational_const( to_vector( a ),
|
|
VIPS_OPERATION_RELATIONAL_EQUAL ) );
|
|
}
|
|
|
|
VImage
|
|
operator==( VImage a, double b )
|
|
{
|
|
return( a.relational_const( to_vector( b ),
|
|
VIPS_OPERATION_RELATIONAL_EQUAL ) );
|
|
}
|
|
|
|
VImage
|
|
operator==( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.relational_const( a,
|
|
VIPS_OPERATION_RELATIONAL_EQUAL ) );
|
|
}
|
|
|
|
VImage
|
|
operator==( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.relational_const( b,
|
|
VIPS_OPERATION_RELATIONAL_EQUAL ) );
|
|
}
|
|
|
|
VImage
|
|
operator!=( VImage a, VImage b )
|
|
{
|
|
return( a.relational( b, VIPS_OPERATION_RELATIONAL_NOTEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator!=( double a, VImage b )
|
|
{
|
|
return( b.relational_const( to_vector( a ),
|
|
VIPS_OPERATION_RELATIONAL_NOTEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator!=( VImage a, double b )
|
|
{
|
|
return( a.relational_const( to_vector( b ),
|
|
VIPS_OPERATION_RELATIONAL_NOTEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator!=( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.relational_const( a,
|
|
VIPS_OPERATION_RELATIONAL_NOTEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator!=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.relational_const( b,
|
|
VIPS_OPERATION_RELATIONAL_NOTEQ ) );
|
|
}
|
|
|
|
VImage
|
|
operator&( VImage a, VImage b )
|
|
{
|
|
return( a.boolean( b, VIPS_OPERATION_BOOLEAN_AND ) );
|
|
}
|
|
|
|
VImage
|
|
operator&( double a, VImage b )
|
|
{
|
|
return( b.boolean_const( to_vector( a ),
|
|
VIPS_OPERATION_BOOLEAN_AND ) );
|
|
}
|
|
|
|
VImage
|
|
operator&( VImage a, double b )
|
|
{
|
|
return( a.boolean_const( to_vector( b ),
|
|
VIPS_OPERATION_BOOLEAN_AND ) );
|
|
}
|
|
|
|
VImage
|
|
operator&( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_AND ) );
|
|
}
|
|
|
|
VImage
|
|
operator&( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_AND ) );
|
|
}
|
|
|
|
VImage &
|
|
operator&=( VImage a, const VImage b )
|
|
{
|
|
return( a = a & b );
|
|
}
|
|
|
|
VImage &
|
|
operator&=( VImage a, const double b )
|
|
{
|
|
return( a = a & b );
|
|
}
|
|
|
|
VImage &
|
|
operator&=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a = a & b );
|
|
}
|
|
|
|
VImage
|
|
operator|( VImage a, VImage b )
|
|
{
|
|
return( a.boolean( b, VIPS_OPERATION_BOOLEAN_OR ) );
|
|
}
|
|
|
|
VImage
|
|
operator|( double a, VImage b )
|
|
{
|
|
return( b.boolean_const( to_vector( a ),
|
|
VIPS_OPERATION_BOOLEAN_OR ) );
|
|
}
|
|
|
|
VImage
|
|
operator|( VImage a, double b )
|
|
{
|
|
return( a.boolean_const( to_vector( b ),
|
|
VIPS_OPERATION_BOOLEAN_OR ) );
|
|
}
|
|
|
|
VImage
|
|
operator|( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_OR ) );
|
|
}
|
|
|
|
VImage
|
|
operator|( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_OR ) );
|
|
}
|
|
|
|
VImage &
|
|
operator|=( VImage a, const VImage b )
|
|
{
|
|
return( a = a | b );
|
|
}
|
|
|
|
VImage &
|
|
operator|=( VImage a, const double b )
|
|
{
|
|
return( a = a | b );
|
|
}
|
|
|
|
VImage &
|
|
operator|=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a = a | b );
|
|
}
|
|
|
|
VImage
|
|
operator^( VImage a, VImage b )
|
|
{
|
|
return( a.boolean( b, VIPS_OPERATION_BOOLEAN_EOR ) );
|
|
}
|
|
|
|
VImage
|
|
operator^( double a, VImage b )
|
|
{
|
|
return( b.boolean_const( to_vector( a ),
|
|
VIPS_OPERATION_BOOLEAN_EOR ) );
|
|
}
|
|
|
|
VImage
|
|
operator^( VImage a, double b )
|
|
{
|
|
return( a.boolean_const( to_vector( b ),
|
|
VIPS_OPERATION_BOOLEAN_EOR ) );
|
|
}
|
|
|
|
VImage
|
|
operator^( std::vector<double> a, VImage b )
|
|
{
|
|
return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_EOR ) );
|
|
}
|
|
|
|
VImage
|
|
operator^( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_EOR ) );
|
|
}
|
|
|
|
VImage &
|
|
operator^=( VImage a, const VImage b )
|
|
{
|
|
return( a = a ^ b );
|
|
}
|
|
|
|
VImage &
|
|
operator^=( VImage a, const double b )
|
|
{
|
|
return( a = a ^ b );
|
|
}
|
|
|
|
VImage &
|
|
operator^=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a = a ^ b );
|
|
}
|
|
|
|
VImage
|
|
operator<<( VImage a, VImage b )
|
|
{
|
|
return( a.boolean( b, VIPS_OPERATION_BOOLEAN_LSHIFT ) );
|
|
}
|
|
|
|
VImage
|
|
operator<<( VImage a, double b )
|
|
{
|
|
return( a.boolean_const( to_vector( b ),
|
|
VIPS_OPERATION_BOOLEAN_LSHIFT ) );
|
|
}
|
|
|
|
VImage
|
|
operator<<( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_LSHIFT ) );
|
|
}
|
|
|
|
VImage &
|
|
operator<<=( VImage a, const VImage b )
|
|
{
|
|
return( a = a << b );
|
|
}
|
|
|
|
VImage &
|
|
operator<<=( VImage a, const double b )
|
|
{
|
|
return( a = a << b );
|
|
}
|
|
|
|
VImage &
|
|
operator<<=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a = a << b );
|
|
}
|
|
|
|
VImage
|
|
operator>>( VImage a, VImage b )
|
|
{
|
|
return( a.boolean( b, VIPS_OPERATION_BOOLEAN_RSHIFT ) );
|
|
}
|
|
|
|
VImage
|
|
operator>>( VImage a, double b )
|
|
{
|
|
return( a.boolean_const( to_vector( b ),
|
|
VIPS_OPERATION_BOOLEAN_RSHIFT ) );
|
|
}
|
|
|
|
VImage
|
|
operator>>( VImage a, std::vector<double> b )
|
|
{
|
|
return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_RSHIFT ) );
|
|
}
|
|
|
|
VImage &
|
|
operator>>=( VImage a, const VImage b )
|
|
{
|
|
return( a = a << b );
|
|
}
|
|
|
|
VImage &
|
|
operator>>=( VImage a, const double b )
|
|
{
|
|
return( a = a << b );
|
|
}
|
|
|
|
VImage &
|
|
operator>>=( VImage a, std::vector<double> b )
|
|
{
|
|
return( a = a << b );
|
|
}
|
|
|
|
VIPS_NAMESPACE_END
|