From 022150ceeac8352984122870b7bafe027a2b6716 Mon Sep 17 00:00:00 2001 From: John Cupitt Date: Mon, 20 Oct 2014 11:50:34 +0100 Subject: [PATCH] start vips8++ --- cplusplus/Makefile.am | 35 + cplusplus/VError.cc | 100 + cplusplus/VImage.cc | 552 ++ cplusplus/include/Makefile.am | 2 + cplusplus/include/vips/Makefile.am | 18 + cplusplus/include/vips/VError.h | 83 + cplusplus/include/vips/VImage.h | 242 + cplusplus/include/vips/vips-operators.h | 418 ++ cplusplus/include/vips/vips8 | 43 + cplusplus/vips-operators.cc | 6202 +++++++++++++++++++++++ 10 files changed, 7695 insertions(+) create mode 100644 cplusplus/Makefile.am create mode 100644 cplusplus/VError.cc create mode 100644 cplusplus/VImage.cc create mode 100644 cplusplus/include/Makefile.am create mode 100644 cplusplus/include/vips/Makefile.am create mode 100644 cplusplus/include/vips/VError.h create mode 100644 cplusplus/include/vips/VImage.h create mode 100644 cplusplus/include/vips/vips-operators.h create mode 100644 cplusplus/include/vips/vips8 create mode 100644 cplusplus/vips-operators.cc diff --git a/cplusplus/Makefile.am b/cplusplus/Makefile.am new file mode 100644 index 00000000..9ab3717a --- /dev/null +++ b/cplusplus/Makefile.am @@ -0,0 +1,35 @@ +SUBDIRS = \ + include + +AM_CPPFLAGS = \ + -I$(top_srcdir)/libvips/include \ + -I$(top_srcdir)/cplusplus/include \ + @VIPS_CFLAGS@ + +lib_LTLIBRARIES = libvips-cc.la + +libvipsCC_la_SOURCES = \ + VImage.cc \ + VError.cc + +libvipsCC_la_LDFLAGS = \ + -no-undefined \ + -version-info @LIBRARY_CURRENT@:@LIBRARY_REVISION@:@LIBRARY_AGE@ + +libvipsCC_la_LIBADD = \ + $(top_builddir)/libvips/libvips.la @VIPS_LIBS@ + +# swap the 'awk' line for this: +# awk '{if($$1!="deprecated") print $$1}'` ; \ +# to not generate the wrappers for deprecated functions +vipsc++.cc: + packages=`vips list packages | \ + awk '{print $$1}'` ; \ + echo > vipsc++.cc ; \ + for name in $$packages; do \ + echo "// bodies for package $$name" >> vipsc++.cc ; \ + vips cppc $$name >> vipsc++.cc ; \ + echo >> vipsc++.cc ; \ + done + +EXTRA_DIST = vips-operators.cc diff --git a/cplusplus/VError.cc b/cplusplus/VError.cc new file mode 100644 index 00000000..999d51e4 --- /dev/null +++ b/cplusplus/VError.cc @@ -0,0 +1,100 @@ +// Code for error type + +/* + + Copyright (C) 1991-2001 The National Gallery + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301 USA + + */ + +/* + + These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk + + */ + +#ifdef HAVE_CONFIG_H +#include +#endif /*HAVE_CONFIG_H*/ +#include + +#include +#include + +#include + +#include + +#include + +#ifdef WITH_DMALLOC +#include +#endif /*WITH_DMALLOC*/ + +VIPS_NAMESPACE_START + +void VError::perror() +{ + std::cerr << _what; + exit( 1 ); +} + +void VError::perror( const char *name ) +{ + std::cerr << name << ": " << _what; + exit( 1 ); +} + +// Add a new bit to the end of the error buffer +VError &VError::app( const int i ) +{ + char buf[ 256 ]; + + sprintf( buf, "%d", i ); + _what += buf; + + return( *this ); +} + +VError &VError::app( std::string txt ) +{ + _what += txt; + + return( *this ); +}; + +void VError::ostream_print( std::ostream &file ) const +{ + file << _what; +} + +void verror( std::string str ) throw( VError ) +{ + VError err; + + err.app( "VIPS error: " ); + if( str == "" ) { + err.app( im_error_buffer() ); + im_error_clear(); + } + else + err.app( str ).app( "\n" ); + + throw( err ); +} + +VIPS_NAMESPACE_END diff --git a/cplusplus/VImage.cc b/cplusplus/VImage.cc new file mode 100644 index 00000000..f229d1d9 --- /dev/null +++ b/cplusplus/VImage.cc @@ -0,0 +1,552 @@ +// Object part of VImage class + +/* + + Copyright (C) 1991-2001 The National Gallery + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301 USA + + */ + +/* + + These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk + + */ + +#ifdef HAVE_CONFIG_H +#include +#endif /*HAVE_CONFIG_H*/ +#include + +#include +#include +#include + +#include +#include +#include + +#include + +#ifdef WITH_DMALLOC +#include +#endif /*WITH_DMALLOC*/ + +/* +#define DEBUG + */ + +VIPS_NAMESPACE_START + +/* Useful to have these as C++ functions. + */ +bool init( const char *argv0 ) +{ + return( vips__init( argv0 ) == 0 ); +} + +void shutdown() +{ + vips_shutdown(); +} + +void thread_shutdown() +{ + vips_thread_shutdown(); +} + +void VImage::refblock::debug_print() +{ + std::list::iterator i; + + printf( "refblock %p:\n", this ); + printf( " im = %p", im ); + if( im && im->filename ) + printf( " (im->filename = \"%s\")", im->filename ); + printf( "\n" ); + printf( " close_on_delete = %d\n", close_on_delete ); + printf( " nrefs (refs to us) = %d\n", nrefs ); + printf( " orefs (refs we make) = refblocks " ); + for( i = orefs.begin(); i != orefs.end(); i++ ) + printf( "%p ", *i ); + printf( "\n" ); +} + +// dump all refblocks for debugging +void VImage::print_all() +{ +#ifdef DEBUG + std::list::iterator i; + + printf( "*** VImage::refblock::print_all() start\n" ); + for( i = all_refblock.begin(); i != all_refblock.end(); i++ ) + (*i)->debug_print(); + printf( "*** VImage::refblock::print_all() end\n" ); +#endif /*DEBUG*/ +} + +// easy call from C version +void im__ccp_print_all() +{ + VImage::print_all(); +} + +// constructor +VImage::refblock::refblock() +{ + im = 0; + close_on_delete = 1; + nrefs = 1; + +#ifdef DEBUG + all_refblock.push_front( this ); +#endif /*DEBUG*/ +} + +// Add a ref - this (output image) depends upon VipsImage in +void VImage::refblock::addref( refblock *in ) throw( VError ) +{ + if( this == in ) + verror( "sanity failure" ); + + in->nrefs++; + orefs.push_front( in ); +} + +VImage::refblock::~refblock() throw( VError ) +{ +#ifdef DEBUG + printf( "VImage::refblock::removeref(): death!\n" ); + debug_print(); +#endif /*DEBUG*/ + + std::list::iterator i; + + if( close_on_delete && im ) { + if( im_close( im ) ) + verror(); + im = 0; + } + + // remove any refs we have ... may trigger other destructs in turn + for( i = orefs.begin(); i != orefs.end(); i++ ) + (*i)->removeref(); + +#ifdef DEBUG + all_refblock.remove( this ); +#endif /*DEBUG*/ +} + +// Remove a ref +void VImage::refblock::removeref() throw( VError ) +{ + nrefs--; + if( nrefs < 0 ) + verror( "too many closes!" ); + if( nrefs == 0 ) + delete this; +} + +// Init with name ... mode defaults to "rd" +VImage::VImage( const char *name, const char *mode ) throw( VError ) +{ + _ref = new refblock; + + if( !(_ref->im = im_open( name, mode )) ) + verror(); + _ref->close_on_delete = 1; + +#ifdef DEBUG + printf( "VImage::VImage( \"%s\", \"%s\" )\n", name, mode ); + _ref->debug_print(); +#endif /*DEBUG*/ +} + +// Build a VImage from an VipsImage structure +VImage::VImage( _VipsImage *in ) +{ + _ref = new refblock; + + _ref->im = in; + _ref->close_on_delete = 0; + +#ifdef DEBUG + printf( "VImage::VImage( VipsImage* %p )\n", in ); + _ref->debug_print(); +#endif /*DEBUG*/ +} + +// Build from memory buffer +VImage::VImage( void *buffer, int width, int height, + int bands, TBandFmt format ) throw( VError ) +{ + _ref = new refblock; + + if( !(_ref->im = im_image( buffer, width, height, + bands, VipsBandFmt( format ) )) ) + verror(); + _ref->close_on_delete = 1; + +#ifdef DEBUG + printf( "VImage::VImage( void* %p, %d, %d )\n", + buffer, width, height ); + _ref->debug_print(); +#endif /*DEBUG*/ +} + +// Empty init ... means open intermediate +VImage::VImage() throw( VError ) +{ + static int id = 0; + char filename[256]; + + _ref = new refblock; + + /* This is not 100% safe if VIPS threading is not implemented on this + * platform ... but it doesn't really matter. + */ + g_mutex_lock( im__global_lock ); + im_snprintf( filename, 256, "intermediate image #%d", id++ ); + g_mutex_unlock( im__global_lock ); + + if( !(_ref->im = im_open( filename, "p" )) ) + verror(); + _ref->close_on_delete = 1; + +#ifdef DEBUG + printf( "VImage::VImage()\n" ); + _ref->debug_print(); +#endif /*DEBUG*/ +} + +// Copy constructor +VImage::VImage( const VImage &a ) +{ + _ref = a._ref; + _ref->nrefs++; +} + +// Assignment +VImage &VImage::operator=( const VImage &a ) throw( VError ) +{ + _ref->removeref(); + _ref = a._ref; + _ref->nrefs++; + + return( *this ); +} + +// Extract underlying data pointer +void *VImage::data() const throw( VError ) +{ + if( im_incheck( _ref->im ) ) + verror(); + + return( (void *) _ref->im->data ); +} + +void VImage::debug_print() +{ + im_printdesc( image() ); +} + +// Like jpeg2vips, but convert to a disc file rather than to memory +// We can handle huge files without running out of RAM +VImage VImage::convert2disc( const char* convert, + const char* in, const char* disc ) throw( VError ) +{ + VImage out( disc, "w" ); + + Vargv _vec( convert ); + + _vec.data(0) = (im_object) in; + _vec.data(1) = out.image(); + _vec.call(); + + return( out ); +} + +// Write this to a VImage +VImage VImage::write( VImage out ) throw( VError ) +{ + if( im_copy( _ref->im, out._ref->im ) ) + verror(); + out._ref->addref( _ref ); + + return( out ); +} + +VImage VImage::write( const char *name ) throw( VError ) +{ + VImage out( name, "w" ); + + if( im_copy( _ref->im, out._ref->im ) ) + verror(); + out._ref->addref( _ref ); + + return( out ); +} + +VImage VImage::write() throw( VError ) +{ + VImage out( "VImage:w1", "t" ); + + if( im_copy( _ref->im, out._ref->im ) ) + verror(); + out._ref->addref( _ref ); + + return( out ); +} + +// Projection functions to get header fields +int VImage::Xsize() { return( _ref->im->Xsize ); } +int VImage::Ysize() { return( _ref->im->Ysize ); } +int VImage::Bands() { return( _ref->im->Bands ); } +VImage::TBandFmt VImage::BandFmt() + { return( (TBandFmt) _ref->im->BandFmt ); } +VImage::TCoding VImage::Coding() + { return( (TCoding) _ref->im->Coding ); } +VImage::TType VImage::Type() { return( (TType) _ref->im->Type ); } +float VImage::Xres() { return( _ref->im->Xres ); } +float VImage::Yres() { return( _ref->im->Yres ); } +int VImage::Length() { return( _ref->im->Length ); } +VImage::TCompression VImage::Compression() + { return( (TCompression) _ref->im->Compression ); } +short VImage::Level() { return( _ref->im->Level ); } +int VImage::Xoffset() { return( _ref->im->Xoffset ); } +int VImage::Yoffset() { return( _ref->im->Yoffset ); } + +// Derived fields +const char *VImage::filename() { return( _ref->im->filename ); } +const char *VImage::Hist() { return( im_history_get( _ref->im ) ); } + +VImage VImage::hough_circle( int scale, int min_radius, int max_radius ) + throw( VError ) +{ + VImage in = *this; + VipsImage *x; + VImage out; + + if( vips_hough_circle( in.image(), &x, + "scale", scale, + "min_radius", min_radius, + "max_radius", max_radius, + NULL ) ) + verror(); + + if( vips_image_write( x, out.image() ) ) { + g_object_unref( x ); + verror(); + } + g_object_unref( x ); + + return( out ); +} + +// metadata + +// base functionality +void VImage::meta_set( const char *field, GValue *value ) throw( VError ) +{ + if( im_meta_set( _ref->im, field, value ) ) + verror(); +} + +gboolean VImage::meta_remove( const char *field ) +{ + return( im_meta_remove( _ref->im, field ) ); +} + +void VImage::meta_get( const char *field, GValue *value_copy ) throw( VError ) +{ + if( im_meta_get( _ref->im, field, value_copy ) ) + verror(); +} + +GType VImage::meta_get_typeof( const char *field ) +{ + return( im_meta_get_typeof( _ref->im, field ) ); +} + +// convenience functions +int VImage::meta_get_int( const char *field ) + throw( VError ) +{ + int result; + + if( im_meta_get_int( _ref->im, field, &result ) ) + verror(); + + return( result ); +} + +double VImage::meta_get_double( const char *field ) + throw( VError ) +{ + double result; + + if( im_meta_get_double( _ref->im, field, &result ) ) + verror(); + + return( result ); +} + +const char *VImage::meta_get_string( const char *field ) + throw( VError ) +{ + const char *result; + + if( im_meta_get_string( _ref->im, field, &result ) ) + verror(); + + return( result ); +} + +void *VImage::meta_get_area( const char *field ) throw( VError ) +{ + void *result; + + if( im_meta_get_area( _ref->im, field, &result ) ) + verror(); + + return( result ); +} + +void *VImage::meta_get_blob( const char *field, size_t *length ) throw( VError ) +{ + void *result; + + if( im_meta_get_blob( _ref->im, field, &result, length ) ) + verror(); + + return( result ); +} + +void VImage::meta_set( const char *field, int value ) + throw( VError ) +{ + if( im_meta_set_int( _ref->im, field, value ) ) + verror(); +} + +void VImage::meta_set( const char *field, double value ) + throw( VError ) +{ + if( im_meta_set_double( _ref->im, field, value ) ) + verror(); +} + +void VImage::meta_set( const char *field, const char *value ) + throw( VError ) +{ + if( im_meta_set_string( _ref->im, field, value ) ) + verror(); +} + +void VImage::meta_set( const char *field, + VCallback free_fn, void *value ) + throw( VError ) +{ + if( im_meta_set_area( _ref->im, field, free_fn, value ) ) + verror(); +} + +void VImage::meta_set( const char *field, + VCallback free_fn, void *value, size_t length ) + throw( VError ) +{ + if( im_meta_set_blob( _ref->im, field, free_fn, value, length ) ) + verror(); +} + +// Set header fields and setbuf() in one go. +void VImage::initdesc( int x, int y, int b, + TBandFmt f, TCoding c, TType t, float xr, float yr, int xo, int yo ) + throw( VError ) +{ + im_initdesc( _ref->im, x, y, b, 0, + VipsBandFmt( f ), VipsCoding( c ), VipsType( t ), + xr, yr, xo, yo ); + if( im_setupout( _ref->im ) ) + verror(); +} + +// Create a Vargv from a name +Vargv::Vargv( const char *name ) +{ + im_function *f = im_find_function( (char *) name ); + + if( !f ) + verror(); + + fn = (im__function *) f; + base = new im_object[f->argc]; + if( im_allocate_vargv( f, base ) ) { + delete[] base; + verror(); + } +} + +// Destroy a Vargv +Vargv::~Vargv() +{ + im_function *f = (im_function *) fn; + + // free any memory allocated for input vectors + // this is the stuff allocated in each function during _object* build, + // see vipsc++.cc + for( int i = 0; i < f->argc; i++ ) { + im_type_desc *ty = f->argv[i].desc; + + if( !(ty->flags & IM_TYPE_OUTPUT) ) { + if( strcmp( ty->type, IM_TYPE_IMAGEVEC ) == 0 || + strcmp( ty->type, IM_TYPE_DOUBLEVEC ) == 0 || + strcmp( ty->type, IM_TYPE_INTVEC ) == 0 ) { + // will work for doublevec and intvec too + im_imagevec_object *io = + (im_imagevec_object *) base[i]; + + if( io->vec ) { + delete[] io->vec; + io->vec = NULL; + } + } + else if( strcmp( ty->type, IM_TYPE_INTERPOLATE ) == 0 ) + g_object_unref( base[i] ); + } + } + + im_free_vargv( f, base ); + delete[] base; +} + +// Call the function +void +Vargv::call() +{ + im_function *f = (im_function *) fn; + + if( f->disp( base ) ) + verror(); +} + +/* Insert automatically generated wrappers for VIPS image processing + * functions. + */ +#include "vipsc++.cc" + +VIPS_NAMESPACE_END diff --git a/cplusplus/include/Makefile.am b/cplusplus/include/Makefile.am new file mode 100644 index 00000000..227a7696 --- /dev/null +++ b/cplusplus/include/Makefile.am @@ -0,0 +1,2 @@ + +SUBDIRS = vips diff --git a/cplusplus/include/vips/Makefile.am b/cplusplus/include/vips/Makefile.am new file mode 100644 index 00000000..94eceef4 --- /dev/null +++ b/cplusplus/include/vips/Makefile.am @@ -0,0 +1,18 @@ +pkginclude_HEADERS = \ + VError.h \ + VImage.h \ + vips8 \ + vips-operators.h + +# swap the 'awk' line for this: +# awk '{if($$1!="deprecated") print $$1}'` ; \ +# to not generate the wrappers for deprecated functions +vips-operators.h: + packages=`vips list packages | \ + awk '{print $$1}'` ; \ + echo > vips-operators.h ; \ + for name in $$packages; do \ + echo "// headers for package $$name" >> vips-operators.h ; \ + vips cpph $$name >> vips-operators.h ; \ + echo >> vips-operators.h ; \ + done diff --git a/cplusplus/include/vips/VError.h b/cplusplus/include/vips/VError.h new file mode 100644 index 00000000..9cfdb41f --- /dev/null +++ b/cplusplus/include/vips/VError.h @@ -0,0 +1,83 @@ +// Header for error type + +/* + + This file is part of VIPS. + + VIPS is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301 USA + + */ + +/* + + These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk + + */ + +#ifndef IM_VERROR_H +#define IM_VERROR_H + +/* SWIG includes this file directly rather than going through vipscpp.h ... so + * we have to define these macros here as well. + */ +#ifdef SWIG +#define VIPS_NAMESPACE_START namespace vips { +#define VIPS_NAMESPACE_END } +#endif /*SWIG*/ + +/* Don't include these when parsing for SWIG. + */ +#ifndef SWIG +# include +# include +# include +#endif /*!SWIG*/ + +VIPS_NAMESPACE_START + +// Error type +class VError : public std::exception { + std::string _what; + +public: + VError( std::string what ) : _what( what ) {} + VError() {} + virtual ~VError() throw() {} + + // Print message and exit + void perror( const char * ); + void perror(); + + // Append some more text to the message + VError &app( std::string txt ); + VError &app( const int i ); + + // Extract string + virtual const char *what() const throw() { return _what.c_str(); } + void ostream_print( std::ostream & ) const; +}; + +inline std::ostream &operator<<( std::ostream &file, const VError &err ) +{ + err.ostream_print( file ); + return( file ); +} + +void verror( std::string str = "" ) throw( VError ); + +VIPS_NAMESPACE_END + +#endif /*IM_VERROR_H*/ diff --git a/cplusplus/include/vips/VImage.h b/cplusplus/include/vips/VImage.h new file mode 100644 index 00000000..9a21019d --- /dev/null +++ b/cplusplus/include/vips/VImage.h @@ -0,0 +1,242 @@ +// VIPS image wrapper + +/* + + This file is part of VIPS. + + VIPS is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301 USA + + */ + +/* + + These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk + + */ + +#ifndef VIPS_VIMAGE_H +#define VIPS_VIMAGE_H + +#include +#include +#include + +#include + +VIPS_NAMESPACE_START + +/* vips_init() and vips_shutdown as namespaced C++ functions. + */ +bool init( const char *argv0 = "nothing" ); +void thread_shutdown( void ); +void shutdown( void ); + +/* VIPS image class. + */ +class VImage { +protected: + _VipsImage *im; // Underlying vips pointer + +public: + // Plain constructors + VImage( const char *name, const char *mode = "rd" ) throw( VError ); + VImage( void *data, int width, int height, + int bands, VipsBandFormat format ) throw( VError ); + VImage( VipsImage *image ); + VImage() throw( VError ); + + // Copy constructor + VImage( const VImage &a ); + + // Assignment - delete old ref + VImage &operator=( const VImage &a ) throw( VError ); + + // Destructor + ~VImage() throw( VError ) { VIPS_UNREF( im ); } + + // Extract underlying VipsImage pointer + VipsImage *image() const { return( im ); } + + // Write this to another VImage, to a file, or to a mem buffer + VImage write( VImage out ) throw( VError ); + VImage write( const char *name ) throw( VError ); + VImage write() throw( VError ); + + // Debugging ... print header fields + void debug_print(); + + // Projection functions to get header fields + int width(); + int height(); + int bands(); + VipsBandFormat format(); + VipsCoding coding(); + VipsInterpretation interpretation(); + float xres(); + float yres(); + int xoffset(); + int yoffset(); + + // Derived fields + const char *filename(); + const char *hist(); + + // metadata + + // base functionality + void meta_set( const char *field, GValue *value ) throw( VError ); + void meta_get( const char *field, GValue *value_copy ) throw( VError ); + gboolean meta_remove( const char *field ); + GType meta_get_typeof( const char *field ); + + // convenience functions + int meta_get_int( const char *field ) throw( VError ); + double meta_get_double( const char *field ) throw( VError ); + const char *meta_get_string( const char *field ) throw( VError ); + void *meta_get_area( const char *field ) throw( VError ); + void *meta_get_blob( const char *field, size_t *length ) + throw( VError ); + + void meta_set( const char *field, int value ) throw( VError ); + void meta_set( const char *field, double value ) throw( VError ); + void meta_set( const char *field, const char *value ) throw( VError ); + + void meta_set( const char *field, + VCallback free_fn, void *value ) + throw( VError ); + void meta_set( const char *field, + VCallback free_fn, void *value, size_t length ) + throw( VError ); + + // Set header fields + void initdesc( int, int, int, + VipsBandFormat, VipsCoding, VipsInterpretation, + float = 1.0, float = 1.0, int = 0, int = 0 ) throw( VError ); + + /* Insert automatically generated headers. + */ +#include "vips-operators.h" + + // And some in-line operator equivalences done by hand + friend VImage operator+( VImage a, VImage b ) throw( VError ) + { return( a.add( b ) ); } + friend VImage operator+( double a, VImage b ) throw( VError ) + { return( b.lin( 1.0, a ) ); } + friend VImage operator+( VImage a, double b ) throw( VError ) + { return( a.lin( 1.0, b ) ); } + + friend VImage operator-( VImage a, VImage b ) throw( VError ) + { return( a.subtract( b ) ); } + friend VImage operator-( double a, VImage b ) throw( VError ) + { return( b.lin( -1.0, a ) ); } + friend VImage operator-( VImage a, double b ) throw( VError ) + { return( a.lin( 1.0, -b ) ); } + + friend VImage operator*( VImage a, VImage b ) throw( VError ) + { return( a.multiply( b ) ); } + friend VImage operator*( double a, VImage b ) throw( VError ) + { return( b.lin( a, 0.0 ) ); } + friend VImage operator*( VImage a, double b ) throw( VError ) + { return( a.lin( b, 0.0 ) ); } + + friend VImage operator/( VImage a, VImage b ) throw( VError ) + { return( a.divide( b ) ); } + friend VImage operator/( double a, VImage b ) throw( VError ) + { return( b.pow( -1.0 ).lin( a, 0.0 ) ); } + friend VImage operator/( VImage a, double b ) throw( VError ) + { return( a.lin( 1.0/b, 0.0 ) ); } + + friend VImage operator%( VImage a, VImage b ) throw( VError ) + { return( a.remainder( b ) ); } + friend VImage operator%( VImage a, double b ) throw( VError ) + { return( a.remainder( b ) ); } + + friend VImage operator<( VImage a, VImage b ) throw( VError ) + { return( a.less( b ) ); } + friend VImage operator<( double a, VImage b ) throw( VError ) + { return( b.more( a ) ); } + friend VImage operator<( VImage a, double b ) throw( VError ) + { return( a.less( b ) ); } + + friend VImage operator<=( VImage a, VImage b ) throw( VError ) + { return( a.lesseq( b ) ); } + friend VImage operator<=( double a, VImage b ) throw( VError ) + { return( b.moreeq( a ) ); } + friend VImage operator<=( VImage a, double b ) throw( VError ) + { return( a.lesseq( b ) ); } + + friend VImage operator>( VImage a, VImage b ) throw( VError ) + { return( a.more( b ) ); } + friend VImage operator>( double a, VImage b ) throw( VError ) + { return( b.less( a ) ); } + friend VImage operator>( VImage a, double b ) throw( VError ) + { return( a.more( b ) ); } + + friend VImage operator>=( VImage a, VImage b ) throw( VError ) + { return( a.moreeq( b ) ); } + friend VImage operator>=( double a, VImage b ) throw( VError ) + { return( b.lesseq( a ) ); } + friend VImage operator>=( VImage a, double b ) throw( VError ) + { return( a.moreeq( b ) ); } + + friend VImage operator==( VImage a, VImage b ) throw( VError ) + { return( a.equal( b ) ); } + friend VImage operator==( double a, VImage b ) throw( VError ) + { return( b.equal( a ) ); } + friend VImage operator==( VImage a, double b ) throw( VError ) + { return( a.equal( b ) ); } + + friend VImage operator!=( VImage a, VImage b ) throw( VError ) + { return( a.notequal( b ) ); } + friend VImage operator!=( double a, VImage b ) throw( VError ) + { return( b.notequal( a ) ); } + friend VImage operator!=( VImage a, double b ) throw( VError ) + { return( a.notequal( b ) ); } + + friend VImage operator&( VImage a, VImage b ) throw( VError ) + { return( a.andimage( b ) ); } + friend VImage operator&( int a, VImage b ) throw( VError ) + { return( b.andimage( a ) ); } + friend VImage operator&( VImage a, int b ) throw( VError ) + { return( a.andimage( b ) ); } + + friend VImage operator|( VImage a, VImage b ) throw( VError ) + { return( a.orimage( b ) ); } + friend VImage operator|( int a, VImage b ) throw( VError ) + { return( b.orimage( a ) ); } + friend VImage operator|( VImage a, int b ) throw( VError ) + { return( a.orimage( b ) ); } + + friend VImage operator^( VImage a, VImage b ) throw( VError ) + { return( a.eorimage( b ) ); } + friend VImage operator^( int a, VImage b ) throw( VError ) + { return( b.eorimage( a ) ); } + friend VImage operator^( VImage a, int b ) throw( VError ) + { return( a.eorimage( b ) ); } + + friend VImage operator<<( VImage a, int b ) throw( VError ) + { return( a.shiftleft( b ) ); } + friend VImage operator>>( VImage a, int b ) throw( VError ) + { return( a.shiftright( b ) ); } + + friend VImage operator-( VImage a ) throw( VError ) + { return( a * -1 ); } + +}; + +VIPS_NAMESPACE_END + +#endif /*VIPS_VIMAGE_H*/ diff --git a/cplusplus/include/vips/vips-operators.h b/cplusplus/include/vips/vips-operators.h new file mode 100644 index 00000000..ea3be1e9 --- /dev/null +++ b/cplusplus/include/vips/vips-operators.h @@ -0,0 +1,418 @@ + +// headers for package arithmetic +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +VImage abs() throw( VError ); +VImage acos() throw( VError ); +VImage add( VImage add_in2 ) throw( VError ); +VImage asin() throw( VError ); +VImage atan() throw( VError ); +double avg() throw( VError ); +double point( char* point_interpolate, double point_x, double point_y, int point_band ) throw( VError ); +double point_bilinear( double point_bilinear_x, double point_bilinear_y, int point_bilinear_band ) throw( VError ); +VImage bandmean() throw( VError ); +VImage ceil() throw( VError ); +VImage cos() throw( VError ); +VImage cross_phase( VImage cross_phase_in2 ) throw( VError ); +double deviate() throw( VError ); +VImage divide( VImage divide_in2 ) throw( VError ); +VImage exp10() throw( VError ); +VImage expn( double expn_x ) throw( VError ); +VImage expn( std::vector expn_v ) throw( VError ); +VImage exp() throw( VError ); +VImage floor() throw( VError ); +VImage invert() throw( VError ); +VImage lin( double lin_a, double lin_b ) throw( VError ); +static VImage linreg( std::vector linreg_ins, std::vector linreg_xs ) throw( VError ); +VImage lin( std::vector lin_a, std::vector lin_b ) throw( VError ); +VImage log10() throw( VError ); +VImage log() throw( VError ); +double max() throw( VError ); +std::complex maxpos() throw( VError ); +double maxpos_avg( double& maxpos_avg_y, double& maxpos_avg_out ) throw( VError ); +VDMask measure( int measure_x, int measure_y, int measure_w, int measure_h, int measure_h_patches, int measure_v_patches ) throw( VError ); +double min() throw( VError ); +std::complex minpos() throw( VError ); +VImage multiply( VImage multiply_in2 ) throw( VError ); +VImage pow( double pow_x ) throw( VError ); +VImage pow( std::vector pow_v ) throw( VError ); +VImage recomb( VDMask recomb_matrix ) throw( VError ); +VImage remainder( VImage remainder_in2 ) throw( VError ); +VImage remainder( double remainder_x ) throw( VError ); +VImage remainder( std::vector remainder_x ) throw( VError ); +VImage rint() throw( VError ); +VImage sign() throw( VError ); +VImage sin() throw( VError ); +VDMask stats() throw( VError ); +VImage subtract( VImage subtract_in2 ) throw( VError ); +VImage tan() throw( VError ); + +// headers for package cimg +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +VImage greyc( int greyc_iterations, double greyc_amplitude, double greyc_sharpness, double greyc_anisotropy, double greyc_alpha, double greyc_sigma, double greyc_dl, double greyc_da, double greyc_gauss_prec, int greyc_interpolation, int greyc_fast_approx ) throw( VError ); +VImage greyc_mask( VImage greyc_mask_mask, int greyc_mask_iterations, double greyc_mask_amplitude, double greyc_mask_sharpness, double greyc_mask_anisotropy, double greyc_mask_alpha, double greyc_mask_sigma, double greyc_mask_dl, double greyc_mask_da, double greyc_mask_gauss_prec, int greyc_mask_interpolation, int greyc_mask_fast_approx ) throw( VError ); + +// headers for package colour +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +VImage LCh2Lab() throw( VError ); +VImage LCh2UCS() throw( VError ); +VImage Lab2LCh() throw( VError ); +VImage Lab2LabQ() throw( VError ); +VImage Lab2LabS() throw( VError ); +VImage Lab2UCS() throw( VError ); +VImage Lab2XYZ() throw( VError ); +VImage Lab2XYZ_temp( double Lab2XYZ_temp_X0, double Lab2XYZ_temp_Y0, double Lab2XYZ_temp_Z0 ) throw( VError ); +VImage Lab2disp( VDisplay Lab2disp_disp ) throw( VError ); +VImage LabQ2LabS() throw( VError ); +VImage LabQ2Lab() throw( VError ); +VImage LabQ2XYZ() throw( VError ); +VImage LabQ2disp( VDisplay LabQ2disp_disp ) throw( VError ); +VImage LabS2LabQ() throw( VError ); +VImage LabS2Lab() throw( VError ); +VImage UCS2LCh() throw( VError ); +VImage UCS2Lab() throw( VError ); +VImage UCS2XYZ() throw( VError ); +VImage XYZ2Lab() throw( VError ); +VImage XYZ2Lab_temp( double XYZ2Lab_temp_X0, double XYZ2Lab_temp_Y0, double XYZ2Lab_temp_Z0 ) throw( VError ); +VImage XYZ2UCS() throw( VError ); +VImage XYZ2Yxy() throw( VError ); +VImage XYZ2disp( VDisplay XYZ2disp_disp ) throw( VError ); +VImage XYZ2sRGB() throw( VError ); +VImage Yxy2XYZ() throw( VError ); +VImage dE00_fromLab( VImage dE00_fromLab_in2 ) throw( VError ); +VImage dECMC_fromLab( VImage dECMC_fromLab_in2 ) throw( VError ); +VImage dECMC_fromdisp( VImage dECMC_fromdisp_in2, VDisplay dECMC_fromdisp_disp ) throw( VError ); +VImage dE_fromLab( VImage dE_fromLab_in2 ) throw( VError ); +VImage dE_fromXYZ( VImage dE_fromXYZ_in2 ) throw( VError ); +VImage dE_fromdisp( VImage dE_fromdisp_in2, VDisplay dE_fromdisp_disp ) throw( VError ); +VImage disp2Lab( VDisplay disp2Lab_disp ) throw( VError ); +VImage disp2XYZ( VDisplay disp2XYZ_disp ) throw( VError ); +VImage float2rad() throw( VError ); +VImage icc_ac2rc( char* icc_ac2rc_profile ) throw( VError ); +VImage icc_export_depth( int icc_export_depth_depth, char* icc_export_depth_output_profile, int icc_export_depth_intent ) throw( VError ); +VImage icc_import( char* icc_import_input_profile, int icc_import_intent ) throw( VError ); +VImage icc_import_embedded( int icc_import_embedded_intent ) throw( VError ); +VImage icc_transform( char* icc_transform_input_profile, char* icc_transform_output_profile, int icc_transform_intent ) throw( VError ); +VImage lab_morph( VDMask lab_morph_greyscale, double lab_morph_L_offset, double lab_morph_L_scale, double lab_morph_a_scale, double lab_morph_b_scale ) throw( VError ); +VImage rad2float() throw( VError ); +VImage sRGB2XYZ() throw( VError ); + +// headers for package conversion +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +static VImage gaussnoise( int gaussnoise_xsize, int gaussnoise_ysize, double gaussnoise_mean, double gaussnoise_sigma ) throw( VError ); +VImage bandjoin( VImage bandjoin_in2 ) throw( VError ); +static VImage black( int black_x_size, int black_y_size, int black_bands ) throw( VError ); +VImage c2amph() throw( VError ); +VImage c2imag() throw( VError ); +VImage c2real() throw( VError ); +VImage c2rect() throw( VError ); +VImage clip2fmt( int clip2fmt_ofmt ) throw( VError ); +VImage copy() throw( VError ); +VImage copy_file() throw( VError ); +VImage copy_morph( int copy_morph_Bands, int copy_morph_BandFmt, int copy_morph_Coding ) throw( VError ); +VImage copy_swap() throw( VError ); +VImage copy_set( int copy_set_Type, double copy_set_Xres, double copy_set_Yres, int copy_set_Xoffset, int copy_set_Yoffset ) throw( VError ); +VImage extract_area( int extract_area_left, int extract_area_top, int extract_area_width, int extract_area_height ) throw( VError ); +VImage extract_areabands( int extract_areabands_left, int extract_areabands_top, int extract_areabands_width, int extract_areabands_height, int extract_areabands_band, int extract_areabands_nbands ) throw( VError ); +VImage extract_band( int extract_band_band ) throw( VError ); +VImage extract_bands( int extract_bands_band, int extract_bands_nbands ) throw( VError ); +VImage extract( int extract_left, int extract_top, int extract_width, int extract_height, int extract_band ) throw( VError ); +VImage falsecolour() throw( VError ); +VImage fliphor() throw( VError ); +VImage flipver() throw( VError ); +static VImage gbandjoin( std::vector gbandjoin_in ) throw( VError ); +VImage grid( int grid_tile_height, int grid_across, int grid_down ) throw( VError ); +VImage insert( VImage insert_sub, int insert_x, int insert_y ) throw( VError ); +VImage insert( VImage insert_sub, std::vector insert_x, std::vector insert_y ) throw( VError ); +VImage insert_noexpand( VImage insert_noexpand_sub, int insert_noexpand_x, int insert_noexpand_y ) throw( VError ); +VImage embed( int embed_type, int embed_x, int embed_y, int embed_width, int embed_height ) throw( VError ); +VImage lrjoin( VImage lrjoin_in2 ) throw( VError ); +VImage msb() throw( VError ); +VImage msb_band( int msb_band_band ) throw( VError ); +VImage replicate( int replicate_across, int replicate_down ) throw( VError ); +VImage ri2c( VImage ri2c_in2 ) throw( VError ); +VImage rot180() throw( VError ); +VImage rot270() throw( VError ); +VImage rot90() throw( VError ); +VImage scale() throw( VError ); +VImage scaleps() throw( VError ); +VImage subsample( int subsample_xshrink, int subsample_yshrink ) throw( VError ); +char* system( char* system_command ) throw( VError ); +VImage system_image( char* system_image_in_format, char* system_image_out_format, char* system_image_command, char*& system_image_log ) throw( VError ); +VImage tbjoin( VImage tbjoin_in2 ) throw( VError ); +static VImage text( char* text_text, char* text_font, int text_width, int text_alignment, int text_dpi ) throw( VError ); +VImage wrap( int wrap_x, int wrap_y ) throw( VError ); +VImage zoom( int zoom_xfac, int zoom_yfac ) throw( VError ); + +// headers for package convolution +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +VImage aconvsep( VDMask aconvsep_matrix, int aconvsep_n_layers ) throw( VError ); +VImage aconv( VDMask aconv_matrix, int aconv_n_layers, int aconv_cluster ) throw( VError ); +VImage addgnoise( double addgnoise_sigma ) throw( VError ); +VImage compass( VIMask compass_matrix ) throw( VError ); +VImage contrast_surface( int contrast_surface_half_win_size, int contrast_surface_spacing ) throw( VError ); +VImage conv( VIMask conv_matrix ) throw( VError ); +VImage conv( VDMask conv_matrix ) throw( VError ); +VImage convsep( VIMask convsep_matrix ) throw( VError ); +VImage convsep( VDMask convsep_matrix ) throw( VError ); +VImage fastcor( VImage fastcor_in2 ) throw( VError ); +VImage gradcor( VImage gradcor_in2 ) throw( VError ); +VImage gradient( VIMask gradient_matrix ) throw( VError ); +VImage grad_x() throw( VError ); +VImage grad_y() throw( VError ); +VImage lindetect( VIMask lindetect_matrix ) throw( VError ); +VImage sharpen( int sharpen_mask_size, double sharpen_x1, double sharpen_y2, double sharpen_y3, double sharpen_m1, double sharpen_m2 ) throw( VError ); +VImage spcor( VImage spcor_in2 ) throw( VError ); + +// headers for package deprecated +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +VImage argb2rgba() throw( VError ); +VImage flood_copy( int flood_copy_start_x, int flood_copy_start_y, std::vector flood_copy_ink ) throw( VError ); +VImage flood_blob_copy( int flood_blob_copy_start_x, int flood_blob_copy_start_y, std::vector flood_blob_copy_ink ) throw( VError ); +VImage flood_other_copy( VImage flood_other_copy_mark, int flood_other_copy_start_x, int flood_other_copy_start_y, int flood_other_copy_serial ) throw( VError ); +VImage clip() throw( VError ); +VImage c2ps() throw( VError ); +VImage resize_linear( int resize_linear_X, int resize_linear_Y ) throw( VError ); +VImage cmulnorm( VImage cmulnorm_in2 ) throw( VError ); +VImage fav4( VImage fav4_in2, VImage fav4_in3, VImage fav4_in4 ) throw( VError ); +VImage gadd( double gadd_a, double gadd_b, VImage gadd_in2, double gadd_c ) throw( VError ); +VImage icc_export( char* icc_export_output_profile, int icc_export_intent ) throw( VError ); +VImage litecor( VImage litecor_white, int litecor_clip, double litecor_factor ) throw( VError ); +VImage affine( double affine_a, double affine_b, double affine_c, double affine_d, double affine_dx, double affine_dy, int affine_x, int affine_y, int affine_w, int affine_h ) throw( VError ); +VImage clip2c() throw( VError ); +VImage clip2cm() throw( VError ); +VImage clip2d() throw( VError ); +VImage clip2dcm() throw( VError ); +VImage clip2f() throw( VError ); +VImage clip2i() throw( VError ); +VImage convsub( VIMask convsub_matrix, int convsub_xskip, int convsub_yskip ) throw( VError ); +VImage convf( VDMask convf_matrix ) throw( VError ); +VImage convsepf( VDMask convsepf_matrix ) throw( VError ); +VImage clip2s() throw( VError ); +VImage clip2ui() throw( VError ); +VImage insertplace( VImage insertplace_sub, std::vector insertplace_x, std::vector insertplace_y ) throw( VError ); +VImage clip2us() throw( VError ); +VImage slice( double slice_thresh1, double slice_thresh2 ) throw( VError ); +VImage segment( int& segment_segments ) throw( VError ); +void line( int line_x1, int line_y1, int line_x2, int line_y2, int line_pelval ) throw( VError ); +VImage thresh( double thresh_threshold ) throw( VError ); +VImage convf_raw( VDMask convf_raw_matrix ) throw( VError ); +VImage conv_raw( VIMask conv_raw_matrix ) throw( VError ); +VImage contrast_surface_raw( int contrast_surface_raw_half_win_size, int contrast_surface_raw_spacing ) throw( VError ); +VImage convsepf_raw( VDMask convsepf_raw_matrix ) throw( VError ); +VImage convsep_raw( VIMask convsep_raw_matrix ) throw( VError ); +VImage fastcor_raw( VImage fastcor_raw_in2 ) throw( VError ); +VImage gradcor_raw( VImage gradcor_raw_in2 ) throw( VError ); +VImage spcor_raw( VImage spcor_raw_in2 ) throw( VError ); +VImage lhisteq_raw( int lhisteq_raw_width, int lhisteq_raw_height ) throw( VError ); +VImage stdif_raw( double stdif_raw_a, double stdif_raw_m0, double stdif_raw_b, double stdif_raw_s0, int stdif_raw_xw, int stdif_raw_yw ) throw( VError ); +VImage rank_raw( int rank_raw_xsize, int rank_raw_ysize, int rank_raw_n ) throw( VError ); +VImage dilate_raw( VIMask dilate_raw_mask ) throw( VError ); +VImage erode_raw( VIMask erode_raw_mask ) throw( VError ); +VImage similarity_area( double similarity_area_a, double similarity_area_b, double similarity_area_dx, double similarity_area_dy, int similarity_area_x, int similarity_area_y, int similarity_area_w, int similarity_area_h ) throw( VError ); +VImage similarity( double similarity_a, double similarity_b, double similarity_dx, double similarity_dy ) throw( VError ); +static VImage mask2vips( VDMask mask2vips_input ) throw( VError ); +VDMask vips2mask() throw( VError ); +void insertplace( VImage insertplace_sub, int insertplace_x, int insertplace_y ) throw( VError ); +void circle( int circle_cx, int circle_cy, int circle_radius, int circle_intensity ) throw( VError ); +VImage andimage( VImage andimage_in2 ) throw( VError ); +VImage andimage( int andimage_c ) throw( VError ); +VImage andimage( std::vector andimage_vec ) throw( VError ); +VImage orimage( VImage orimage_in2 ) throw( VError ); +VImage orimage( int orimage_c ) throw( VError ); +VImage orimage( std::vector orimage_vec ) throw( VError ); +VImage eorimage( VImage eorimage_in2 ) throw( VError ); +VImage eorimage( int eorimage_c ) throw( VError ); +VImage eorimage( std::vector eorimage_vec ) throw( VError ); +VImage shiftleft( std::vector shiftleft_vec ) throw( VError ); +VImage shiftleft( int shiftleft_c ) throw( VError ); +VImage shiftright( std::vector shiftright_vec ) throw( VError ); +VImage shiftright( int shiftright_c ) throw( VError ); +VImage blend( VImage blend_in1, VImage blend_in2 ) throw( VError ); +VImage equal( VImage equal_in2 ) throw( VError ); +VImage equal( std::vector equal_vec ) throw( VError ); +VImage equal( double equal_c ) throw( VError ); +VImage ifthenelse( VImage ifthenelse_in1, VImage ifthenelse_in2 ) throw( VError ); +VImage less( VImage less_in2 ) throw( VError ); +VImage less( std::vector less_vec ) throw( VError ); +VImage less( double less_c ) throw( VError ); +VImage lesseq( VImage lesseq_in2 ) throw( VError ); +VImage lesseq( std::vector lesseq_vec ) throw( VError ); +VImage lesseq( double lesseq_c ) throw( VError ); +VImage more( VImage more_in2 ) throw( VError ); +VImage more( std::vector more_vec ) throw( VError ); +VImage more( double more_c ) throw( VError ); +VImage moreeq( VImage moreeq_in2 ) throw( VError ); +VImage moreeq( std::vector moreeq_vec ) throw( VError ); +VImage moreeq( double moreeq_c ) throw( VError ); +VImage notequal( VImage notequal_in2 ) throw( VError ); +VImage notequal( std::vector notequal_vec ) throw( VError ); +VImage notequal( double notequal_c ) throw( VError ); +VImage quadratic( VImage quadratic_coeff ) throw( VError ); + +// headers for package format +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +static VImage csv2vips( char* csv2vips_filename ) throw( VError ); +static VImage fits2vips( char* fits2vips_in ) throw( VError ); +static VImage jpeg2vips( char* jpeg2vips_in ) throw( VError ); +static VImage magick2vips( char* magick2vips_in ) throw( VError ); +static VImage png2vips( char* png2vips_in ) throw( VError ); +static VImage exr2vips( char* exr2vips_in ) throw( VError ); +static VImage ppm2vips( char* ppm2vips_filename ) throw( VError ); +static VImage analyze2vips( char* analyze2vips_filename ) throw( VError ); +static VImage tiff2vips( char* tiff2vips_in ) throw( VError ); +void vips2csv( char* vips2csv_filename ) throw( VError ); +void vips2dz( char* vips2dz_out ) throw( VError ); +void vips2jpeg( char* vips2jpeg_out ) throw( VError ); +void vips2mimejpeg( int vips2mimejpeg_qfac ) throw( VError ); +void vips2png( char* vips2png_out ) throw( VError ); +void vips2ppm( char* vips2ppm_filename ) throw( VError ); +void vips2tiff( char* vips2tiff_out ) throw( VError ); + +// headers for package freq_filt +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +static VImage create_fmask( int create_fmask_width, int create_fmask_height, int create_fmask_type, double create_fmask_p1, double create_fmask_p2, double create_fmask_p3, double create_fmask_p4, double create_fmask_p5 ) throw( VError ); +VImage disp_ps() throw( VError ); +VImage flt_image_freq( int flt_image_freq_type, double flt_image_freq_p1, double flt_image_freq_p2, double flt_image_freq_p3, double flt_image_freq_p4, double flt_image_freq_p5 ) throw( VError ); +static VImage fractsurf( int fractsurf_size, double fractsurf_dimension ) throw( VError ); +VImage freqflt( VImage freqflt_mask ) throw( VError ); +VImage fwfft() throw( VError ); +VImage rotquad() throw( VError ); +VImage invfft() throw( VError ); +VImage phasecor_fft( VImage phasecor_fft_in2 ) throw( VError ); +VImage invfftr() throw( VError ); + +// headers for package histograms_lut +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +VImage gammacorrect( double gammacorrect_exponent ) throw( VError ); +VImage heq( int heq_band_number ) throw( VError ); +VImage hist( int hist_band_number ) throw( VError ); +VImage histcum() throw( VError ); +VImage histeq() throw( VError ); +VImage hist_indexed( VImage hist_indexed_value ) throw( VError ); +VImage histgr( int histgr_band_number ) throw( VError ); +VImage histnD( int histnD_bins ) throw( VError ); +VImage histnorm() throw( VError ); +VImage histplot() throw( VError ); +VImage histspec( VImage histspec_ref ) throw( VError ); +VImage hsp( VImage hsp_ref ) throw( VError ); +static VImage identity( int identity_nbands ) throw( VError ); +static VImage identity_ushort( int identity_ushort_nbands, int identity_ushort_size ) throw( VError ); +int ismonotonic() throw( VError ); +VImage lhisteq( int lhisteq_width, int lhisteq_height ) throw( VError ); +int mpercent( double mpercent_percent ) throw( VError ); +static VImage invertlut( VDMask invertlut_measures, int invertlut_lut_size ) throw( VError ); +static VImage buildlut( VDMask buildlut_xyes ) throw( VError ); +VImage maplut( VImage maplut_lut ) throw( VError ); +VImage project( VImage& project_vout ) throw( VError ); +VImage stdif( double stdif_a, double stdif_m0, double stdif_b, double stdif_s0, int stdif_xw, int stdif_yw ) throw( VError ); +VImage tone_analyse( double tone_analyse_Ps, double tone_analyse_Pm, double tone_analyse_Ph, double tone_analyse_S, double tone_analyse_M, double tone_analyse_H ) throw( VError ); +static VImage tone_build( double tone_build_Lb, double tone_build_Lw, double tone_build_Ps, double tone_build_Pm, double tone_build_Ph, double tone_build_S, double tone_build_M, double tone_build_H ) throw( VError ); +static VImage tone_build_range( int tone_build_range_in_max, int tone_build_range_out_max, double tone_build_range_Lb, double tone_build_range_Lw, double tone_build_range_Ps, double tone_build_range_Pm, double tone_build_range_Ph, double tone_build_range_S, double tone_build_range_M, double tone_build_range_H ) throw( VError ); +VImage tone_map( VImage tone_map_lut ) throw( VError ); + +// headers for package inplace +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +void draw_circle( int draw_circle_cx, int draw_circle_cy, int draw_circle_radius, int draw_circle_fill, std::vector draw_circle_ink ) throw( VError ); +void draw_rect( int draw_rect_left, int draw_rect_top, int draw_rect_width, int draw_rect_height, int draw_rect_fill, std::vector draw_rect_ink ) throw( VError ); +void draw_line( int draw_line_x1, int draw_line_y1, int draw_line_x2, int draw_line_y2, std::vector draw_line_ink ) throw( VError ); +void draw_point( int draw_point_x, int draw_point_y, std::vector draw_point_ink ) throw( VError ); +void draw_smudge( int draw_smudge_left, int draw_smudge_top, int draw_smudge_width, int draw_smudge_height ) throw( VError ); +void draw_flood( int draw_flood_x, int draw_flood_y, std::vector draw_flood_ink ) throw( VError ); +void draw_flood_blob( int draw_flood_blob_x, int draw_flood_blob_y, std::vector draw_flood_blob_ink ) throw( VError ); +void draw_flood_other( VImage draw_flood_other_test, int draw_flood_other_x, int draw_flood_other_y, int draw_flood_other_serial ) throw( VError ); +void draw_image( VImage draw_image_sub, int draw_image_x, int draw_image_y ) throw( VError ); +void draw_mask( VImage draw_mask_mask, int draw_mask_x, int draw_mask_y, std::vector draw_mask_ink ) throw( VError ); +VImage line( VImage line_mask, VImage line_ink, std::vector line_x1, std::vector line_y1, std::vector line_x2, std::vector line_y2 ) throw( VError ); + +// headers for package iofuncs +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +static VImage binfile( char* binfile_filename, int binfile_width, int binfile_height, int binfile_bands, int binfile_offset ) throw( VError ); +VImage cache( int cache_tile_width, int cache_tile_height, int cache_max_tiles ) throw( VError ); +char* getext() throw( VError ); +int header_get_typeof( char* header_get_typeof_field ) throw( VError ); +int header_int( char* header_int_field ) throw( VError ); +double header_double( char* header_double_field ) throw( VError ); +char* header_string( char* header_string_field ) throw( VError ); +char* history_get() throw( VError ); +void printdesc() throw( VError ); + +// headers for package mask +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 + +// headers for package morphology +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +double cntlines( int cntlines_direction ) throw( VError ); +VImage dilate( VIMask dilate_mask ) throw( VError ); +VImage rank( int rank_xsize, int rank_ysize, int rank_n ) throw( VError ); +static VImage rank_image( std::vector rank_image_in, int rank_image_index ) throw( VError ); +static VImage maxvalue( std::vector maxvalue_in ) throw( VError ); +VImage label_regions( int& label_regions_segments ) throw( VError ); +VImage zerox( int zerox_flag ) throw( VError ); +VImage erode( VIMask erode_mask ) throw( VError ); +VImage profile( int profile_direction ) throw( VError ); + +// headers for package mosaicing +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +VImage align_bands() throw( VError ); +double correl( VImage correl_sec, int correl_xref, int correl_yref, int correl_xsec, int correl_ysec, int correl_hwindowsize, int correl_hsearchsize, int& correl_x, int& correl_y ) throw( VError ); +int _find_lroverlap( VImage _find_lroverlap_sec, int _find_lroverlap_bandno, int _find_lroverlap_xr, int _find_lroverlap_yr, int _find_lroverlap_xs, int _find_lroverlap_ys, int _find_lroverlap_halfcorrelation, int _find_lroverlap_halfarea, int& _find_lroverlap_dy0, double& _find_lroverlap_scale1, double& _find_lroverlap_angle1, double& _find_lroverlap_dx1, double& _find_lroverlap_dy1 ) throw( VError ); +int _find_tboverlap( VImage _find_tboverlap_sec, int _find_tboverlap_bandno, int _find_tboverlap_xr, int _find_tboverlap_yr, int _find_tboverlap_xs, int _find_tboverlap_ys, int _find_tboverlap_halfcorrelation, int _find_tboverlap_halfarea, int& _find_tboverlap_dy0, double& _find_tboverlap_scale1, double& _find_tboverlap_angle1, double& _find_tboverlap_dx1, double& _find_tboverlap_dy1 ) throw( VError ); +VImage global_balance( double global_balance_gamma ) throw( VError ); +VImage global_balancef( double global_balancef_gamma ) throw( VError ); +VImage lrmerge( VImage lrmerge_sec, int lrmerge_dx, int lrmerge_dy, int lrmerge_mwidth ) throw( VError ); +VImage lrmerge1( VImage lrmerge1_sec, int lrmerge1_xr1, int lrmerge1_yr1, int lrmerge1_xs1, int lrmerge1_ys1, int lrmerge1_xr2, int lrmerge1_yr2, int lrmerge1_xs2, int lrmerge1_ys2, int lrmerge1_mwidth ) throw( VError ); +VImage lrmosaic( VImage lrmosaic_sec, int lrmosaic_bandno, int lrmosaic_xr, int lrmosaic_yr, int lrmosaic_xs, int lrmosaic_ys, int lrmosaic_halfcorrelation, int lrmosaic_halfarea, int lrmosaic_balancetype, int lrmosaic_mwidth ) throw( VError ); +VImage lrmosaic1( VImage lrmosaic1_sec, int lrmosaic1_bandno, int lrmosaic1_xr1, int lrmosaic1_yr1, int lrmosaic1_xs1, int lrmosaic1_ys1, int lrmosaic1_xr2, int lrmosaic1_yr2, int lrmosaic1_xs2, int lrmosaic1_ys2, int lrmosaic1_halfcorrelation, int lrmosaic1_halfarea, int lrmosaic1_balancetype, int lrmosaic1_mwidth ) throw( VError ); +VImage match_linear( VImage match_linear_sec, int match_linear_xref1, int match_linear_yref1, int match_linear_xsec1, int match_linear_ysec1, int match_linear_xref2, int match_linear_yref2, int match_linear_xsec2, int match_linear_ysec2 ) throw( VError ); +VImage match_linear_search( VImage match_linear_search_sec, int match_linear_search_xref1, int match_linear_search_yref1, int match_linear_search_xsec1, int match_linear_search_ysec1, int match_linear_search_xref2, int match_linear_search_yref2, int match_linear_search_xsec2, int match_linear_search_ysec2, int match_linear_search_hwindowsize, int match_linear_search_hsearchsize ) throw( VError ); +double maxpos_subpel( double& maxpos_subpel_y ) throw( VError ); +VImage remosaic( char* remosaic_old_str, char* remosaic_new_str ) throw( VError ); +VImage tbmerge( VImage tbmerge_sec, int tbmerge_dx, int tbmerge_dy, int tbmerge_mwidth ) throw( VError ); +VImage tbmerge1( VImage tbmerge1_sec, int tbmerge1_xr1, int tbmerge1_yr1, int tbmerge1_xs1, int tbmerge1_ys1, int tbmerge1_xr2, int tbmerge1_yr2, int tbmerge1_xs2, int tbmerge1_ys2, int tbmerge1_mwidth ) throw( VError ); +VImage tbmosaic( VImage tbmosaic_sec, int tbmosaic_bandno, int tbmosaic_xr, int tbmosaic_yr, int tbmosaic_xs, int tbmosaic_ys, int tbmosaic_halfcorrelation, int tbmosaic_halfarea, int tbmosaic_balancetype, int tbmosaic_mwidth ) throw( VError ); +VImage tbmosaic1( VImage tbmosaic1_sec, int tbmosaic1_bandno, int tbmosaic1_xr1, int tbmosaic1_yr1, int tbmosaic1_xs1, int tbmosaic1_ys1, int tbmosaic1_xr2, int tbmosaic1_yr2, int tbmosaic1_xs2, int tbmosaic1_ys2, int tbmosaic1_halfcorrelation, int tbmosaic1_halfarea, int tbmosaic1_balancetype, int tbmosaic1_mwidth ) throw( VError ); + +// headers for package other +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +VImage benchmark() throw( VError ); +double benchmark2() throw( VError ); +VImage benchmarkn( int benchmarkn_n ) throw( VError ); +static VImage eye( int eye_xsize, int eye_ysize, double eye_factor ) throw( VError ); +static VImage grey( int grey_xsize, int grey_ysize ) throw( VError ); +static VImage feye( int feye_xsize, int feye_ysize, double feye_factor ) throw( VError ); +static VImage fgrey( int fgrey_xsize, int fgrey_ysize ) throw( VError ); +static VImage fzone( int fzone_size ) throw( VError ); +static VImage make_xy( int make_xy_xsize, int make_xy_ysize ) throw( VError ); +static VImage sines( int sines_xsize, int sines_ysize, double sines_horfreq, double sines_verfreq ) throw( VError ); +static VImage zone( int zone_size ) throw( VError ); + +// headers for package resample +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +VImage rightshift_size( int rightshift_size_xshift, int rightshift_size_yshift, int rightshift_size_band_fmt ) throw( VError ); +VImage shrink( double shrink_xfac, double shrink_yfac ) throw( VError ); +VImage stretch3( double stretch3_xdisp, double stretch3_ydisp ) throw( VError ); +VImage affinei( char* affinei_interpolate, double affinei_a, double affinei_b, double affinei_c, double affinei_d, double affinei_dx, double affinei_dy, int affinei_x, int affinei_y, int affinei_w, int affinei_h ) throw( VError ); +VImage affinei_all( char* affinei_all_interpolate, double affinei_all_a, double affinei_all_b, double affinei_all_c, double affinei_all_d, double affinei_all_dx, double affinei_all_dy ) throw( VError ); + +// headers for package video +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +static VImage video_test( int video_test_brightness, int video_test_error ) throw( VError ); +static VImage video_v4l1( char* video_v4l1_device, int video_v4l1_channel, int video_v4l1_brightness, int video_v4l1_colour, int video_v4l1_contrast, int video_v4l1_hue, int video_v4l1_ngrabs ) throw( VError ); + diff --git a/cplusplus/include/vips/vips8 b/cplusplus/include/vips/vips8 new file mode 100644 index 00000000..6a5f8147 --- /dev/null +++ b/cplusplus/include/vips/vips8 @@ -0,0 +1,43 @@ +// Include file to get vips C++ binding + +/* + + This file is part of VIPS. + + VIPS is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301 USA + + */ + +/* + + These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk + + */ + +#ifndef VIPS_CPLUSPLUS +#define VIPS_CPLUSPLUS + +#include + +#include + +#define VIPS_NAMESPACE_START namespace vips8 { +#define VIPS_NAMESPACE_END } + +#include +#include + +#endif /*VIPS_CPLUSPLUS*/ diff --git a/cplusplus/vips-operators.cc b/cplusplus/vips-operators.cc new file mode 100644 index 00000000..3e4afa29 --- /dev/null +++ b/cplusplus/vips-operators.cc @@ -0,0 +1,6202 @@ + +// bodies for package arithmetic +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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: interpolate value at single point +double VImage::point( char* interpolate, double x, double y, int band ) throw( VError ) +{ + VImage in = *this; + double out; + + Vargv _vec( "im_point" ); + + _vec.data(0) = in.image(); + if( vips__input_interpolate_init( &_vec.data(1), interpolate ) ) + verror(); + *((double*) _vec.data(2)) = x; + *((double*) _vec.data(3)) = y; + *((int*) _vec.data(4)) = band; + _vec.call(); + out = *((double*)_vec.data(5)); + + return( out ); +} + +// 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 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 ins, std::vector 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 a, std::vector 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 VImage::maxpos() throw( VError ) +{ + VImage in = *this; + std::complex position; + + Vargv _vec( "im_maxpos" ); + + _vec.data(0) = in.image(); + _vec.call(); + position = *((std::complex*)_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 VImage::minpos() throw( VError ) +{ + VImage in = *this; + std::complex position; + + Vargv _vec( "im_minpos" ); + + _vec.data(0) = in.image(); + _vec.call(); + position = *((std::complex*)_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 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 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.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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 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 x, std::vector 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.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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_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 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 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 x, std::vector 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 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 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 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 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 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 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 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 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 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 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 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 ); +} + +// im_quadratic: transform via quadratic +VImage VImage::quadratic( VImage coeff ) throw( VError ) +{ + VImage in = *this; + VImage out; + + Vargv _vec( "im_quadratic" ); + + _vec.data(0) = in.image(); + _vec.data(1) = out.image(); + _vec.data(2) = coeff.image(); + _vec.call(); + out._ref->addref( in._ref ); + out._ref->addref( coeff._ref ); + + return( out ); +} + + +// bodies for package format +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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_vips2dz: save as deepzoom +void VImage::vips2dz( char* out ) throw( VError ) +{ + VImage in = *this; + Vargv _vec( "im_vips2dz" ); + + _vec.data(0) = in.image(); + _vec.data(1) = (im_object) out; + _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.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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.34.0-Tue Jun 11 11:18:24 BST 2013 +// im_draw_circle: draw circle on image +void VImage::draw_circle( int cx, int cy, int radius, int fill, std::vector ink ) throw( VError ) +{ + VImage image = *this; + Vargv _vec( "im_draw_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)) = fill; + ((im_doublevec_object*) _vec.data(5))->n = ink.size(); + ((im_doublevec_object*) _vec.data(5))->vec = new double[ink.size()]; + for( unsigned int i = 0; i < ink.size(); i++ ) + ((im_doublevec_object*) _vec.data(5))->vec[i] = ink[i]; + _vec.call(); +} + +// im_draw_rect: draw rect on image +void VImage::draw_rect( int left, int top, int width, int height, int fill, std::vector ink ) throw( VError ) +{ + VImage image = *this; + Vargv _vec( "im_draw_rect" ); + + _vec.data(0) = image.image(); + *((int*) _vec.data(1)) = left; + *((int*) _vec.data(2)) = top; + *((int*) _vec.data(3)) = width; + *((int*) _vec.data(4)) = height; + *((int*) _vec.data(5)) = fill; + ((im_doublevec_object*) _vec.data(6))->n = ink.size(); + ((im_doublevec_object*) _vec.data(6))->vec = new double[ink.size()]; + for( unsigned int i = 0; i < ink.size(); i++ ) + ((im_doublevec_object*) _vec.data(6))->vec[i] = ink[i]; + _vec.call(); +} + +// im_draw_line: draw line on image +void VImage::draw_line( int x1, int y1, int x2, int y2, std::vector ink ) throw( VError ) +{ + VImage image = *this; + Vargv _vec( "im_draw_line" ); + + _vec.data(0) = image.image(); + *((int*) _vec.data(1)) = x1; + *((int*) _vec.data(2)) = y1; + *((int*) _vec.data(3)) = x2; + *((int*) _vec.data(4)) = y2; + ((im_doublevec_object*) _vec.data(5))->n = ink.size(); + ((im_doublevec_object*) _vec.data(5))->vec = new double[ink.size()]; + for( unsigned int i = 0; i < ink.size(); i++ ) + ((im_doublevec_object*) _vec.data(5))->vec[i] = ink[i]; + _vec.call(); +} + +// im_draw_point: draw point on image +void VImage::draw_point( int x, int y, std::vector ink ) throw( VError ) +{ + VImage image = *this; + Vargv _vec( "im_draw_point" ); + + _vec.data(0) = image.image(); + *((int*) _vec.data(1)) = x; + *((int*) _vec.data(2)) = y; + ((im_doublevec_object*) _vec.data(3))->n = ink.size(); + ((im_doublevec_object*) _vec.data(3))->vec = new double[ink.size()]; + for( unsigned int i = 0; i < ink.size(); i++ ) + ((im_doublevec_object*) _vec.data(3))->vec[i] = ink[i]; + _vec.call(); +} + +// im_draw_smudge: smudge part of an image +void VImage::draw_smudge( int left, int top, int width, int height ) throw( VError ) +{ + VImage image = *this; + Vargv _vec( "im_draw_smudge" ); + + _vec.data(0) = image.image(); + *((int*) _vec.data(1)) = left; + *((int*) _vec.data(2)) = top; + *((int*) _vec.data(3)) = width; + *((int*) _vec.data(4)) = height; + _vec.call(); +} + +// im_draw_flood: flood with ink from x, y while pixel != ink +void VImage::draw_flood( int x, int y, std::vector ink ) throw( VError ) +{ + VImage image = *this; + Vargv _vec( "im_draw_flood" ); + + _vec.data(0) = image.image(); + *((int*) _vec.data(1)) = x; + *((int*) _vec.data(2)) = y; + ((im_doublevec_object*) _vec.data(3))->n = ink.size(); + ((im_doublevec_object*) _vec.data(3))->vec = new double[ink.size()]; + for( unsigned int i = 0; i < ink.size(); i++ ) + ((im_doublevec_object*) _vec.data(3))->vec[i] = ink[i]; + _vec.call(); +} + +// im_draw_flood_blob: flood with ink from x, y while pixel == start +void VImage::draw_flood_blob( int x, int y, std::vector ink ) throw( VError ) +{ + VImage image = *this; + Vargv _vec( "im_draw_flood_blob" ); + + _vec.data(0) = image.image(); + *((int*) _vec.data(1)) = x; + *((int*) _vec.data(2)) = y; + ((im_doublevec_object*) _vec.data(3))->n = ink.size(); + ((im_doublevec_object*) _vec.data(3))->vec = new double[ink.size()]; + for( unsigned int i = 0; i < ink.size(); i++ ) + ((im_doublevec_object*) _vec.data(3))->vec[i] = ink[i]; + _vec.call(); +} + +// im_draw_flood_other: flood image with serial from x, y while pixel == start +void VImage::draw_flood_other( VImage test, int x, int y, int serial ) throw( VError ) +{ + VImage image = *this; + Vargv _vec( "im_draw_flood_other" ); + + _vec.data(0) = image.image(); + _vec.data(1) = test.image(); + *((int*) _vec.data(2)) = x; + *((int*) _vec.data(3)) = y; + *((int*) _vec.data(4)) = serial; + _vec.call(); +} + +// im_draw_image: draw image sub inside image main at position (x,y) +void VImage::draw_image( VImage sub, int x, int y ) throw( VError ) +{ + VImage image = *this; + Vargv _vec( "im_draw_image" ); + + _vec.data(0) = image.image(); + _vec.data(1) = sub.image(); + *((int*) _vec.data(2)) = x; + *((int*) _vec.data(3)) = y; + _vec.call(); +} + +// im_draw_mask: draw mask sub inside image main at position (x,y) +void VImage::draw_mask( VImage mask, int x, int y, std::vector ink ) throw( VError ) +{ + VImage image = *this; + Vargv _vec( "im_draw_mask" ); + + _vec.data(0) = image.image(); + _vec.data(1) = mask.image(); + *((int*) _vec.data(2)) = x; + *((int*) _vec.data(3)) = 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(); +} + +// im_lineset: draw line between points (x1,y1) and (x2,y2) +VImage VImage::line( VImage mask, VImage ink, std::vector x1, std::vector y1, std::vector x2, std::vector 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.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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.34.0-Tue Jun 11 11:18:24 BST 2013 + +// bodies for package morphology +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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 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 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.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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_sines: generate 2D sine image +VImage VImage::sines( int xsize, int ysize, double horfreq, double verfreq ) throw( VError ) +{ + VImage out; + + Vargv _vec( "im_sines" ); + + _vec.data(0) = out.image(); + *((int*) _vec.data(1)) = xsize; + *((int*) _vec.data(2)) = ysize; + *((double*) _vec.data(3)) = horfreq; + *((double*) _vec.data(4)) = verfreq; + _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 resample +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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 ); +} + +// im_affinei: affine transform +VImage VImage::affinei( char* interpolate, 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_affinei" ); + + _vec.data(0) = in.image(); + _vec.data(1) = out.image(); + if( vips__input_interpolate_init( &_vec.data(2), interpolate ) ) + verror(); + *((double*) _vec.data(3)) = a; + *((double*) _vec.data(4)) = b; + *((double*) _vec.data(5)) = c; + *((double*) _vec.data(6)) = d; + *((double*) _vec.data(7)) = dx; + *((double*) _vec.data(8)) = dy; + *((int*) _vec.data(9)) = x; + *((int*) _vec.data(10)) = y; + *((int*) _vec.data(11)) = w; + *((int*) _vec.data(12)) = h; + _vec.call(); + out._ref->addref( in._ref ); + + return( out ); +} + +// im_affinei_all: affine transform of whole image +VImage VImage::affinei_all( char* interpolate, double a, double b, double c, double d, double dx, double dy ) throw( VError ) +{ + VImage in = *this; + VImage out; + + Vargv _vec( "im_affinei_all" ); + + _vec.data(0) = in.image(); + _vec.data(1) = out.image(); + if( vips__input_interpolate_init( &_vec.data(2), interpolate ) ) + verror(); + *((double*) _vec.data(3)) = a; + *((double*) _vec.data(4)) = b; + *((double*) _vec.data(5)) = c; + *((double*) _vec.data(6)) = d; + *((double*) _vec.data(7)) = dx; + *((double*) _vec.data(8)) = dy; + _vec.call(); + out._ref->addref( in._ref ); + + return( out ); +} + + +// bodies for package video +// this file automatically generated from +// VIPS library 7.34.0-Tue Jun 11 11:18:24 BST 2013 +// 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 ); +} + +