sergiotarxz
/
libvips
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' into region-shrink-method

This commit is contained in:
John Cupitt 2018-06-13 17:13:16 +01:00 committed by GitHub
parent b752d2e442 539cc0616c
commit 2c7684669f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
196 changed files with 2075 additions and 1332 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
ChangeLog
View File

@ -20,11 +20,24 @@
chrominance subsampling.
- tiffload, pdfload, magickload set VIPS_META_N_PAGES "n-pages" metadata item
- add fontfile option to vips_text() [fangqiao]
- add vips_transpose3d() -- swap major dimensions in a volumetric image
- remove vips7 stuff from default API ... you must now #include it explicitly
- added vips_argument_get_id() to fix derived classes on win32 [angelmixu]
- fix compile with MSVC 2017 [angelmixu]
- pdfload has a option for background
- vips7 C++ interface defaults off
- make members, getters and operators "const" in cpp API
- composite has params for x/y position of sub-images [medakk]
- add Mitchell kernel
12/3/18 started 8.6.4
- better fitting of fonts with overhanging edges [Adrià]
- revise C++ example [fangqiao]
- strict round down on jpeg shrink on load [davidwood]
- configure test for g++ 7.2 and composite.cpp
- don't Ping in magickload, too unreliable
- ensure WebP can add metadata when compiled with libwebpmux [lovell]
- improve accuracy of vector path convolution [felixbuenemann]
12/2/18 started 8.6.3
- use pkg-config to find libjpeg, if we can

20
Makefile.am
View File

@ -1,5 +1,5 @@
# turn on Python if we can
# build deprecated vips7 Python interface
if HAVE_PYTHON
P_COMPILE_DIR = swig
P_DIST_DIR =
@ -8,7 +8,7 @@ P_COMPILE_DIR =
P_DIST_DIR = swig
endif
# turn on vips8 Python if we can
# build deprecated vips8 Python interface
if ENABLE_PYVIPS8
P8_COMPILE_DIR = python
P8_DIST_DIR =
@ -17,15 +17,26 @@ P8_COMPILE_DIR =
P8_DIST_DIR = python
endif
# build deprecated vips7 C++ API
if ENABLE_CPP7
CPP7_COMPILE_DIR = libvipsCC
CPP7_DIST_DIR =
CPP7_PKG = vipsCC.pc
else
CPP7_COMPILE_DIR =
CPP7_DIST_DIR = libvipsCC
CPP7_PKG =
endif
SUBDIRS = \
libvips \
libvipsCC \
cplusplus \
tools \
po \
man \
doc \
test \
$(CPP7_COMPILE_DIR) \
$(P_COMPILE_DIR) \
$(P8_COMPILE_DIR)
@ -39,11 +50,12 @@ EXTRA_DIST = \
libvips.supp \
depcomp \
README.md \
$(CPP7_DIST_DIR) \
$(P_DIST_DIR) \
$(P8_DIST_DIR)
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = vips.pc vipsCC.pc vips-cpp.pc
pkgconfig_DATA = vips.pc $(CPP7_PKG) vips-cpp.pc
dist-hook:
# make sure we don't get any .svn dirs from EXTRA_DIST

15
README.md
View File

@ -50,9 +50,6 @@ Check the summary at the end of `configure` carefully.
libvips must have `build-essential`, `pkg-config`, `glib2.0-dev`,
`libexpat1-dev`.
For the vips8 Python binding, you must also have
`gobject-introspection`, `python-gi-dev`, and `libgirepository1.0-dev`.
You'll need the dev packages for the file format support you
want. For basic jpeg and tiff support, you'll need `libtiff5-dev`,
`libjpeg-turbo8-dev`, and `libgsf-1-dev`. See the **Dependencies** section
@ -179,11 +176,6 @@ or perhaps:
to get libvips to see your builds.
### vips8 Python binding
If `gobject-introspection`, `python-gi-dev`, and `libgirepository1.0-dev` are
available, libvips will install the vips8 Python binding.
### libjpeg
The IJG JPEG library. Use the `-turbo` version if you can.
@ -250,8 +242,7 @@ image file types. Use `--with-magickpackage=GraphicsMagick` to build against
graphicsmagick instead.
Imagemagick 6.9+ needs to have been built with `--with-modules`. Most packaged
IMs are, I think, but if you are rolling your own, you'll need to pass
this flag to configure.
IMs are, I think.
If you are going to be using libvips with untrusted images, perhaps in a
web-server, for example, you should consider the security implications of
@ -290,10 +281,6 @@ OpenEXR images.
If available, libvips can load OpenSlide-supported virtual slide
files: Aperio, Hamamatsu, Leica, MIRAX, Sakura, Trestle, and Ventana.
### swig, python, python-dev
If available, we build the vips7 python binding.
# Disclaimer
No guarantees of performance accompany this software, nor is any

73
configure.ac
View File

@ -416,6 +416,30 @@ if test x$have_vector_shuffle = x"yes"; then
have_vector_arith=no
])
AC_LANG_POP([C++])
fi
# gcc 7.2 seems to work, but then gets confused by signed constants in
# templates
if test x$have_vector_arith = x"yes"; then
AC_MSG_CHECKING([for C++ signed constants in vector templates])
AC_LANG_PUSH([C++])
AC_TRY_COMPILE([
typedef float v4f __attribute__((vector_size(4 * sizeof(float))));
template <typename T>
static void
h( v4f B )
{
v4f f;
f = -1 * B;
}
],[
],[
AC_MSG_RESULT([yes])
], [
AC_MSG_RESULT([no])
have_vector_arith=no
])
AC_LANG_POP([C++])
if test x$have_vector_arith = x"yes"; then
AC_DEFINE_UNQUOTED(HAVE_VECTOR_ARITH, 1,
@ -502,6 +526,19 @@ if test x$expat_found = xno; then
exit 1
fi
# enable vips7 C++ binding ... this defaults off, the vips8 C++ binding
# defaults on
AC_ARG_ENABLE([cpp7],
AS_HELP_STRING([--enable-cpp7],
[enable deprecated vips7 C++ binding (default: no)]),
[enable_cpp7=$enableval
AM_CONDITIONAL(ENABLE_CPP7, true)
],
[enable_cpp7="no (default)"
AM_CONDITIONAL(ENABLE_CPP7, false)
]
)
# optional supporting libraries
AC_ARG_WITH([gsf],
@ -658,8 +695,7 @@ if test x"$magick6" = x"yes"; then
fi
if test x"$magick6" = x"yes"; then
# do we have number_scenes in image_info ... imagemagick uses this, gm
# still uses subrange
# do we have number_scenes in image_info ... imagemagick uses this
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $MAGICK_CFLAGS"
AC_CHECK_MEMBER([struct _ImageInfo.number_scenes],
@ -720,6 +756,21 @@ AC_ARG_ENABLE([magicksave],
AS_HELP_STRING([--disable-magicksave],
[disable libMagic save (default: enabled)]))
if test x"$enable_magicksave" != x"yes"; then
# we need ImportImagePixels ... GM is missing this sadly
save_LIBS="$LIBS"
LIBS="$LIBS $MAGICK_LIBS"
AC_CHECK_FUNCS(ImportImagePixels,[
AC_DEFINE(HAVE_IMPORTIMAGEPIXELS,1,
[define if you have ImportImagePixels.])
],[
AC_MSG_WARN([ImportImagePixels not found; disabling magicksave])
enable_magicksave=no
]
)
LIBS="$save_LIBS"
fi
if test x"$with_magick" != x"no"; then
if test x"$enable_magickload" != x"no"; then
AC_DEFINE(ENABLE_MAGICKLOAD,1,[define to enable load with libMagick])
@ -1209,7 +1260,7 @@ fi
# Gather all up for VIPS_CFLAGS, VIPS_INCLUDES, VIPS_LIBS
# sort includes to get longer, more specific dirs first
# helps, for example, selecting graphicsmagick over imagemagick
VIPS_CFLAGS=`for i in $VIPS_CFLAGS $GTHREAD_CFLAGS $REQUIRED_CFLAGS $EXPAT_CFLAGS $ZLIB_CFLAGS $PANGOFT2_CFLAGS $GSF_CFLAGS $FFTW_CFLAGS $MAGICK_CFLAGS $PNG_CFLAGS $EXIF_CFLAGS $MATIO_CFLAGS $CFITSIO_CFLAGS $LIBWEBP_CFLAGS $LIBWEBPMUX_CFLAGS $GIFLIB_INCLUDES $RSVG_CFLAGS $PDFIUM_INCLUDES $POPPLER_CFLAGS $OPENEXR_CFLAGS $OPENSLIDE_CFLAGS $ORC_CFLAGS $TIFF_CFLAGS $LCMS_CFLAGS
VIPS_CFLAGS=`for i in $VIPS_CFLAGS $GTHREAD_CFLAGS $REQUIRED_CFLAGS $EXPAT_CFLAGS $ZLIB_CFLAGS $PANGOFT2_CFLAGS $GSF_CFLAGS $FFTW_CFLAGS $MAGICK_CFLAGS $JPEG_CFLAGS $PNG_CFLAGS $EXIF_CFLAGS $MATIO_CFLAGS $CFITSIO_CFLAGS $LIBWEBP_CFLAGS $LIBWEBPMUX_CFLAGS $GIFLIB_INCLUDES $RSVG_CFLAGS $PDFIUM_INCLUDES $POPPLER_CFLAGS $OPENEXR_CFLAGS $OPENSLIDE_CFLAGS $ORC_CFLAGS $TIFF_CFLAGS $LCMS_CFLAGS
do
echo $i
done | sort -ru`
@ -1254,7 +1305,6 @@ AC_OUTPUT([
libvips/mosaicing/Makefile
libvips/create/Makefile
libvips/resample/Makefile
libvips/video/Makefile
libvipsCC/include/Makefile
libvipsCC/include/vips/Makefile
libvipsCC/Makefile
@ -1287,15 +1337,16 @@ native win32: $vips_os_win32
native OS X: $vips_os_darwin
open files in binary mode: $vips_binary_open
enable debug: $enable_debug
build deprecated components: $enable_deprecated
build docs with gtkdoc: $enable_gtk_doc
enable deprecated library components: $enable_deprecated
enable docs with gtkdoc: $enable_gtk_doc
gobject introspection: $found_introspection
build vips7 Python binding: $enable_pyvips7
install vips8 Python overrides: $enable_pyvips8
enable vips7 C++ API: $enable_cpp7
enable vips7 Python binding: $enable_pyvips7
enable vips8 Python overrides: $enable_pyvips8
(requires pygobject-3.13.0 or later)
build radiance support: $with_radiance
build analyze support: $with_analyze
build PPM support: $with_ppm
enable radiance support: $with_radiance
enable analyze support: $with_analyze
enable PPM support: $with_ppm
* optional dependencies
use fftw3 for FFT: $with_fftw

190
cplusplus/VImage.cpp
View File

@ -613,7 +613,7 @@ VImage::new_matrixv( int width, int height, ... )
}
VImage
VImage::write( VImage out )
VImage::write( VImage out ) const
{
if( vips_image_write( this->get_image(), out.get_image() ) )
throw VError();
@ -622,7 +622,7 @@ VImage::write( VImage out )
}
void
VImage::write_to_file( const char *name, VOption *options )
VImage::write_to_file( const char *name, VOption *options ) const
{
char filename[VIPS_PATH_MAX];
char option_string[VIPS_PATH_MAX];
@ -642,7 +642,7 @@ VImage::write_to_file( const char *name, VOption *options )
void
VImage::write_to_buffer( const char *suffix, void **buf, size_t *size,
VOption *options )
VOption *options ) const
{
char filename[VIPS_PATH_MAX];
char option_string[VIPS_PATH_MAX];
@ -675,7 +675,7 @@ VImage::write_to_buffer( const char *suffix, void **buf, size_t *size,
#include "vips-operators.cpp"
std::vector<VImage>
VImage::bandsplit( VOption *options )
VImage::bandsplit( VOption *options ) const
{
std::vector<VImage> b;
@ -686,7 +686,7 @@ VImage::bandsplit( VOption *options )
}
VImage
VImage::bandjoin( VImage other, VOption *options )
VImage::bandjoin( VImage other, VOption *options ) const
{
VImage v[2] = { *this, other };
std::vector<VImage> vec( v, v + VIPS_NUMBER( v ) );
@ -695,7 +695,7 @@ VImage::bandjoin( VImage other, VOption *options )
}
VImage
VImage::composite( VImage other, VipsBlendMode mode, VOption *options )
VImage::composite( VImage other, VipsBlendMode mode, VOption *options ) const
{
VImage v[2] = { *this, other };
std::vector<VImage> ivec( v, v + VIPS_NUMBER( v ) );
@ -706,7 +706,7 @@ VImage::composite( VImage other, VipsBlendMode mode, VOption *options )
}
std::complex<double>
VImage::minpos( VOption *options )
VImage::minpos( VOption *options ) const
{
double x, y;
@ -719,7 +719,7 @@ VImage::minpos( VOption *options )
}
std::complex<double>
VImage::maxpos( VOption *options )
VImage::maxpos( VOption *options ) const
{
double x, y;
@ -734,43 +734,43 @@ VImage::maxpos( VOption *options )
// Operator overloads
VImage
VImage::operator[]( int index )
VImage::operator[]( int index ) const
{
return( this->extract_band( index ) );
}
std::vector<double>
VImage::operator()( int x, int y )
VImage::operator()( int x, int y ) const
{
return( this->getpoint( x, y ) );
}
VImage
operator+( VImage a, VImage b )
operator+( const VImage a, const VImage b )
{
return( a.add( b ) );
}
VImage
operator+( double a, VImage b )
operator+( double a, const VImage b )
{
return( b.linear( 1.0, a ) );
}
VImage
operator+( VImage a, double b )
operator+( const VImage a, double b )
{
return( a.linear( 1.0, b ) );
}
VImage
operator+( std::vector<double> a, VImage b )
operator+( const std::vector<double> a, const VImage b )
{
return( b.linear( 1.0, a ) );
}
VImage
operator+( VImage a, std::vector<double> b )
operator+( const VImage a, const std::vector<double> b )
{
return( a.linear( 1.0, b ) );
}
@ -788,37 +788,37 @@ operator+=( VImage &a, const double b )
}
VImage &
operator+=( VImage &a, std::vector<double> b )
operator+=( VImage &a, const std::vector<double> b )
{
return( a = a + b );
}
VImage
operator-( VImage a, VImage b )
operator-( const VImage a, const VImage b )
{
return( a.subtract( b ) );
}
VImage
operator-( double a, VImage b )
operator-( double a, const VImage b )
{
return( b.linear( -1.0, a ) );
}
VImage
operator-( VImage a, double b )
operator-( const VImage a, double b )
{
return( a.linear( 1.0, -b ) );
}
VImage
operator-( std::vector<double> a, VImage b )
operator-( const std::vector<double> a, const VImage b )
{
return( b.linear( -1.0, a ) );
}
VImage
operator-( VImage a, std::vector<double> b )
operator-( const VImage a, const std::vector<double> b )
{
return( a.linear( 1.0, vips::negate( b ) ) );
}
@ -836,43 +836,43 @@ operator-=( VImage &a, const double b )
}
VImage &
operator-=( VImage &a, std::vector<double> b )
operator-=( VImage &a, const std::vector<double> b )
{
return( a = a - b );
}
VImage
operator-( VImage a )
operator-( const VImage a )
{
return( a * -1 );
}
VImage
operator*( VImage a, VImage b )
operator*( const VImage a, const VImage b )
{
return( a.multiply( b ) );
}
VImage
operator*( double a, VImage b )
operator*( double a, const VImage b )
{
return( b.linear( a, 0.0 ) );
}
VImage
operator*( VImage a, double b )
operator*( const VImage a, double b )
{
return( a.linear( b, 0.0 ) );
}
VImage
operator*( std::vector<double> a, VImage b )
operator*( const std::vector<double> a, const VImage b )
{
return( b.linear( a, 0.0 ) );
}
VImage
operator*( VImage a, std::vector<double> b )
operator*( const VImage a, const std::vector<double> b )
{
return( a.linear( b, 0.0 ) );
}
@ -890,37 +890,37 @@ operator*=( VImage &a, const double b )
}
VImage &
operator*=( VImage &a, std::vector<double> b )
operator*=( VImage &a, const std::vector<double> b )
{
return( a = a * b );
}
VImage
operator/( VImage a, VImage b )
operator/( const VImage a, const VImage b )
{
return( a.divide( b ) );
}
VImage
operator/( double a, VImage b )
operator/( double a, const VImage b )
{
return( b.pow( -1.0 ).linear( a, 0.0 ) );
}
VImage
operator/( VImage a, double b )
operator/( const VImage a, double b )
{
return( a.linear( 1.0 / b, 0.0 ) );
}
VImage
operator/( std::vector<double> a, VImage b )
operator/( const std::vector<double> a, const VImage b )
{
return( b.pow( -1.0 ).linear( a, 0.0 ) );
}
VImage
operator/( VImage a, std::vector<double> b )
operator/( const VImage a, const std::vector<double> b )
{
return( a.linear( vips::invert( b ), 0.0 ) );
}
@ -938,25 +938,25 @@ operator/=( VImage &a, const double b )
}
VImage &
operator/=( VImage &a, std::vector<double> b )
operator/=( VImage &a, const std::vector<double> b )
{
return( a = a / b );
}
VImage
operator%( VImage a, VImage b )
operator%( const VImage a, const VImage b )
{
return( a.remainder( b ) );
}
VImage
operator%( VImage a, double b )
operator%( const VImage a, const double b )
{
return( a.remainder_const( to_vector( b ) ) );
}
VImage
operator%( VImage a, std::vector<double> b )
operator%( const VImage a, const std::vector<double> b )
{
return( a.remainder_const( b ) );
}
@ -974,243 +974,243 @@ operator%=( VImage &a, const double b )
}
VImage &
operator%=( VImage &a, std::vector<double> b )
operator%=( VImage &a, const std::vector<double> b )
{
return( a = a % b );
}
VImage
operator<( VImage a, VImage b )
operator<( const VImage a, const VImage b )
{
return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESS ) );
}
VImage
operator<( double a, VImage b )
operator<( const double a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
to_vector( a ) ) );
}
VImage
operator<( VImage a, double b )
operator<( const VImage a, const double b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
to_vector( b ) ) );
}
VImage
operator<( std::vector<double> a, VImage b )
operator<( const std::vector<double> a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
a ) );
}
VImage
operator<( VImage a, std::vector<double> b )
operator<( const VImage a, const std::vector<double> b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
b ) );
}
VImage
operator<=( VImage a, VImage b )
operator<=( const VImage a, const VImage b )
{
return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESSEQ ) );
}
VImage
operator<=( double a, VImage b )
operator<=( const double a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
to_vector( a ) ) );
}
VImage
operator<=( VImage a, double b )
operator<=( const VImage a, const double b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
to_vector( b ) ) );
}
VImage
operator<=( std::vector<double> a, VImage b )
operator<=( const std::vector<double> a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
a ) );
}
VImage
operator<=( VImage a, std::vector<double> b )
operator<=( const VImage a, const std::vector<double> b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
b ) );
}
VImage
operator>( VImage a, VImage b )
operator>( const VImage a, const VImage b )
{
return( a.relational( b, VIPS_OPERATION_RELATIONAL_MORE ) );
}
VImage
operator>( double a, VImage b )
operator>( const double a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
to_vector( a ) ) );
}
VImage
operator>( VImage a, double b )
operator>( const VImage a, const double b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
to_vector( b ) ) );
}
VImage
operator>( std::vector<double> a, VImage b )
operator>( const std::vector<double> a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
a ) );
}
VImage
operator>( VImage a, std::vector<double> b )
operator>( const VImage a, const std::vector<double> b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
b ) );
}
VImage
operator>=( VImage a, VImage b )
operator>=( const VImage a, const VImage b )
{
return( a.relational( b, VIPS_OPERATION_RELATIONAL_MOREEQ ) );
}
VImage
operator>=( double a, VImage b )
operator>=( const double a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
to_vector( a ) ) );
}
VImage
operator>=( VImage a, double b )
operator>=( const VImage a, const double b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
to_vector( b ) ) );
}
VImage
operator>=( std::vector<double> a, VImage b )
operator>=( const std::vector<double> a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
a ) );
}
VImage
operator>=( VImage a, std::vector<double> b )
operator>=( const VImage a, const std::vector<double> b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
b ) );
}
VImage
operator==( VImage a, VImage b )
operator==( const VImage a, const VImage b )
{
return( a.relational( b, VIPS_OPERATION_RELATIONAL_EQUAL ) );
}
VImage
operator==( double a, VImage b )
operator==( const double a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
to_vector( a ) ) );
}
VImage
operator==( VImage a, double b )
operator==( const VImage a, const double b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
to_vector( b ) ) );
}
VImage
operator==( std::vector<double> a, VImage b )
operator==( const std::vector<double> a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
a ) );
}
VImage
operator==( VImage a, std::vector<double> b )
operator==( const VImage a, const std::vector<double> b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
b ) );
}
VImage
operator!=( VImage a, VImage b )
operator!=( const VImage a, const VImage b )
{
return( a.relational( b, VIPS_OPERATION_RELATIONAL_NOTEQ ) );
}
VImage
operator!=( double a, VImage b )
operator!=( const double a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
to_vector( a ) ) );
}
VImage
operator!=( VImage a, double b )
operator!=( const VImage a, const double b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
to_vector( b ) ) );
}
VImage
operator!=( std::vector<double> a, VImage b )
operator!=( const std::vector<double> a, const VImage b )
{
return( b.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
a ) );
}
VImage
operator!=( VImage a, std::vector<double> b )
operator!=( const VImage a, const std::vector<double> b )
{
return( a.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
b ) );
}
VImage
operator&( VImage a, VImage b )
operator&( const VImage a, const VImage b )
{
return( a.boolean( b, VIPS_OPERATION_BOOLEAN_AND ) );
}
VImage
operator&( double a, VImage b )
operator&( const double a, const VImage b )
{
return( b.boolean_const( VIPS_OPERATION_BOOLEAN_AND,
to_vector( a ) ) );
}
VImage
operator&( VImage a, double b )
operator&( const VImage a, const double b )
{
return( a.boolean_const( VIPS_OPERATION_BOOLEAN_AND,
to_vector( b ) ) );
}
VImage
operator&( std::vector<double> a, VImage b )
operator&( const std::vector<double> a, const VImage b )
{
return( b.boolean_const( VIPS_OPERATION_BOOLEAN_AND, a ) );
}
VImage
operator&( VImage a, std::vector<double> b )
operator&( const VImage a, const std::vector<double> b )
{
return( a.boolean_const( VIPS_OPERATION_BOOLEAN_AND, b ) );
}
@ -1228,40 +1228,40 @@ operator&=( VImage &a, const double b )
}
VImage &
operator&=( VImage &a, std::vector<double> b )
operator&=( VImage &a, const std::vector<double> b )
{
return( a = a & b );
}
VImage
operator|( VImage a, VImage b )
operator|( const VImage a, const VImage b )
{
return( a.boolean( b, VIPS_OPERATION_BOOLEAN_OR ) );
}
VImage
operator|( double a, VImage b )
operator|( const double a, const VImage b )
{
return( b.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
to_vector( a ) ) );
}
VImage
operator|( VImage a, double b )
operator|( const VImage a, const double b )
{
return( a.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
to_vector( b ) ) );
}
VImage
operator|( std::vector<double> a, VImage b )
operator|( const std::vector<double> a, const VImage b )
{
return( b.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
a ) );
}
VImage
operator|( VImage a, std::vector<double> b )
operator|( const VImage a, const std::vector<double> b )
{
return( a.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
b ) );
@ -1280,40 +1280,40 @@ operator|=( VImage &a, const double b )
}
VImage &
operator|=( VImage &a, std::vector<double> b )
operator|=( VImage &a, const std::vector<double> b )
{
return( a = a | b );
}
VImage
operator^( VImage a, VImage b )
operator^( const VImage a, const VImage b )
{
return( a.boolean( b, VIPS_OPERATION_BOOLEAN_EOR ) );
}
VImage
operator^( double a, VImage b )
operator^( const double a, const VImage b )
{
return( b.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
to_vector( a ) ) );
}
VImage
operator^( VImage a, double b )
operator^( const VImage a, const double b )
{
return( a.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
to_vector( b ) ) );
}
VImage
operator^( std::vector<double> a, VImage b )
operator^( const std::vector<double> a, const VImage b )
{
return( b.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
a ) );
}
VImage
operator^( VImage a, std::vector<double> b )
operator^( const VImage a, const std::vector<double> b )
{
return( a.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
b ) );
@ -1332,26 +1332,26 @@ operator^=( VImage &a, const double b )
}
VImage &
operator^=( VImage &a, std::vector<double> b )
operator^=( VImage &a, const std::vector<double> b )
{
return( a = a ^ b );
}
VImage
operator<<( VImage a, VImage b )
operator<<( const VImage a, const VImage b )
{
return( a.boolean( b, VIPS_OPERATION_BOOLEAN_LSHIFT ) );
}
VImage
operator<<( VImage a, double b )
operator<<( const VImage a, const double b )
{
return( a.boolean_const( VIPS_OPERATION_BOOLEAN_LSHIFT,
to_vector( b ) ) );
}
VImage
operator<<( VImage a, std::vector<double> b )
operator<<( const VImage a, const std::vector<double> b )
{
return( a.boolean_const( VIPS_OPERATION_BOOLEAN_LSHIFT,
b ) );
@ -1370,26 +1370,26 @@ operator<<=( VImage &a, const double b )
}
VImage &
operator<<=( VImage &a, std::vector<double> b )
operator<<=( VImage &a, const std::vector<double> b )
{
return( a = a << b );
}
VImage
operator>>( VImage a, VImage b )
operator>>( const VImage a, const VImage b )
{
return( a.boolean( b, VIPS_OPERATION_BOOLEAN_RSHIFT ) );
}
VImage
operator>>( VImage a, double b )
operator>>( const VImage a, const double b )
{
return( a.boolean_const( VIPS_OPERATION_BOOLEAN_RSHIFT,
to_vector( b ) ) );
}
VImage
operator>>( VImage a, std::vector<double> b )
operator>>( const VImage a, const std::vector<double> b )
{
return( a.boolean_const( VIPS_OPERATION_BOOLEAN_RSHIFT,
b ) );
@ -1408,7 +1408,7 @@ operator>>=( VImage &a, const double b )
}
VImage &
operator>>=( VImage &a, std::vector<double> b )
operator>>=( VImage &a, const std::vector<double> b )
{
return( a = a << b );
}

24
cplusplus/examples/avg.cpp
View File

@ -14,38 +14,16 @@ using namespace vips;
int
main( int argc, char **argv )
{
GOptionContext *context;
GOptionGroup *main_group;
GError *error = NULL;
if( vips_init( argv[0] ) )
vips_error_exit( NULL );
context = g_option_context_new( "" );
main_group = g_option_group_new( NULL, NULL, NULL, NULL, NULL );
g_option_context_set_main_group( context, main_group );
g_option_context_add_group( context, vips_get_option_group() );
if( !g_option_context_parse( context, &argc, &argv, &error ) ) {
if( error ) {
fprintf( stderr, "%s\n", error->message );
g_error_free( error );
}
vips_error_exit( NULL );
}
{
VImage in = VImage::new_from_file( argv[1],
VImage::option()->set( "access", VIPS_ACCESS_SEQUENTIAL_UNBUFFERED ) );
VImage::option()->set( "access", VIPS_ACCESS_SEQUENTIAL ) );
double avg;
avg = in.avg();
printf( "avg = %g\n", avg );
}
vips_shutdown();

19
cplusplus/examples/buffer.cpp
View File

@ -14,28 +14,9 @@ using namespace vips;
int
main( int argc, char **argv )
{
GOptionContext *context;
GOptionGroup *main_group;
GError *error = NULL;
if( VIPS_INIT( argv[0] ) )
vips_error_exit( NULL );
context = g_option_context_new( "" );
main_group = g_option_group_new( NULL, NULL, NULL, NULL, NULL );
g_option_context_set_main_group( context, main_group );
g_option_context_add_group( context, vips_get_option_group() );
if( !g_option_context_parse( context, &argc, &argv, &error ) ) {
if( error ) {
fprintf( stderr, "%s\n", error->message );
g_error_free( error );
}
vips_error_exit( NULL );
}
// load an image from a file
VImage im = VImage::new_from_file( argv[1],
VImage::option()->set( "access", "sequential" ) );

26
cplusplus/examples/embed.cpp
View File

@ -14,38 +14,16 @@ using namespace vips;
int
main( int argc, char **argv )
{
GOptionContext *context;
GOptionGroup *main_group;
GError *error = NULL;
if( vips_init( argv[0] ) )
vips_error_exit( NULL );
context = g_option_context_new( "" );
main_group = g_option_group_new( NULL, NULL, NULL, NULL, NULL );
g_option_context_set_main_group( context, main_group );
g_option_context_add_group( context, vips_get_option_group() );
if( !g_option_context_parse( context, &argc, &argv, &error ) ) {
if( error ) {
fprintf( stderr, "%s\n", error->message );
g_error_free( error );
}
vips_error_exit( NULL );
}
{
VImage in = VImage::new_from_file( argv[1],
VImage::option()->set( "access", VIPS_ACCESS_SEQUENTIAL_UNBUFFERED ) );
VImage::option()->set( "access", "sequential" ) );
VImage out = in.embed( 10, 10, 1000, 1000,
VImage::option()->set( "extend", VIPS_EXTEND_COPY ) );
VImage::option()->set( "extend", "copy" ) );
out.write_to_file( argv[2] );
}
vips_shutdown();

24
cplusplus/examples/invert.cpp
View File

@ -14,43 +14,21 @@ using namespace vips;
int
main( int argc, char **argv )
{
GOptionContext *context;
GOptionGroup *main_group;
GError *error = NULL;
if( vips_init( argv[0] ) )
vips_error_exit( NULL );
context = g_option_context_new( "" );
main_group = g_option_group_new( NULL, NULL, NULL, NULL, NULL );
g_option_context_set_main_group( context, main_group );
g_option_context_add_group( context, vips_get_option_group() );
if( !g_option_context_parse( context, &argc, &argv, &error ) ) {
if( error ) {
fprintf( stderr, "%s\n", error->message );
g_error_free( error );
}
vips_error_exit( NULL );
}
printf( "these should match if VImage is compile-time-only\n" );
printf( "sizeof( VipsImage *) = %zd\n", sizeof( VipsImage *) );
printf( "sizeof( VImage ) = %zd\n", sizeof( VImage ) );
{
VImage in = VImage::new_from_file( argv[1],
VImage::option()->set( "access", VIPS_ACCESS_SEQUENTIAL_UNBUFFERED ) );
VImage::option()->set( "access", VIPS_ACCESS_SEQUENTIAL ) );
VImage out;
out = in.invert();
out.write_to_file( argv[2] );
}
vips_shutdown();

22
cplusplus/examples/profile.cpp
View File

@ -14,30 +14,9 @@ using namespace vips;
int
main( int argc, char **argv )
{
GOptionContext *context;
GOptionGroup *main_group;
GError *error = NULL;
if( vips_init( argv[0] ) )
vips_error_exit( NULL );
context = g_option_context_new( "" );
main_group = g_option_group_new( NULL, NULL, NULL, NULL, NULL );
g_option_context_set_main_group( context, main_group );
g_option_context_add_group( context, vips_get_option_group() );
if( !g_option_context_parse( context, &argc, &argv, &error ) ) {
if( error ) {
fprintf( stderr, "%s\n", error->message );
g_error_free( error );
}
vips_error_exit( NULL );
}
{
VImage in = VImage::new_from_file( argv[1] );
VImage rows;
@ -45,7 +24,6 @@ main( int argc, char **argv )
rows.write_to_file( argv[2] );
cols.write_to_file( argv[3] );
}
vips_shutdown();

21
cplusplus/examples/resize.cpp
View File

@ -14,29 +14,9 @@ using namespace vips;
int
main( int argc, char **argv )
{
GOptionContext *context;
GOptionGroup *main_group;
GError *error = NULL;
if( vips_init( argv[0] ) )
vips_error_exit( NULL );
context = g_option_context_new( "" );
main_group = g_option_group_new( NULL, NULL, NULL, NULL, NULL );
g_option_context_set_main_group( context, main_group );
g_option_context_add_group( context, vips_get_option_group() );
if( !g_option_context_parse( context, &argc, &argv, &error ) ) {
if( error ) {
fprintf( stderr, "%s\n", error->message );
g_error_free( error );
}
vips_error_exit( NULL );
}
{
VImage in = VImage::new_from_file( argv[1],
VImage::option()->set( "access", VIPS_ACCESS_SEQUENTIAL ) );
VInterpolate interp = VInterpolate::new_from_name( "nohalo" );
@ -46,7 +26,6 @@ main( int argc, char **argv )
out = in.resize( 0.2, VImage::option()->set( "interpolate", interp ) );
out.write_to_file( argv[2] );
}
vips_shutdown();

21
cplusplus/examples/test.cpp
View File

@ -242,30 +242,9 @@ TEST_BINARY( test_divide );
int
main( int argc, char **argv )
{
GOptionContext *context;
GOptionGroup *main_group;
GError *error = NULL;
if( VIPS_INIT( argv[0] ) )
vips_error_exit( NULL );
context = g_option_context_new( "" );
main_group = g_option_group_new( NULL, NULL, NULL, NULL, NULL );
g_option_context_set_main_group( context, main_group );
g_option_context_add_group( context, vips_get_option_group() );
if( !g_option_context_parse( context, &argc, &argv, &error ) ) {
if( error ) {
fprintf( stderr, "%s\n", error->message );
g_error_free( error );
}
vips_error_exit( NULL );
}
g_option_context_free( context );
VImage left = VImage::new_from_file( argv[1] );
VImage right = VImage::new_from_file( argv[2] );

23
cplusplus/examples/test_overloads.cpp
View File

@ -366,31 +366,9 @@ TEST_ASSIGNMENT( test_divideequals );
int
main( int argc, char **argv )
{
GOptionContext *context;
GOptionGroup *main_group;
GError *error = NULL;
if( VIPS_INIT( argv[0] ) )
vips_error_exit( NULL );
context = g_option_context_new( "" );
main_group = g_option_group_new( NULL, NULL, NULL, NULL, NULL );
g_option_context_set_main_group( context, main_group );
g_option_context_add_group( context, vips_get_option_group() );
if( !g_option_context_parse( context, &argc, &argv, &error ) ) {
if( error ) {
fprintf( stderr, "%s\n", error->message );
g_error_free( error );
}
vips_error_exit( NULL );
}
g_option_context_free( context );
{
VImage left = VImage::new_from_file( argv[1] );
VImage right = VImage::new_from_file( argv[2] );
@ -406,7 +384,6 @@ main( int argc, char **argv )
test_assignment_test_minusequals( left, right );
test_assignment_test_timesequals( left, right );
test_assignment_test_divideequals( left, right );
}
vips_shutdown();

6
cplusplus/gen-operators.py
View File

@ -152,7 +152,11 @@ def gen_operation(cls):
gen_arg_list(op, required)
print ')'
print ')',
if this != None:
print 'const',
print
print '{'
if result != None:
print ' %s %s;' % (get_ctype(result), cppize(result.name))

481
cplusplus/include/vips/VImage8.h
View File

@ -152,7 +152,7 @@ public:
g_object_unref( vobject );
}
VipsObject *get_object()
VipsObject *get_object() const
{
g_assert( !vobject ||
VIPS_IS_OBJECT( vobject ) );
@ -248,86 +248,86 @@ public:
{
}
VipsImage *
get_image()
VipsImage *
get_image() const
{
return( (VipsImage *) VObject::get_object() );
}
int
width()
width() const
{
return( vips_image_get_width( get_image() ) );
}
int
height()
height() const
{
return( vips_image_get_height( get_image() ) );
}
int
bands()
bands() const
{
return( vips_image_get_bands( get_image() ) );
}
VipsBandFormat
format()
format() const
{
return( vips_image_get_format( get_image() ) );
}
VipsCoding
coding()
coding() const
{
return( vips_image_get_coding( get_image() ) );
}
VipsInterpretation
interpretation()
interpretation() const
{
return( vips_image_get_interpretation( get_image() ) );
}
VipsInterpretation
guess_interpretation()
guess_interpretation() const
{
return( vips_image_guess_interpretation( get_image() ) );
}
double
xres()
xres() const
{
return( vips_image_get_xres( get_image() ) );
}
double
yres()
yres() const
{
return( vips_image_get_yres( get_image() ) );
}
int
xoffset()
xoffset() const
{
return( vips_image_get_xoffset( get_image() ) );
}
int
yoffset()
yoffset() const
{
return( vips_image_get_yoffset( get_image() ) );
}
const char *
filename()
filename() const
{
return( vips_image_get_filename( get_image() ) );
}
const void *
data()
data() const
{
return( vips_image_get_data( get_image() ) );
}
@ -359,13 +359,13 @@ public:
}
GType
get_typeof( const char *field )
get_typeof( const char *field ) const
{
return( vips_image_get_typeof( this->get_image(), field ) );
}
int
get_int( const char *field )
get_int( const char *field ) const
{
int value;
@ -376,7 +376,7 @@ public:
}
double
get_double( const char *field )
get_double( const char *field ) const
{
double value;
@ -387,7 +387,7 @@ public:
}
const char *
get_string( const char *field )
get_string( const char *field ) const
{
const char *value;
@ -398,7 +398,7 @@ public:
}
const void *
get_blob( const char *field, size_t *length )
get_blob( const char *field, size_t *length ) const
{
void *value;
@ -438,7 +438,8 @@ public:
static VImage new_from_file( const char *name, VOption *options = 0 );
static VImage new_from_memory( void *data, size_t size,
static VImage
new_from_memory( void *data, size_t size,
int width, int height, int bands, VipsBandFormat format )
{
VipsImage *image;
@ -455,8 +456,8 @@ public:
static VImage new_matrix( int width, int height );
static VImage new_matrix( int width, int height,
double *array, int size )
static VImage
new_matrix( int width, int height, double *array, int size )
{
VipsImage *image;
@ -469,7 +470,8 @@ public:
static VImage new_matrixv( int width, int height, ... );
VImage new_from_image( std::vector<double> pixel )
VImage
new_from_image( std::vector<double> pixel ) const
{
VipsImage *image;
@ -480,19 +482,21 @@ public:
return( VImage( image ) );
}
VImage new_from_image( double pixel )
VImage
new_from_image( double pixel ) const
{
return( new_from_image( to_vectorv( 1, pixel ) ) );
}
VImage write( VImage out );
VImage write( VImage out ) const;
void write_to_file( const char *name, VOption *options = 0 );
void write_to_file( const char *name, VOption *options = 0 ) const;
void write_to_buffer( const char *suffix, void **buf, size_t *size,
VOption *options = 0 );
VOption *options = 0 ) const;
void *write_to_memory( size_t *size )
void *
write_to_memory( size_t *size ) const
{
void *result;
@ -508,279 +512,281 @@ public:
// a few useful things
VImage
linear( double a, double b, VOption *options = 0 )
linear( double a, double b, VOption *options = 0 ) const
{
return( this->linear( to_vector( a ), to_vector( b ),
options ) );
}
VImage
linear( std::vector<double> a, double b, VOption *options = 0 )
linear( std::vector<double> a, double b, VOption *options = 0 ) const
{
return( this->linear( a, to_vector( b ), options ) );
}
VImage
linear( double a, std::vector<double> b, VOption *options = 0 )
linear( double a, std::vector<double> b, VOption *options = 0 ) const
{
return( this->linear( to_vector( a ), b, options ) );
}
std::vector<VImage> bandsplit( VOption *options = 0 );
std::vector<VImage> bandsplit( VOption *options = 0 ) const;
VImage bandjoin( VImage other, VOption *options = 0 );
VImage bandjoin( VImage other, VOption *options = 0 ) const;
VImage
bandjoin( double other, VOption *options = 0 )
bandjoin( double other, VOption *options = 0 ) const
{
return( bandjoin( to_vector( other ), options ) );
}
VImage
bandjoin( std::vector<double> other, VOption *options = 0 )
bandjoin( std::vector<double> other, VOption *options = 0 ) const
{
return( bandjoin_const( other, options ) );
}
VImage composite( VImage other, VipsBlendMode mode,
VOption *options = 0 );
VOption *options = 0 ) const;
std::complex<double> minpos( VOption *options = 0 );
std::complex<double> minpos( VOption *options = 0 ) const;
std::complex<double> maxpos( VOption *options = 0 );
std::complex<double> maxpos( VOption *options = 0 ) const;
VImage
fliphor( VOption *options = 0 )
fliphor( VOption *options = 0 ) const
{
return( flip( VIPS_DIRECTION_HORIZONTAL, options ) );
}
VImage
flipver( VOption *options = 0 )
flipver( VOption *options = 0 ) const
{
return( flip( VIPS_DIRECTION_VERTICAL, options ) );
}
VImage
rot90( VOption *options = 0 )
rot90( VOption *options = 0 ) const
{
return( rot( VIPS_ANGLE_D90, options ) );
}
VImage
rot180( VOption *options = 0 )
rot180( VOption *options = 0 ) const
{
return( rot( VIPS_ANGLE_D180, options ) );
}
VImage
rot270( VOption *options = 0 )
rot270( VOption *options = 0 ) const
{
return( rot( VIPS_ANGLE_D270, options ) );
}
VImage
dilate( VImage mask, VOption *options = 0 )
dilate( VImage mask, VOption *options = 0 ) const
{
return( morph( mask, VIPS_OPERATION_MORPHOLOGY_DILATE,
options ) );
}
VImage
erode( VImage mask, VOption *options = 0 )
erode( VImage mask, VOption *options = 0 ) const
{
return( morph( mask, VIPS_OPERATION_MORPHOLOGY_ERODE,
options ) );
}
VImage
median( int size = 3, VOption *options = 0 )
median( int size = 3, VOption *options = 0 ) const
{
return( rank( size, size, (size * size) / 2, options ) );
}
VImage
floor( VOption *options = 0 )
floor( VOption *options = 0 ) const
{
return( round( VIPS_OPERATION_ROUND_FLOOR, options ) );
}
VImage
ceil( VOption *options = 0 )
ceil( VOption *options = 0 ) const
{
return( round( VIPS_OPERATION_ROUND_CEIL, options ) );
}
VImage
rint( VOption *options = 0 )
rint( VOption *options = 0 ) const
{
return( round( VIPS_OPERATION_ROUND_RINT, options ) );
}
VImage
real( VOption *options = 0 )
real( VOption *options = 0 ) const
{
return( complexget( VIPS_OPERATION_COMPLEXGET_REAL, options ) );
}
VImage
imag( VOption *options = 0 )
imag( VOption *options = 0 ) const
{
return( complexget( VIPS_OPERATION_COMPLEXGET_IMAG, options ) );
}
VImage
polar( VOption *options = 0 )
polar( VOption *options = 0 ) const
{
return( complex( VIPS_OPERATION_COMPLEX_POLAR, options ) );
}
VImage
rect( VOption *options = 0 )
rect( VOption *options = 0 ) const
{
return( complex( VIPS_OPERATION_COMPLEX_RECT, options ) );
}
VImage
conj( VOption *options = 0 )
conj( VOption *options = 0 ) const
{
return( complex( VIPS_OPERATION_COMPLEX_CONJ, options ) );
}
VImage
sin( VOption *options = 0 )
sin( VOption *options = 0 ) const
{
return( math( VIPS_OPERATION_MATH_SIN, options ) );
}
VImage
cos( VOption *options = 0 )
cos( VOption *options = 0 ) const
{
return( math( VIPS_OPERATION_MATH_COS, options ) );
}
VImage
tan( VOption *options = 0 )
tan( VOption *options = 0 ) const
{
return( math( VIPS_OPERATION_MATH_TAN, options ) );
}
VImage
asin( VOption *options = 0 )
asin( VOption *options = 0 ) const
{
return( math( VIPS_OPERATION_MATH_ASIN, options ) );
}
VImage
acos( VOption *options = 0 )
acos( VOption *options = 0 ) const
{
return( math( VIPS_OPERATION_MATH_ACOS, options ) );
}
VImage
atan( VOption *options = 0 )
atan( VOption *options = 0 ) const
{
return( math( VIPS_OPERATION_MATH_ATAN, options ) );
}
VImage
log( VOption *options = 0 )
log( VOption *options = 0 ) const
{
return( math( VIPS_OPERATION_MATH_LOG, options ) );
}
VImage
log10( VOption *options = 0 )
log10( VOption *options = 0 ) const
{
return( math( VIPS_OPERATION_MATH_LOG10, options ) );
}
VImage
exp( VOption *options = 0 )
exp( VOption *options = 0 ) const
{
return( math( VIPS_OPERATION_MATH_EXP, options ) );
}
VImage
exp10( VOption *options = 0 )
exp10( VOption *options = 0 ) const
{
return( math( VIPS_OPERATION_MATH_EXP10, options ) );
}
VImage
pow( VImage other, VOption *options = 0 )
pow( VImage other, VOption *options = 0 ) const
{
return( math2( other, VIPS_OPERATION_MATH2_POW, options ) );
}
VImage
pow( double other, VOption *options = 0 )
pow( double other, VOption *options = 0 ) const
{
return( math2_const( VIPS_OPERATION_MATH2_POW,
to_vector( other ), options ) );
}
VImage
pow( std::vector<double> other, VOption *options = 0 )
pow( std::vector<double> other, VOption *options = 0 ) const
{
return( math2_const( VIPS_OPERATION_MATH2_POW,
other, options ) );
}
VImage
wop( VImage other, VOption *options = 0 )
wop( VImage other, VOption *options = 0 ) const
{
return( math2( other, VIPS_OPERATION_MATH2_WOP, options ) );
}
VImage
wop( double other, VOption *options = 0 )
wop( double other, VOption *options = 0 ) const
{
return( math2_const( VIPS_OPERATION_MATH2_WOP,
to_vector( other ), options ) );
}
VImage
wop( std::vector<double> other, VOption *options = 0 )
wop( std::vector<double> other, VOption *options = 0 ) const
{
return( math2_const( VIPS_OPERATION_MATH2_WOP,
other, options ) );
}
VImage
ifthenelse( std::vector<double> th, VImage el, VOption *options = 0 )
ifthenelse( std::vector<double> th, VImage el,
VOption *options = 0 ) const
{
return( ifthenelse( el.new_from_image( th ), el, options ) );
}
VImage
ifthenelse( VImage th, std::vector<double> el, VOption *options = 0 )
ifthenelse( VImage th, std::vector<double> el,
VOption *options = 0 ) const
{
return( ifthenelse( th, th.new_from_image( el ), options ) );
}
VImage
ifthenelse( std::vector<double> th, std::vector<double> el,
VOption *options = 0 )
VOption *options = 0 ) const
{
return( ifthenelse( new_from_image( th ), new_from_image( el ),
options ) );
}
VImage
ifthenelse( double th, VImage el, VOption *options = 0 )
ifthenelse( double th, VImage el, VOption *options = 0 ) const
{
return( ifthenelse( to_vector( th ), el, options ) );
}
VImage
ifthenelse( VImage th, double el, VOption *options = 0 )
ifthenelse( VImage th, double el, VOption *options = 0 ) const
{
return( ifthenelse( th, to_vector( el ), options ) );
}
VImage
ifthenelse( double th, double el, VOption *options = 0 )
ifthenelse( double th, double el, VOption *options = 0 ) const
{
return( ifthenelse( to_vector( th ), to_vector( el ),
options ) );
@ -788,141 +794,246 @@ public:
// Operator overloads
VImage operator[]( int index );
VImage operator[]( int index ) const;
std::vector<double> operator()( int x, int y );
std::vector<double> operator()( int x, int y ) const;
friend VIPS_CPLUSPLUS_API VImage operator+( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator+( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator+( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator+( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator+( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator+( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator+( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator+( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator+( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator+( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage & operator+=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage & operator+=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage & operator+=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage &
operator+=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage &
operator+=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage &
operator+=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator-( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator-( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator-( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator-( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator-( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator-( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator-( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator-( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator-( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator-( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage & operator-=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage & operator-=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage & operator-=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage &
operator-=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage &
operator-=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage &
operator-=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator-( VImage a );
friend VIPS_CPLUSPLUS_API VImage
operator-( const VImage a );
friend VIPS_CPLUSPLUS_API VImage operator*( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator*( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator*( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator*( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator*( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator*( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator*( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator*( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator*( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator*( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage & operator*=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage & operator*=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage & operator*=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage &
operator*=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage &
operator*=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage &
operator*=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator/( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator/( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator/( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator/( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator/( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator/( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator/( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator/( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator/( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator/( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage & operator/=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage & operator/=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage & operator/=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage &
operator/=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage &
operator/=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage &
operator/=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator%( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator%( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator%( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator%( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator%( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator%( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage & operator%=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage & operator%=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage & operator%=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage &
operator%=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage &
operator%=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage &
operator%=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator<( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator<( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator<( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator<( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator<( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator<( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator<( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator<( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator<( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator<( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator<=( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator<=( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator<=( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator<=( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator<=( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator<=( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator<=( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator<=( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator<=( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator<=( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator>( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator>( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator>( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator>( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator>( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator>( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator>( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator>( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator>( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator>( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator>=( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator>=( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator>=( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator>=( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator>=( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator>=( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator>=( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator>=( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator>=( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator>=( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator==( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator==( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator==( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator==( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator==( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator==( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator==( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator==( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator==( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator==( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator!=( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator!=( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator!=( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator!=( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator!=( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator!=( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator!=( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator!=( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator!=( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator!=( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator&( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator&( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator&( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator&( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator&( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator&( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator&( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator&( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator&( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator&( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage & operator&=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage & operator&=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage & operator&=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage &
operator&=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage &
operator&=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage &
operator&=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator|( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator|( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator|( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator|( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator|( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator|( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator|( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator|( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator|( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator|( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage & operator|=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage & operator|=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage & operator|=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage &
operator|=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage &
operator|=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage &
operator|=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator^( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator^( double a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator^( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator^( std::vector<double> a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator^( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator^( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator^( const double a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator^( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator^( const std::vector<double> a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator^( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage & operator^=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage & operator^=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage & operator^=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage &
operator^=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage &
operator^=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage &
operator^=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator<<( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator<<( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator<<( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator<<( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator<<( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator<<( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage & operator<<=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage & operator<<=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage & operator<<=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage &
operator<<=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage &
operator<<=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage &
operator<<=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage operator>>( VImage a, VImage b );
friend VIPS_CPLUSPLUS_API VImage operator>>( VImage a, double b );
friend VIPS_CPLUSPLUS_API VImage operator>>( VImage a, std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage
operator>>( const VImage a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage
operator>>( const VImage a, const double b );
friend VIPS_CPLUSPLUS_API VImage
operator>>( const VImage a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage & operator>>=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage & operator>>=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage & operator>>=( VImage &a, const std::vector<double> b );
friend VIPS_CPLUSPLUS_API VImage &
operator>>=( VImage &a, const VImage b );
friend VIPS_CPLUSPLUS_API VImage &
operator>>=( VImage &a, const double b );
friend VIPS_CPLUSPLUS_API VImage &
operator>>=( VImage &a, const std::vector<double> b );
};

2
cplusplus/include/vips/VInterpolate8.h
View File

@ -52,7 +52,7 @@ public:
VInterpolate new_from_name( const char *name, VOption *options = 0 );
VipsInterpolate *
get_interpolate()
get_interpolate() const
{
return( (VipsInterpolate *) VObject::get_object() );
}

8
cplusplus/include/vips/gen-operators-h.py
View File

@ -146,7 +146,13 @@ def gen_operation(cls):
gen_arg_list(op, required)
print ');'
print ')',
# if no "this" available, it's a class method and they are all const
if this != None:
print ' const',
print ';'
# we have a few synonyms ... don't generate twice
generated = {}

497
cplusplus/include/vips/vips-operators.h
View File

@ -1,248 +1,255 @@
// headers for vips operations
// Sun 26 Nov 17:44:41 GMT 2017
// Mon 11 Jun 14:21:32 BST 2018
// this file is generated automatically, do not edit!
static void system( char * cmd_format , VOption *options = 0 );
VImage add( VImage right , VOption *options = 0 );
VImage subtract( VImage right , VOption *options = 0 );
VImage multiply( VImage right , VOption *options = 0 );
VImage divide( VImage right , VOption *options = 0 );
VImage relational( VImage right , VipsOperationRelational relational , VOption *options = 0 );
VImage remainder( VImage right , VOption *options = 0 );
VImage boolean( VImage right , VipsOperationBoolean boolean , VOption *options = 0 );
VImage math2( VImage right , VipsOperationMath2 math2 , VOption *options = 0 );
VImage complex2( VImage right , VipsOperationComplex2 cmplx , VOption *options = 0 );
VImage complexform( VImage right , VOption *options = 0 );
static VImage sum( std::vector<VImage> in , VOption *options = 0 );
VImage invert( VOption *options = 0 );
VImage linear( std::vector<double> a , std::vector<double> b , VOption *options = 0 );
VImage math( VipsOperationMath math , VOption *options = 0 );
VImage abs( VOption *options = 0 );
VImage sign( VOption *options = 0 );
VImage round( VipsOperationRound round , VOption *options = 0 );
VImage relational_const( VipsOperationRelational relational , std::vector<double> c , VOption *options = 0 );
VImage remainder_const( std::vector<double> c , VOption *options = 0 );
VImage boolean_const( VipsOperationBoolean boolean , std::vector<double> c , VOption *options = 0 );
VImage math2_const( VipsOperationMath2 math2 , std::vector<double> c , VOption *options = 0 );
VImage complex( VipsOperationComplex cmplx , VOption *options = 0 );
VImage complexget( VipsOperationComplexget get , VOption *options = 0 );
double avg( VOption *options = 0 );
double min( VOption *options = 0 );
double max( VOption *options = 0 );
double deviate( VOption *options = 0 );
VImage stats( VOption *options = 0 );
VImage hist_find( VOption *options = 0 );
VImage hist_find_ndim( VOption *options = 0 );
VImage hist_find_indexed( VImage index , VOption *options = 0 );
VImage hough_line( VOption *options = 0 );
VImage hough_circle( VOption *options = 0 );
VImage project( VImage * rows , VOption *options = 0 );
VImage profile( VImage * rows , VOption *options = 0 );
VImage measure( int h , int v , VOption *options = 0 );
std::vector<double> getpoint( int x , int y , VOption *options = 0 );
int find_trim( int * top , int * width , int * height , VOption *options = 0 );
VImage copy( VOption *options = 0 );
VImage tilecache( VOption *options = 0 );
VImage linecache( VOption *options = 0 );
VImage sequential( VOption *options = 0 );
VImage cache( VOption *options = 0 );
VImage embed( int x , int y , int width , int height , VOption *options = 0 );
VImage gravity( VipsCompassDirection direction , int width , int height , VOption *options = 0 );
VImage flip( VipsDirection direction , VOption *options = 0 );
VImage insert( VImage sub , int x , int y , VOption *options = 0 );
VImage join( VImage in2 , VipsDirection direction , VOption *options = 0 );
static VImage arrayjoin( std::vector<VImage> in , VOption *options = 0 );
VImage extract_area( int left , int top , int width , int height , VOption *options = 0 );
VImage smartcrop( int width , int height , VOption *options = 0 );
VImage extract_band( int band , VOption *options = 0 );
static VImage bandjoin( std::vector<VImage> in , VOption *options = 0 );
VImage bandjoin_const( std::vector<double> c , VOption *options = 0 );
static VImage bandrank( std::vector<VImage> in , VOption *options = 0 );
VImage bandmean( VOption *options = 0 );
VImage bandbool( VipsOperationBoolean boolean , VOption *options = 0 );
VImage replicate( int across , int down , VOption *options = 0 );
VImage cast( VipsBandFormat format , VOption *options = 0 );
VImage rot( VipsAngle angle , VOption *options = 0 );
VImage rot45( VOption *options = 0 );
VImage autorot( VOption *options = 0 );
VImage ifthenelse( VImage in1 , VImage in2 , VOption *options = 0 );
VImage recomb( VImage m , VOption *options = 0 );
VImage bandfold( VOption *options = 0 );
VImage bandunfold( VOption *options = 0 );
VImage flatten( VOption *options = 0 );
VImage premultiply( VOption *options = 0 );
VImage unpremultiply( VOption *options = 0 );
VImage grid( int tile_height , int across , int down , VOption *options = 0 );
VImage scale( VOption *options = 0 );
VImage wrap( VOption *options = 0 );
VImage zoom( int xfac , int yfac , VOption *options = 0 );
VImage subsample( int xfac , int yfac , VOption *options = 0 );
VImage msb( VOption *options = 0 );
VImage byteswap( VOption *options = 0 );
VImage falsecolour( VOption *options = 0 );
VImage gamma( VOption *options = 0 );
static VImage composite( std::vector<VImage> in , std::vector<int> mode , VOption *options = 0 );
static VImage black( int width , int height , VOption *options = 0 );
static VImage gaussnoise( int width , int height , VOption *options = 0 );
static VImage text( char * text , VOption *options = 0 );
static VImage xyz( int width , int height , VOption *options = 0 );
static VImage gaussmat( double sigma , double min_ampl , VOption *options = 0 );
static VImage logmat( double sigma , double min_ampl , VOption *options = 0 );
static VImage eye( int width , int height , VOption *options = 0 );
static VImage grey( int width , int height , VOption *options = 0 );
static VImage zone( int width , int height , VOption *options = 0 );
static VImage sines( int width , int height , VOption *options = 0 );
static VImage mask_ideal( int width , int height , double frequency_cutoff , VOption *options = 0 );
static VImage mask_ideal_ring( int width , int height , double frequency_cutoff , double ringwidth , VOption *options = 0 );
static VImage mask_ideal_band( int width , int height , double frequency_cutoff_x , double frequency_cutoff_y , double radius , VOption *options = 0 );
static VImage mask_butterworth( int width , int height , double order , double frequency_cutoff , double amplitude_cutoff , VOption *options = 0 );
static VImage mask_butterworth_ring( int width , int height , double order , double frequency_cutoff , double amplitude_cutoff , double ringwidth , VOption *options = 0 );
static VImage mask_butterworth_band( int width , int height , double order , double frequency_cutoff_x , double frequency_cutoff_y , double radius , double amplitude_cutoff , VOption *options = 0 );
static VImage mask_gaussian( int width , int height , double frequency_cutoff , double amplitude_cutoff , VOption *options = 0 );
static VImage mask_gaussian_ring( int width , int height , double frequency_cutoff , double amplitude_cutoff , double ringwidth , VOption *options = 0 );
static VImage mask_gaussian_band( int width , int height , double frequency_cutoff_x , double frequency_cutoff_y , double radius , double amplitude_cutoff , VOption *options = 0 );
static VImage mask_fractal( int width , int height , double fractal_dimension , VOption *options = 0 );
VImage buildlut( VOption *options = 0 );
VImage invertlut( VOption *options = 0 );
static VImage tonelut( VOption *options = 0 );
static VImage identity( VOption *options = 0 );
static VImage fractsurf( int width , int height , double fractal_dimension , VOption *options = 0 );
static VImage worley( int width , int height , VOption *options = 0 );
static VImage perlin( int width , int height , VOption *options = 0 );
static VImage csvload( char * filename , VOption *options = 0 );
static VImage matrixload( char * filename , VOption *options = 0 );
static VImage rawload( char * filename , int width , int height , int bands , VOption *options = 0 );
static VImage vipsload( char * filename , VOption *options = 0 );
static VImage analyzeload( char * filename , VOption *options = 0 );
static VImage ppmload( char * filename , VOption *options = 0 );
static VImage radload( char * filename , VOption *options = 0 );
static VImage pdfload( char * filename , VOption *options = 0 );
static VImage pdfload_buffer( VipsBlob * buffer , VOption *options = 0 );
static VImage svgload( char * filename , VOption *options = 0 );
static VImage svgload_buffer( VipsBlob * buffer , VOption *options = 0 );
static VImage gifload( char * filename , VOption *options = 0 );
static VImage gifload_buffer( VipsBlob * buffer , VOption *options = 0 );
static VImage pngload( char * filename , VOption *options = 0 );
static VImage pngload_buffer( VipsBlob * buffer , VOption *options = 0 );
static VImage matload( char * filename , VOption *options = 0 );
static VImage jpegload( char * filename , VOption *options = 0 );
static VImage jpegload_buffer( VipsBlob * buffer , VOption *options = 0 );
static VImage webpload( char * filename , VOption *options = 0 );
static VImage webpload_buffer( VipsBlob * buffer , VOption *options = 0 );
static VImage tiffload( char * filename , VOption *options = 0 );
static VImage tiffload_buffer( VipsBlob * buffer , VOption *options = 0 );
static VImage openslideload( char * filename , VOption *options = 0 );
static VImage magickload( char * filename , VOption *options = 0 );
static VImage magickload_buffer( VipsBlob * buffer , VOption *options = 0 );
static VImage fitsload( char * filename , VOption *options = 0 );
static VImage openexrload( char * filename , VOption *options = 0 );
void csvsave( char * filename , VOption *options = 0 );
void matrixsave( char * filename , VOption *options = 0 );
void matrixprint( VOption *options = 0 );
void rawsave( char * filename , VOption *options = 0 );
void rawsave_fd( int fd , VOption *options = 0 );
void vipssave( char * filename , VOption *options = 0 );
void ppmsave( char * filename , VOption *options = 0 );
void radsave( char * filename , VOption *options = 0 );
VipsBlob * radsave_buffer( VOption *options = 0 );
void dzsave( char * filename , VOption *options = 0 );
VipsBlob * dzsave_buffer( VOption *options = 0 );
void pngsave( char * filename , VOption *options = 0 );
VipsBlob * pngsave_buffer( VOption *options = 0 );
void jpegsave( char * filename , VOption *options = 0 );
VipsBlob * jpegsave_buffer( VOption *options = 0 );
void jpegsave_mime( VOption *options = 0 );
void webpsave( char * filename , VOption *options = 0 );
VipsBlob * webpsave_buffer( VOption *options = 0 );
void tiffsave( char * filename , VOption *options = 0 );
VipsBlob * tiffsave_buffer( VOption *options = 0 );
void fitssave( char * filename , VOption *options = 0 );
static VImage thumbnail( char * filename , int width , VOption *options = 0 );
static VImage thumbnail_buffer( VipsBlob * buffer , int width , VOption *options = 0 );
VImage thumbnail_image( int width , VOption *options = 0 );
VImage mapim( VImage index , VOption *options = 0 );
VImage shrink( double hshrink , double vshrink , VOption *options = 0 );
VImage shrinkh( int hshrink , VOption *options = 0 );
VImage shrinkv( int vshrink , VOption *options = 0 );
VImage reduceh( double hshrink , VOption *options = 0 );
VImage reducev( double vshrink , VOption *options = 0 );
VImage reduce( double hshrink , double vshrink , VOption *options = 0 );
VImage quadratic( VImage coeff , VOption *options = 0 );
VImage affine( std::vector<double> matrix , VOption *options = 0 );
VImage similarity( VOption *options = 0 );
VImage resize( double scale , VOption *options = 0 );
VImage colourspace( VipsInterpretation space , VOption *options = 0 );
VImage Lab2XYZ( VOption *options = 0 );
VImage XYZ2Lab( VOption *options = 0 );
VImage Lab2LCh( VOption *options = 0 );
VImage LCh2Lab( VOption *options = 0 );
VImage LCh2CMC( VOption *options = 0 );
VImage CMC2LCh( VOption *options = 0 );
VImage XYZ2Yxy( VOption *options = 0 );
VImage Yxy2XYZ( VOption *options = 0 );
VImage scRGB2XYZ( VOption *options = 0 );
VImage XYZ2scRGB( VOption *options = 0 );
VImage LabQ2Lab( VOption *options = 0 );
VImage Lab2LabQ( VOption *options = 0 );
VImage LabQ2LabS( VOption *options = 0 );
VImage LabS2LabQ( VOption *options = 0 );
VImage LabS2Lab( VOption *options = 0 );
VImage Lab2LabS( VOption *options = 0 );
VImage rad2float( VOption *options = 0 );
VImage float2rad( VOption *options = 0 );
VImage LabQ2sRGB( VOption *options = 0 );
VImage sRGB2HSV( VOption *options = 0 );
VImage HSV2sRGB( VOption *options = 0 );
VImage icc_import( VOption *options = 0 );
VImage icc_export( VOption *options = 0 );
VImage icc_transform( char * output_profile , VOption *options = 0 );
VImage dE76( VImage right , VOption *options = 0 );
VImage dE00( VImage right , VOption *options = 0 );
VImage dECMC( VImage right , VOption *options = 0 );
VImage sRGB2scRGB( VOption *options = 0 );
VImage scRGB2BW( VOption *options = 0 );
VImage scRGB2sRGB( VOption *options = 0 );
VImage maplut( VImage lut , VOption *options = 0 );
int percent( double percent , VOption *options = 0 );
VImage stdif( int width , int height , VOption *options = 0 );
VImage hist_cum( VOption *options = 0 );
VImage hist_match( VImage ref , VOption *options = 0 );
VImage hist_norm( VOption *options = 0 );
VImage hist_equal( VOption *options = 0 );
VImage hist_plot( VOption *options = 0 );
VImage hist_local( int width , int height , VOption *options = 0 );
bool hist_ismonotonic( VOption *options = 0 );
double hist_entropy( VOption *options = 0 );
VImage conv( VImage mask , VOption *options = 0 );
VImage conva( VImage mask , VOption *options = 0 );
VImage convf( VImage mask , VOption *options = 0 );
VImage convi( VImage mask , VOption *options = 0 );
VImage compass( VImage mask , VOption *options = 0 );
VImage convsep( VImage mask , VOption *options = 0 );
VImage convasep( VImage mask , VOption *options = 0 );
VImage fastcor( VImage ref , VOption *options = 0 );
VImage spcor( VImage ref , VOption *options = 0 );
VImage sharpen( VOption *options = 0 );
VImage gaussblur( double sigma , VOption *options = 0 );
VImage fwfft( VOption *options = 0 );
VImage invfft( VOption *options = 0 );
VImage freqmult( VImage mask , VOption *options = 0 );
VImage spectrum( VOption *options = 0 );
VImage phasecor( VImage in2 , VOption *options = 0 );
VImage morph( VImage mask , VipsOperationMorphology morph , VOption *options = 0 );
VImage rank( int width , int height , int index , VOption *options = 0 );
double countlines( VipsDirection direction , VOption *options = 0 );
VImage labelregions( VOption *options = 0 );
VImage fill_nearest( VOption *options = 0 );
void draw_rect( std::vector<double> ink , int left , int top , int width , int height , VOption *options = 0 );
void draw_mask( std::vector<double> ink , VImage mask , int x , int y , VOption *options = 0 );
void draw_line( std::vector<double> ink , int x1 , int y1 , int x2 , int y2 , VOption *options = 0 );
void draw_circle( std::vector<double> ink , int cx , int cy , int radius , VOption *options = 0 );
void draw_flood( std::vector<double> ink , int x , int y , VOption *options = 0 );
void draw_image( VImage sub , int x , int y , VOption *options = 0 );
void draw_smudge( int left , int top , int width , int height , VOption *options = 0 );
VImage merge( VImage sec , VipsDirection direction , int dx , int dy , VOption *options = 0 );
VImage mosaic( VImage sec , VipsDirection direction , int xref , int yref , int xsec , int ysec , VOption *options = 0 );
VImage mosaic1( VImage sec , VipsDirection direction , int xr1 , int yr1 , int xs1 , int ys1 , int xr2 , int yr2 , int xs2 , int ys2 , VOption *options = 0 );
VImage match( VImage sec , int xr1 , int yr1 , int xs1 , int ys1 , int xr2 , int yr2 , int xs2 , int ys2 , VOption *options = 0 );
VImage globalbalance( VOption *options = 0 );
static void system( char * cmd_format , VOption *options = 0 ) ;
VImage add( VImage right , VOption *options = 0 ) const ;
VImage subtract( VImage right , VOption *options = 0 ) const ;
VImage multiply( VImage right , VOption *options = 0 ) const ;
VImage divide( VImage right , VOption *options = 0 ) const ;
VImage relational( VImage right , VipsOperationRelational relational , VOption *options = 0 ) const ;
VImage remainder( VImage right , VOption *options = 0 ) const ;
VImage boolean( VImage right , VipsOperationBoolean boolean , VOption *options = 0 ) const ;
VImage math2( VImage right , VipsOperationMath2 math2 , VOption *options = 0 ) const ;
VImage complex2( VImage right , VipsOperationComplex2 cmplx , VOption *options = 0 ) const ;
VImage complexform( VImage right , VOption *options = 0 ) const ;
static VImage sum( std::vector<VImage> in , VOption *options = 0 ) ;
VImage invert( VOption *options = 0 ) const ;
VImage linear( std::vector<double> a , std::vector<double> b , VOption *options = 0 ) const ;
VImage math( VipsOperationMath math , VOption *options = 0 ) const ;
VImage abs( VOption *options = 0 ) const ;
VImage sign( VOption *options = 0 ) const ;
VImage round( VipsOperationRound round , VOption *options = 0 ) const ;
VImage relational_const( VipsOperationRelational relational , std::vector<double> c , VOption *options = 0 ) const ;
VImage remainder_const( std::vector<double> c , VOption *options = 0 ) const ;
VImage boolean_const( VipsOperationBoolean boolean , std::vector<double> c , VOption *options = 0 ) const ;
VImage math2_const( VipsOperationMath2 math2 , std::vector<double> c , VOption *options = 0 ) const ;
VImage complex( VipsOperationComplex cmplx , VOption *options = 0 ) const ;
VImage complexget( VipsOperationComplexget get , VOption *options = 0 ) const ;
double avg( VOption *options = 0 ) const ;
double min( VOption *options = 0 ) const ;
double max( VOption *options = 0 ) const ;
double deviate( VOption *options = 0 ) const ;
VImage stats( VOption *options = 0 ) const ;
VImage hist_find( VOption *options = 0 ) const ;
VImage hist_find_ndim( VOption *options = 0 ) const ;
VImage hist_find_indexed( VImage index , VOption *options = 0 ) const ;
VImage hough_line( VOption *options = 0 ) const ;
VImage hough_circle( VOption *options = 0 ) const ;
VImage project( VImage * rows , VOption *options = 0 ) const ;
VImage profile( VImage * rows , VOption *options = 0 ) const ;
VImage measure( int h , int v , VOption *options = 0 ) const ;
std::vector<double> getpoint( int x , int y , VOption *options = 0 ) const ;
int find_trim( int * top , int * width , int * height , VOption *options = 0 ) const ;
VImage copy( VOption *options = 0 ) const ;
VImage tilecache( VOption *options = 0 ) const ;
VImage linecache( VOption *options = 0 ) const ;
VImage sequential( VOption *options = 0 ) const ;
VImage cache( VOption *options = 0 ) const ;
VImage embed( int x , int y , int width , int height , VOption *options = 0 ) const ;
VImage gravity( VipsCompassDirection direction , int width , int height , VOption *options = 0 ) const ;
VImage flip( VipsDirection direction , VOption *options = 0 ) const ;
VImage insert( VImage sub , int x , int y , VOption *options = 0 ) const ;
VImage join( VImage in2 , VipsDirection direction , VOption *options = 0 ) const ;
static VImage arrayjoin( std::vector<VImage> in , VOption *options = 0 ) ;
VImage extract_area( int left , int top , int width , int height , VOption *options = 0 ) const ;
VImage smartcrop( int width , int height , VOption *options = 0 ) const ;
VImage extract_band( int band , VOption *options = 0 ) const ;
static VImage bandjoin( std::vector<VImage> in , VOption *options = 0 ) ;
VImage bandjoin_const( std::vector<double> c , VOption *options = 0 ) const ;
static VImage bandrank( std::vector<VImage> in , VOption *options = 0 ) ;
VImage bandmean( VOption *options = 0 ) const ;
VImage bandbool( VipsOperationBoolean boolean , VOption *options = 0 ) const ;
VImage replicate( int across , int down , VOption *options = 0 ) const ;
VImage cast( VipsBandFormat format , VOption *options = 0 ) const ;
VImage rot( VipsAngle angle , VOption *options = 0 ) const ;
VImage rot45( VOption *options = 0 ) const ;
VImage autorot( VOption *options = 0 ) const ;
VImage ifthenelse( VImage in1 , VImage in2 , VOption *options = 0 ) const ;
VImage recomb( VImage m , VOption *options = 0 ) const ;
VImage bandfold( VOption *options = 0 ) const ;
VImage bandunfold( VOption *options = 0 ) const ;
VImage flatten( VOption *options = 0 ) const ;
VImage premultiply( VOption *options = 0 ) const ;
VImage unpremultiply( VOption *options = 0 ) const ;
VImage grid( int tile_height , int across , int down , VOption *options = 0 ) const ;
VImage transpose3d( VOption *options = 0 ) const ;
VImage scale( VOption *options = 0 ) const ;
VImage wrap( VOption *options = 0 ) const ;
VImage zoom( int xfac , int yfac , VOption *options = 0 ) const ;
VImage subsample( int xfac , int yfac , VOption *options = 0 ) const ;
VImage msb( VOption *options = 0 ) const ;
VImage byteswap( VOption *options = 0 ) const ;
VImage falsecolour( VOption *options = 0 ) const ;
VImage gamma( VOption *options = 0 ) const ;
static VImage composite( std::vector<VImage> in , std::vector<int> mode , VOption *options = 0 ) ;
VImage composite2( VImage overlay , VipsBlendMode mode , VOption *options = 0 ) const ;
static VImage black( int width , int height , VOption *options = 0 ) ;
static VImage gaussnoise( int width , int height , VOption *options = 0 ) ;
static VImage text( char * text , VOption *options = 0 ) ;
static VImage xyz( int width , int height , VOption *options = 0 ) ;
static VImage gaussmat( double sigma , double min_ampl , VOption *options = 0 ) ;
static VImage logmat( double sigma , double min_ampl , VOption *options = 0 ) ;
static VImage eye( int width , int height , VOption *options = 0 ) ;
static VImage grey( int width , int height , VOption *options = 0 ) ;
static VImage zone( int width , int height , VOption *options = 0 ) ;
static VImage sines( int width , int height , VOption *options = 0 ) ;
static VImage mask_ideal( int width , int height , double frequency_cutoff , VOption *options = 0 ) ;
static VImage mask_ideal_ring( int width , int height , double frequency_cutoff , double ringwidth , VOption *options = 0 ) ;
static VImage mask_ideal_band( int width , int height , double frequency_cutoff_x , double frequency_cutoff_y , double radius , VOption *options = 0 ) ;
static VImage mask_butterworth( int width , int height , double order , double frequency_cutoff , double amplitude_cutoff , VOption *options = 0 ) ;
static VImage mask_butterworth_ring( int width , int height , double order , double frequency_cutoff , double amplitude_cutoff , double ringwidth , VOption *options = 0 ) ;
static VImage mask_butterworth_band( int width , int height , double order , double frequency_cutoff_x , double frequency_cutoff_y , double radius , double amplitude_cutoff , VOption *options = 0 ) ;
static VImage mask_gaussian( int width , int height , double frequency_cutoff , double amplitude_cutoff , VOption *options = 0 ) ;
static VImage mask_gaussian_ring( int width , int height , double frequency_cutoff , double amplitude_cutoff , double ringwidth , VOption *options = 0 ) ;
static VImage mask_gaussian_band( int width , int height , double frequency_cutoff_x , double frequency_cutoff_y , double radius , double amplitude_cutoff , VOption *options = 0 ) ;
static VImage mask_fractal( int width , int height , double fractal_dimension , VOption *options = 0 ) ;
VImage buildlut( VOption *options = 0 ) const ;
VImage invertlut( VOption *options = 0 ) const ;
static VImage tonelut( VOption *options = 0 ) ;
static VImage identity( VOption *options = 0 ) ;
static VImage fractsurf( int width , int height , double fractal_dimension , VOption *options = 0 ) ;
static VImage worley( int width , int height , VOption *options = 0 ) ;
static VImage perlin( int width , int height , VOption *options = 0 ) ;
static VImage csvload( char * filename , VOption *options = 0 ) ;
static VImage matrixload( char * filename , VOption *options = 0 ) ;
static VImage rawload( char * filename , int width , int height , int bands , VOption *options = 0 ) ;
static VImage vipsload( char * filename , VOption *options = 0 ) ;
static VImage analyzeload( char * filename , VOption *options = 0 ) ;
static VImage ppmload( char * filename , VOption *options = 0 ) ;
static VImage radload( char * filename , VOption *options = 0 ) ;
static VImage pdfload( char * filename , VOption *options = 0 ) ;
static VImage pdfload_buffer( VipsBlob * buffer , VOption *options = 0 ) ;
static VImage svgload( char * filename , VOption *options = 0 ) ;
static VImage svgload_buffer( VipsBlob * buffer , VOption *options = 0 ) ;
static VImage gifload( char * filename , VOption *options = 0 ) ;
static VImage gifload_buffer( VipsBlob * buffer , VOption *options = 0 ) ;
static VImage pngload( char * filename , VOption *options = 0 ) ;
static VImage pngload_buffer( VipsBlob * buffer , VOption *options = 0 ) ;
static VImage matload( char * filename , VOption *options = 0 ) ;
static VImage jpegload( char * filename , VOption *options = 0 ) ;
static VImage jpegload_buffer( VipsBlob * buffer , VOption *options = 0 ) ;
static VImage webpload( char * filename , VOption *options = 0 ) ;
static VImage webpload_buffer( VipsBlob * buffer , VOption *options = 0 ) ;
static VImage tiffload( char * filename , VOption *options = 0 ) ;
static VImage tiffload_buffer( VipsBlob * buffer , VOption *options = 0 ) ;
static VImage openslideload( char * filename , VOption *options = 0 ) ;
static VImage magickload( char * filename , VOption *options = 0 ) ;
static VImage magickload_buffer( VipsBlob * buffer , VOption *options = 0 ) ;
static VImage fitsload( char * filename , VOption *options = 0 ) ;
static VImage openexrload( char * filename , VOption *options = 0 ) ;
void csvsave( char * filename , VOption *options = 0 ) const ;
void matrixsave( char * filename , VOption *options = 0 ) const ;
void matrixprint( VOption *options = 0 ) const ;
void rawsave( char * filename , VOption *options = 0 ) const ;
void rawsave_fd( int fd , VOption *options = 0 ) const ;
void vipssave( char * filename , VOption *options = 0 ) const ;
void ppmsave( char * filename , VOption *options = 0 ) const ;
void radsave( char * filename , VOption *options = 0 ) const ;
VipsBlob * radsave_buffer( VOption *options = 0 ) const ;
void dzsave( char * filename , VOption *options = 0 ) const ;
VipsBlob * dzsave_buffer( VOption *options = 0 ) const ;
void pngsave( char * filename , VOption *options = 0 ) const ;
VipsBlob * pngsave_buffer( VOption *options = 0 ) const ;
void jpegsave( char * filename , VOption *options = 0 ) const ;
VipsBlob * jpegsave_buffer( VOption *options = 0 ) const ;
void jpegsave_mime( VOption *options = 0 ) const ;
void webpsave( char * filename , VOption *options = 0 ) const ;
VipsBlob * webpsave_buffer( VOption *options = 0 ) const ;
void tiffsave( char * filename , VOption *options = 0 ) const ;
VipsBlob * tiffsave_buffer( VOption *options = 0 ) const ;
void magicksave( char * filename , VOption *options = 0 ) const ;
VipsBlob * magicksave_buffer( VOption *options = 0 ) const ;
void fitssave( char * filename , VOption *options = 0 ) const ;
static VImage thumbnail( char * filename , int width , VOption *options = 0 ) ;
static VImage thumbnail_buffer( VipsBlob * buffer , int width , VOption *options = 0 ) ;
VImage thumbnail_image( int width , VOption *options = 0 ) const ;
VImage mapim( VImage index , VOption *options = 0 ) const ;
VImage shrink( double hshrink , double vshrink , VOption *options = 0 ) const ;
VImage shrinkh( int hshrink , VOption *options = 0 ) const ;
VImage shrinkv( int vshrink , VOption *options = 0 ) const ;
VImage reduceh( double hshrink , VOption *options = 0 ) const ;
VImage reducev( double vshrink , VOption *options = 0 ) const ;
VImage reduce( double hshrink , double vshrink , VOption *options = 0 ) const ;
VImage quadratic( VImage coeff , VOption *options = 0 ) const ;
VImage affine( std::vector<double> matrix , VOption *options = 0 ) const ;
VImage similarity( VOption *options = 0 ) const ;
VImage rotate( double angle , VOption *options = 0 ) const ;
VImage resize( double scale , VOption *options = 0 ) const ;
VImage colourspace( VipsInterpretation space , VOption *options = 0 ) const ;
VImage Lab2XYZ( VOption *options = 0 ) const ;
VImage XYZ2Lab( VOption *options = 0 ) const ;
VImage Lab2LCh( VOption *options = 0 ) const ;
VImage LCh2Lab( VOption *options = 0 ) const ;
VImage LCh2CMC( VOption *options = 0 ) const ;
VImage CMC2LCh( VOption *options = 0 ) const ;
VImage XYZ2Yxy( VOption *options = 0 ) const ;
VImage Yxy2XYZ( VOption *options = 0 ) const ;
VImage scRGB2XYZ( VOption *options = 0 ) const ;
VImage XYZ2scRGB( VOption *options = 0 ) const ;
VImage LabQ2Lab( VOption *options = 0 ) const ;
VImage Lab2LabQ( VOption *options = 0 ) const ;
VImage LabQ2LabS( VOption *options = 0 ) const ;
VImage LabS2LabQ( VOption *options = 0 ) const ;
VImage LabS2Lab( VOption *options = 0 ) const ;
VImage Lab2LabS( VOption *options = 0 ) const ;
VImage rad2float( VOption *options = 0 ) const ;
VImage float2rad( VOption *options = 0 ) const ;
VImage LabQ2sRGB( VOption *options = 0 ) const ;
VImage sRGB2HSV( VOption *options = 0 ) const ;
VImage HSV2sRGB( VOption *options = 0 ) const ;
VImage icc_import( VOption *options = 0 ) const ;
VImage icc_export( VOption *options = 0 ) const ;
VImage icc_transform( char * output_profile , VOption *options = 0 ) const ;
VImage dE76( VImage right , VOption *options = 0 ) const ;
VImage dE00( VImage right , VOption *options = 0 ) const ;
VImage dECMC( VImage right , VOption *options = 0 ) const ;
VImage sRGB2scRGB( VOption *options = 0 ) const ;
VImage scRGB2BW( VOption *options = 0 ) const ;
VImage scRGB2sRGB( VOption *options = 0 ) const ;
VImage maplut( VImage lut , VOption *options = 0 ) const ;
int percent( double percent , VOption *options = 0 ) const ;
VImage stdif( int width , int height , VOption *options = 0 ) const ;
VImage hist_cum( VOption *options = 0 ) const ;
VImage hist_match( VImage ref , VOption *options = 0 ) const ;
VImage hist_norm( VOption *options = 0 ) const ;
VImage hist_equal( VOption *options = 0 ) const ;
VImage hist_plot( VOption *options = 0 ) const ;
VImage hist_local( int width , int height , VOption *options = 0 ) const ;
bool hist_ismonotonic( VOption *options = 0 ) const ;
double hist_entropy( VOption *options = 0 ) const ;
VImage conv( VImage mask , VOption *options = 0 ) const ;
VImage conva( VImage mask , VOption *options = 0 ) const ;
VImage convf( VImage mask , VOption *options = 0 ) const ;
VImage convi( VImage mask , VOption *options = 0 ) const ;
VImage compass( VImage mask , VOption *options = 0 ) const ;
VImage convsep( VImage mask , VOption *options = 0 ) const ;
VImage convasep( VImage mask , VOption *options = 0 ) const ;
VImage fastcor( VImage ref , VOption *options = 0 ) const ;
VImage spcor( VImage ref , VOption *options = 0 ) const ;
VImage sharpen( VOption *options = 0 ) const ;
VImage gaussblur( double sigma , VOption *options = 0 ) const ;
VImage canny( VOption *options = 0 ) const ;
VImage sobel( VOption *options = 0 ) const ;
VImage fwfft( VOption *options = 0 ) const ;
VImage invfft( VOption *options = 0 ) const ;
VImage freqmult( VImage mask , VOption *options = 0 ) const ;
VImage spectrum( VOption *options = 0 ) const ;
VImage phasecor( VImage in2 , VOption *options = 0 ) const ;
VImage morph( VImage mask , VipsOperationMorphology morph , VOption *options = 0 ) const ;
VImage rank( int width , int height , int index , VOption *options = 0 ) const ;
double countlines( VipsDirection direction , VOption *options = 0 ) const ;
VImage labelregions( VOption *options = 0 ) const ;
VImage fill_nearest( VOption *options = 0 ) const ;
void draw_rect( std::vector<double> ink , int left , int top , int width , int height , VOption *options = 0 ) const ;
void draw_mask( std::vector<double> ink , VImage mask , int x , int y , VOption *options = 0 ) const ;
void draw_line( std::vector<double> ink , int x1 , int y1 , int x2 , int y2 , VOption *options = 0 ) const ;
void draw_circle( std::vector<double> ink , int cx , int cy , int radius , VOption *options = 0 ) const ;
void draw_flood( std::vector<double> ink , int x , int y , VOption *options = 0 ) const ;
void draw_image( VImage sub , int x , int y , VOption *options = 0 ) const ;
void draw_smudge( int left , int top , int width , int height , VOption *options = 0 ) const ;
VImage merge( VImage sec , VipsDirection direction , int dx , int dy , VOption *options = 0 ) const ;
VImage mosaic( VImage sec , VipsDirection direction , int xref , int yref , int xsec , int ysec , VOption *options = 0 ) const ;
VImage mosaic1( VImage sec , VipsDirection direction , int xr1 , int yr1 , int xs1 , int ys1 , int xr2 , int yr2 , int xs2 , int ys2 , VOption *options = 0 ) const ;
VImage match( VImage sec , int xr1 , int yr1 , int xs1 , int ys1 , int xr2 , int yr2 , int xs2 , int ys2 , VOption *options = 0 ) const ;
VImage globalbalance( VOption *options = 0 ) const ;

453
cplusplus/vips-operators.cpp
View File

File diff suppressed because it is too large Load Diff

4
libvips/Makefile.am
View File

@ -24,8 +24,7 @@ SUBDIRS = \
iofuncs \
morphology \
mosaicing \
create \
video \
create
.
lib_LTLIBRARIES = libvips.la
@ -52,7 +51,6 @@ libvips_la_LIBADD = \
morphology/libmorphology.la \
mosaicing/libmosaicing.la \
create/libcreate.la \
video/libvideo.la \
@VIPS_LIBS@
libvips_la_LDFLAGS = \

2
libvips/arithmetic/divide.c
View File

@ -13,7 +13,7 @@
* 19/10/93 JC
* - coredump-inducing bug in complex*complex fixed
* 13/12/93
* - char*short bug fixed
* - char * short bug fixed
* 12/6/95 JC
* - new im_multiply adapted to make new im_divide
* 27/9/04

2
libvips/arithmetic/multiply.c
View File

@ -13,7 +13,7 @@
* 19/10/93 JC
* - coredump-inducing bug in complex*complex fixed
* 13/12/93
* - char*short bug fixed
* - char * short bug fixed
* 12/6/95 JC
* - new im_add adapted to make new im_multiply
* 27/9/04

2
libvips/arithmetic/stats.c
View File

@ -409,7 +409,7 @@ vips_stats_class_init( VipsStatsClass *class )
gobject_class->get_property = vips_object_get_property;
object_class->nickname = "stats";
object_class->description = _( "find image average" );
object_class->description = _( "find many image stats" );
object_class->build = vips_stats_build;
sclass->start = vips_stats_start;

26
libvips/colour/icc_transform.c
View File

@ -540,9 +540,33 @@ vips_image_expected_sig( VipsImage *image )
expected_sig = cmsSigYxyData;
break;
case VIPS_INTERPRETATION_MULTIBAND:
/* A generic many-band image. Try to guess from the number of
* image bands instead.
*/
switch( image->Bands ) {
case 1:
case 2:
expected_sig = cmsSigGrayData;
break;
case 3:
expected_sig = cmsSigRgbData;
break;
case 4:
case 5:
expected_sig = cmsSigCmykData;
break;
default:
expected_sig = -1;
break;
}
break;
case VIPS_INTERPRETATION_LCH:
case VIPS_INTERPRETATION_CMC:
case VIPS_INTERPRETATION_MULTIBAND:
case VIPS_INTERPRETATION_HISTOGRAM:
case VIPS_INTERPRETATION_MATRIX:
case VIPS_INTERPRETATION_FOURIER:

1
libvips/conversion/Makefile.am
View File

@ -1,6 +1,7 @@
noinst_LTLIBRARIES = libconversion.la
libconversion_la_SOURCES = \
transpose3d.c \
composite.cpp \
smartcrop.c \
conversion.c \

3
libvips/conversion/bandjoin.c
View File

@ -499,7 +499,8 @@ vips_bandjoin_const1( VipsImage *in, VipsImage **out, double c, ... )
return( result );
}
/* vips_addalpha: (method)
/**
* vips_addalpha: (method)
* @in: input image
* @out: (out): output image
* @...: %NULL-terminated list of optional named arguments

135
libvips/conversion/composite.cpp
View File

@ -7,6 +7,8 @@
* 30/1/18
* - remove number of images limit
* - allow one mode ... reused for all joins
* 11/8/18 [medakk]
* - x/y params let you position images
*/
/*
@ -47,7 +49,11 @@
#include <stdio.h>
#include <string.h>
#if _MSC_VER
#include <cstdlib>
#else
#include <stdlib.h>
#endif
#include <math.h>
#include <vips/vips.h>
@ -92,6 +98,13 @@ typedef struct _VipsCompositeBase {
*/
gboolean premultiplied;
/* The x and y positions for each image in the stack. There are n - 1
* of these, since image 0 is always positioned at (0, 0). Set by
* subclasses. Can be NULL.
*/
int *x_offset;
int *y_offset;
/* The number of inputs. This can be less than the number of images in
* @in.
*/
@ -160,7 +173,7 @@ vips_composite_stop( void *vseq, void *a, void *b )
{
VipsCompositeSequence *seq = (VipsCompositeSequence *) vseq;
if( seq->ir ) {
if( seq->ir ) {
int i;
for( i = 0; seq->ir[i]; i++ )
@ -196,7 +209,7 @@ vips_composite_start( VipsImage *out, void *a, void *b )
for( n = 0; in[n]; n++ )
;
/* Alocate space for region array.
/* Allocate space for region array.
*/
if( !(seq->ir = VIPS_ARRAY( NULL, n + 1, VipsRegion * )) ) {
vips_composite_stop( seq, NULL, NULL );
@ -210,6 +223,7 @@ vips_composite_start( VipsImage *out, void *a, void *b )
vips_composite_stop( seq, NULL, NULL );
return( NULL );
}
seq->ir[n] = NULL;
/* Input pointers.
@ -1153,13 +1167,43 @@ vips_composite_base_build( VipsObject *object )
composite->max_band_vec[b] = composite->max_band[b];
#endif /*HAVE_VECTOR_ARITH*/
/* Transform the input images to match in size and format. We may have
/* Transform the input images to match format. We may have
* mixed float and double, for example.
*/
format = (VipsImage **) vips_object_local_array( object, composite->n );
if( vips__formatalike_vec( in, format, composite->n ) )
return( -1 );
in = format;
/* Position all images, if x/y is set.
*/
if( composite->x_offset &&
composite->y_offset ) {
int width = vips_image_get_width( in[0] );
int height = vips_image_get_height( in[0] );
VipsImage **position = (VipsImage **)
vips_object_local_array( object, composite->n );
/* The zero image does not move.
*/
g_object_ref( in[0] );
position[0] = in[0];
for( int i = 1; i < composite->n; i++ )
if( vips_embed( in[i], &position[i],
composite->x_offset[i - 1],
composite->y_offset[i - 1],
width, height, NULL ) )
return( -1 );
in = position;
}
/* Transform the input images to match in size. They can be mismatched
* if there was no supplied x/y.
*/
size = (VipsImage **) vips_object_local_array( object, composite->n );
if( vips__formatalike_vec( in, format, composite->n ) ||
vips__sizealike_vec( format, size, composite->n ) )
if( vips__sizealike_vec( in, size, composite->n ) )
return( -1 );
in = size;
@ -1221,6 +1265,14 @@ vips_composite_base_init( VipsCompositeBase *composite )
typedef struct _VipsComposite {
VipsCompositeBase parent_instance;
/* For N input images, N - 1 x coordinates.
*/
VipsArrayInt *x;
/* For N input images, N - 1 y coordinates.
*/
VipsArrayInt *y;
} VipsComposite;
typedef VipsCompositeBaseClass VipsCompositeClass;
@ -1231,6 +1283,44 @@ extern "C" {
G_DEFINE_TYPE( VipsComposite, vips_composite, vips_composite_base_get_type() );
}
static int
vips_composite_build( VipsObject *object )
{
VipsObjectClass *klass = VIPS_OBJECT_GET_CLASS( object );
VipsCompositeBase *base = (VipsCompositeBase *) object;
VipsComposite *composite = (VipsComposite *) object;
int n;
n = 0;
if( vips_object_argument_isset( object, "in" ) )
n = base->in->area.n;
if( vips_object_argument_isset( object, "x" ) ) {
if( composite->x->area.n != n - 1 ) {
vips_error( klass->nickname,
_( "must be %d x coordinates" ), n - 1 );
return( -1 );
}
base->x_offset = (int *) composite->x->area.data;
}
if( vips_object_argument_isset( object, "y" ) ) {
if( composite->y->area.n != n - 1 ) {
vips_error( klass->nickname,
_( "must be %d y coordinates" ), n - 1 );
return( -1 );
}
base->y_offset = (int *) composite->y->area.data;
}
if( VIPS_OBJECT_CLASS( vips_composite_parent_class )->
build( object ) )
return( -1 );
return( 0 );
}
static void
vips_composite_class_init( VipsCompositeClass *klass )
{
@ -1246,7 +1336,7 @@ vips_composite_class_init( VipsCompositeClass *klass )
vobject_class->nickname = "composite";
vobject_class->description =
_( "blend an array of images with an array of blend modes" );
vobject_class->build = vips_composite_base_build;
vobject_class->build = vips_composite_build;
operation_class->flags = VIPS_OPERATION_SEQUENTIAL;
@ -1264,6 +1354,20 @@ vips_composite_class_init( VipsCompositeClass *klass )
G_STRUCT_OFFSET( VipsCompositeBase, mode ),
VIPS_TYPE_ARRAY_INT );
VIPS_ARG_BOXED( klass, "x", 4,
_( "x coordinates" ),
_( "Array of x coordinates to join at" ),
VIPS_ARGUMENT_OPTIONAL_INPUT,
G_STRUCT_OFFSET( VipsComposite, x ),
VIPS_TYPE_ARRAY_INT );
VIPS_ARG_BOXED( klass, "y", 5,
_( "y coordinates" ),
_( "Array of y coordinates to join at" ),
VIPS_ARGUMENT_OPTIONAL_INPUT,
G_STRUCT_OFFSET( VipsComposite, y ),
VIPS_TYPE_ARRAY_INT );
}
static void
@ -1310,6 +1414,8 @@ typedef struct _VipsComposite2 {
VipsImage *base;
VipsImage *overlay;
VipsBlendMode mode;
int x;
int y;
} VipsComposite2;
@ -1341,6 +1447,9 @@ vips_composite2_build( VipsObject *object )
base->mode = vips_array_int_new( mode, 1 );
}
base->x_offset = &composite2->x;
base->y_offset = &composite2->y;
if( VIPS_OBJECT_CLASS( vips_composite2_parent_class )->build( object ) )
return( -1 );
@ -1385,6 +1494,20 @@ vips_composite2_class_init( VipsCompositeClass *klass )
G_STRUCT_OFFSET( VipsComposite2, mode ),
VIPS_TYPE_BLEND_MODE, VIPS_BLEND_MODE_OVER );
VIPS_ARG_INT( klass, "x", 4,
_( "x" ),
_( "x position of overlay" ),
VIPS_ARGUMENT_OPTIONAL_INPUT,
G_STRUCT_OFFSET( VipsComposite2, x ),
-VIPS_MAX_COORD, VIPS_MAX_COORD, 0 );
VIPS_ARG_INT( klass, "y", 5,
_( "y" ),
_( "y position of overlay" ),
VIPS_ARGUMENT_OPTIONAL_INPUT,
G_STRUCT_OFFSET( VipsComposite2, y ),
-VIPS_MAX_COORD, VIPS_MAX_COORD, 0 );
}
static void

14
libvips/conversion/conversion.c
View File

@ -81,6 +81,8 @@
*
* * @compositing_space: #VipsInterpretation to composite in
* * @premultiplied: %gboolean, images are already premultiplied
* * @x: #VipsArrayInt, position of subimages
* * @y: #VipsArrayInt, position of subimages
*
* Composite an array of images together.
*
@ -106,7 +108,8 @@
* added to any input missing an alpha.
*
* The images do not need to match in size or format. They will be expanded to
* the smallest common size and format in the usual way.
* the smallest common size and format in the usual way. Images are positioned
* using the @x and @y parameters, if set.
*
* Image are normally treated as unpremultiplied, so this operation can be used
* directly on PNG images. If your images have been through vips_premultiply(),
@ -125,6 +128,13 @@
* @mode: composite with this blend mode
* @...: %NULL-terminated list of optional named arguments
*
* Optional arguments:
*
* * @compositing_space: #VipsInterpretation to composite in
* * @premultiplied: %gboolean, images are already premultiplied
* * @x: %gint, position of overlay
* * @y: %gint, position of overlay
*
* Composite @overlay on top of @base with @mode. See vips_composite().
*
* Returns: 0 on success, -1 on error
@ -377,6 +387,7 @@ vips_conversion_operation_init( void )
extern GType vips_bandbool_get_type( void );
extern GType vips_gaussnoise_get_type( void );
extern GType vips_grid_get_type( void );
extern GType vips_transpose3d_get_type( void );
extern GType vips_scale_get_type( void );
extern GType vips_wrap_get_type( void );
extern GType vips_zoom_get_type( void );
@ -427,6 +438,7 @@ vips_conversion_operation_init( void )
vips_bandbool_get_type();
vips_gaussnoise_get_type();
vips_grid_get_type();
vips_transpose3d_get_type();
vips_scale_get_type();
vips_wrap_get_type();
vips_zoom_get_type();

226
libvips/conversion/transpose3d.c Normal file
View File

@ -0,0 +1,226 @@
/* vips_transpose3d
*
* 30/4/18
* - from grid.c
*/
/*
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
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif /*HAVE_CONFIG_H*/
#include <vips/intl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vips/vips.h>
#include "pconversion.h"
typedef struct _VipsTranspose3d {
VipsConversion parent_instance;
VipsImage *in;
int page_height;
} VipsTranspose3d;
typedef VipsConversionClass VipsTranspose3dClass;
G_DEFINE_TYPE( VipsTranspose3d, vips_transpose3d, VIPS_TYPE_CONVERSION );
static int
vips_transpose3d_gen( VipsRegion *or, void *vseq, void *a, void *b,
gboolean *stop )
{
VipsRegion *ir = (VipsRegion *) vseq;
VipsImage *in = (VipsImage *) a;
VipsTranspose3d *transpose3d = (VipsTranspose3d *) b;
VipsRect *r = &or->valid;
int output_page_height = in->Ysize / transpose3d->page_height;
int y;
VipsRect tile;
tile = *r;
tile.height = 1;
for( y = 0; y < r->height; y++ ) {
/* y in output.
*/
int yo = r->top + y;
/* On output page.
*/
int yop = yo / output_page_height;
/* Line on output page.
*/
int yol = yo % output_page_height;
/* y of input page.
*/
int yip = yol * transpose3d->page_height;
/* y of input line.
*/
int yi = yip + yop;
tile.top = yi;
/* Render into or.
*/
if( vips_region_prepare_to( ir, or, &tile, tile.left, yo ) )
return( -1 );
}
return( 0 );
}
static int
vips_transpose3d_build( VipsObject *object )
{
VipsObjectClass *class = VIPS_OBJECT_GET_CLASS( object );
VipsConversion *conversion = VIPS_CONVERSION( object );
VipsTranspose3d *transpose3d = (VipsTranspose3d *) object;
VipsImage *in;
if( VIPS_OBJECT_CLASS( vips_transpose3d_parent_class )->
build( object ) )
return( -1 );
in = transpose3d->in;
if( vips_check_coding_known( class->nickname, in ) ||
vips_image_pio_input( in ) )
return( -1 );
if( !vips_object_argument_isset( object, "page_height" ) ) {
if( vips_image_get_int( in,
VIPS_META_PAGE_HEIGHT, &transpose3d->page_height ) )
return( -1 );
}
if( transpose3d->page_height <= 0 ||
in->Ysize % transpose3d->page_height != 0 ) {
vips_error( class->nickname, "%s", _( "bad page_height" ) );
return( -1 );
}
if( vips_image_pipelinev( conversion->out,
VIPS_DEMAND_STYLE_SMALLTILE, in, NULL ) )
return( -1 );
vips_image_set_int( conversion->out,
VIPS_META_PAGE_HEIGHT, in->Ysize / transpose3d->page_height );
if( vips_image_generate( conversion->out,
vips_start_one, vips_transpose3d_gen, vips_stop_one,
in, transpose3d ) )
return( -1 );
return( 0 );
}
static void
vips_transpose3d_class_init( VipsTranspose3dClass *class )
{
GObjectClass *gobject_class = G_OBJECT_CLASS( class );
VipsObjectClass *vobject_class = VIPS_OBJECT_CLASS( class );
gobject_class->set_property = vips_object_set_property;
gobject_class->get_property = vips_object_get_property;
vobject_class->nickname = "transpose3d";
vobject_class->description = _( "transpose3d an image" );
vobject_class->build = vips_transpose3d_build;
VIPS_ARG_IMAGE( class, "in", 1,
_( "Input" ),
_( "Input image" ),
VIPS_ARGUMENT_REQUIRED_INPUT,
G_STRUCT_OFFSET( VipsTranspose3d, in ) );
VIPS_ARG_INT( class, "page_height", 3,
_( "Page height" ),
_( "Height of each input page" ),
VIPS_ARGUMENT_OPTIONAL_INPUT,
G_STRUCT_OFFSET( VipsTranspose3d, page_height ),
0, 10000000, 0 );
}
static void
vips_transpose3d_init( VipsTranspose3d *transpose3d )
{
}
/**
* vips_transpose3d: (method)
* @in: input image
* @out: (out): output image
* @...: %NULL-terminated list of optional named arguments
*
* Optional arguments:
*
* @page_height: %gint, size of each input page
*
* Transpose a volumetric image.
*
* Volumetric images are very tall, thin images, with the metadata item
* #VIPS_META_PAGE_HEIGHT set to the height of each sub-image.
*
* This operation swaps the two major dimensions, so that page N in the
* output contains the Nth scanline, in order, from each input page.
*
* You can override the #VIPS_META_PAGE_HEIGHT metadata item with the optional
* @page_height parameter.
*
* #VIPS_META_PAGE_HEIGHT in the output image is the number of pages in the
* input image.
*
* See also: vips_grid().
*
* Returns: 0 on success, -1 on error
*/
int
vips_transpose3d( VipsImage *in, VipsImage **out, ... )
{
va_list ap;
int result;
va_start( ap, out );
result = vips_call_split( "transpose3d", ap, in, out );
va_end( ap );
return( result );
}

2
libvips/convolution/convasep.c
View File

@ -372,7 +372,7 @@ vips_convasep_stop( void *vseq, void *a, void *b )
static void *
vips_convasep_start( VipsImage *out, void *a, void *b )
{
VipsImage *in = (IMAGE *) a;
VipsImage *in = (VipsImage *) a;
VipsConvasep *convasep = (VipsConvasep *) b;
VipsConvasepSeq *seq;

6
libvips/convolution/convf.c
View File

@ -176,7 +176,7 @@ vips_convf_start( VipsImage *out, void *a, void *b )
/* Convolve!
*/
static int
vips_convf_gen( REGION *or, void *vseq, void *a, void *b, gboolean *stop )
vips_convf_gen( VipsRegion *or, void *vseq, void *a, void *b, gboolean *stop )
{
VipsConvfSequence *seq = (VipsConvfSequence *) vseq;
VipsConvf *convf = (VipsConvf *) b;
@ -337,8 +337,8 @@ vips_convf_build( VipsObject *object )
/* Prepare output. Consider a 7x7 mask and a 7x7 image --- the output
* would be 1x1.
*/
if( vips_bandfmt_isint( in->BandFmt ) )
convolution->out->BandFmt = IM_BANDFMT_FLOAT;
if( vips_band_format_isint( in->BandFmt ) )
convolution->out->BandFmt = VIPS_FORMAT_FLOAT;
convolution->out->Xsize -= M->Xsize - 1;
convolution->out->Ysize -= M->Ysize - 1;

2
libvips/convolution/convi.c
View File

@ -909,7 +909,7 @@ vips_convi_intize( VipsConvi *convi, VipsImage *M )
* later, so 1.0 (for example) would become 128, which is outside
* signed 8 bit.
*/
shift = ceil( log2( mx + 1 ) );
shift = ceil( log2( mx ) + 1 );
/* We need to sum n_points, so we have to shift right before adding a
* new value to make sure we have enough range.

2
libvips/create/perlin.c
View File

@ -267,7 +267,7 @@ vips_perlin_make_tables( void *client )
int i;
for( i = 0; i < 256; i++ ) {
double angle = 2 * M_PI * i / 256.0;
double angle = 2 * VIPS_PI * i / 256.0;
vips_perlin_cos[i] = cos( angle );
vips_perlin_sin[i] = sin( angle );

2
libvips/deprecated/Makefile.am
View File

@ -1,6 +1,8 @@
noinst_LTLIBRARIES = libdeprecated.la
libdeprecated_la_SOURCES = \
video_dispatch.c \
im_video_test.c \
cimg_dispatch.c \
inplace_dispatch.c \
tone.c \

1
libvips/deprecated/arith_dispatch.c
View File

@ -38,6 +38,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* One image in, one out.
*/

1
libvips/deprecated/cimg_dispatch.c
View File

@ -36,6 +36,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
static int
greyc_vec( im_object *argv )

1
libvips/deprecated/colour_dispatch.c
View File

@ -38,6 +38,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* One image in, one out.
*/

1
libvips/deprecated/conver_dispatch.c
View File

@ -36,6 +36,7 @@
#include <vips/intl.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
static int
system_vec( im_object *argv )

1
libvips/deprecated/convol_dispatch.c
View File

@ -38,6 +38,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* One image in, one out.
*/

1
libvips/deprecated/cooc_funcs.c
View File

@ -75,6 +75,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
static
int im_cooc_sym(IMAGE *im, IMAGE *m, int xpos, int ypos, int xsize, int ysize, int dx, int dy)

1
libvips/deprecated/deprecated_dispatch.c
View File

@ -36,6 +36,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
/* One image in, one out.

1
libvips/deprecated/dispatch_types.c
View File

@ -47,6 +47,7 @@
#include <string.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
/* String containing each of the characters which can be used within a

1
libvips/deprecated/fits.c
View File

@ -41,6 +41,7 @@
#include <string.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
#include <vips/debug.h>

1
libvips/deprecated/format.c
View File

@ -36,6 +36,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
/* To iterate over supported formats, we build a temp list of subclasses of

1
libvips/deprecated/format_dispatch.c
View File

@ -36,6 +36,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
static int
jpeg2vips_vec( im_object *argv )

1
libvips/deprecated/freq_dispatch.c
View File

@ -41,6 +41,7 @@
#include <stdarg.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* One image in, one out.
*/

1
libvips/deprecated/glds_funcs.c
View File

@ -72,6 +72,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* Keep the greylevel difference matrix as a 256x1 double image */

1
libvips/deprecated/hist_dispatch.c
View File

@ -38,6 +38,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* One image in, one out.
*/

1
libvips/deprecated/im_align_bands.c
View File

@ -39,6 +39,7 @@
#include <vips/intl.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/**
* im_align_bands:

1
libvips/deprecated/im_analyze2vips.c
View File

@ -41,6 +41,7 @@
#include <vips/intl.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
static VipsFormatFlags
analyze_flags( const char *filename )

1
libvips/deprecated/im_benchmark.c
View File

@ -45,6 +45,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/*

1
libvips/deprecated/im_bernd.c
View File

@ -52,6 +52,7 @@
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
static int
extract( IMAGE *in, int x, int y, int w, int h )

1
libvips/deprecated/im_clamp.c
View File

@ -48,6 +48,7 @@
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
int

1
libvips/deprecated/im_cmulnorm.c
View File

@ -47,6 +47,7 @@
#include <vips/intl.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <stdio.h>
#include <stdlib.h>

1
libvips/deprecated/im_convsub.c
View File

@ -55,6 +55,7 @@
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
/* Create multiplication luts for all non zero elements of the original mask;

1
libvips/deprecated/im_csv2vips.c
View File

@ -43,6 +43,7 @@
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include "../foreign/pforeign.h"

1
libvips/deprecated/im_debugim.c
View File

@ -57,6 +57,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
int
im_debugim( IMAGE *in )

1
libvips/deprecated/im_dif_std.c
View File

@ -45,6 +45,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
static int

1
libvips/deprecated/im_exr2vips.c
View File

@ -46,6 +46,7 @@
#include <string.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/thread.h>
#include <vips/internal.h>

1
libvips/deprecated/im_fav4.c
View File

@ -38,6 +38,7 @@ Copyright (C) 1992, Kirk Martinez, History of Art Dept, Birkbeck College
#include <string.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#define ARGS "fav4: frame average 4 frames\nARGS: im1 im2 im3 im4 outfile"
#define NFRAMES 4

1
libvips/deprecated/im_freq_mask.c
View File

@ -46,6 +46,7 @@
#include <stdarg.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
/* Make a mask image.

1
libvips/deprecated/im_gadd.c
View File

@ -57,6 +57,7 @@
#include <assert.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
int im_gfadd(double a, IMAGE *in1, double b, IMAGE *in2, double c, IMAGE *out);
int im_gaddim(double a, IMAGE *in1, double b, IMAGE *in2, double c, IMAGE *out);

1
libvips/deprecated/im_gaddim.c
View File

@ -58,6 +58,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* This function works on either mmaped files or on images in buffer
*/

1
libvips/deprecated/im_gfadd.c
View File

@ -61,6 +61,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* uchar char ushort short uint int float double */
static int array[8][8] = {

1
libvips/deprecated/im_gradcor.c
View File

@ -47,6 +47,7 @@
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/** LOCAL TYPES **/

1
libvips/deprecated/im_jpeg2vips.c
View File

@ -47,6 +47,7 @@
#include <setjmp.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include "../foreign/pforeign.h"

1
libvips/deprecated/im_lab_morph.c
View File

@ -45,6 +45,7 @@
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
int

1
libvips/deprecated/im_line.c
View File

@ -52,6 +52,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
int im_line(image, x1, y1, x2, y2, pelval)
IMAGE *image;

1
libvips/deprecated/im_linreg.c
View File

@ -50,6 +50,7 @@
#include <stdlib.h>
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/** TYPES **/

1
libvips/deprecated/im_litecor.c
View File

@ -66,6 +66,7 @@
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* If maximum output is > 255 scale output between minout and maxout,
* by normalising maxout to 255.

1
libvips/deprecated/im_magick2vips.c
View File

@ -41,6 +41,7 @@
#include <vips/intl.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include "../foreign/pforeign.h"

1
libvips/deprecated/im_mask2vips.c
View File

@ -45,6 +45,7 @@
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/**
* im_mask2vips:

1
libvips/deprecated/im_matcat.c
View File

@ -42,6 +42,7 @@
#include <string.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/**
* im_matcat:

1
libvips/deprecated/im_matinv.c
View File

@ -54,6 +54,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/** CONSTANTS **/

1
libvips/deprecated/im_matmul.c
View File

@ -41,6 +41,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/**
* im_matmul:

1
libvips/deprecated/im_mattrn.c
View File

@ -39,6 +39,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/**
* im_mattrn:

1
libvips/deprecated/im_maxpos_avg.c
View File

@ -62,6 +62,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
/* A position and maximum.

1
libvips/deprecated/im_maxpos_subpel.c
View File

@ -42,6 +42,7 @@
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#define MOST_OF( A, B ) ( (A) > 0.9 * (B) )

1
libvips/deprecated/im_measure.c
View File

@ -60,6 +60,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* Measure into array.
*/

1
libvips/deprecated/im_openslide2vips.c
View File

@ -50,6 +50,7 @@
#include <string.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/thread.h>
#include <vips/internal.h>

1
libvips/deprecated/im_png2vips.c
View File

@ -43,6 +43,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
#include "../foreign/pforeign.h"

1
libvips/deprecated/im_point_bilinear.c
View File

@ -45,6 +45,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/**
* im_point:

1
libvips/deprecated/im_ppm2vips.c
View File

@ -37,6 +37,7 @@
#include <vips/intl.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
int
im_ppm2vips( const char *filename, IMAGE *out )

1
libvips/deprecated/im_print.c
View File

@ -36,6 +36,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* Print a string to stdout, with a "\n". Sometimes useful for debugging
* language bindings.

1
libvips/deprecated/im_printlines.c
View File

@ -54,6 +54,7 @@
#include <stdio.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* Useful: Call a macro with the name, type pairs for all VIPS functions.
*/

1
libvips/deprecated/im_resize_linear.c
View File

@ -48,6 +48,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* What we do for each pel.
*/

1
libvips/deprecated/im_setbox.c
View File

@ -48,6 +48,7 @@
#include <sys/types.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
void im_setbox(IMAGE_BOX *pbox, int xst, int yst, int xsiz, int ysiz, int ch_select)
{

1
libvips/deprecated/im_simcontr.c
View File

@ -49,6 +49,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/**
* im_simcontr:

1
libvips/deprecated/im_slice.c
View File

@ -55,6 +55,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#define BRIGHT 255
#define GREY 128

1
libvips/deprecated/im_spatres.c
View File

@ -52,6 +52,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
int
im_spatres( IMAGE *in, IMAGE *out, int step )

1
libvips/deprecated/im_stretch3.c
View File

@ -62,6 +62,7 @@
#include <math.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* Data for the cubic interpolation function.
*/

1
libvips/deprecated/im_thresh.c
View File

@ -51,6 +51,7 @@
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/* Useful: Call a macro with the name, type pairs for all VIPS functions. */
#define BRIGHT 255

1
libvips/deprecated/im_tiff2vips.c
View File

@ -46,6 +46,7 @@
#include <string.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
#include <vips/thread.h>

1
libvips/video/im_video_test.c → libvips/deprecated/im_video_test.c
View File

@ -34,6 +34,7 @@
#include <vips/intl.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/**
* im_video_test:

1
libvips/deprecated/im_vips2csv.c
View File

@ -37,6 +37,7 @@
#include <vips/intl.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
int
im_vips2csv( IMAGE *in, const char *filename )

1
libvips/deprecated/im_vips2dz.c
View File

@ -45,6 +45,7 @@
#include <string.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
int
im_vips2dz( IMAGE *in, const char *filename )

1
libvips/deprecated/im_vips2jpeg.c
View File

@ -46,6 +46,7 @@
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
int

1
libvips/deprecated/im_vips2mask.c
View File

@ -48,6 +48,7 @@
#include <string.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
/**
* im_vips2mask:

1
libvips/deprecated/im_vips2png.c
View File

@ -45,6 +45,7 @@
#include <string.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
#include <vips/internal.h>
#include <vips/debug.h>

1
libvips/deprecated/im_vips2ppm.c
View File

@ -39,6 +39,7 @@
#include <string.h>
#include <vips/vips.h>
#include <vips/vips7compat.h>
int
im_vips2ppm( IMAGE *in, const char *filename )

Some files were not shown because too many files have changed in this diff Show More