split to a separate branch

TODO

@@ -1,4 +1,23 @@
-- remove VipsCollect
+- output arrays need an extra * in
+
+  body must be:
+
+  	std::vector<double> *out_array;
+
+	call( "thing", options->set( "out-array", &out_array ) ); 
+
+  and call will new() a vector and place the pointer in out_array
+
+  alternative:
+
+  	std::vector<double> out_array;
+
+	call( "thing", options->set( "out-array", &out_array ) ); 
+
+  now the caller must pass in an empty vector (or not?) which we fill (or
+  empty?) ... seems odd, but makes lifetime management much simpler
+
+
 
 
 

cplusplus/Makefile.am

@@ -19,17 +19,14 @@ libvips_cc_la_LDFLAGS = \
 libvips_cc_la_LIBADD = \
 	$(top_builddir)/libvips/libvips.la @VIPS_LIBS@
 
-# swap the 'awk' line for this:
-# awk '{if($$1!="deprecated") print $$1}'` ; \
-# to not generate the wrappers for deprecated functions
 vips-operators.cc:
-	packages=`vips list packages | \
+	echo "// bodies for vips operations" > vips-operators.cc; \
-	  awk '{print $$1}'` ; \
+	echo -n "// " >> vips-operators.cc; \
-	  echo > vips-operators.cc ; \
+	date >> vips-operators.cc; \
-	  for name in $$packages; do \
+	echo "// this file is generated automatically, do not edit!" >> vips-operators.cc; \
-	    echo "// bodies for package $$name" >> vips-operators.cc ; \
+	echo "" >> vips-operators.cc; \
-	    vips cppc $$name >> vips-operators.cc ; \
+	./gen-operators.py >> vips-operators.cc 
-	    echo >> vips-operators.cc ; \
-	  done 
 
-EXTRA_DIST = vips-operators.cc
+EXTRA_DIST = \
+	     vips-operators.cc \
+	     gen-operators.py

cplusplus/VImage.cc

@@ -90,6 +90,52 @@ VOption *VOption::set( const char *name, VImage value )
 	return( this );
 }
 
+// input double array
+VOption *VOption::set( const char *name, std::vector<double> value )
+{
+	Pair *pair = new Pair( name );
+
+	double *array;
+	unsigned int i; 
+
+	pair->input = true;
+
+	vips_value_set_array_double( &pair->value, NULL, value.size() ); 
+	array = vips_value_get_array_double( &pair->value, NULL ); 
+
+	for( i = 0; i < value.size(); i++ )  
+		array[i] = value[i]; 
+
+	options.push_back( pair );
+
+	return( this );
+}
+
+// input image array
+VOption *VOption::set( const char *name, std::vector<VImage> value )
+{
+	Pair *pair = new Pair( name );
+
+	VipsImage **array;
+	unsigned int i; 
+
+	pair->input = true;
+
+	vips_value_set_array_image( &pair->value, value.size() );
+	array = vips_value_get_array_image( &pair->value, NULL );
+
+	for( i = 0; i < value.size(); i++ ) { 
+		VipsImage *vips_image = value[i].get_image();
+
+		array[i] = vips_image; 
+		g_object_ref( vips_image );  
+	}
+
+	options.push_back( pair );
+
+	return( this );
+}
+
 // output image
 VOption *VOption::set( const char *name, VImage *value )
 {
@@ -105,6 +151,50 @@ VOption *VOption::set( const char *name, VImage *value )
 	return( this );
 }
 
+// output double
+VOption *VOption::set( const char *name, double *value )
+{
+	Pair *pair = new Pair( name );
+
+	// note where we will write the VImage on success
+	pair->input = false;
+	pair->vdouble = value;
+	g_value_init( &pair->value, G_TYPE_DOUBLE );
+
+	options.push_back( pair );
+
+	return( this );
+}
+
+// output int
+VOption *VOption::set( const char *name, int *value )
+{
+	Pair *pair = new Pair( name );
+
+	// note where we will write the VImage on success
+	pair->input = false;
+	pair->vint = value;
+	g_value_init( &pair->value, G_TYPE_INT );
+
+	options.push_back( pair );
+
+	return( this );
+}
+
+// output doublearray
+VOption *VOption::set( const char *name, std::vector<double> **value )
+{
+	Pair *pair = new Pair( name );
+
+	// note where we will write the VImage on success
+	pair->input = false;
+	pair->vdoublearray = value;
+
+	options.push_back( pair );
+
+	return( this );
+}
+
 // walk the options and set props on the operation 
 void VOption::set_operation( VipsOperation *operation )
 {
@@ -133,23 +223,45 @@ void VOption::get_operation( VipsOperation *operation )
 
 	for( i = options.begin(); i != options.end(); i++ ) 
 		if( not (*i)->input ) {
+			const char *name = (*i)->name;
+			GValue *value = &(*i)->value;
+
 			g_object_get_property( G_OBJECT( operation ),
-				(*i)->name, &(*i)->value );
+				name, value );
 
 #ifdef DEBUG
 			printf( "get_operation: " );
 			vips_object_print_name( VIPS_OBJECT( operation ) );
-			char *str_value = 
+			char *str_value = g_strdup_value_contents( value );
-				g_strdup_value_contents( &(*i)->value );
+			printf( ".%s = %s\n", name, str_value );
-			printf( ".%s = %s\n", (*i)->name, str_value );
 			g_free( str_value );
 #endif /*DEBUG*/
 
-			// rebox object
+			GType type = G_VALUE_TYPE( value );
-			VipsImage *image = VIPS_IMAGE( 
+			if( type == VIPS_TYPE_IMAGE ) {
-				g_value_get_object( &(*i)->value ) );  
+				// rebox object
-			if( (*i)->vimage )
+				VipsImage *image = VIPS_IMAGE( 
+					g_value_get_object( value ) );  
 				*((*i)->vimage) = VImage( image ); 
+			}
+			else if( type == G_TYPE_INT ) 
+				*((*i)->vint) = g_value_get_int( value ); 
+			else if( type == G_TYPE_DOUBLE ) 
+				*((*i)->vint) = g_value_get_double( value ); 
+			else if( type == VIPS_TYPE_ARRAY_DOUBLE ) {
+				int length;
+				double *array = 
+					vips_value_get_array_double( value, 
+					&length );
+				std::vector<double> *vector = 
+					new std::vector<double>( length ); 
+				int j;
+
+				for( j = 0; j < length; j++ )
+					(*vector)[j] = array[j];
+
+				*((*i)->vdoublearray) = vector;
+			}
 		}
 }
 

cplusplus/gen-operators.py

@@ -0,0 +1,193 @@
+#!/usr/bin/python
+
+# walk vips and generate member definitions for all operators
+
+# sample member definition:
+
+# VImage VImage::invert( VOption *options )
+#	throw( VError )
+# {
+# 	VImage out;
+# 
+# 	call( "invert", 
+# 		(options ? options : VImage::option())-> 
+# 			set( "in", *this )->
+# 			set( "out", &out ) );
+# 
+# 	return( out );
+# }
+
+import sys
+import re
+
+import logging
+#logging.basicConfig(level = logging.DEBUG)
+
+from gi.repository import Vips, GObject
+
+vips_type_image = GObject.GType.from_name("VipsImage")
+vips_type_operation = GObject.GType.from_name("VipsOperation")
+param_enum = GObject.GType.from_name("GParamEnum")
+
+# turn a GType into a C++ type
+gtype_to_cpp = {
+    "VipsImage" : "VImage",
+    "gint" : "int",
+    "gdouble" : "double",
+    "gboolean" : "bool",
+    "gchararray" : "char *",
+    "VipsArrayDouble" : "std::vector<double>",
+    "VipsArrayImage" : "std::vector<VImage>",
+    "VipsBlob" : "void *"
+}
+
+def get_ctype(prop):
+    # enum params use the C name as their name
+    if GObject.type_is_a(param_enum, prop):
+        return prop.value_type.name
+
+    return gtype_to_cpp[prop.value_type.name]
+
+def find_required(op):
+    required = []
+    for prop in op.props:
+        flags = op.get_argument_flags(prop.name)
+        if not flags & Vips.ArgumentFlags.REQUIRED:
+            continue
+
+        required.append(prop)
+
+    return required
+
+# find the first input image ... this will be used as "this"
+def find_first_input_image(op, required):
+    found = False
+    for prop in required:
+        flags = op.get_argument_flags(prop.name)
+        if not flags & Vips.ArgumentFlags.INPUT:
+            continue
+        if GObject.type_is_a(vips_type_image, prop.value_type):
+            found = True
+            break
+
+    if not found:
+        return None
+
+    return prop
+
+# find the first output arg ... this will be used as the result
+def find_first_output(op, required):
+    found = False
+    for prop in required:
+        flags = op.get_argument_flags(prop.name)
+        if not flags & Vips.ArgumentFlags.OUTPUT:
+            continue
+        found = True
+        break
+
+    if not found:
+        return None
+
+    return prop
+
+# swap any "-" for "_"
+def cppize(name):
+    return re.sub('-', '_', name)
+
+def gen_arg_list(required):
+    first = True
+    for prop in required:
+        if not first:
+            print ',',
+        else:
+            first = False
+
+        print get_ctype(prop),
+        print cppize(prop.name),
+
+    if not first:
+        print ',',
+    print 'VOption *options',
+
+def gen_operation(cls):
+    op = Vips.Operation.new(cls.name)
+    gtype = Vips.type_find("VipsOperation", cls.name)
+    nickname = Vips.nickname_find(gtype)
+    all_required = find_required(op)
+
+    result = find_first_output(op, all_required)
+    this = find_first_input_image(op, all_required)
+
+    # shallow copy
+    required = all_required[:]
+    if result != None:
+        required.remove(result)
+    if this != None:
+        required.remove(this)
+
+    if result == None:
+        print 'void',
+    else:
+        print '%s' % gtype_to_cpp[result.value_type.name],
+
+    print 'VImage::%s(' % nickname,
+
+    gen_arg_list(required)
+
+    print ')'
+    print '    throw( VError )'
+    print '{'
+    if result != None:
+        print '    %s %s;' % (get_ctype(result), cppize(result.name))
+        print ''
+
+    print '    call( "%s"' % nickname,
+
+    first = True
+    for prop in all_required:
+        if first:
+            print ','
+            print '        (options ? options : VImage::option())',
+            first = False
+
+        print '->'
+        print '           ',
+        if prop == this:
+            print 'set( "%s", *this )' % prop.name,
+        else:
+            flags = op.get_argument_flags(prop.name)
+            arg = cppize(prop.name)
+            if flags & Vips.ArgumentFlags.OUTPUT:
+                arg = '&' + arg
+
+            print 'set( "%s", %s )' % (prop.name, arg),
+
+    print ');'
+
+    if result != None:
+        print ''
+        print '    return( %s );' % cppize(result.name)
+
+    print '}'
+    print ''
+
+# we have a few synonyms ... don't generate twice
+generated = {}
+
+def find_class_methods(cls):
+    if not cls.is_abstract():
+        gtype = Vips.type_find("VipsOperation", cls.name)
+        nickname = Vips.nickname_find(gtype)
+        if not nickname in generated:
+            gen_operation(cls)
+            generated[nickname] = True
+
+    if len(cls.children) > 0:
+        for child in cls.children:
+            # not easy to get at the deprecated flag in an abtract type?
+            if cls.name != 'VipsWrap7':
+                find_class_methods(child)
+
+if __name__ == '__main__':
+    find_class_methods(vips_type_operation)
+

cplusplus/include/vips/Makefile.am

@@ -4,15 +4,13 @@ pkginclude_HEADERS = \
 	vips8 \
 	vips-operators.h 
 
-# swap the 'awk' line for this:
-# awk '{if($$1!="deprecated") print $$1}'` ; \
-# to not generate the wrappers for deprecated functions
 vips-operators.h:
-	packages=`vips list packages | \
+	echo "// headers for vips operations" > vips-operators.h; \
-	  awk '{print $$1}'` ; \
+	echo -n "// " >> vips-operators.h; \
-	  echo > vips-operators.h ; \
+	date >> vips-operators.h; \
-	  for name in $$packages; do \
+	echo "// this file is generated automatically, do not edit!" >> vips-operators.h; \
-	    echo "// headers for package $$name" >> vips-operators.h ; \
+	echo "" >> vips-operators.h; \
-	    vips cpph $$name >> vips-operators.h ; \
+	./gen-operators-h.py >> vips-operators.h 
-	    echo >> vips-operators.h ; \
+
-	  done 
+EXTRA_DIST = \
+	     gen-operators-h.py

cplusplus/include/vips/VImage8.h

@@ -167,9 +167,20 @@ private:
 		// from the arg to set()
 		bool input; 
 
-		// we need to box and unbox VImage ... keep a pointer to the
+		union {
-		// VImage from C++ here
+			// we need to box and unbox VImage ... keep a pointer 
-		VImage *vimage;
+			// to the VImage from C++ here
+			VImage *vimage;
+
+			// output double
+			double *vdouble;
+
+			// output int
+			int *vint;
+
+			// output doublearray
+			std::vector<double> **vdoublearray;
+		}; 
 
 		Pair( const char *name ) : 
 			name( name ), input( false ), vimage( 0 )
@@ -196,6 +207,12 @@ public:
 	VOption *set( const char *name, int value );
 	VOption *set( const char *name, VImage value );
 	VOption *set( const char *name, VImage *value );
+	VOption *set( const char *name, std::vector<VImage> value );
+	VOption *set( const char *name, std::vector<double> value );
+
+	VOption *set( const char *name, int *value );
+	VOption *set( const char *name, double *value );
+	VOption *set( const char *name, std::vector<double> **value );
 
 	void set_operation( VipsOperation *operation );
 	void get_operation( VipsOperation *operation );

cplusplus/include/vips/gen-operators-h.py

@@ -0,0 +1,153 @@
+#!/usr/bin/python
+
+# walk vips and generate headers for all operators
+
+# sample member declaration :
+
+# VImage invert( VOption *options = 0 )
+#	throw( VError );
+
+import sys
+import re
+
+import logging
+#logging.basicConfig(level = logging.DEBUG)
+
+from gi.repository import Vips, GObject
+
+vips_type_image = GObject.GType.from_name("VipsImage")
+vips_type_operation = GObject.GType.from_name("VipsOperation")
+param_enum = GObject.GType.from_name("GParamEnum")
+
+# turn a GType into a C++ type
+gtype_to_cpp = {
+    "VipsImage" : "VImage",
+    "gint" : "int",
+    "gdouble" : "double",
+    "gboolean" : "bool",
+    "gchararray" : "char *",
+    "VipsArrayDouble" : "std::vector<double>",
+    "VipsArrayImage" : "std::vector<VImage>",
+    "VipsBlob" : "void *"
+}
+
+def get_ctype(prop):
+    # enum params use the C name as their name
+    if GObject.type_is_a(param_enum, prop):
+        return prop.value_type.name
+
+    return gtype_to_cpp[prop.value_type.name]
+
+def find_required(op):
+    required = []
+    for prop in op.props:
+        flags = op.get_argument_flags(prop.name)
+        if not flags & Vips.ArgumentFlags.REQUIRED:
+            continue
+
+        required.append(prop)
+
+    return required
+
+# find the first input image ... this will be used as "this"
+def find_first_input_image(op, required):
+    found = False
+    for prop in required:
+        flags = op.get_argument_flags(prop.name)
+        if not flags & Vips.ArgumentFlags.INPUT:
+            continue
+        if GObject.type_is_a(vips_type_image, prop.value_type):
+            found = True
+            break
+
+    if not found:
+        return None
+
+    return prop
+
+# find the first output arg ... this will be used as the result
+def find_first_output(op, required):
+    found = False
+    for prop in required:
+        flags = op.get_argument_flags(prop.name)
+        if not flags & Vips.ArgumentFlags.OUTPUT:
+            continue
+        found = True
+        break
+
+    if not found:
+        return None
+
+    return prop
+
+# swap any "-" for "_"
+def cppize(name):
+    return re.sub('-', '_', name)
+
+def gen_arg_list(required):
+    first = True
+    for prop in required:
+        if not first:
+            print ',',
+        else:
+            first = False
+
+        print get_ctype(prop),
+        print cppize(prop.name),
+
+    if not first:
+        print ',',
+    print 'VOption *options = 0',
+
+def gen_operation(cls):
+    op = Vips.Operation.new(cls.name)
+    gtype = Vips.type_find("VipsOperation", cls.name)
+    nickname = Vips.nickname_find(gtype)
+    all_required = find_required(op)
+
+    result = find_first_output(op, all_required)
+    this = find_first_input_image(op, all_required)
+
+    # shallow copy
+    required = all_required[:]
+    if result != None:
+        required.remove(result)
+    if this != None:
+        required.remove(this)
+
+    # no "this" available, it's a class method
+    if this == None:
+        print 'static',
+
+    if result == None:
+        print 'void',
+    else:
+        print '%s' % gtype_to_cpp[result.value_type.name],
+
+    print '%s(' % nickname,
+
+    gen_arg_list(required)
+
+    print ')'
+    print '    throw( VError );'
+
+# we have a few synonyms ... don't generate twice
+generated = {}
+
+def find_class_methods(cls):
+    if not cls.is_abstract():
+        gtype = Vips.type_find("VipsOperation", cls.name)
+        nickname = Vips.nickname_find(gtype)
+        if not nickname in generated:
+            gen_operation(cls)
+            generated[nickname] = True
+
+    if len(cls.children) > 0:
+        for child in cls.children:
+            # not easy to get at the deprecated flag in an abtract type?
+            if cls.name != 'VipsWrap7':
+                find_class_methods(child)
+
+if __name__ == '__main__':
+    find_class_methods(vips_type_operation)
+

cplusplus/include/vips/vips-operators.h

@@ -1 +1,412 @@
-VImage invert( VOption *options = 0 ) throw( VError );
+// headers for vips operations
+// Mon Oct 27 17:00:38 GMT 2014
+// this file is generated automatically, do not edit!
+
+static void system( char * cmd_format , VOption *options = 0 )
+    throw( VError );
+VImage add( VImage right , VOption *options = 0 )
+    throw( VError );
+VImage subtract( VImage right , VOption *options = 0 )
+    throw( VError );
+VImage multiply( VImage right , VOption *options = 0 )
+    throw( VError );
+VImage divide( VImage right , VOption *options = 0 )
+    throw( VError );
+VImage relational( VImage right , VipsOperationRelational relational , VOption *options = 0 )
+    throw( VError );
+VImage remainder( VImage right , VOption *options = 0 )
+    throw( VError );
+VImage boolean( VImage right , VipsOperationBoolean boolean , VOption *options = 0 )
+    throw( VError );
+VImage math2( VImage right , VipsOperationMath2 math2 , VOption *options = 0 )
+    throw( VError );
+VImage complex2( VImage right , VipsOperationComplex2 cmplx , VOption *options = 0 )
+    throw( VError );
+VImage complexform( VImage right , VOption *options = 0 )
+    throw( VError );
+static VImage sum( std::vector<VImage> in , VOption *options = 0 )
+    throw( VError );
+VImage invert( VOption *options = 0 )
+    throw( VError );
+VImage linear( std::vector<double> a , std::vector<double> b , VOption *options = 0 )
+    throw( VError );
+VImage math( VipsOperationMath math , VOption *options = 0 )
+    throw( VError );
+VImage abs( VOption *options = 0 )
+    throw( VError );
+VImage sign( VOption *options = 0 )
+    throw( VError );
+VImage round( VipsOperationRound round , VOption *options = 0 )
+    throw( VError );
+VImage relational_const( std::vector<double> c , VipsOperationRelational relational , VOption *options = 0 )
+    throw( VError );
+VImage remainder_const( std::vector<double> c , VOption *options = 0 )
+    throw( VError );
+VImage boolean_const( std::vector<double> c , VipsOperationBoolean boolean , VOption *options = 0 )
+    throw( VError );
+VImage math2_const( std::vector<double> c , VipsOperationMath2 math2 , VOption *options = 0 )
+    throw( VError );
+VImage complex( VipsOperationComplex cmplx , VOption *options = 0 )
+    throw( VError );
+VImage complexget( VipsOperationComplexget get , VOption *options = 0 )
+    throw( VError );
+double avg( VOption *options = 0 )
+    throw( VError );
+double min( VOption *options = 0 )
+    throw( VError );
+double max( VOption *options = 0 )
+    throw( VError );
+double deviate( VOption *options = 0 )
+    throw( VError );
+VImage stats( VOption *options = 0 )
+    throw( VError );
+VImage hist_find( VOption *options = 0 )
+    throw( VError );
+VImage hist_find_ndim( VOption *options = 0 )
+    throw( VError );
+VImage hist_find_indexed( VImage index , VOption *options = 0 )
+    throw( VError );
+VImage hough_line( VOption *options = 0 )
+    throw( VError );
+VImage hough_circle( VOption *options = 0 )
+    throw( VError );
+VImage project( VImage rows , VOption *options = 0 )
+    throw( VError );
+VImage profile( VImage rows , VOption *options = 0 )
+    throw( VError );
+VImage measure( int h , int v , VOption *options = 0 )
+    throw( VError );
+std::vector<double> getpoint( int x , int y , VOption *options = 0 )
+    throw( VError );
+VImage copy( VOption *options = 0 )
+    throw( VError );
+VImage blockcache( VOption *options = 0 )
+    throw( VError );
+VImage tilecache( VOption *options = 0 )
+    throw( VError );
+VImage linecache( VOption *options = 0 )
+    throw( VError );
+VImage sequential( VOption *options = 0 )
+    throw( VError );
+VImage cache( VOption *options = 0 )
+    throw( VError );
+VImage embed( int x , int y , int width , int height , VOption *options = 0 )
+    throw( VError );
+VImage flip( VipsDirection direction , VOption *options = 0 )
+    throw( VError );
+VImage insert( VImage sub , int x , int y , VOption *options = 0 )
+    throw( VError );
+VImage join( VImage in2 , VipsDirection direction , VOption *options = 0 )
+    throw( VError );
+VImage extract_area( int left , int top , int width , int height , VOption *options = 0 )
+    throw( VError );
+VImage extract_band( int band , VOption *options = 0 )
+    throw( VError );
+static VImage bandjoin( std::vector<VImage> in , VOption *options = 0 )
+    throw( VError );
+static VImage bandrank( std::vector<VImage> in , VOption *options = 0 )
+    throw( VError );
+VImage bandmean( VOption *options = 0 )
+    throw( VError );
+VImage bandbool( VipsOperationBoolean boolean , VOption *options = 0 )
+    throw( VError );
+VImage replicate( int across , int down , VOption *options = 0 )
+    throw( VError );
+VImage cast( VipsBandFormat format , VOption *options = 0 )
+    throw( VError );
+VImage rot( VipsAngle angle , VOption *options = 0 )
+    throw( VError );
+VImage rot45( VOption *options = 0 )
+    throw( VError );
+VImage autorot( VOption *options = 0 )
+    throw( VError );
+VImage ifthenelse( VImage in1 , VImage in2 , VOption *options = 0 )
+    throw( VError );
+VImage recomb( VImage m , VOption *options = 0 )
+    throw( VError );
+VImage flatten( VOption *options = 0 )
+    throw( VError );
+VImage grid( int tile_height , int across , int down , VOption *options = 0 )
+    throw( VError );
+VImage scale( VOption *options = 0 )
+    throw( VError );
+VImage wrap( VOption *options = 0 )
+    throw( VError );
+VImage zoom( int xfac , int yfac , VOption *options = 0 )
+    throw( VError );
+VImage subsample( int xfac , int yfac , VOption *options = 0 )
+    throw( VError );
+VImage msb( VOption *options = 0 )
+    throw( VError );
+VImage falsecolour( VOption *options = 0 )
+    throw( VError );
+VImage gamma( VOption *options = 0 )
+    throw( VError );
+static VImage black( int width , int height , VOption *options = 0 )
+    throw( VError );
+static VImage gaussnoise( int width , int height , VOption *options = 0 )
+    throw( VError );
+static VImage text( char * text , VOption *options = 0 )
+    throw( VError );
+static VImage xyz( int width , int height , VOption *options = 0 )
+    throw( VError );
+static VImage gaussmat( double sigma , double min_ampl , VOption *options = 0 )
+    throw( VError );
+static VImage logmat( double sigma , double min_ampl , VOption *options = 0 )
+    throw( VError );
+static VImage eye( int width , int height , VOption *options = 0 )
+    throw( VError );
+static VImage grey( int width , int height , VOption *options = 0 )
+    throw( VError );
+static VImage zone( int width , int height , VOption *options = 0 )
+    throw( VError );
+static VImage sines( int width , int height , VOption *options = 0 )
+    throw( VError );
+static VImage mask_ideal( int width , int height , double frequency_cutoff , VOption *options = 0 )
+    throw( VError );
+static VImage mask_ideal_ring( int width , int height , double frequency_cutoff , double ringwidth , VOption *options = 0 )
+    throw( VError );
+static VImage mask_ideal_band( int width , int height , double frequency_cutoff_x , double frequency_cutoff_y , double radius , VOption *options = 0 )
+    throw( VError );
+static VImage mask_butterworth( int width , int height , double order , double frequency_cutoff , double amplitude_cutoff , VOption *options = 0 )
+    throw( VError );
+static VImage mask_butterworth_ring( int width , int height , double order , double frequency_cutoff , double amplitude_cutoff , double ringwidth , VOption *options = 0 )
+    throw( VError );
+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 )
+    throw( VError );
+static VImage mask_gaussian( int width , int height , double frequency_cutoff , double amplitude_cutoff , VOption *options = 0 )
+    throw( VError );
+static VImage mask_gaussian_ring( int width , int height , double frequency_cutoff , double amplitude_cutoff , double ringwidth , VOption *options = 0 )
+    throw( VError );
+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 )
+    throw( VError );
+static VImage mask_fractal( int width , int height , double fractal_dimension , VOption *options = 0 )
+    throw( VError );
+VImage buildlut( VOption *options = 0 )
+    throw( VError );
+VImage invertlut( VOption *options = 0 )
+    throw( VError );
+static VImage tonelut( VOption *options = 0 )
+    throw( VError );
+static VImage identity( VOption *options = 0 )
+    throw( VError );
+static VImage fractsurf( int width , int height , double fractal_dimension , VOption *options = 0 )
+    throw( VError );
+static VImage radload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage ppmload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage csvload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage matrixload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage analyzeload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage rawload( char * filename , int width , int height , int bands , VOption *options = 0 )
+    throw( VError );
+static VImage vipsload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage pngload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage pngload_buffer( void * buffer , VOption *options = 0 )
+    throw( VError );
+static VImage matload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage jpegload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage jpegload_buffer( void * buffer , VOption *options = 0 )
+    throw( VError );
+static VImage webpload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage webpload_buffer( void * buffer , VOption *options = 0 )
+    throw( VError );
+static VImage tiffload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage tiffload_buffer( void * buffer , VOption *options = 0 )
+    throw( VError );
+static VImage openslideload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage magickload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage fitsload( char * filename , VOption *options = 0 )
+    throw( VError );
+static VImage openexrload( char * filename , VOption *options = 0 )
+    throw( VError );
+void radsave( char * filename , VOption *options = 0 )
+    throw( VError );
+void ppmsave( char * filename , VOption *options = 0 )
+    throw( VError );
+void csvsave( char * filename , VOption *options = 0 )
+    throw( VError );
+void matrixsave( char * filename , VOption *options = 0 )
+    throw( VError );
+void matrixprint( VOption *options = 0 )
+    throw( VError );
+void rawsave( char * filename , VOption *options = 0 )
+    throw( VError );
+void rawsave_fd( int fd , VOption *options = 0 )
+    throw( VError );
+void vipssave( char * filename , VOption *options = 0 )
+    throw( VError );
+void dzsave( char * filename , VOption *options = 0 )
+    throw( VError );
+void pngsave( char * filename , VOption *options = 0 )
+    throw( VError );
+void * pngsave_buffer( VOption *options = 0 )
+    throw( VError );
+void jpegsave( char * filename , VOption *options = 0 )
+    throw( VError );
+void * jpegsave_buffer( VOption *options = 0 )
+    throw( VError );
+void jpegsave_mime( VOption *options = 0 )
+    throw( VError );
+void webpsave( char * filename , VOption *options = 0 )
+    throw( VError );
+void * webpsave_buffer( VOption *options = 0 )
+    throw( VError );
+void tiffsave( char * filename , VOption *options = 0 )
+    throw( VError );
+void fitssave( char * filename , VOption *options = 0 )
+    throw( VError );
+VImage shrink( double xshrink , double yshrink , VOption *options = 0 )
+    throw( VError );
+VImage quadratic( VImage coeff , VOption *options = 0 )
+    throw( VError );
+VImage affine( std::vector<double> matrix , VOption *options = 0 )
+    throw( VError );
+VImage similarity( VOption *options = 0 )
+    throw( VError );
+VImage resize( double h_scale , double v_scale , VOption *options = 0 )
+    throw( VError );
+VImage colourspace( VipsInterpretation space , VOption *options = 0 )
+    throw( VError );
+VImage Lab2XYZ( VOption *options = 0 )
+    throw( VError );
+VImage XYZ2Lab( VOption *options = 0 )
+    throw( VError );
+VImage Lab2LCh( VOption *options = 0 )
+    throw( VError );
+VImage LCh2Lab( VOption *options = 0 )
+    throw( VError );
+VImage LCh2CMC( VOption *options = 0 )
+    throw( VError );
+VImage CMC2LCh( VOption *options = 0 )
+    throw( VError );
+VImage XYZ2Yxy( VOption *options = 0 )
+    throw( VError );
+VImage Yxy2XYZ( VOption *options = 0 )
+    throw( VError );
+VImage scRGB2XYZ( VOption *options = 0 )
+    throw( VError );
+VImage XYZ2scRGB( VOption *options = 0 )
+    throw( VError );
+VImage LabQ2Lab( VOption *options = 0 )
+    throw( VError );
+VImage Lab2LabQ( VOption *options = 0 )
+    throw( VError );
+VImage LabQ2LabS( VOption *options = 0 )
+    throw( VError );
+VImage LabS2LabQ( VOption *options = 0 )
+    throw( VError );
+VImage LabS2Lab( VOption *options = 0 )
+    throw( VError );
+VImage Lab2LabS( VOption *options = 0 )
+    throw( VError );
+VImage rad2float( VOption *options = 0 )
+    throw( VError );
+VImage float2rad( VOption *options = 0 )
+    throw( VError );
+VImage LabQ2sRGB( VOption *options = 0 )
+    throw( VError );
+VImage sRGB2scRGB( VOption *options = 0 )
+    throw( VError );
+VImage scRGB2sRGB( VOption *options = 0 )
+    throw( VError );
+VImage icc_import( VOption *options = 0 )
+    throw( VError );
+VImage icc_export( VOption *options = 0 )
+    throw( VError );
+VImage icc_transform( char * output_profile , VOption *options = 0 )
+    throw( VError );
+VImage dE76( VImage right , VOption *options = 0 )
+    throw( VError );
+VImage dE00( VImage right , VOption *options = 0 )
+    throw( VError );
+VImage dECMC( VImage right , VOption *options = 0 )
+    throw( VError );
+VImage maplut( VImage lut , VOption *options = 0 )
+    throw( VError );
+int percent( double percent , VOption *options = 0 )
+    throw( VError );
+VImage stdif( int width , int height , VOption *options = 0 )
+    throw( VError );
+VImage hist_cum( VOption *options = 0 )
+    throw( VError );
+VImage hist_match( VImage ref , VOption *options = 0 )
+    throw( VError );
+VImage hist_norm( VOption *options = 0 )
+    throw( VError );
+VImage hist_equal( VOption *options = 0 )
+    throw( VError );
+VImage hist_plot( VOption *options = 0 )
+    throw( VError );
+VImage hist_local( int width , int height , VOption *options = 0 )
+    throw( VError );
+bool hist_ismonotonic( VOption *options = 0 )
+    throw( VError );
+VImage conv( VImage mask , VOption *options = 0 )
+    throw( VError );
+VImage compass( VImage mask , VOption *options = 0 )
+    throw( VError );
+VImage convsep( VImage mask , VOption *options = 0 )
+    throw( VError );
+VImage fastcor( VImage ref , VOption *options = 0 )
+    throw( VError );
+VImage spcor( VImage ref , VOption *options = 0 )
+    throw( VError );
+VImage sharpen( VOption *options = 0 )
+    throw( VError );
+VImage gaussblur( int radius , VOption *options = 0 )
+    throw( VError );
+VImage fwfft( VOption *options = 0 )
+    throw( VError );
+VImage invfft( VOption *options = 0 )
+    throw( VError );
+VImage freqmult( VImage mask , VOption *options = 0 )
+    throw( VError );
+VImage spectrum( VOption *options = 0 )
+    throw( VError );
+VImage phasecor( VImage in2 , VOption *options = 0 )
+    throw( VError );
+VImage morph( VImage mask , VipsOperationMorphology morph , VOption *options = 0 )
+    throw( VError );
+VImage rank( int width , int height , int index , VOption *options = 0 )
+    throw( VError );
+double countlines( VipsDirection direction , VOption *options = 0 )
+    throw( VError );
+VImage labelregions( VOption *options = 0 )
+    throw( VError );
+void draw_rect( std::vector<double> ink , int left , int top , int width , int height , VOption *options = 0 )
+    throw( VError );
+void draw_mask( std::vector<double> ink , VImage mask , int x , int y , VOption *options = 0 )
+    throw( VError );
+void draw_line( std::vector<double> ink , int x1 , int y1 , int x2 , int y2 , VOption *options = 0 )
+    throw( VError );
+void draw_circle( std::vector<double> ink , int cx , int cy , int radius , VOption *options = 0 )
+    throw( VError );
+void draw_flood( std::vector<double> ink , int x , int y , VOption *options = 0 )
+    throw( VError );
+void draw_image( VImage sub , int x , int y , VOption *options = 0 )
+    throw( VError );
+void draw_smudge( int left , int top , int width , int height , VOption *options = 0 )
+    throw( VError );
+VImage merge( VImage sec , VipsDirection direction , int dx , int dy , VOption *options = 0 )
+    throw( VError );
+VImage mosaic( VImage sec , VipsDirection direction , int xref , int yref , int xsec , int ysec , VOption *options = 0 )
+    throw( VError );
+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 )
+    throw( VError );
+VImage match( VImage sec , int xr1 , int yr1 , int xs1 , int ys1 , int xr2 , int yr2 , int xs2 , int ys2 , VOption *options = 0 )
+    throw( VError );
+VImage globalbalance( VOption *options = 0 )
+    throw( VError );

libvips/iofuncs/type.c

@@ -1458,7 +1458,7 @@ vips_value_get_array_image( const GValue *value, int *n )
  * @value: (out): %GValue to get from
  * @n: the number of elements 
  *
- * Set @value to hold a copy of @array. Pass in the array length in @n. 
+ * Set @value to hold an array of images. Pass in the array length in @n. 
  *
  * See also: vips_array_image_get().
  */
@@ -1479,7 +1479,7 @@ vips_value_set_array_image( GValue *value, int n )
  * @n: (allow-none): return the number of elements here, optionally
  *
  * Return the start of the array of %GObject held by @value.
- * optionally return the number of elements in @n.
+ * Optionally return the number of elements in @n.
  *
  * See also: vips_array_object_set().
  *