sergiotarxz/libvips
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
de026e0750
libvips/libvipsCC/vipsc++.cc
John Cupitt 2cbaf93b18 stuff
2010-06-24 19:40:12 +00:00

5865 lines
123 KiB
C++
Raw Blame History

// bodies for package arithmetic
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_abs: absolute value
VImage VImage::abs() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_abs" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_acostra: acos of image (result in degrees)
VImage VImage::acos() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_acostra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_add: add two images
VImage VImage::add( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_add" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_asintra: asin of image (result in degrees)
VImage VImage::asin() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_asintra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_atantra: atan of image (result in degrees)
VImage VImage::atan() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_atantra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_avg: average value of image
double VImage::avg() throw( VError )
{
VImage in = *this;
double value;
Vargv _vec( "im_avg" );
_vec.data(0) = in.image();
_vec.call();
value = *((double*)_vec.data(1));
return( value );
}
// im_point_bilinear: interpolate value at single point, linearly
double VImage::point_bilinear( double x, double y, int band ) throw( VError )
{
VImage in = *this;
double val;
Vargv _vec( "im_point_bilinear" );
_vec.data(0) = in.image();
*((double*) _vec.data(1)) = x;
*((double*) _vec.data(2)) = y;
*((int*) _vec.data(3)) = band;
_vec.call();
val = *((double*)_vec.data(4));
return( val );
}
// im_bandmean: average image bands
VImage VImage::bandmean() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_bandmean" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_ceil: round to smallest integer value not less than
VImage VImage::ceil() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_ceil" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_costra: cos of image (angles in degrees)
VImage VImage::cos() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_costra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_cross_phase: phase of cross power spectrum of two complex images
VImage VImage::cross_phase( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_cross_phase" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_deviate: standard deviation of image
double VImage::deviate() throw( VError )
{
VImage in = *this;
double value;
Vargv _vec( "im_deviate" );
_vec.data(0) = in.image();
_vec.call();
value = *((double*)_vec.data(1));
return( value );
}
// im_divide: divide two images
VImage VImage::divide( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_divide" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_exp10tra: 10^pel of image
VImage VImage::exp10() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_exp10tra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_expntra: x^pel of image
VImage VImage::expn( double x ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_expntra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = x;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_expntra_vec: [x,y,z]^pel of image
VImage VImage::expn( std::vector<double> v ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_expntra_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = v.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[v.size()];
for( unsigned int i = 0; i < v.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = v[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_exptra: e^pel of image
VImage VImage::exp() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_exptra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_floor: round to largest integer value not greater than
VImage VImage::floor() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_floor" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_invert: photographic negative
VImage VImage::invert() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_invert" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_lintra: calculate a*in + b = outfile
VImage VImage::lin( double a, double b ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_lintra" );
*((double*) _vec.data(0)) = a;
_vec.data(1) = in.image();
*((double*) _vec.data(2)) = b;
_vec.data(3) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_linreg: pixelwise linear regression
VImage VImage::linreg( std::vector<VImage> ins, std::vector<double> xs ) throw( VError )
{
VImage out;
Vargv _vec( "im_linreg" );
((im_imagevec_object*) _vec.data(0))->n = ins.size();
((im_imagevec_object*) _vec.data(0))->vec = new IMAGE *[ins.size()];
for( unsigned int i = 0; i < ins.size(); i++ )
((im_imagevec_object*) _vec.data(0))->vec[i] = ins[i].image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = xs.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[xs.size()];
for( unsigned int i = 0; i < xs.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = xs[i];
_vec.call();
for( unsigned int i = 0; i < ins.size(); i++ )
out._ref->addref( ins[i]._ref );
return( out );
}
// im_lintra_vec: calculate a*in + b -> out, a and b vectors
VImage VImage::lin( std::vector<double> a, std::vector<double> b ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_lintra_vec" );
((im_doublevec_object*) _vec.data(0))->n = a.size();
((im_doublevec_object*) _vec.data(0))->vec = new double[a.size()];
for( unsigned int i = 0; i < a.size(); i++ )
((im_doublevec_object*) _vec.data(0))->vec[i] = a[i];
_vec.data(1) = in.image();
((im_doublevec_object*) _vec.data(2))->n = b.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[b.size()];
for( unsigned int i = 0; i < b.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = b[i];
_vec.data(3) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_log10tra: log10 of image
VImage VImage::log10() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_log10tra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_logtra: ln of image
VImage VImage::log() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_logtra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_max: maximum value of image
double VImage::max() throw( VError )
{
VImage in = *this;
double value;
Vargv _vec( "im_max" );
_vec.data(0) = in.image();
_vec.call();
value = *((double*)_vec.data(1));
return( value );
}
// im_maxpos: position of maximum value of image
std::complex<double> VImage::maxpos() throw( VError )
{
VImage in = *this;
std::complex<double> position;
Vargv _vec( "im_maxpos" );
_vec.data(0) = in.image();
_vec.call();
position = *((std::complex<double>*)_vec.data(1));
return( position );
}
// im_maxpos_avg: position of maximum value of image, averaging in case of draw
double VImage::maxpos_avg( double& y, double& out ) throw( VError )
{
VImage in = *this;
double x;
Vargv _vec( "im_maxpos_avg" );
_vec.data(0) = in.image();
_vec.call();
x = *((double*)_vec.data(1));
y = *((double*)_vec.data(2));
out = *((double*)_vec.data(3));
return( x );
}
// im_measure: measure averages of a grid of patches
VDMask VImage::measure( int x, int y, int w, int h, int h_patches, int v_patches ) throw( VError )
{
VImage in = *this;
VDMask mask;
Vargv _vec( "im_measure" );
_vec.data(0) = in.image();
((im_mask_object*) _vec.data(1))->name = (char*)"noname";
*((int*) _vec.data(2)) = x;
*((int*) _vec.data(3)) = y;
*((int*) _vec.data(4)) = w;
*((int*) _vec.data(5)) = h;
*((int*) _vec.data(6)) = h_patches;
*((int*) _vec.data(7)) = v_patches;
_vec.call();
mask.embed( (DOUBLEMASK *)((im_mask_object*)_vec.data(1))->mask );
return( mask );
}
// im_min: minimum value of image
double VImage::min() throw( VError )
{
VImage in = *this;
double value;
Vargv _vec( "im_min" );
_vec.data(0) = in.image();
_vec.call();
value = *((double*)_vec.data(1));
return( value );
}
// im_minpos: position of minimum value of image
std::complex<double> VImage::minpos() throw( VError )
{
VImage in = *this;
std::complex<double> position;
Vargv _vec( "im_minpos" );
_vec.data(0) = in.image();
_vec.call();
position = *((std::complex<double>*)_vec.data(1));
return( position );
}
// im_multiply: multiply two images
VImage VImage::multiply( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_multiply" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_powtra: pel^x of image
VImage VImage::pow( double x ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_powtra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = x;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_powtra_vec: pel^[x,y,z] of image
VImage VImage::pow( std::vector<double> v ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_powtra_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = v.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[v.size()];
for( unsigned int i = 0; i < v.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = v[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_recomb: linear recombination with mask
VImage VImage::recomb( VDMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_recomb" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().dptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_remainder: remainder after integer division
VImage VImage::remainder( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_remainder" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_remainderconst: remainder after integer division by a constant
VImage VImage::remainder( double x ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_remainderconst" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = x;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_remainder_vec: remainder after integer division by a vector of constants
VImage VImage::remainder( std::vector<double> x ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_remainder_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = x.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[x.size()];
for( unsigned int i = 0; i < x.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = x[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_rint: round to nearest integer value
VImage VImage::rint() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_rint" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_sign: unit vector in direction of value
VImage VImage::sign() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_sign" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_sintra: sin of image (angles in degrees)
VImage VImage::sin() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_sintra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_stats: many image statistics in one pass
VDMask VImage::stats() throw( VError )
{
VImage in = *this;
VDMask statistics;
Vargv _vec( "im_stats" );
_vec.data(0) = in.image();
((im_mask_object*) _vec.data(1))->name = (char*)"noname";
_vec.call();
statistics.embed( (DOUBLEMASK *)((im_mask_object*)_vec.data(1))->mask );
return( statistics );
}
// im_subtract: subtract two images
VImage VImage::subtract( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_subtract" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_tantra: tan of image (angles in degrees)
VImage VImage::tan() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_tantra" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// bodies for package boolean
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_andimage: bitwise and of two images
VImage VImage::andimage( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_andimage" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_andimageconst: bitwise and of an image with a constant
VImage VImage::andimage( int c ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_andimageconst" );
_vec.data(0) = in1.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in1._ref );
return( out );
}
// im_andimage_vec: bitwise and of an image with a vector constant
VImage VImage::andimage( std::vector<double> vec ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_andimage_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = vec.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[vec.size()];
for( unsigned int i = 0; i < vec.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = vec[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_orimage: bitwise or of two images
VImage VImage::orimage( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_orimage" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_orimageconst: bitwise or of an image with a constant
VImage VImage::orimage( int c ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_orimageconst" );
_vec.data(0) = in1.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in1._ref );
return( out );
}
// im_orimage_vec: bitwise or of an image with a vector constant
VImage VImage::orimage( std::vector<double> vec ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_orimage_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = vec.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[vec.size()];
for( unsigned int i = 0; i < vec.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = vec[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_eorimage: bitwise eor of two images
VImage VImage::eorimage( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_eorimage" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_eorimageconst: bitwise eor of an image with a constant
VImage VImage::eorimage( int c ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_eorimageconst" );
_vec.data(0) = in1.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in1._ref );
return( out );
}
// im_eorimage_vec: bitwise eor of an image with a vector constant
VImage VImage::eorimage( std::vector<double> vec ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_eorimage_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = vec.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[vec.size()];
for( unsigned int i = 0; i < vec.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = vec[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_shiftleft_vec: shift image array bits to left
VImage VImage::shiftleft( std::vector<double> vec ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_shiftleft_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = vec.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[vec.size()];
for( unsigned int i = 0; i < vec.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = vec[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_shiftleft: shift image n bits to left
VImage VImage::shiftleft( int c ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_shiftleft" );
_vec.data(0) = in1.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in1._ref );
return( out );
}
// im_shiftright_vec: shift image array bits to right
VImage VImage::shiftright( std::vector<double> vec ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_shiftright_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = vec.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[vec.size()];
for( unsigned int i = 0; i < vec.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = vec[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_shiftright: shift integer image n bits to right
VImage VImage::shiftright( int c ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_shiftright" );
_vec.data(0) = in1.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in1._ref );
return( out );
}
// bodies for package cimg
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_greyc: noise-removing filter
VImage VImage::greyc( int iterations, double amplitude, double sharpness, double anisotropy, double alpha, double sigma, double dl, double da, double gauss_prec, int interpolation, int fast_approx ) throw( VError )
{
VImage src = *this;
VImage dst;
Vargv _vec( "im_greyc" );
_vec.data(0) = src.image();
_vec.data(1) = dst.image();
*((int*) _vec.data(2)) = iterations;
*((double*) _vec.data(3)) = amplitude;
*((double*) _vec.data(4)) = sharpness;
*((double*) _vec.data(5)) = anisotropy;
*((double*) _vec.data(6)) = alpha;
*((double*) _vec.data(7)) = sigma;
*((double*) _vec.data(8)) = dl;
*((double*) _vec.data(9)) = da;
*((double*) _vec.data(10)) = gauss_prec;
*((int*) _vec.data(11)) = interpolation;
*((int*) _vec.data(12)) = fast_approx;
_vec.call();
dst._ref->addref( src._ref );
return( dst );
}
// im_greyc_mask: noise-removing filter, with a mask
VImage VImage::greyc_mask( VImage mask, int iterations, double amplitude, double sharpness, double anisotropy, double alpha, double sigma, double dl, double da, double gauss_prec, int interpolation, int fast_approx ) throw( VError )
{
VImage src = *this;
VImage dst;
Vargv _vec( "im_greyc_mask" );
_vec.data(0) = src.image();
_vec.data(1) = dst.image();
_vec.data(2) = mask.image();
*((int*) _vec.data(3)) = iterations;
*((double*) _vec.data(4)) = amplitude;
*((double*) _vec.data(5)) = sharpness;
*((double*) _vec.data(6)) = anisotropy;
*((double*) _vec.data(7)) = alpha;
*((double*) _vec.data(8)) = sigma;
*((double*) _vec.data(9)) = dl;
*((double*) _vec.data(10)) = da;
*((double*) _vec.data(11)) = gauss_prec;
*((int*) _vec.data(12)) = interpolation;
*((int*) _vec.data(13)) = fast_approx;
_vec.call();
dst._ref->addref( src._ref );
dst._ref->addref( mask._ref );
return( dst );
}
// bodies for package colour
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_LCh2Lab: convert LCh to Lab
VImage VImage::LCh2Lab() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_LCh2Lab" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_LCh2UCS: convert LCh to UCS
VImage VImage::LCh2UCS() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_LCh2UCS" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_Lab2LCh: convert Lab to LCh
VImage VImage::Lab2LCh() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_Lab2LCh" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_Lab2LabQ: convert Lab to LabQ
VImage VImage::Lab2LabQ() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_Lab2LabQ" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_Lab2LabS: convert Lab to LabS
VImage VImage::Lab2LabS() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_Lab2LabS" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_Lab2UCS: convert Lab to UCS
VImage VImage::Lab2UCS() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_Lab2UCS" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_Lab2XYZ: convert D65 Lab to XYZ
VImage VImage::Lab2XYZ() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_Lab2XYZ" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_Lab2XYZ_temp: convert Lab to XYZ, with a specified colour temperature
VImage VImage::Lab2XYZ_temp( double X0, double Y0, double Z0 ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_Lab2XYZ_temp" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = X0;
*((double*) _vec.data(3)) = Y0;
*((double*) _vec.data(4)) = Z0;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_Lab2disp: convert Lab to displayable
VImage VImage::Lab2disp( VDisplay disp ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_Lab2disp" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = disp.disp();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_LabQ2LabS: convert LabQ to LabS
VImage VImage::LabQ2LabS() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_LabQ2LabS" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_LabQ2Lab: convert LabQ to Lab
VImage VImage::LabQ2Lab() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_LabQ2Lab" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_LabQ2XYZ: convert LabQ to XYZ
VImage VImage::LabQ2XYZ() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_LabQ2XYZ" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_LabQ2disp: convert LabQ to displayable
VImage VImage::LabQ2disp( VDisplay disp ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_LabQ2disp" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = disp.disp();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_LabS2LabQ: convert LabS to LabQ
VImage VImage::LabS2LabQ() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_LabS2LabQ" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_LabS2Lab: convert LabS to Lab
VImage VImage::LabS2Lab() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_LabS2Lab" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_UCS2LCh: convert UCS to LCh
VImage VImage::UCS2LCh() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_UCS2LCh" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_UCS2Lab: convert UCS to Lab
VImage VImage::UCS2Lab() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_UCS2Lab" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_UCS2XYZ: convert UCS to XYZ
VImage VImage::UCS2XYZ() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_UCS2XYZ" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_XYZ2Lab: convert D65 XYZ to Lab
VImage VImage::XYZ2Lab() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_XYZ2Lab" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_XYZ2Lab_temp: convert XYZ to Lab, with a specified colour temperature
VImage VImage::XYZ2Lab_temp( double X0, double Y0, double Z0 ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_XYZ2Lab_temp" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = X0;
*((double*) _vec.data(3)) = Y0;
*((double*) _vec.data(4)) = Z0;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_XYZ2UCS: convert XYZ to UCS
VImage VImage::XYZ2UCS() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_XYZ2UCS" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_XYZ2Yxy: convert XYZ to Yxy
VImage VImage::XYZ2Yxy() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_XYZ2Yxy" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_XYZ2disp: convert XYZ to displayble
VImage VImage::XYZ2disp( VDisplay disp ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_XYZ2disp" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = disp.disp();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_XYZ2sRGB: convert XYZ to sRGB
VImage VImage::XYZ2sRGB() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_XYZ2sRGB" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_Yxy2XYZ: convert Yxy to XYZ
VImage VImage::Yxy2XYZ() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_Yxy2XYZ" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_dE00_fromLab: calculate delta-E CIE2000 for two Lab images
VImage VImage::dE00_fromLab( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_dE00_fromLab" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_dECMC_fromLab: calculate delta-E CMC(1:1) for two Lab images
VImage VImage::dECMC_fromLab( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_dECMC_fromLab" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_dECMC_fromdisp: calculate delta-E CMC(1:1) for two displayable images
VImage VImage::dECMC_fromdisp( VImage in2, VDisplay disp ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_dECMC_fromdisp" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.data(3) = disp.disp();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_dE_fromLab: calculate delta-E for two Lab images
VImage VImage::dE_fromLab( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_dE_fromLab" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_dE_fromXYZ: calculate delta-E for two XYZ images
VImage VImage::dE_fromXYZ( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_dE_fromXYZ" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_dE_fromdisp: calculate delta-E for two displayable images
VImage VImage::dE_fromdisp( VImage in2, VDisplay disp ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_dE_fromdisp" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.data(3) = disp.disp();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_disp2Lab: convert displayable to Lab
VImage VImage::disp2Lab( VDisplay disp ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_disp2Lab" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = disp.disp();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_disp2XYZ: convert displayable to XYZ
VImage VImage::disp2XYZ( VDisplay disp ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_disp2XYZ" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = disp.disp();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_float2rad: convert float to Radiance packed
VImage VImage::float2rad() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_float2rad" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_icc_ac2rc: convert LAB from AC to RC using an ICC profile
VImage VImage::icc_ac2rc( char* profile ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_icc_ac2rc" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = (im_object) profile;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_icc_export_depth: convert a float LAB to device space with an ICC profile
VImage VImage::icc_export_depth( int depth, char* output_profile, int intent ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_icc_export_depth" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = depth;
_vec.data(3) = (im_object) output_profile;
*((int*) _vec.data(4)) = intent;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_icc_import: convert a device image to float LAB with an ICC profile
VImage VImage::icc_import( char* input_profile, int intent ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_icc_import" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = (im_object) input_profile;
*((int*) _vec.data(3)) = intent;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_icc_import_embedded: convert a device image to float LAB using the embedded profile
VImage VImage::icc_import_embedded( int intent ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_icc_import_embedded" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = intent;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_icc_transform: convert between two device images with a pair of ICC profiles
VImage VImage::icc_transform( char* input_profile, char* output_profile, int intent ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_icc_transform" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = (im_object) input_profile;
_vec.data(3) = (im_object) output_profile;
*((int*) _vec.data(4)) = intent;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_lab_morph: morph colourspace of a LAB image
VImage VImage::lab_morph( VDMask greyscale, double L_offset, double L_scale, double a_scale, double b_scale ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_lab_morph" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = greyscale.mask().dptr;
*((double*) _vec.data(3)) = L_offset;
*((double*) _vec.data(4)) = L_scale;
*((double*) _vec.data(5)) = a_scale;
*((double*) _vec.data(6)) = b_scale;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_rad2float: convert Radiance packed to float
VImage VImage::rad2float() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_rad2float" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_sRGB2XYZ: convert sRGB to XYZ
VImage VImage::sRGB2XYZ() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_sRGB2XYZ" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// bodies for package conversion
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_gaussnoise: generate image of gaussian noise with specified statistics
VImage VImage::gaussnoise( int xsize, int ysize, double mean, double sigma ) throw( VError )
{
VImage out;
Vargv _vec( "im_gaussnoise" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = xsize;
*((int*) _vec.data(2)) = ysize;
*((double*) _vec.data(3)) = mean;
*((double*) _vec.data(4)) = sigma;
_vec.call();
return( out );
}
// im_bandjoin: bandwise join of two images
VImage VImage::bandjoin( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_bandjoin" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_black: generate black image
VImage VImage::black( int x_size, int y_size, int bands ) throw( VError )
{
VImage output;
Vargv _vec( "im_black" );
_vec.data(0) = output.image();
*((int*) _vec.data(1)) = x_size;
*((int*) _vec.data(2)) = y_size;
*((int*) _vec.data(3)) = bands;
_vec.call();
return( output );
}
// im_c2amph: convert real and imaginary to phase and amplitude
VImage VImage::c2amph() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_c2amph" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_c2imag: extract imaginary part of complex image
VImage VImage::c2imag() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_c2imag" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_c2real: extract real part of complex image
VImage VImage::c2real() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_c2real" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_c2rect: convert phase and amplitude to real and imaginary
VImage VImage::c2rect() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_c2rect" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_clip2fmt: convert image format to ofmt
VImage VImage::clip2fmt( int ofmt ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_clip2fmt" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = ofmt;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_copy: copy image
VImage VImage::copy() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_copy" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_copy_file: copy image to a file and return that
VImage VImage::copy_file() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_copy_file" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_copy_morph: copy image, setting pixel layout
VImage VImage::copy_morph( int Bands, int BandFmt, int Coding ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_copy_morph" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((int*) _vec.data(2)) = Bands;
*((int*) _vec.data(3)) = BandFmt;
*((int*) _vec.data(4)) = Coding;
_vec.call();
output._ref->addref( input._ref );
return( output );
}
// im_copy_swap: copy image, swapping byte order
VImage VImage::copy_swap() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_copy_swap" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_copy_set: copy image, setting informational fields
VImage VImage::copy_set( int Type, double Xres, double Yres, int Xoffset, int Yoffset ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_copy_set" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((int*) _vec.data(2)) = Type;
*((double*) _vec.data(3)) = Xres;
*((double*) _vec.data(4)) = Yres;
*((int*) _vec.data(5)) = Xoffset;
*((int*) _vec.data(6)) = Yoffset;
_vec.call();
output._ref->addref( input._ref );
return( output );
}
// im_extract_area: extract area
VImage VImage::extract_area( int left, int top, int width, int height ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_extract_area" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((int*) _vec.data(2)) = left;
*((int*) _vec.data(3)) = top;
*((int*) _vec.data(4)) = width;
*((int*) _vec.data(5)) = height;
_vec.call();
output._ref->addref( input._ref );
return( output );
}
// im_extract_areabands: extract area and bands
VImage VImage::extract_areabands( int left, int top, int width, int height, int band, int nbands ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_extract_areabands" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((int*) _vec.data(2)) = left;
*((int*) _vec.data(3)) = top;
*((int*) _vec.data(4)) = width;
*((int*) _vec.data(5)) = height;
*((int*) _vec.data(6)) = band;
*((int*) _vec.data(7)) = nbands;
_vec.call();
output._ref->addref( input._ref );
return( output );
}
// im_extract_band: extract band
VImage VImage::extract_band( int band ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_extract_band" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((int*) _vec.data(2)) = band;
_vec.call();
output._ref->addref( input._ref );
return( output );
}
// im_extract_bands: extract several bands
VImage VImage::extract_bands( int band, int nbands ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_extract_bands" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((int*) _vec.data(2)) = band;
*((int*) _vec.data(3)) = nbands;
_vec.call();
output._ref->addref( input._ref );
return( output );
}
// im_extract: extract area/band
VImage VImage::extract( int left, int top, int width, int height, int band ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_extract" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((int*) _vec.data(2)) = left;
*((int*) _vec.data(3)) = top;
*((int*) _vec.data(4)) = width;
*((int*) _vec.data(5)) = height;
*((int*) _vec.data(6)) = band;
_vec.call();
output._ref->addref( input._ref );
return( output );
}
// im_falsecolour: turn luminance changes into chrominance changes
VImage VImage::falsecolour() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_falsecolour" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_fliphor: flip image left-right
VImage VImage::fliphor() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_fliphor" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_flipver: flip image top-bottom
VImage VImage::flipver() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_flipver" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_gbandjoin: bandwise join of many images
VImage VImage::gbandjoin( std::vector<VImage> in ) throw( VError )
{
VImage out;
Vargv _vec( "im_gbandjoin" );
((im_imagevec_object*) _vec.data(0))->n = in.size();
((im_imagevec_object*) _vec.data(0))->vec = new IMAGE *[in.size()];
for( unsigned int i = 0; i < in.size(); i++ )
((im_imagevec_object*) _vec.data(0))->vec[i] = in[i].image();
_vec.data(1) = out.image();
_vec.call();
for( unsigned int i = 0; i < in.size(); i++ )
out._ref->addref( in[i]._ref );
return( out );
}
// im_grid: chop a tall thin image into a grid of images
VImage VImage::grid( int tile_height, int across, int down ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_grid" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((int*) _vec.data(2)) = tile_height;
*((int*) _vec.data(3)) = across;
*((int*) _vec.data(4)) = down;
_vec.call();
output._ref->addref( input._ref );
return( output );
}
// im_insert: insert sub-image into main image at position
VImage VImage::insert( VImage sub, int x, int y ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_insert" );
_vec.data(0) = in.image();
_vec.data(1) = sub.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = x;
*((int*) _vec.data(4)) = y;
_vec.call();
out._ref->addref( in._ref );
out._ref->addref( sub._ref );
return( out );
}
// im_insertset: insert sub into main at every position in x, y
VImage VImage::insert( VImage sub, std::vector<int> x, std::vector<int> y ) throw( VError )
{
VImage main = *this;
VImage out;
Vargv _vec( "im_insertset" );
_vec.data(0) = main.image();
_vec.data(1) = sub.image();
_vec.data(2) = out.image();
((im_intvec_object*) _vec.data(3))->n = x.size();
((im_intvec_object*) _vec.data(3))->vec = new int[x.size()];
for( unsigned int i = 0; i < x.size(); i++ )
((im_intvec_object*) _vec.data(3))->vec[i] = x[i];
((im_intvec_object*) _vec.data(4))->n = y.size();
((im_intvec_object*) _vec.data(4))->vec = new int[y.size()];
for( unsigned int i = 0; i < y.size(); i++ )
((im_intvec_object*) _vec.data(4))->vec[i] = y[i];
_vec.call();
return( out );
}
// im_insert_noexpand: insert sub-image into main image at position, no expansion
VImage VImage::insert_noexpand( VImage sub, int x, int y ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_insert_noexpand" );
_vec.data(0) = in.image();
_vec.data(1) = sub.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = x;
*((int*) _vec.data(4)) = y;
_vec.call();
out._ref->addref( in._ref );
out._ref->addref( sub._ref );
return( out );
}
// im_embed: embed in within a set of borders
VImage VImage::embed( int type, int x, int y, int width, int height ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_embed" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = type;
*((int*) _vec.data(3)) = x;
*((int*) _vec.data(4)) = y;
*((int*) _vec.data(5)) = width;
*((int*) _vec.data(6)) = height;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_lrjoin: join two images left-right
VImage VImage::lrjoin( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_lrjoin" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_mask2vips: convert DOUBLEMASK to VIPS image
VImage VImage::mask2vips( VDMask input ) throw( VError )
{
VImage output;
Vargv _vec( "im_mask2vips" );
((im_mask_object*) _vec.data(0))->mask = input.mask().dptr;
_vec.data(1) = output.image();
_vec.call();
return( output );
}
// im_msb: convert to uchar by discarding bits
VImage VImage::msb() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_msb" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_msb_band: convert to single band uchar by discarding bits
VImage VImage::msb_band( int band ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_msb_band" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = band;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_replicate: replicate an image horizontally and vertically
VImage VImage::replicate( int across, int down ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_replicate" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((int*) _vec.data(2)) = across;
*((int*) _vec.data(3)) = down;
_vec.call();
output._ref->addref( input._ref );
return( output );
}
// im_ri2c: join two non-complex images to form complex
VImage VImage::ri2c( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_ri2c" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_rot180: rotate image 180 degrees
VImage VImage::rot180() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_rot180" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_rot270: rotate image 270 degrees clockwise
VImage VImage::rot270() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_rot270" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_rot90: rotate image 90 degrees clockwise
VImage VImage::rot90() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_rot90" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_scale: scale image linearly to fit range 0-255
VImage VImage::scale() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_scale" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_scaleps: logarithmic scale of image to fit range 0-255
VImage VImage::scaleps() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_scaleps" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// im_subsample: subsample image by integer factors
VImage VImage::subsample( int xshrink, int yshrink ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_subsample" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = xshrink;
*((int*) _vec.data(3)) = yshrink;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_system: run command on image
char* VImage::system( char* command ) throw( VError )
{
VImage im = *this;
char* output;
Vargv _vec( "im_system" );
_vec.data(0) = im.image();
_vec.data(1) = (im_object) command;
_vec.call();
output = (char*) _vec.data(2);
return( output );
}
// im_system_image: run command on image, with image output
VImage VImage::system_image( char* in_format, char* out_format, char* command, char*& log ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_system_image" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = (im_object) in_format;
_vec.data(3) = (im_object) out_format;
_vec.data(4) = (im_object) command;
_vec.call();
log = (char*) _vec.data(5);
return( out );
}
// im_tbjoin: join two images top-bottom
VImage VImage::tbjoin( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_tbjoin" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_text: generate text image
VImage VImage::text( char* text, char* font, int width, int alignment, int dpi ) throw( VError )
{
VImage out;
Vargv _vec( "im_text" );
_vec.data(0) = out.image();
_vec.data(1) = (im_object) text;
_vec.data(2) = (im_object) font;
*((int*) _vec.data(3)) = width;
*((int*) _vec.data(4)) = alignment;
*((int*) _vec.data(5)) = dpi;
_vec.call();
return( out );
}
// im_vips2mask: convert VIPS image to DOUBLEMASK
VDMask VImage::vips2mask() throw( VError )
{
VImage input = *this;
VDMask output;
Vargv _vec( "im_vips2mask" );
_vec.data(0) = input.image();
((im_mask_object*) _vec.data(1))->name = (char*)"noname";
_vec.call();
output.embed( (DOUBLEMASK *)((im_mask_object*)_vec.data(1))->mask );
return( output );
}
// im_wrap: shift image origin, wrapping at sides
VImage VImage::wrap( int x, int y ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_wrap" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = x;
*((int*) _vec.data(3)) = y;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_zoom: simple zoom of an image by integer factors
VImage VImage::zoom( int xfac, int yfac ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_zoom" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((int*) _vec.data(2)) = xfac;
*((int*) _vec.data(3)) = yfac;
_vec.call();
output._ref->addref( input._ref );
return( output );
}
// bodies for package convolution
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_addgnoise: add gaussian noise with mean 0 and std. dev. sigma
VImage VImage::addgnoise( double sigma ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_addgnoise" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = sigma;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_compass: convolve with 8-way rotating integer mask
VImage VImage::compass( VIMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_compass" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().iptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_contrast_surface: find high-contrast points in an image
VImage VImage::contrast_surface( int half_win_size, int spacing ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_contrast_surface" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = half_win_size;
*((int*) _vec.data(3)) = spacing;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_conv: convolve
VImage VImage::conv( VIMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_conv" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().iptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_conv_f: convolve, with DOUBLEMASK
VImage VImage::conv( VDMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_conv_f" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().dptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_convsep: seperable convolution
VImage VImage::convsep( VIMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_convsep" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().iptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_convsep_f: seperable convolution, with DOUBLEMASK
VImage VImage::convsep( VDMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_convsep_f" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().dptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_fastcor: fast correlate in2 within in1
VImage VImage::fastcor( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_fastcor" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_gradcor: non-normalised correlation of gradient of in2 within in1
VImage VImage::gradcor( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_gradcor" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_gradient: convolve with 2-way rotating mask
VImage VImage::gradient( VIMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_gradient" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().iptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_grad_x: horizontal difference image
VImage VImage::grad_x() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_grad_x" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_grad_y: vertical difference image
VImage VImage::grad_y() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_grad_y" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_lindetect: convolve with 4-way rotating mask
VImage VImage::lindetect( VIMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_lindetect" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().iptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_sharpen: sharpen high frequencies of L channel of LabQ
VImage VImage::sharpen( int mask_size, double x1, double y2, double y3, double m1, double m2 ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_sharpen" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = mask_size;
*((double*) _vec.data(3)) = x1;
*((double*) _vec.data(4)) = y2;
*((double*) _vec.data(5)) = y3;
*((double*) _vec.data(6)) = m1;
*((double*) _vec.data(7)) = m2;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_spcor: normalised correlation of in2 within in1
VImage VImage::spcor( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_spcor" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// bodies for package deprecated
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_clip: convert to unsigned 8-bit integer
VImage VImage::clip() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_clip" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_c2ps: find power spectrum of complex image
VImage VImage::c2ps() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_c2ps" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_resize_linear: resize to X by Y pixels with linear interpolation
VImage VImage::resize_linear( int X, int Y ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_resize_linear" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = X;
*((int*) _vec.data(3)) = Y;
_vec.call();
return( out );
}
// im_cmulnorm: multiply two complex images, normalising output
VImage VImage::cmulnorm( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_cmulnorm" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_fav4: average of 4 images
VImage VImage::fav4( VImage in2, VImage in3, VImage in4 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_fav4" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = in3.image();
_vec.data(3) = in4.image();
_vec.data(4) = out.image();
_vec.call();
return( out );
}
// im_gadd: calculate a*in1 + b*in2 + c = outfile
VImage VImage::gadd( double a, double b, VImage in2, double c ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_gadd" );
*((double*) _vec.data(0)) = a;
_vec.data(1) = in1.image();
*((double*) _vec.data(2)) = b;
_vec.data(3) = in2.image();
*((double*) _vec.data(4)) = c;
_vec.data(5) = out.image();
_vec.call();
return( out );
}
// im_icc_export: convert a float LAB to an 8-bit device image with an ICC profile
VImage VImage::icc_export( char* output_profile, int intent ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_icc_export" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = (im_object) output_profile;
*((int*) _vec.data(3)) = intent;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_litecor: calculate max(white)*factor*(in/white), if clip == 1
VImage VImage::litecor( VImage white, int clip, double factor ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_litecor" );
_vec.data(0) = in.image();
_vec.data(1) = white.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = clip;
*((double*) _vec.data(4)) = factor;
_vec.call();
return( out );
}
// im_affine: affine transform
VImage VImage::affine( double a, double b, double c, double d, double dx, double dy, int x, int y, int w, int h ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_affine" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = a;
*((double*) _vec.data(3)) = b;
*((double*) _vec.data(4)) = c;
*((double*) _vec.data(5)) = d;
*((double*) _vec.data(6)) = dx;
*((double*) _vec.data(7)) = dy;
*((int*) _vec.data(8)) = x;
*((int*) _vec.data(9)) = y;
*((int*) _vec.data(10)) = w;
*((int*) _vec.data(11)) = h;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_clip2c: convert to signed 8-bit integer
VImage VImage::clip2c() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_clip2c" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_clip2cm: convert to complex
VImage VImage::clip2cm() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_clip2cm" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_clip2d: convert to double-precision float
VImage VImage::clip2d() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_clip2d" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_clip2dcm: convert to double complex
VImage VImage::clip2dcm() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_clip2dcm" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_clip2f: convert to single-precision float
VImage VImage::clip2f() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_clip2f" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_clip2i: convert to signed 32-bit integer
VImage VImage::clip2i() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_clip2i" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_convsub: convolve uchar to uchar, sub-sampling by xskip, yskip
VImage VImage::convsub( VIMask matrix, int xskip, int yskip ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_convsub" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().iptr;
*((int*) _vec.data(3)) = xskip;
*((int*) _vec.data(4)) = yskip;
_vec.call();
return( out );
}
// im_convf: convolve, with DOUBLEMASK
VImage VImage::convf( VDMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_convf" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().dptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_convsepf: seperable convolution, with DOUBLEMASK
VImage VImage::convsepf( VDMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_convsepf" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().dptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_clip2s: convert to signed 16-bit integer
VImage VImage::clip2s() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_clip2s" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_clip2ui: convert to unsigned 32-bit integer
VImage VImage::clip2ui() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_clip2ui" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_insertplaceset: insert sub into main at every position in x, y
VImage VImage::insertplace( VImage sub, std::vector<int> x, std::vector<int> y ) throw( VError )
{
VImage main = *this;
VImage out;
Vargv _vec( "im_insertplaceset" );
_vec.data(0) = main.image();
_vec.data(1) = sub.image();
_vec.data(2) = out.image();
((im_intvec_object*) _vec.data(3))->n = x.size();
((im_intvec_object*) _vec.data(3))->vec = new int[x.size()];
for( unsigned int i = 0; i < x.size(); i++ )
((im_intvec_object*) _vec.data(3))->vec[i] = x[i];
((im_intvec_object*) _vec.data(4))->n = y.size();
((im_intvec_object*) _vec.data(4))->vec = new int[y.size()];
for( unsigned int i = 0; i < y.size(); i++ )
((im_intvec_object*) _vec.data(4))->vec[i] = y[i];
_vec.call();
return( out );
}
// im_clip2us: convert to unsigned 16-bit integer
VImage VImage::clip2us() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_clip2us" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_slice: slice an image using two thresholds
VImage VImage::slice( double thresh1, double thresh2 ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_slice" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((double*) _vec.data(2)) = thresh1;
*((double*) _vec.data(3)) = thresh2;
_vec.call();
return( output );
}
// im_segment: number continuous regions in an image
VImage VImage::segment( int& segments ) throw( VError )
{
VImage test = *this;
VImage mask;
Vargv _vec( "im_segment" );
_vec.data(0) = test.image();
_vec.data(1) = mask.image();
_vec.call();
segments = *((int*)_vec.data(2));
return( mask );
}
// im_line: draw line between points (x1,y1) and (x2,y2)
void VImage::line( int x1, int y1, int x2, int y2, int pelval ) throw( VError )
{
VImage im = *this;
Vargv _vec( "im_line" );
_vec.data(0) = im.image();
*((int*) _vec.data(1)) = x1;
*((int*) _vec.data(2)) = y1;
*((int*) _vec.data(3)) = x2;
*((int*) _vec.data(4)) = y2;
*((int*) _vec.data(5)) = pelval;
_vec.call();
}
// im_thresh: slice an image at a threshold
VImage VImage::thresh( double threshold ) throw( VError )
{
VImage input = *this;
VImage output;
Vargv _vec( "im_thresh" );
_vec.data(0) = input.image();
_vec.data(1) = output.image();
*((double*) _vec.data(2)) = threshold;
_vec.call();
return( output );
}
// im_convf_raw: convolve, with DOUBLEMASK, no border
VImage VImage::convf_raw( VDMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_convf_raw" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().dptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_conv_raw: convolve, no border
VImage VImage::conv_raw( VIMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_conv_raw" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().iptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_contrast_surface_raw: find high-contrast points in an image
VImage VImage::contrast_surface_raw( int half_win_size, int spacing ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_contrast_surface_raw" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = half_win_size;
*((int*) _vec.data(3)) = spacing;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_convsepf_raw: seperable convolution, with DOUBLEMASK, no border
VImage VImage::convsepf_raw( VDMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_convsepf_raw" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().dptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_convsep_raw: seperable convolution, no border
VImage VImage::convsep_raw( VIMask matrix ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_convsep_raw" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().iptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_fastcor_raw: fast correlate in2 within in1, no border
VImage VImage::fastcor_raw( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_fastcor_raw" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_gradcor_raw: non-normalised correlation of gradient of in2 within in1, no padding
VImage VImage::gradcor_raw( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_gradcor_raw" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_spcor_raw: normalised correlation of in2 within in1, no black padding
VImage VImage::spcor_raw( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_spcor_raw" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_lhisteq_raw: local histogram equalisation, no border
VImage VImage::lhisteq_raw( int width, int height ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_lhisteq_raw" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = width;
*((int*) _vec.data(3)) = height;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_stdif_raw: statistical differencing, no border
VImage VImage::stdif_raw( double a, double m0, double b, double s0, int xw, int yw ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_stdif_raw" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = a;
*((double*) _vec.data(3)) = m0;
*((double*) _vec.data(4)) = b;
*((double*) _vec.data(5)) = s0;
*((int*) _vec.data(6)) = xw;
*((int*) _vec.data(7)) = yw;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_rank_raw: rank filter nth element of xsize/ysize window, no border
VImage VImage::rank_raw( int xsize, int ysize, int n ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_rank_raw" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = xsize;
*((int*) _vec.data(3)) = ysize;
*((int*) _vec.data(4)) = n;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_dilate_raw: dilate image with mask
VImage VImage::dilate_raw( VIMask mask ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_dilate_raw" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = mask.mask().iptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_erode_raw: erode image with mask
VImage VImage::erode_raw( VIMask mask ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_erode_raw" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = mask.mask().iptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_similarity_area: output area xywh of similarity transformation
VImage VImage::similarity_area( double a, double b, double dx, double dy, int x, int y, int w, int h ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_similarity_area" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = a;
*((double*) _vec.data(3)) = b;
*((double*) _vec.data(4)) = dx;
*((double*) _vec.data(5)) = dy;
*((int*) _vec.data(6)) = x;
*((int*) _vec.data(7)) = y;
*((int*) _vec.data(8)) = w;
*((int*) _vec.data(9)) = h;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_similarity: similarity transformation
VImage VImage::similarity( double a, double b, double dx, double dy ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_similarity" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = a;
*((double*) _vec.data(3)) = b;
*((double*) _vec.data(4)) = dx;
*((double*) _vec.data(5)) = dy;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// bodies for package format
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_csv2vips: read a file in csv format
VImage VImage::csv2vips( char* filename ) throw( VError )
{
VImage im;
Vargv _vec( "im_csv2vips" );
_vec.data(0) = (im_object) filename;
_vec.data(1) = im.image();
_vec.call();
return( im );
}
// im_jpeg2vips: convert from jpeg
VImage VImage::jpeg2vips( char* in ) throw( VError )
{
VImage out;
Vargv _vec( "im_jpeg2vips" );
_vec.data(0) = (im_object) in;
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// im_magick2vips: load file with libMagick
VImage VImage::magick2vips( char* in ) throw( VError )
{
VImage out;
Vargv _vec( "im_magick2vips" );
_vec.data(0) = (im_object) in;
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// im_png2vips: convert PNG file to VIPS image
VImage VImage::png2vips( char* in ) throw( VError )
{
VImage out;
Vargv _vec( "im_png2vips" );
_vec.data(0) = (im_object) in;
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// im_exr2vips: convert an OpenEXR file to VIPS
VImage VImage::exr2vips( char* in ) throw( VError )
{
VImage out;
Vargv _vec( "im_exr2vips" );
_vec.data(0) = (im_object) in;
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// im_ppm2vips: read a file in pbm/pgm/ppm format
VImage VImage::ppm2vips( char* filename ) throw( VError )
{
VImage im;
Vargv _vec( "im_ppm2vips" );
_vec.data(0) = (im_object) filename;
_vec.data(1) = im.image();
_vec.call();
return( im );
}
// im_analyze2vips: read a file in analyze format
VImage VImage::analyze2vips( char* filename ) throw( VError )
{
VImage im;
Vargv _vec( "im_analyze2vips" );
_vec.data(0) = (im_object) filename;
_vec.data(1) = im.image();
_vec.call();
return( im );
}
// im_tiff2vips: convert TIFF file to VIPS image
VImage VImage::tiff2vips( char* in ) throw( VError )
{
VImage out;
Vargv _vec( "im_tiff2vips" );
_vec.data(0) = (im_object) in;
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// im_vips2csv: write an image in csv format
void VImage::vips2csv( char* filename ) throw( VError )
{
VImage in = *this;
Vargv _vec( "im_vips2csv" );
_vec.data(0) = in.image();
_vec.data(1) = (im_object) filename;
_vec.call();
}
// im_vips2jpeg: convert to jpeg
void VImage::vips2jpeg( char* out ) throw( VError )
{
VImage in = *this;
Vargv _vec( "im_vips2jpeg" );
_vec.data(0) = in.image();
_vec.data(1) = (im_object) out;
_vec.call();
}
// im_vips2mimejpeg: convert to jpeg as mime type on stdout
void VImage::vips2mimejpeg( int qfac ) throw( VError )
{
VImage in = *this;
Vargv _vec( "im_vips2mimejpeg" );
_vec.data(0) = in.image();
*((int*) _vec.data(1)) = qfac;
_vec.call();
}
// im_vips2png: convert VIPS image to PNG file
void VImage::vips2png( char* out ) throw( VError )
{
VImage in = *this;
Vargv _vec( "im_vips2png" );
_vec.data(0) = in.image();
_vec.data(1) = (im_object) out;
_vec.call();
}
// im_vips2ppm: write a file in pbm/pgm/ppm format
void VImage::vips2ppm( char* filename ) throw( VError )
{
VImage im = *this;
Vargv _vec( "im_vips2ppm" );
_vec.data(0) = im.image();
_vec.data(1) = (im_object) filename;
_vec.call();
}
// im_vips2tiff: convert VIPS image to TIFF file
void VImage::vips2tiff( char* out ) throw( VError )
{
VImage in = *this;
Vargv _vec( "im_vips2tiff" );
_vec.data(0) = in.image();
_vec.data(1) = (im_object) out;
_vec.call();
}
// bodies for package freq_filt
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_create_fmask: create frequency domain filter mask
VImage VImage::create_fmask( int width, int height, int type, double p1, double p2, double p3, double p4, double p5 ) throw( VError )
{
VImage out;
Vargv _vec( "im_create_fmask" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = width;
*((int*) _vec.data(2)) = height;
*((int*) _vec.data(3)) = type;
*((double*) _vec.data(4)) = p1;
*((double*) _vec.data(5)) = p2;
*((double*) _vec.data(6)) = p3;
*((double*) _vec.data(7)) = p4;
*((double*) _vec.data(8)) = p5;
_vec.call();
return( out );
}
// im_disp_ps: make displayable power spectrum
VImage VImage::disp_ps() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_disp_ps" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// im_flt_image_freq: frequency domain filter image
VImage VImage::flt_image_freq( int type, double p1, double p2, double p3, double p4, double p5 ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_flt_image_freq" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = type;
*((double*) _vec.data(3)) = p1;
*((double*) _vec.data(4)) = p2;
*((double*) _vec.data(5)) = p3;
*((double*) _vec.data(6)) = p4;
*((double*) _vec.data(7)) = p5;
_vec.call();
return( out );
}
// im_fractsurf: generate a fractal surface of given dimension
VImage VImage::fractsurf( int size, double dimension ) throw( VError )
{
VImage out;
Vargv _vec( "im_fractsurf" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = size;
*((double*) _vec.data(2)) = dimension;
_vec.call();
return( out );
}
// im_freqflt: frequency-domain filter of in with mask
VImage VImage::freqflt( VImage mask ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_freqflt" );
_vec.data(0) = in.image();
_vec.data(1) = mask.image();
_vec.data(2) = out.image();
_vec.call();
return( out );
}
// im_fwfft: forward fast-fourier transform
VImage VImage::fwfft() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_fwfft" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// im_rotquad: rotate image quadrants to move origin to centre
VImage VImage::rotquad() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_rotquad" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// im_invfft: inverse fast-fourier transform
VImage VImage::invfft() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_invfft" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// im_phasecor_fft: non-normalised correlation of gradient of in2 within in1
VImage VImage::phasecor_fft( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_phasecor_fft" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
return( out );
}
// im_invfftr: real part of inverse fast-fourier transform
VImage VImage::invfftr() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_invfftr" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// bodies for package histograms_lut
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_gammacorrect: gamma-correct image
VImage VImage::gammacorrect( double exponent ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_gammacorrect" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = exponent;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_heq: histogram-equalise image
VImage VImage::heq( int band_number ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_heq" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = band_number;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_hist: find and graph histogram of image
VImage VImage::hist( int band_number ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_hist" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = band_number;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_histcum: turn histogram to cumulative histogram
VImage VImage::histcum() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_histcum" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_histeq: form histogram equalistion LUT
VImage VImage::histeq() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_histeq" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_hist_indexed: make a histogram with an index image
VImage VImage::hist_indexed( VImage value ) throw( VError )
{
VImage index = *this;
VImage out;
Vargv _vec( "im_hist_indexed" );
_vec.data(0) = index.image();
_vec.data(1) = value.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( index._ref );
out._ref->addref( value._ref );
return( out );
}
// im_histgr: find histogram of image
VImage VImage::histgr( int band_number ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_histgr" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = band_number;
_vec.call();
return( out );
}
// im_histnD: find 1D, 2D or 3D histogram of image
VImage VImage::histnD( int bins ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_histnD" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = bins;
_vec.call();
return( out );
}
// im_histnorm: form normalised histogram
VImage VImage::histnorm() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_histnorm" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_histplot: plot graph of histogram
VImage VImage::histplot() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_histplot" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_histspec: find histogram which will make pdf of in match ref
VImage VImage::histspec( VImage ref ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_histspec" );
_vec.data(0) = in.image();
_vec.data(1) = ref.image();
_vec.data(2) = out.image();
_vec.call();
return( out );
}
// im_hsp: match stats of in to stats of ref
VImage VImage::hsp( VImage ref ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_hsp" );
_vec.data(0) = in.image();
_vec.data(1) = ref.image();
_vec.data(2) = out.image();
_vec.call();
return( out );
}
// im_identity: generate identity histogram
VImage VImage::identity( int nbands ) throw( VError )
{
VImage out;
Vargv _vec( "im_identity" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = nbands;
_vec.call();
return( out );
}
// im_identity_ushort: generate ushort identity histogram
VImage VImage::identity_ushort( int nbands, int size ) throw( VError )
{
VImage out;
Vargv _vec( "im_identity_ushort" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = nbands;
*((int*) _vec.data(2)) = size;
_vec.call();
return( out );
}
// im_ismonotonic: test LUT for monotonicity
int VImage::ismonotonic() throw( VError )
{
VImage lut = *this;
int mono;
Vargv _vec( "im_ismonotonic" );
_vec.data(0) = lut.image();
_vec.call();
mono = *((int*)_vec.data(1));
return( mono );
}
// im_lhisteq: local histogram equalisation
VImage VImage::lhisteq( int width, int height ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_lhisteq" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = width;
*((int*) _vec.data(3)) = height;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_mpercent: find threshold above which there are percent values
int VImage::mpercent( double percent ) throw( VError )
{
VImage in = *this;
int thresh;
Vargv _vec( "im_mpercent" );
_vec.data(0) = in.image();
*((double*) _vec.data(1)) = percent;
_vec.call();
thresh = *((int*)_vec.data(2));
return( thresh );
}
// im_invertlut: generate correction table from set of measures
VImage VImage::invertlut( VDMask measures, int lut_size ) throw( VError )
{
VImage lut;
Vargv _vec( "im_invertlut" );
((im_mask_object*) _vec.data(0))->mask = measures.mask().dptr;
_vec.data(1) = lut.image();
*((int*) _vec.data(2)) = lut_size;
_vec.call();
return( lut );
}
// im_buildlut: generate LUT table from set of x/y positions
VImage VImage::buildlut( VDMask xyes ) throw( VError )
{
VImage lut;
Vargv _vec( "im_buildlut" );
((im_mask_object*) _vec.data(0))->mask = xyes.mask().dptr;
_vec.data(1) = lut.image();
_vec.call();
return( lut );
}
// im_maplut: map image through LUT
VImage VImage::maplut( VImage lut ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_maplut" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = lut.image();
_vec.call();
out._ref->addref( in._ref );
out._ref->addref( lut._ref );
return( out );
}
// im_project: find horizontal and vertical projections of an image
VImage VImage::project( VImage& vout ) throw( VError )
{
VImage in = *this;
VImage hout;
Vargv _vec( "im_project" );
_vec.data(0) = in.image();
_vec.data(1) = hout.image();
_vec.data(2) = vout.image();
_vec.call();
return( hout );
}
// im_stdif: statistical differencing
VImage VImage::stdif( double a, double m0, double b, double s0, int xw, int yw ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_stdif" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = a;
*((double*) _vec.data(3)) = m0;
*((double*) _vec.data(4)) = b;
*((double*) _vec.data(5)) = s0;
*((int*) _vec.data(6)) = xw;
*((int*) _vec.data(7)) = yw;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_tone_analyse: analyse in and create LUT for tone adjustment
VImage VImage::tone_analyse( double Ps, double Pm, double Ph, double S, double M, double H ) throw( VError )
{
VImage in = *this;
VImage hist;
Vargv _vec( "im_tone_analyse" );
_vec.data(0) = in.image();
_vec.data(1) = hist.image();
*((double*) _vec.data(2)) = Ps;
*((double*) _vec.data(3)) = Pm;
*((double*) _vec.data(4)) = Ph;
*((double*) _vec.data(5)) = S;
*((double*) _vec.data(6)) = M;
*((double*) _vec.data(7)) = H;
_vec.call();
return( hist );
}
// im_tone_build: create LUT for tone adjustment of LabS images
VImage VImage::tone_build( double Lb, double Lw, double Ps, double Pm, double Ph, double S, double M, double H ) throw( VError )
{
VImage hist;
Vargv _vec( "im_tone_build" );
_vec.data(0) = hist.image();
*((double*) _vec.data(1)) = Lb;
*((double*) _vec.data(2)) = Lw;
*((double*) _vec.data(3)) = Ps;
*((double*) _vec.data(4)) = Pm;
*((double*) _vec.data(5)) = Ph;
*((double*) _vec.data(6)) = S;
*((double*) _vec.data(7)) = M;
*((double*) _vec.data(8)) = H;
_vec.call();
return( hist );
}
// im_tone_build_range: create LUT for tone adjustment
VImage VImage::tone_build_range( int in_max, int out_max, double Lb, double Lw, double Ps, double Pm, double Ph, double S, double M, double H ) throw( VError )
{
VImage hist;
Vargv _vec( "im_tone_build_range" );
_vec.data(0) = hist.image();
*((int*) _vec.data(1)) = in_max;
*((int*) _vec.data(2)) = out_max;
*((double*) _vec.data(3)) = Lb;
*((double*) _vec.data(4)) = Lw;
*((double*) _vec.data(5)) = Ps;
*((double*) _vec.data(6)) = Pm;
*((double*) _vec.data(7)) = Ph;
*((double*) _vec.data(8)) = S;
*((double*) _vec.data(9)) = M;
*((double*) _vec.data(10)) = H;
_vec.call();
return( hist );
}
// im_tone_map: map L channel of LabS or LabQ image through LUT
VImage VImage::tone_map( VImage lut ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_tone_map" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = lut.image();
_vec.call();
out._ref->addref( in._ref );
out._ref->addref( lut._ref );
return( out );
}
// bodies for package inplace
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_circle: plot circle on image
void VImage::circle( int cx, int cy, int radius, int intensity ) throw( VError )
{
VImage image = *this;
Vargv _vec( "im_circle" );
_vec.data(0) = image.image();
*((int*) _vec.data(1)) = cx;
*((int*) _vec.data(2)) = cy;
*((int*) _vec.data(3)) = radius;
*((int*) _vec.data(4)) = intensity;
_vec.call();
}
// im_flood_copy: flood with ink from start_x, start_y while pixel == start pixel
VImage VImage::flood_copy( int start_x, int start_y, std::vector<double> ink ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_flood_copy" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = start_x;
*((int*) _vec.data(3)) = start_y;
((im_doublevec_object*) _vec.data(4))->n = ink.size();
((im_doublevec_object*) _vec.data(4))->vec = new double[ink.size()];
for( unsigned int i = 0; i < ink.size(); i++ )
((im_doublevec_object*) _vec.data(4))->vec[i] = ink[i];
_vec.call();
return( out );
}
// im_flood_blob_copy: flood with ink from start_x, start_y while pixel == start pixel
VImage VImage::flood_blob_copy( int start_x, int start_y, std::vector<double> ink ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_flood_blob_copy" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = start_x;
*((int*) _vec.data(3)) = start_y;
((im_doublevec_object*) _vec.data(4))->n = ink.size();
((im_doublevec_object*) _vec.data(4))->vec = new double[ink.size()];
for( unsigned int i = 0; i < ink.size(); i++ )
((im_doublevec_object*) _vec.data(4))->vec[i] = ink[i];
_vec.call();
return( out );
}
// im_flood_other_copy: flood mark with serial from start_x, start_y while pixel == start pixel
VImage VImage::flood_other_copy( VImage mark, int start_x, int start_y, int serial ) throw( VError )
{
VImage test = *this;
VImage out;
Vargv _vec( "im_flood_other_copy" );
_vec.data(0) = test.image();
_vec.data(1) = mark.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = start_x;
*((int*) _vec.data(4)) = start_y;
*((int*) _vec.data(5)) = serial;
_vec.call();
return( out );
}
// im_insertplace: draw image sub inside image main at position (x,y)
void VImage::insertplace( VImage sub, int x, int y ) throw( VError )
{
VImage main = *this;
Vargv _vec( "im_insertplace" );
_vec.data(0) = main.image();
_vec.data(1) = sub.image();
*((int*) _vec.data(2)) = x;
*((int*) _vec.data(3)) = y;
_vec.call();
}
// im_lineset: draw line between points (x1,y1) and (x2,y2)
VImage VImage::line( VImage mask, VImage ink, std::vector<int> x1, std::vector<int> y1, std::vector<int> x2, std::vector<int> y2 ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_lineset" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = mask.image();
_vec.data(3) = ink.image();
((im_intvec_object*) _vec.data(4))->n = x1.size();
((im_intvec_object*) _vec.data(4))->vec = new int[x1.size()];
for( unsigned int i = 0; i < x1.size(); i++ )
((im_intvec_object*) _vec.data(4))->vec[i] = x1[i];
((im_intvec_object*) _vec.data(5))->n = y1.size();
((im_intvec_object*) _vec.data(5))->vec = new int[y1.size()];
for( unsigned int i = 0; i < y1.size(); i++ )
((im_intvec_object*) _vec.data(5))->vec[i] = y1[i];
((im_intvec_object*) _vec.data(6))->n = x2.size();
((im_intvec_object*) _vec.data(6))->vec = new int[x2.size()];
for( unsigned int i = 0; i < x2.size(); i++ )
((im_intvec_object*) _vec.data(6))->vec[i] = x2[i];
((im_intvec_object*) _vec.data(7))->n = y2.size();
((im_intvec_object*) _vec.data(7))->vec = new int[y2.size()];
for( unsigned int i = 0; i < y2.size(); i++ )
((im_intvec_object*) _vec.data(7))->vec[i] = y2[i];
_vec.call();
return( out );
}
// bodies for package iofuncs
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_binfile: open a headerless binary file
VImage VImage::binfile( char* filename, int width, int height, int bands, int offset ) throw( VError )
{
VImage out;
Vargv _vec( "im_binfile" );
_vec.data(0) = (im_object) filename;
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = width;
*((int*) _vec.data(3)) = height;
*((int*) _vec.data(4)) = bands;
*((int*) _vec.data(5)) = offset;
_vec.call();
return( out );
}
// im_cache: cache results of an operation
VImage VImage::cache( int tile_width, int tile_height, int max_tiles ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_cache" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = tile_width;
*((int*) _vec.data(3)) = tile_height;
*((int*) _vec.data(4)) = max_tiles;
_vec.call();
return( out );
}
// im_getext: return the image metadata XML as a string
char* VImage::getext() throw( VError )
{
VImage image = *this;
char* history;
Vargv _vec( "im_getext" );
_vec.data(0) = image.image();
_vec.call();
history = (char*) _vec.data(1);
return( history );
}
// im_header_get_typeof: return field type
int VImage::header_get_typeof( char* field ) throw( VError )
{
VImage image = *this;
int gtype;
Vargv _vec( "im_header_get_typeof" );
_vec.data(0) = (im_object) field;
_vec.data(1) = image.image();
_vec.call();
gtype = *((int*)_vec.data(2));
return( gtype );
}
// im_header_int: extract int fields from header
int VImage::header_int( char* field ) throw( VError )
{
VImage image = *this;
int value;
Vargv _vec( "im_header_int" );
_vec.data(0) = (im_object) field;
_vec.data(1) = image.image();
_vec.call();
value = *((int*)_vec.data(2));
return( value );
}
// im_header_double: extract double fields from header
double VImage::header_double( char* field ) throw( VError )
{
VImage image = *this;
double value;
Vargv _vec( "im_header_double" );
_vec.data(0) = (im_object) field;
_vec.data(1) = image.image();
_vec.call();
value = *((double*)_vec.data(2));
return( value );
}
// im_header_string: extract fields from headers as strings
char* VImage::header_string( char* field ) throw( VError )
{
VImage image = *this;
char* value;
Vargv _vec( "im_header_string" );
_vec.data(0) = (im_object) field;
_vec.data(1) = image.image();
_vec.call();
value = (char*) _vec.data(2);
return( value );
}
// im_history_get: return the image history as a string
char* VImage::history_get() throw( VError )
{
VImage image = *this;
char* history;
Vargv _vec( "im_history_get" );
_vec.data(0) = image.image();
_vec.call();
history = (char*) _vec.data(1);
return( history );
}
// im_printdesc: print an image header to stdout
void VImage::printdesc() throw( VError )
{
VImage image = *this;
Vargv _vec( "im_printdesc" );
_vec.data(0) = image.image();
_vec.call();
}
// bodies for package mask
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// bodies for package morphology
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_cntlines: count horizontal or vertical lines
double VImage::cntlines( int direction ) throw( VError )
{
VImage in = *this;
double nlines;
Vargv _vec( "im_cntlines" );
_vec.data(0) = in.image();
*((int*) _vec.data(2)) = direction;
_vec.call();
nlines = *((double*)_vec.data(1));
return( nlines );
}
// im_dilate: dilate image with mask, adding a black border
VImage VImage::dilate( VIMask mask ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_dilate" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = mask.mask().iptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_rank: rank filter nth element of xsize/ysize window
VImage VImage::rank( int xsize, int ysize, int n ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_rank" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = xsize;
*((int*) _vec.data(3)) = ysize;
*((int*) _vec.data(4)) = n;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_rank_image: point-wise pixel rank
VImage VImage::rank_image( std::vector<VImage> in, int index ) throw( VError )
{
VImage out;
Vargv _vec( "im_rank_image" );
((im_imagevec_object*) _vec.data(0))->n = in.size();
((im_imagevec_object*) _vec.data(0))->vec = new IMAGE *[in.size()];
for( unsigned int i = 0; i < in.size(); i++ )
((im_imagevec_object*) _vec.data(0))->vec[i] = in[i].image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = index;
_vec.call();
for( unsigned int i = 0; i < in.size(); i++ )
out._ref->addref( in[i]._ref );
return( out );
}
// im_maxvalue: point-wise maximum value
VImage VImage::maxvalue( std::vector<VImage> in ) throw( VError )
{
VImage out;
Vargv _vec( "im_maxvalue" );
((im_imagevec_object*) _vec.data(0))->n = in.size();
((im_imagevec_object*) _vec.data(0))->vec = new IMAGE *[in.size()];
for( unsigned int i = 0; i < in.size(); i++ )
((im_imagevec_object*) _vec.data(0))->vec[i] = in[i].image();
_vec.data(1) = out.image();
_vec.call();
for( unsigned int i = 0; i < in.size(); i++ )
out._ref->addref( in[i]._ref );
return( out );
}
// im_label_regions: number continuous regions in an image
VImage VImage::label_regions( int& segments ) throw( VError )
{
VImage test = *this;
VImage mask;
Vargv _vec( "im_label_regions" );
_vec.data(0) = test.image();
_vec.data(1) = mask.image();
_vec.call();
segments = *((int*)_vec.data(2));
return( mask );
}
// im_zerox: find +ve or -ve zero crossings in image
VImage VImage::zerox( int flag ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_zerox" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = flag;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_erode: erode image with mask, adding a black border
VImage VImage::erode( VIMask mask ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_erode" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = mask.mask().iptr;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_profile: find first horizontal/vertical edge
VImage VImage::profile( int direction ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_profile" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = direction;
_vec.call();
return( out );
}
// bodies for package mosaicing
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_align_bands: align the bands of an image
VImage VImage::align_bands() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_align_bands" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// im_correl: search area around sec for match for area around ref
double VImage::correl( VImage sec, int xref, int yref, int xsec, int ysec, int hwindowsize, int hsearchsize, int& x, int& y ) throw( VError )
{
VImage ref = *this;
double correlation;
Vargv _vec( "im_correl" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
*((int*) _vec.data(2)) = xref;
*((int*) _vec.data(3)) = yref;
*((int*) _vec.data(4)) = xsec;
*((int*) _vec.data(5)) = ysec;
*((int*) _vec.data(6)) = hwindowsize;
*((int*) _vec.data(7)) = hsearchsize;
_vec.call();
correlation = *((double*)_vec.data(8));
x = *((int*)_vec.data(9));
y = *((int*)_vec.data(10));
return( correlation );
}
// im__find_lroverlap: search for left-right overlap of ref and sec
int VImage::_find_lroverlap( VImage sec, int bandno, int xr, int yr, int xs, int ys, int halfcorrelation, int halfarea, int& dy0, double& scale1, double& angle1, double& dx1, double& dy1 ) throw( VError )
{
VImage ref = *this;
int dx0;
Vargv _vec( "im__find_lroverlap" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
*((int*) _vec.data(2)) = bandno;
*((int*) _vec.data(3)) = xr;
*((int*) _vec.data(4)) = yr;
*((int*) _vec.data(5)) = xs;
*((int*) _vec.data(6)) = ys;
*((int*) _vec.data(7)) = halfcorrelation;
*((int*) _vec.data(8)) = halfarea;
_vec.call();
dx0 = *((int*)_vec.data(9));
dy0 = *((int*)_vec.data(10));
scale1 = *((double*)_vec.data(11));
angle1 = *((double*)_vec.data(12));
dx1 = *((double*)_vec.data(13));
dy1 = *((double*)_vec.data(14));
return( dx0 );
}
// im__find_tboverlap: search for top-bottom overlap of ref and sec
int VImage::_find_tboverlap( VImage sec, int bandno, int xr, int yr, int xs, int ys, int halfcorrelation, int halfarea, int& dy0, double& scale1, double& angle1, double& dx1, double& dy1 ) throw( VError )
{
VImage ref = *this;
int dx0;
Vargv _vec( "im__find_tboverlap" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
*((int*) _vec.data(2)) = bandno;
*((int*) _vec.data(3)) = xr;
*((int*) _vec.data(4)) = yr;
*((int*) _vec.data(5)) = xs;
*((int*) _vec.data(6)) = ys;
*((int*) _vec.data(7)) = halfcorrelation;
*((int*) _vec.data(8)) = halfarea;
_vec.call();
dx0 = *((int*)_vec.data(9));
dy0 = *((int*)_vec.data(10));
scale1 = *((double*)_vec.data(11));
angle1 = *((double*)_vec.data(12));
dx1 = *((double*)_vec.data(13));
dy1 = *((double*)_vec.data(14));
return( dx0 );
}
// im_global_balance: automatically rebuild mosaic with balancing
VImage VImage::global_balance( double gamma ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_global_balance" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = gamma;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_global_balancef: automatically rebuild mosaic with balancing, float output
VImage VImage::global_balancef( double gamma ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_global_balancef" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = gamma;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_lrmerge: left-right merge of in1 and in2
VImage VImage::lrmerge( VImage sec, int dx, int dy, int mwidth ) throw( VError )
{
VImage ref = *this;
VImage out;
Vargv _vec( "im_lrmerge" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = dx;
*((int*) _vec.data(4)) = dy;
*((int*) _vec.data(5)) = mwidth;
_vec.call();
out._ref->addref( ref._ref );
out._ref->addref( sec._ref );
return( out );
}
// im_lrmerge1: first-order left-right merge of ref and sec
VImage VImage::lrmerge1( VImage sec, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, int mwidth ) throw( VError )
{
VImage ref = *this;
VImage out;
Vargv _vec( "im_lrmerge1" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = xr1;
*((int*) _vec.data(4)) = yr1;
*((int*) _vec.data(5)) = xs1;
*((int*) _vec.data(6)) = ys1;
*((int*) _vec.data(7)) = xr2;
*((int*) _vec.data(8)) = yr2;
*((int*) _vec.data(9)) = xs2;
*((int*) _vec.data(10)) = ys2;
*((int*) _vec.data(11)) = mwidth;
_vec.call();
out._ref->addref( ref._ref );
out._ref->addref( sec._ref );
return( out );
}
// im_lrmosaic: left-right mosaic of ref and sec
VImage VImage::lrmosaic( VImage sec, int bandno, int xr, int yr, int xs, int ys, int halfcorrelation, int halfarea, int balancetype, int mwidth ) throw( VError )
{
VImage ref = *this;
VImage out;
Vargv _vec( "im_lrmosaic" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = bandno;
*((int*) _vec.data(4)) = xr;
*((int*) _vec.data(5)) = yr;
*((int*) _vec.data(6)) = xs;
*((int*) _vec.data(7)) = ys;
*((int*) _vec.data(8)) = halfcorrelation;
*((int*) _vec.data(9)) = halfarea;
*((int*) _vec.data(10)) = balancetype;
*((int*) _vec.data(11)) = mwidth;
_vec.call();
out._ref->addref( ref._ref );
out._ref->addref( sec._ref );
return( out );
}
// im_lrmosaic1: first-order left-right mosaic of ref and sec
VImage VImage::lrmosaic1( VImage sec, int bandno, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, int halfcorrelation, int halfarea, int balancetype, int mwidth ) throw( VError )
{
VImage ref = *this;
VImage out;
Vargv _vec( "im_lrmosaic1" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = bandno;
*((int*) _vec.data(4)) = xr1;
*((int*) _vec.data(5)) = yr1;
*((int*) _vec.data(6)) = xs1;
*((int*) _vec.data(7)) = ys1;
*((int*) _vec.data(8)) = xr2;
*((int*) _vec.data(9)) = yr2;
*((int*) _vec.data(10)) = xs2;
*((int*) _vec.data(11)) = ys2;
*((int*) _vec.data(12)) = halfcorrelation;
*((int*) _vec.data(13)) = halfarea;
*((int*) _vec.data(14)) = balancetype;
*((int*) _vec.data(15)) = mwidth;
_vec.call();
out._ref->addref( ref._ref );
out._ref->addref( sec._ref );
return( out );
}
// im_match_linear: resample ref so that tie-points match
VImage VImage::match_linear( VImage sec, int xref1, int yref1, int xsec1, int ysec1, int xref2, int yref2, int xsec2, int ysec2 ) throw( VError )
{
VImage ref = *this;
VImage out;
Vargv _vec( "im_match_linear" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = xref1;
*((int*) _vec.data(4)) = yref1;
*((int*) _vec.data(5)) = xsec1;
*((int*) _vec.data(6)) = ysec1;
*((int*) _vec.data(7)) = xref2;
*((int*) _vec.data(8)) = yref2;
*((int*) _vec.data(9)) = xsec2;
*((int*) _vec.data(10)) = ysec2;
_vec.call();
out._ref->addref( ref._ref );
out._ref->addref( sec._ref );
return( out );
}
// im_match_linear_search: search sec, then resample so that tie-points match
VImage VImage::match_linear_search( VImage sec, int xref1, int yref1, int xsec1, int ysec1, int xref2, int yref2, int xsec2, int ysec2, int hwindowsize, int hsearchsize ) throw( VError )
{
VImage ref = *this;
VImage out;
Vargv _vec( "im_match_linear_search" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = xref1;
*((int*) _vec.data(4)) = yref1;
*((int*) _vec.data(5)) = xsec1;
*((int*) _vec.data(6)) = ysec1;
*((int*) _vec.data(7)) = xref2;
*((int*) _vec.data(8)) = yref2;
*((int*) _vec.data(9)) = xsec2;
*((int*) _vec.data(10)) = ysec2;
*((int*) _vec.data(11)) = hwindowsize;
*((int*) _vec.data(12)) = hsearchsize;
_vec.call();
out._ref->addref( ref._ref );
out._ref->addref( sec._ref );
return( out );
}
// im_maxpos_subpel: subpixel position of maximum of (phase correlation) image
double VImage::maxpos_subpel( double& y ) throw( VError )
{
VImage im = *this;
double x;
Vargv _vec( "im_maxpos_subpel" );
_vec.data(0) = im.image();
_vec.call();
x = *((double*)_vec.data(1));
y = *((double*)_vec.data(2));
return( x );
}
// im_remosaic: automatically rebuild mosaic with new files
VImage VImage::remosaic( char* old_str, char* new_str ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_remosaic" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.data(2) = (im_object) old_str;
_vec.data(3) = (im_object) new_str;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_tbmerge: top-bottom merge of in1 and in2
VImage VImage::tbmerge( VImage sec, int dx, int dy, int mwidth ) throw( VError )
{
VImage ref = *this;
VImage out;
Vargv _vec( "im_tbmerge" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = dx;
*((int*) _vec.data(4)) = dy;
*((int*) _vec.data(5)) = mwidth;
_vec.call();
out._ref->addref( ref._ref );
out._ref->addref( sec._ref );
return( out );
}
// im_tbmerge1: first-order top-bottom merge of in1 and in2
VImage VImage::tbmerge1( VImage sec, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, int mwidth ) throw( VError )
{
VImage ref = *this;
VImage out;
Vargv _vec( "im_tbmerge1" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = xr1;
*((int*) _vec.data(4)) = yr1;
*((int*) _vec.data(5)) = xs1;
*((int*) _vec.data(6)) = ys1;
*((int*) _vec.data(7)) = xr2;
*((int*) _vec.data(8)) = yr2;
*((int*) _vec.data(9)) = xs2;
*((int*) _vec.data(10)) = ys2;
*((int*) _vec.data(11)) = mwidth;
_vec.call();
out._ref->addref( ref._ref );
out._ref->addref( sec._ref );
return( out );
}
// im_tbmosaic: top-bottom mosaic of in1 and in2
VImage VImage::tbmosaic( VImage sec, int bandno, int xr, int yr, int xs, int ys, int halfcorrelation, int halfarea, int balancetype, int mwidth ) throw( VError )
{
VImage ref = *this;
VImage out;
Vargv _vec( "im_tbmosaic" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = bandno;
*((int*) _vec.data(4)) = xr;
*((int*) _vec.data(5)) = yr;
*((int*) _vec.data(6)) = xs;
*((int*) _vec.data(7)) = ys;
*((int*) _vec.data(8)) = halfcorrelation;
*((int*) _vec.data(9)) = halfarea;
*((int*) _vec.data(10)) = balancetype;
*((int*) _vec.data(11)) = mwidth;
_vec.call();
out._ref->addref( ref._ref );
out._ref->addref( sec._ref );
return( out );
}
// im_tbmosaic1: first-order top-bottom mosaic of ref and sec
VImage VImage::tbmosaic1( VImage sec, int bandno, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, int halfcorrelation, int halfarea, int balancetype, int mwidth ) throw( VError )
{
VImage ref = *this;
VImage out;
Vargv _vec( "im_tbmosaic1" );
_vec.data(0) = ref.image();
_vec.data(1) = sec.image();
_vec.data(2) = out.image();
*((int*) _vec.data(3)) = bandno;
*((int*) _vec.data(4)) = xr1;
*((int*) _vec.data(5)) = yr1;
*((int*) _vec.data(6)) = xs1;
*((int*) _vec.data(7)) = ys1;
*((int*) _vec.data(8)) = xr2;
*((int*) _vec.data(9)) = yr2;
*((int*) _vec.data(10)) = xs2;
*((int*) _vec.data(11)) = ys2;
*((int*) _vec.data(12)) = halfcorrelation;
*((int*) _vec.data(13)) = halfarea;
*((int*) _vec.data(14)) = balancetype;
*((int*) _vec.data(15)) = mwidth;
_vec.call();
out._ref->addref( ref._ref );
out._ref->addref( sec._ref );
return( out );
}
// bodies for package other
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_benchmark: do something complicated for testing
VImage VImage::benchmark() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_benchmark" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_benchmark2: do something complicated for testing
double VImage::benchmark2() throw( VError )
{
VImage in = *this;
double value;
Vargv _vec( "im_benchmark2" );
_vec.data(0) = in.image();
_vec.call();
value = *((double*)_vec.data(1));
return( value );
}
// im_benchmarkn: do something complicated for testing
VImage VImage::benchmarkn( int n ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_benchmarkn" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = n;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_eye: generate IM_BANDFMT_UCHAR [0,255] frequency/amplitude image
VImage VImage::eye( int xsize, int ysize, double factor ) throw( VError )
{
VImage out;
Vargv _vec( "im_eye" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = xsize;
*((int*) _vec.data(2)) = ysize;
*((double*) _vec.data(3)) = factor;
_vec.call();
return( out );
}
// im_grey: generate IM_BANDFMT_UCHAR [0,255] grey scale image
VImage VImage::grey( int xsize, int ysize ) throw( VError )
{
VImage out;
Vargv _vec( "im_grey" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = xsize;
*((int*) _vec.data(2)) = ysize;
_vec.call();
return( out );
}
// im_feye: generate IM_BANDFMT_FLOAT [-1,1] frequency/amplitude image
VImage VImage::feye( int xsize, int ysize, double factor ) throw( VError )
{
VImage out;
Vargv _vec( "im_feye" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = xsize;
*((int*) _vec.data(2)) = ysize;
*((double*) _vec.data(3)) = factor;
_vec.call();
return( out );
}
// im_fgrey: generate IM_BANDFMT_FLOAT [0,1] grey scale image
VImage VImage::fgrey( int xsize, int ysize ) throw( VError )
{
VImage out;
Vargv _vec( "im_fgrey" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = xsize;
*((int*) _vec.data(2)) = ysize;
_vec.call();
return( out );
}
// im_fzone: generate IM_BANDFMT_FLOAT [-1,1] zone plate image
VImage VImage::fzone( int size ) throw( VError )
{
VImage out;
Vargv _vec( "im_fzone" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = size;
_vec.call();
return( out );
}
// im_make_xy: generate image with pixel value equal to coordinate
VImage VImage::make_xy( int xsize, int ysize ) throw( VError )
{
VImage out;
Vargv _vec( "im_make_xy" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = xsize;
*((int*) _vec.data(2)) = ysize;
_vec.call();
return( out );
}
// im_zone: generate IM_BANDFMT_UCHAR [0,255] zone plate image
VImage VImage::zone( int size ) throw( VError )
{
VImage out;
Vargv _vec( "im_zone" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = size;
_vec.call();
return( out );
}
// bodies for package relational
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_blend: use cond image to blend between images in1 and in2
VImage VImage::blend( VImage in1, VImage in2 ) throw( VError )
{
VImage cond = *this;
VImage out;
Vargv _vec( "im_blend" );
_vec.data(0) = cond.image();
_vec.data(1) = in1.image();
_vec.data(2) = in2.image();
_vec.data(3) = out.image();
_vec.call();
out._ref->addref( cond._ref );
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_equal: two images equal in value
VImage VImage::equal( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_equal" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_equal_vec: image equals doublevec
VImage VImage::equal( std::vector<double> vec ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_equal_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = vec.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[vec.size()];
for( unsigned int i = 0; i < vec.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = vec[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_equalconst: image equals const
VImage VImage::equal( double c ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_equalconst" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_ifthenelse: use cond image to choose pels from image in1 or in2
VImage VImage::ifthenelse( VImage in1, VImage in2 ) throw( VError )
{
VImage cond = *this;
VImage out;
Vargv _vec( "im_ifthenelse" );
_vec.data(0) = cond.image();
_vec.data(1) = in1.image();
_vec.data(2) = in2.image();
_vec.data(3) = out.image();
_vec.call();
out._ref->addref( cond._ref );
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_less: in1 less than in2 in value
VImage VImage::less( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_less" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_less_vec: in less than doublevec
VImage VImage::less( std::vector<double> vec ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_less_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = vec.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[vec.size()];
for( unsigned int i = 0; i < vec.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = vec[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_lessconst: in less than const
VImage VImage::less( double c ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_lessconst" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_lesseq: in1 less than or equal to in2 in value
VImage VImage::lesseq( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_lesseq" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_lesseq_vec: in less than or equal to doublevec
VImage VImage::lesseq( std::vector<double> vec ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_lesseq_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = vec.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[vec.size()];
for( unsigned int i = 0; i < vec.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = vec[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_lesseqconst: in less than or equal to const
VImage VImage::lesseq( double c ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_lesseqconst" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_more: in1 more than in2 in value
VImage VImage::more( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_more" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_more_vec: in more than doublevec
VImage VImage::more( std::vector<double> vec ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_more_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = vec.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[vec.size()];
for( unsigned int i = 0; i < vec.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = vec[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_moreconst: in more than const
VImage VImage::more( double c ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_moreconst" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_moreeq: in1 more than or equal to in2 in value
VImage VImage::moreeq( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_moreeq" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_moreeq_vec: in more than or equal to doublevec
VImage VImage::moreeq( std::vector<double> vec ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_moreeq_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = vec.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[vec.size()];
for( unsigned int i = 0; i < vec.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = vec[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_moreeqconst: in more than or equal to const
VImage VImage::moreeq( double c ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_moreeqconst" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_notequal: two images not equal in value
VImage VImage::notequal( VImage in2 ) throw( VError )
{
VImage in1 = *this;
VImage out;
Vargv _vec( "im_notequal" );
_vec.data(0) = in1.image();
_vec.data(1) = in2.image();
_vec.data(2) = out.image();
_vec.call();
out._ref->addref( in1._ref );
out._ref->addref( in2._ref );
return( out );
}
// im_notequal_vec: image does not equal doublevec
VImage VImage::notequal( std::vector<double> vec ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_notequal_vec" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_doublevec_object*) _vec.data(2))->n = vec.size();
((im_doublevec_object*) _vec.data(2))->vec = new double[vec.size()];
for( unsigned int i = 0; i < vec.size(); i++ )
((im_doublevec_object*) _vec.data(2))->vec[i] = vec[i];
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_notequalconst: image does not equal const
VImage VImage::notequal( double c ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_notequalconst" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// bodies for package resample
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_rightshift_size: decrease size by a power-of-two factor
VImage VImage::rightshift_size( int xshift, int yshift, int band_fmt ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_rightshift_size" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((int*) _vec.data(2)) = xshift;
*((int*) _vec.data(3)) = yshift;
*((int*) _vec.data(4)) = band_fmt;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_shrink: shrink image by xfac, yfac times
VImage VImage::shrink( double xfac, double yfac ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_shrink" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = xfac;
*((double*) _vec.data(3)) = yfac;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_stretch3: stretch 3%, sub-pixel displace by xdisp/ydisp
VImage VImage::stretch3( double xdisp, double ydisp ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_stretch3" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = xdisp;
*((double*) _vec.data(3)) = ydisp;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// bodies for package video
// this file automatically generated from
// VIPS library 7.22.1-Tue Jun 22 10:26:51 BST 2010
// im_video_test: test video grabber
VImage VImage::video_test( int brightness, int error ) throw( VError )
{
VImage out;
Vargv _vec( "im_video_test" );
_vec.data(0) = out.image();
*((int*) _vec.data(1)) = brightness;
*((int*) _vec.data(2)) = error;
_vec.call();
return( out );
}
// im_video_v4l1: grab a video frame with v4l1
VImage VImage::video_v4l1( char* device, int channel, int brightness, int colour, int contrast, int hue, int ngrabs ) throw( VError )
{
VImage out;
Vargv _vec( "im_video_v4l1" );
_vec.data(0) = out.image();
_vec.data(1) = (im_object) device;
*((int*) _vec.data(2)) = channel;
*((int*) _vec.data(3)) = brightness;
*((int*) _vec.data(4)) = colour;
*((int*) _vec.data(5)) = contrast;
*((int*) _vec.data(6)) = hue;
*((int*) _vec.data(7)) = ngrabs;
_vec.call();
return( out );
}
Reference in New Issue View Git Blame Copy Permalink