Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

6102 lines (4747 sloc) 132.803 kb
// bodies for package arithmetic
// this file automatically generated from
// VIPS library 7.28.0-Tue Jan 31 10:51:45 GMT 2012
// 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 cimg
// this file automatically generated from
// VIPS library 7.28.0-Tue Jan 31 10:51:45 GMT 2012
// 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.28.0-Tue Jan 31 10:51:45 GMT 2012
// 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_argb2rgba: convert pre-multipled argb to png-style rgba
VImage VImage::argb2rgba() throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_argb2rgba" );
_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.28.0-Tue Jan 31 10:51:45 GMT 2012
// 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_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_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.28.0-Tue Jan 31 10:51:45 GMT 2012
// im_aconvsep: approximate separable convolution
VImage VImage::aconvsep( VDMask matrix, int n_layers ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_aconvsep" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().dptr;
*((int*) _vec.data(3)) = n_layers;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// im_aconv: approximate convolution
VImage VImage::aconv( VDMask matrix, int n_layers, int cluster ) throw( VError )
{
VImage in = *this;
VImage out;
Vargv _vec( "im_aconv" );
_vec.data(0) = in.image();
_vec.data(1) = out.image();
((im_mask_object*) _vec.data(2))->mask = matrix.mask().dptr;
*((int*) _vec.data(3)) = n_layers;
*((int*) _vec.data(4)) = cluster;
_vec.call();
out._ref->addref( in._ref );
return( out );
}
// 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.28.0-Tue Jan 31 10:51:45 GMT 2012
// 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_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 );
}
// 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_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_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_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_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 );
}
// 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 in1 = *this;
VImage out;
Vargv _vec( "im_equalconst" );
_vec.data(0) = in1.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in1._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 in1 = *this;
VImage out;
Vargv _vec( "im_lessconst" );
_vec.data(0) = in1.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in1._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 in1 = *this;
VImage out;
Vargv _vec( "im_lesseqconst" );
_vec.data(0) = in1.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in1._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 in1 = *this;
VImage out;
Vargv _vec( "im_moreconst" );
_vec.data(0) = in1.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in1._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 in1 = *this;
VImage out;
Vargv _vec( "im_moreeqconst" );
_vec.data(0) = in1.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in1._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 in1 = *this;
VImage out;
Vargv _vec( "im_notequalconst" );
_vec.data(0) = in1.image();
_vec.data(1) = out.image();
*((double*) _vec.data(2)) = c;
_vec.call();
out._ref->addref( in1._ref );
return( out );
}
// bodies for package format
// this file automatically generated from
// VIPS library 7.28.0-Tue Jan 31 10:51:45 GMT 2012
// 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_fits2vips: convert from fits
VImage VImage::fits2vips( char* in ) throw( VError )
{
VImage out;
Vargv _vec( "im_fits2vips" );
_vec.data(0) = (im_object) in;
_vec.data(1) = out.image();
_vec.call();
return( out );
}
// 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.28.0-Tue Jan 31 10:51:45 GMT 2012
// 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