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

cleanup and bump to 7.42

Browse Source
This commit is contained in:
John Cupitt 2014-11-03 12:01:53 +00:00
parent 63469b1c9d
commit bbf49be063
25 changed files with 80 additions and 2397 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
configure.ac
View File

@ -2,7 +2,7 @@
# also update the version number in the m4 macros below # also update the version number in the m4 macros below
AC_INIT([vips], [7.41.0], [vipsip@jiscmail.ac.uk]) AC_INIT([vips], [7.42.0], [vipsip@jiscmail.ac.uk])
# required for gobject-introspection # required for gobject-introspection
AC_PREREQ(2.62) AC_PREREQ(2.62)
@ -17,7 +17,7 @@ AC_CONFIG_MACRO_DIR([m4])
# user-visible library versioning # user-visible library versioning
m4_define([vips_major_version], [7]) m4_define([vips_major_version], [7])
m4_define([vips_minor_version], [41]) m4_define([vips_minor_version], [42])
m4_define([vips_micro_version], [0]) m4_define([vips_micro_version], [0])
m4_define([vips_version], m4_define([vips_version],
[vips_major_version.vips_minor_version.vips_micro_version]) [vips_major_version.vips_minor_version.vips_micro_version])

1
cplusplus/Makefile.am
View File

@ -28,5 +28,6 @@ vips-operators.cc:
./gen-operators.py >> vips-operators.cc ./gen-operators.py >> vips-operators.cc
EXTRA_DIST = \ EXTRA_DIST = \
README.txt \
vips-operators.cc \ vips-operators.cc \
gen-operators.py gen-operators.py

5
cplusplus/README Normal file
View File

@ -0,0 +1,5 @@
This is the vips8 C++ binding.
The old vips7 binding is still there, but this one is better. See the vips API
docs for documentation.

169
cplusplus/old/try92.cc
View File

@ -1,169 +0,0 @@
/*
* compile with:
*
* g++ -g -Wall try92.cc `pkg-config vips --cflags --libs`
*
*/
#include <vips/vips.h>
enum VSteal {
NOSTEAL = 0,
STEAL = 1
};
class VObject
{
private:
GObject *gobject;
public:
VObject( GObject *new_gobject, VSteal steal = STEAL ) :
gobject( new_gobject )
{
printf( "VObject constructor, obj = %p, steal = %d\n",
new_gobject, steal );
if( !steal ) {
printf( " reffing object\n" );
g_object_ref( gobject );
}
}
// copy constructor
VObject( const VObject &vobject ) :
gobject( vobject.gobject )
{
printf( "VObject copy constructor, obj = %p\n",
gobject );
g_object_ref( gobject );
printf( " reffing object\n" );
}
// assignment ... we must delete the old ref
VObject &operator=( const VObject &a )
{
GObject *old_gobject;
printf( "VObject assignment\n" );
printf( " reffing %p\n", a.gobject );
printf( " unreffing %p\n", gobject );
// delete the old ref at the end ... otherwise "a = a;" could
// unref before reffing again
old_gobject = gobject;
gobject = a.gobject;
g_object_ref( gobject );
g_object_unref( old_gobject );
return( *this );
}
~VObject()
{
printf( "VObject destructor\n" );
printf( " unreffing %p\n", gobject );
g_object_unref( gobject );
}
GObject &operator*()
{
return( *gobject );
}
GObject *operator->()
{
return( gobject );
}
GObject *get()
{
return( gobject );
}
};
class VImage : VObject
{
public:
VImage( VipsImage *image, VSteal steal = STEAL ) :
VObject( (GObject *) image, steal )
{
}
VipsImage *get()
{
return( (VipsImage *) VObject::get() );
}
};
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 );
}
/*
VipsImage *in;
VipsImage *out;
if( !(in = vips_image_new_from_file( argv[1], NULL )) )
vips_error_exit( NULL );
if( vips_invert( in, &out, NULL ) )
vips_error_exit( NULL );
if( vips_image_write_to_file( out, argv[2], NULL ) )
vips_error_exit( NULL );
g_object_unref( in );
g_object_unref( out );
*/
printf( "sizeof( VipsImage *) = %zd\n", sizeof( VipsImage *) );
printf( "sizeof( VImage ) = %zd\n", sizeof( VImage ) );
{
VipsImage *im;
if( !(im = vips_image_new_from_file( argv[1], NULL )) )
vips_error_exit( NULL );
VImage in( im );
VipsImage *out;
if( vips_invert( in, &out, NULL ) )
vips_error_exit( NULL );
if( vips_image_write_to_file( out, argv[2], NULL ) )
vips_error_exit( NULL );
g_object_unref( out );
}
vips_shutdown();
return( 0 );
}

492
cplusplus/old/try93.cc
View File

@ -1,492 +0,0 @@
/*
* compile with:
*
* g++ -g -Wall try93.cc `pkg-config vips --cflags --libs`
*
*/
#include <list>
#include <string>
#include <iosfwd>
#include <exception>
#include <vips/vips.h>
#include <vips/debug.h>
class VError : public std::exception {
std::string _what;
public:
VError( std::string what ) : _what( what ) {}
VError() : _what( vips_error_buffer() ) {}
virtual ~VError() throw() {}
// Extract string
virtual const char *what() const throw() { return _what.c_str(); }
void ostream_print( std::ostream & ) const;
};
inline std::ostream &operator<<( std::ostream &file, const VError &err )
{
err.ostream_print( file );
return( file );
}
void VError::ostream_print( std::ostream &file ) const
{
file << _what;
}
enum VSteal {
NOSTEAL = 0,
STEAL = 1
};
class VObject
{
private:
// can be NULL, see eg. VObject()
VipsObject *vobject;
public:
VObject( VipsObject *new_vobject, VSteal steal = STEAL ) :
vobject( new_vobject )
{
// we allow NULL init, eg. "VImage a;"
g_assert( !new_vobject ||
VIPS_IS_OBJECT( new_vobject ) );
printf( "VObject constructor, obj = %p, steal = %d\n",
new_vobject, steal );
if( new_vobject ) {
printf( " obj " );
vips_object_print_name( VIPS_OBJECT( new_vobject ) );
printf( "\n" );
}
if( !steal ) {
printf( " reffing object\n" );
g_object_ref( vobject );
}
}
VObject() :
vobject( 0 )
{
}
// copy constructor
VObject( const VObject &a ) :
vobject( a.vobject )
{
g_assert( VIPS_IS_OBJECT( a.vobject ) );
printf( "VObject copy constructor, obj = %p\n",
vobject );
g_object_ref( vobject );
printf( " reffing object\n" );
}
// assignment ... we must delete the old ref
// old can be NULL, new must not be NULL
VObject &operator=( const VObject &a )
{
VipsObject *old_vobject;
printf( "VObject assignment\n" );
printf( " reffing %p\n", a.vobject );
printf( " unreffing %p\n", vobject );
g_assert( !vobject ||
VIPS_IS_OBJECT( vobject ) );
g_assert( a.vobject &&
VIPS_IS_OBJECT( a.vobject ) );
// delete the old ref at the end ... otherwise "a = a;" could
// unref before reffing again
old_vobject = vobject;
vobject = a.vobject;
g_object_ref( vobject );
if( old_vobject )
g_object_unref( old_vobject );
return( *this );
}
// this mustn't be virtual: we want this class to only be a pointer,
// no vtable allowed
~VObject()
{
printf( "VObject destructor\n" );
printf( " unreffing %p\n", vobject );
g_assert( !vobject ||
VIPS_IS_OBJECT( vobject ) );
if( vobject )
g_object_unref( vobject );
}
VipsObject *get_object()
{
g_assert( !vobject ||
VIPS_IS_OBJECT( vobject ) );
return( vobject );
}
};
class VImage;
class VOption;
class VOption
{
private:
struct Pair {
const char *name;
// the thing we pass to VipsOperation
GValue value;
// an input or output parameter ... we guess the direction
// from the arg to set()
bool input;
// we need to box and unbox VImage ... keep a pointer to the
// VImage from C++ here
VImage *vimage;
Pair( const char *name ) :
name( name ), input( false ), vimage( 0 )
{
G_VALUE_TYPE( &value ) = 0;
}
~Pair()
{
g_value_unset( &value );
}
};
std::list<Pair *> options;
public:
VOption()
{
}
virtual ~VOption();
VOption *set( const char *name, const char *value );
VOption *set( const char *name, int value );
VOption *set( const char *name, VImage value );
VOption *set( const char *name, VImage *value );
void set_operation( VipsOperation *operation );
void get_operation( VipsOperation *operation );
};
class VImage : VObject
{
public:
VImage( VipsImage *image, VSteal steal = STEAL ) :
VObject( (VipsObject *) image, steal )
{
}
// an empty (NULL) VImage, eg. "VImage a;"
VImage() :
VObject( 0 )
{
}
VipsImage *get_image()
{
return( (VipsImage *) VObject::get_object() );
}
static VOption *option()
{
return( new VOption() );
}
static void call_option_string( const char *operation_name,
const char *option_string, VOption *options = 0 )
throw( VError );
static void call( const char *operation_name, VOption *options = 0 )
throw( VError );
static VImage new_from_file( const char *name, VOption *options = 0 )
throw( VError );
void write_to_file( const char *name, VOption *options = 0 )
throw( VError );
VImage invert( VOption *options = 0 )
throw( VError );
};
VOption::~VOption()
{
std::list<Pair *>::iterator i;
for( i = options.begin(); i != options.end(); i++ )
delete *i;
}
VOption *VOption::set( const char *name, const char *value )
{
Pair *pair = new Pair( name );
pair->input = true;
g_value_init( &pair->value, G_TYPE_STRING );
g_value_set_string( &pair->value, value );
options.push_back( pair );
return( this );
}
VOption *VOption::set( const char *name, int value )
{
Pair *pair = new Pair( name );
pair->input = true;
g_value_init( &pair->value, G_TYPE_INT );
g_value_set_int( &pair->value, value );
options.push_back( pair );
return( this );
}
VOption *VOption::set( const char *name, VImage value )
{
Pair *pair = new Pair( name );
pair->input = true;
g_value_init( &pair->value, VIPS_TYPE_IMAGE );
// we need to unbox
g_value_set_object( &pair->value, value.get_image() );
options.push_back( pair );
return( this );
}
VOption *VOption::set( const char *name, VImage *value )
{
Pair *pair = new Pair( name );
// note where we will write the VImage on success
pair->input = false;
pair->vimage = value;
g_value_init( &pair->value, VIPS_TYPE_IMAGE );
options.push_back( pair );
return( this );
}
// walk the options and set props on the operation
void VOption::set_operation( VipsOperation *operation )
{
std::list<Pair *>::iterator i;
for( i = options.begin(); i != options.end(); i++ )
if( (*i)->input ) {
printf( "set_operation: " );
vips_object_print_name( VIPS_OBJECT( operation ) );
char *str_value =
g_strdup_value_contents( &(*i)->value );
printf( ".%s = %s\n", (*i)->name, str_value );
g_free( str_value );
g_object_set_property( G_OBJECT( operation ),
(*i)->name, &(*i)->value );
}
}
// walk the options and do any processing needed for output objects
void VOption::get_operation( VipsOperation *operation )
{
std::list<Pair *>::iterator i;
for( i = options.begin(); i != options.end(); i++ )
if( not (*i)->input ) {
g_object_get_property( G_OBJECT( operation ),
(*i)->name, &(*i)->value );
printf( "get_operation: " );
vips_object_print_name( VIPS_OBJECT( operation ) );
char *str_value =
g_strdup_value_contents( &(*i)->value );
printf( ".%s = %s\n", (*i)->name, str_value );
g_free( str_value );
// rebox object
VipsImage *image = VIPS_IMAGE(
g_value_get_object( &(*i)->value ) );
if( (*i)->vimage )
*((*i)->vimage) = VImage( image );
}
}
void VImage::call_option_string( const char *operation_name,
const char *option_string, VOption *options )
throw( VError )
{
VipsOperation *operation;
VIPS_DEBUG_MSG( "vips_call_by_name: starting for %s ...\n",
operation_name );
if( !(operation = vips_operation_new( operation_name )) ) {
if( options )
delete options;
throw( VError() );
}
/* Set str options before vargs options, so the user can't
* override things we set deliberately.
*/
if( option_string &&
vips_object_set_from_string( VIPS_OBJECT( operation ),
option_string ) ) {
vips_object_unref_outputs( VIPS_OBJECT( operation ) );
g_object_unref( operation );
delete options;
throw( VError() );
}
if( options )
options->set_operation( operation );
/* Build from cache.
*/
if( vips_cache_operation_buildp( &operation ) ) {
vips_object_unref_outputs( VIPS_OBJECT( operation ) );
delete options;
throw( VError() );
}
/* Walk args again, writing output.
*/
if( options )
options->get_operation( operation );
/* We're done with options!
*/
delete options;
/* The operation we have built should now have been reffed by
* one of its arguments or have finished its work. Either
* way, we can unref.
*/
g_object_unref( operation );
}
void VImage::call( const char *operation_name, VOption *options )
throw( VError )
{
call_option_string( operation_name, NULL, options );
}
VImage VImage::new_from_file( const char *name, VOption *options )
throw( VError )
{
char filename[VIPS_PATH_MAX];
char option_string[VIPS_PATH_MAX];
const char *operation_name;
VImage out;
vips__filename_split8( name, filename, option_string );
if( !(operation_name = vips_foreign_find_load( filename )) ) {
delete options;
throw VError();
}
call_option_string( operation_name, option_string,
(options ? options : VImage::option())->
set( "filename", filename )->
set( "out", &out ) );
return( out );
}
void VImage::write_to_file( const char *name, VOption *options )
throw( VError )
{
char filename[VIPS_PATH_MAX];
char option_string[VIPS_PATH_MAX];
const char *operation_name;
vips__filename_split8( name, filename, option_string );
if( !(operation_name = vips_foreign_find_save( filename )) ) {
delete options;
throw VError();
}
call_option_string( operation_name, option_string,
(options ? options : VImage::option())->
set( "in", *this )->
set( "filename", filename ) );
}
VImage VImage::invert( VOption *options )
throw( VError )
{
VImage out;
call( "invert",
(options ? options : VImage::option())->
set( "in", *this )->
set( "out", &out ) );
return( out );
}
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 the class is compile-time-only,\n" );
printf( "as it should be\n" );
printf( "sizeof( VipsImage *) = %zd\n", sizeof( VipsImage *) );
printf( "sizeof( VImage ) = %zd\n", sizeof( VImage ) );
{
VImage in = VImage::new_from_file( argv[1] );
VImage out;
out = in.invert();
out.write_to_file( argv[2] );
}
vips_shutdown();
return( 0 );
}

57
doc/reference/using-cpp.xml
View File

@ -171,13 +171,13 @@ main( int argc, char **argv )
All other operations follow the same pattern, for example the C API call All other operations follow the same pattern, for example the C API call
vips_add(): vips_add():
<programlisting> <programlisting language="C++">
int vips_add( VipsImage *left, VipsImage *right, VipsImage **out, ... ); int vips_add( VipsImage *left, VipsImage *right, VipsImage **out, ... );
</programlisting> </programlisting>
appears in C++ as: appears in C++ as:
<programlisting> <programlisting language="C++">
VImage VImage::add( VImage right, VOption *options = 0 ); VImage VImage::add( VImage right, VOption *options = 0 );
</programlisting> </programlisting>
</para> </para>
@ -226,14 +226,14 @@ main( int argc, char **argv )
For example, you can join two images together bandwise (the For example, you can join two images together bandwise (the
bandwise join of two RGB images would be a six-band image) with: bandwise join of two RGB images would be a six-band image) with:
<programlisting> <programlisting language="C++">
VImage rgb = ...; VImage rgb = ...;
VImage six_band = rgb.bandjoin( rgb ); VImage six_band = rgb.bandjoin( rgb );
</programlisting> </programlisting>
You can also bandjoin a constant, for example: You can also bandjoin a constant, for example:
<programlisting> <programlisting language="C++">
VImage rgb_with_alpha = rgb.bandjoin( 255 ); VImage rgb_with_alpha = rgb.bandjoin( 255 );
</programlisting> </programlisting>
@ -242,7 +242,7 @@ main( int argc, char **argv )
constant in most places where you can use an image and it will be constant in most places where you can use an image and it will be
converted. For example: converted. For example:
<programlisting> <programlisting language="C++">
VImage a = (a &lt; 128).ifthenelse( 128, a ); VImage a = (a &lt; 128).ifthenelse( 128, a );
</programlisting> </programlisting>
@ -263,24 +263,65 @@ main( int argc, char **argv )
enum, such as vips_math(), are expanded to a set of member functions enum, such as vips_math(), are expanded to a set of member functions
named after the enum. For example, the C function: named after the enum. For example, the C function:
<programlisting> <programlisting language="C++">
int vips_math( VipsImage *in, VipsImage **out, VipsOperationMath math, ... ); int vips_math( VipsImage *in, VipsImage **out, VipsOperationMath math, ... );
</programlisting> </programlisting>
where #VipsOperationMath has the member #VIPS_OPERATION_MATH_SIN, has a where #VipsOperationMath has the member #VIPS_OPERATION_MATH_SIN, has a
C convenience function vips_sin(): C convenience function vips_sin():
<programlisting> <programlisting language="C++">
int vips_sin( VipsImage *in, VipsImage **out, ... ); int vips_sin( VipsImage *in, VipsImage **out, ... );
</programlisting> </programlisting>
and a C++ member function VImage::sin(): and a C++ member function VImage::sin():
<programlisting> <programlisting language="C++">
VImage VImage::sin( VOption *options = 0 ); VImage VImage::sin( VOption *options = 0 );
</programlisting> </programlisting>
</para> </para>
</refsect1>
<refsect1 id="cpp-extend">
<title>Extending the C++ interface</title>
<para>
The C++ interface comes in two parts. First, VImage8.h defines a simple
layer over #GObject for automatic reference counting, then a generic way
to call any vips8 operation with VImage::call(), then a few convenience
functions, then a set of overloads.
</para>
<para>
The member function for each operation, for example VImage::add(), is
generated by a small Python program called <code>gen-operators.py</code>,
and its companion, <code>gen-operators-h.py</code> to generate the
headers. If you write a new VIPS operator, you'll need to rerun these
programs to make the new member function.
</para>
<para>
You can write the wrapper yourself, of course, they are very simple.
The one for VImage::add() looks like this:
<programlisting language="C++">
VImage VImage::add(VImage right, VOption *options)
throw VError
{
VImage out;
call("add" ,
(options ? options : VImage::option()) ->
set("out", &amp;out) ->
set("left", *this) ->
set("right", right));
return out;
}
</programlisting>
Where VImage::call() is the generic call-a-vips8-operation function.
</para>
</refsect1> </refsect1>
</refentry> </refentry>

4
libvipsCC/Makefile.am
View File

@ -34,4 +34,6 @@ vipsc++.cc:
echo >> vipsc++.cc ; \ echo >> vipsc++.cc ; \
done done
EXTRA_DIST = vipsc++.cc EXTRA_DIST = \
README.txt \
vipsc++.cc

3
libvipsCC/README.txt Normal file
View File

@ -0,0 +1,3 @@
This is the old vips7 C++ API. Use the vips8 one in preference for new
projects.

502
python/LICENSE.txt
View File

@ -1,502 +0,0 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library 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.1 of the License, or (at your option) any later version.
This library 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 library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!

3
python/Makefile.am
View File

@ -2,3 +2,6 @@ pygioverridesdir = $(pyexecdir)/gi/overrides
pygioverrides_PYTHON = \ pygioverrides_PYTHON = \
Vips.py Vips.py
EXTRA_DIST = \
README.txt

8
python/README.txt
View File

@ -3,9 +3,11 @@ vips8 binding for Python
This binding adds a few small helper functions to the gobject-introspection This binding adds a few small helper functions to the gobject-introspection
binding for libvips. binding for libvips.
This is the vips8 API, so it's not yet fully implemented. Use the older vipsCC The test/ directory has a test suite.
binding if you want a more complete system.
To install, try: Vips.py needs to be in the overrides directory of your gobject-introspection
pygobject area, for example:
sudo cp Vips.py /usr/lib/python2.7/dist-packages/gi/overrides sudo cp Vips.py /usr/lib/python2.7/dist-packages/gi/overrides

11
python/old/README
View File

@ -1,11 +0,0 @@
Experimental Python binding using ctypes
The current Python binding uses swig to wrap the C++ interface. This causes
problems on Windows, since compiling all of the DLLs correctly to work with
the various python binaries is painful, and makes the binding very large.
The idea here is to use ctypes to make a binding that's just Python and which
directly wraps the C API. The new vips8 C API is much more wrapper-friendly,
plus we can reuse parts of the gobject binding, so this should be possible.

105
python/old/finalizable.py
View File

@ -1,105 +0,0 @@
#!/usr/bin/python
import weakref
class Finalizable(object):
"""
Base class enabling the use a __finalize__ method without all the
problems associated with __del__ and reference cycles.
If you call enable_finalizer(), it will call __finalize__
with a single "ghost instance" argument after the object has been
deleted. Creation of this "ghost instance" does not involve calling
the __init__ method, but merely copying the attributes whose names
were given as arguments to enable_finalizer().
A Finalizable can be part of any reference cycle, but you must be careful
that the attributes given to enable_finalizer() don't reference back to
self, otherwise self will be immortal.
"""
__wr_map = {}
__wr_id = None
def bind_finalizer(self, *attrs):
"""
Enable __finalize__ on the current instance.
The __finalize__ method will be called with a "ghost instance" as
single argument.
This ghost instance is constructed from the attributes whose names
are given to bind_finalizer(), *at the time bind_finalizer() is called*.
"""
cls = type(self)
ghost = object.__new__(cls)
ghost.__dict__.update((k, getattr(self, k)) for k in attrs)
cls_wr_map = cls.__wr_map
def _finalize(ref):
try:
ghost.__finalize__()
finally:
del cls_wr_map[id_ref]
ref = weakref.ref(self, _finalize)
id_ref = id(ref)
cls_wr_map[id_ref] = ref
self.__wr_id = id_ref
def remove_finalizer(self):
"""
Disable __finalize__, provided it has been enabled.
"""
if self.__wr_id:
cls = type(self)
cls_wr_map = cls.__wr_map
del cls_wr_map[self.__wr_id]
del self.__wr_id
class TransactionBase(Finalizable):
"""
A convenience base class to write transaction-like objects,
with automatic rollback() on object destruction if required.
"""
finished = False
def enable_auto_rollback(self):
self.bind_finalizer(*self.ghost_attributes)
def commit(self):
assert not self.finished
self.remove_finalizer()
self.do_commit()
self.finished = True
def rollback(self):
assert not self.finished
self.remove_finalizer()
self.do_rollback(auto=False)
self.finished = True
def __finalize__(ghost):
ghost.do_rollback(auto=True)
class TransactionExample(TransactionBase):
"""
A transaction example which close()s a resource on rollback
"""
ghost_attributes = ('resource', )
def __init__(self, resource):
self.resource = resource
self.enable_auto_rollback()
def __str__(self):
return "ghost-or-object %s" % object.__str__(self)
def do_commit(self):
pass
def do_rollback(self, auto):
if auto:
print "auto rollback", self
else:
print "manual rollback", self
self.resource.close()

692
python/old/old_Vips.py
View File

@ -1,692 +0,0 @@
# -*- Mode: Python; py-indent-offset: 4 -*-
# vim: tabstop=4 shiftwidth=4 expandtab
# copy this file to /usr/lib/python2.7/dist-packages/gi/overrides/
# 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
import sys
import re
import logging
from gi import _gobject
from gi.repository import GObject
from ..importer import modules
Vips = modules['Vips']._introspection_module
__all__ = []
# start up vips!
Vips.init(sys.argv[0])
# need the gtypes for various vips types
vips_type_array_int = GObject.GType.from_name("VipsArrayInt")
vips_type_array_double = GObject.GType.from_name("VipsArrayDouble")
vips_type_array_image = GObject.GType.from_name("VipsArrayImage")
vips_type_blob = GObject.GType.from_name("VipsBlob")
vips_type_image = GObject.GType.from_name("VipsImage")
vips_type_operation = GObject.GType.from_name("VipsOperation")
unpack_types = [Vips.Blob, Vips.ArrayDouble, Vips.ArrayImage, Vips.ArrayInt]
def isunpack(obj):
for t in unpack_types:
if isinstance(obj, t):
return True
return False
arrayize_types = [[vips_type_array_int, Vips.ArrayInt.new],
[vips_type_array_double, Vips.ArrayDouble.new],
[vips_type_array_image, Vips.ArrayImage.new]]
def arrayize(gtype, value):
for t, cast in arrayize_types:
if GObject.type_is_a(gtype, t):
if not isinstance(value, list):
value = [value]
value = cast(value)
return value
class Error(Exception):
"""An error from vips.
message -- a high-level description of the error
detail -- a string with some detailed diagnostics
"""
def __init__(self, message, detail = None):
self.message = message
if detail == None:
detail = Vips.error_buffer()
Vips.error_clear()
self.detail = detail
logging.debug('vips: Error %s %s', self.message, self.detail)
def __str__(self):
return '%s\n %s' % (self.message, self.detail)
Vips.Error = Error
class Argument:
def __init__(self, op, prop):
self.op = op;
self.prop = prop;
self.name = re.sub("-", "_", prop.name);
self.flags = op.get_argument_flags(self.name)
self.priority = op.get_argument_priority(self.name)
self.isset = op.argument_isset(self.name)
def set_value(self, value):
logging.debug('assigning %s to %s' % (value, self.name))
logging.debug('%s needs a %s' % (self.name, self.prop.value_type))
# array-ize some types, if necessary
value = arrayize(self.prop.value_type, value)
# blob-ize
if GObject.type_is_a(self.prop.value_type, vips_type_blob):
if not isinstance(value, Vips.Blob):
value = Vips.Blob.new(None, value)
# MODIFY input images need to be copied before assigning them
if self.flags & Vips.ArgumentFlags.MODIFY:
value = value.copy()
logging.debug('assigning %s' % self.prop.value_type)
self.op.props.__setattr__(self.name, value)
def get_value(self):
value = self.op.props.__getattribute__(self.name)
logging.debug('read out %s from %s' % (value, self.name))
# turn VipsBlobs into strings, VipsArrayDouble into lists etc.
# FIXME ... this will involve a copy, we should use
# buffer() instead
if isunpack(value):
value = value.get()
return value
Vips.Argument = Argument
def _call_base(name, required, optional, self = None, option_string = None):
logging.debug('_call_base name=%s, required=%s optional=%s' %
(name, required, optional))
if self:
logging.debug('_call_base self=%s' % self)
if option_string:
logging.debug('_call_base option_string = %s' % option_string)
try:
op = Vips.Operation.new(name)
except TypeError, e:
raise Error('No such operator.')
# set str options first so the user can't override things we set
# deliberately and break stuff
if option_string:
if op.set_from_string(option_string) != 0:
raise Error('Bad arguments.')
# find all the args for this op, sort into priority order
args = [Argument(op, x) for x in op.props]
args.sort(lambda a, b: a.priority - b.priority)
enm = Vips.ArgumentFlags
# find all required, unassigned input args
required_input = [x for x in args if x.flags & enm.INPUT and
x.flags & enm.REQUIRED and
not x.isset]
# do we have a non-None self pointer? this is used to set the first
# compatible input arg
if self is not None:
found = False
for x in required_input:
if GObject.type_is_a(self, x.prop.value_type):
x.set_value(self)
required_input.remove(x)
found = True
break
if not found:
raise Error('Bad arguments.', 'No %s argument to %s.' %
(str(self.__class__), name))
if len(required_input) != len(required):
raise Error('Wrong number of arguments.',
'%s needs %d arguments, you supplied %d' %
(name, len(required_input), len(required)))
for i in range(len(required_input)):
required_input[i].set_value(required[i])
# find all optional, unassigned input args ... make a hash from name to
# Argument
optional_input = {x.name: x for x in args if x.flags & enm.INPUT and
not x.flags & enm.REQUIRED and
not x.isset}
# find all optional output args ... we use "x = True"
# in args to mean add that to output
optional_output = {x.name: x for x in args if x.flags & enm.OUTPUT and
not x.flags & enm.REQUIRED}
# set optional input args
for key in optional.keys():
if key in optional_input:
optional_input[key].set_value(optional[key])
elif key in optional_output:
# must be a literal True value
if optional[key] is not True:
raise Error('Optional output argument must be True.',
'Argument %s should equal True.' % key)
else:
raise Error('Unknown argument.',
'Operator %s has no argument %s' % (name, key))
# call
op2 = Vips.cache_operation_build(op)
if op2 == None:
raise Error('Error calling operator %s.' % name)
# rescan args if op2 is different from op
if op2 != op:
args = [Argument(op2, x) for x in op2.props]
args.sort(lambda a, b: a.priority - b.priority)
optional_output = {x.name: x for x in args if x.flags & enm.OUTPUT and
not x.flags & enm.REQUIRED}
# gather output args
out = []
for x in args:
# required output arg
if x.flags & enm.OUTPUT and x.flags & enm.REQUIRED:
out.append(x.get_value())
# modified input arg ... this will get the result of the copy() we
# did above
if x.flags & enm.INPUT and x.flags & enm.MODIFY:
out.append(x.get_value())
out_dict = {}
for x in optional.keys():
if x in optional_output:
out_dict[x] = optional_output[x].get_value()
if out_dict != {}:
out.append(out_dict)
if len(out) == 1:
out = out[0]
elif len(out) == 0:
out = None
# unref everything now we have refs to all outputs we want
op2.unref_outputs()
logging.debug('success')
return out
# general user entrypoint
def call(name, *args, **kwargs):
return _call_base(name, args, kwargs)
Vips.call = call
# here from getattr ... try to run the attr as a method
def _call_instance(self, name, args, kwargs):
return _call_base(name, args, kwargs, self)
# this is a class method
def vips_image_new_from_file(cls, vips_filename, **kwargs):
filename = Vips.filename_get_filename(vips_filename)
option_string = Vips.filename_get_options(vips_filename)
loader = Vips.Foreign.find_load(filename)
if loader == None:
raise Error('No known loader for "%s".' % filename)
logging.debug('Image.new_from_file: loader = %s' % loader)
return _call_base(loader, [filename], kwargs, None, option_string)
setattr(Vips.Image, 'new_from_file', classmethod(vips_image_new_from_file))
# this is a class method
def vips_image_new_from_buffer(cls, data, option_string, **kwargs):
loader = Vips.Foreign.find_load_buffer(data)
if loader == None:
raise Error('No known loader for buffer.')
logging.debug('Image.new_from_buffer: loader = %s' % loader)
setattr(Vips.Image, 'new_from_buffer', classmethod(vips_image_new_from_buffer))
# this is a class method
def vips_image_new_from_array(cls, array, scale = 1, offset = 0):
# we accept a 1D array and assume height == 1, or a 2D array and check all
# lines are the same length
if not isinstance(array, list):
raise TypeError('new_from_array() takes a list argument')
if not isinstance(array[0], list):
height = 1
width = len(array)
else:
flat_array = array[0]
height = len(array)
width = len(array[0])
for i in range(1, height):
if len(array[i]) != width:
raise TypeError('new_from_array() array not rectangular')
flat_array += array[i]
array = flat_array
image = cls.new_matrix_from_array(width, height, array)
# be careful to set them as double
image.set('scale', float(scale))
image.set('offset', float(offset))
return image
setattr(Vips.Image, 'new_from_array', classmethod(vips_image_new_from_array))
def vips_image_getattr(self, name):
logging.debug('Image.__getattr__ %s' % name)
# look up in props first, eg. x.props.width
if name in dir(self.props):
return getattr(self.props, name)
return lambda *args, **kwargs: _call_instance(self, name, args, kwargs)
def vips_image_write_to_file(self, vips_filename, **kwargs):
filename = Vips.filename_get_filename(vips_filename)
option_string = Vips.filename_get_options(vips_filename)
saver = Vips.Foreign.find_save(filename)
if saver == None:
raise Error('No known saver for "%s".' % filename)
logging.debug('Image.write_to_file: saver = %s' % saver)
_call_base(saver, [filename], kwargs, self, option_string)
def vips_image_write_to_buffer(self, vips_filename, **kwargs):
filename = Vips.filename_get_filename(vips_filename)
option_string = Vips.filename_get_options(vips_filename)
saver = Vips.Foreign.find_save_buffer(filename)
if saver == None:
raise Error('No known saver for "%s".' % filename)
logging.debug('Image.write_to_buffer: saver = %s' % saver)
return _call_base(saver, [], kwargs, self, option_string)
def vips_bandsplit(self):
return [self.extract_band(i) for i in range(0, self.bands)]
def vips_maxpos(self):
v, opts = self.max(x = True, y = True)
x = opts['x']
y = opts['y']
return v, x, y
def vips_minpos(self):
v, opts = self.min(x = True, y = True)
x = opts['x']
y = opts['y']
return v, x, y
# apply a function to a thing, or map over a list
# we often need to do something like (1.0 / other) and need to work for lists
# as well as scalars
def smap(func, x):
if isinstance(x, list):
return map(func, x)
else:
return func(x)
def vips_add(self, other):
if isinstance(other, Vips.Image):
return self.add(other)
else:
return self.linear(1, other)
def vips_sub(self, other):
if isinstance(other, Vips.Image):
return self.subtract(other)
else:
return self.linear(1, smap(lambda x: -1 * x, other))
def vips_rsub(self, other):
return self.linear(-1, other)
def vips_mul(self, other):
if isinstance(other, Vips.Image):
return self.multiply(other)
else:
return self.linear(other, 0)
def vips_div(self, other):
if isinstance(other, Vips.Image):
return self.divide(other)
else:
return self.linear(smap(lambda x: 1.0 / x, other), 0)
def vips_rdiv(self, other):
return (self ** -1) * other
def vips_floor(self):
return self.round(Vips.OperationRound.FLOOR)
def vips_get_value(self, field):
value = self.get(field)
logging.debug('read out %s from %s' % (value, self))
# turn VipsBlobs into strings, VipsArrayDouble into lists etc.
# FIXME ... this will involve a copy, we should use
# buffer() instead
if isunpack(value):
value = value.get()
return value
def vips_set_value(self, field, value):
gtype = self.get_typeof(field)
logging.debug('assigning %s to %s' % (value, self))
logging.debug('%s needs a %s' % (self, gtype))
# array-ize some types, if necessary
value = arrayize(gtype, value)
# blob-ize
if GObject.type_is_a(gtype, vips_type_blob):
if not isinstance(value, Vips.Blob):
value = Vips.Blob.new(None, value)
self.set(field, value)
def vips_ceil(self):
return self.round(Vips.OperationRound.CEIL)
def vips_rint(self):
return self.round(Vips.OperationRound.RINT)
def vips_floordiv(self, other):
if isinstance(other, Vips.Image):
return self.divide(other).floor()
else:
return self.linear(smap(lambda x: 1.0 / x, other), 0).floor()
def vips_rfloordiv(self, other):
return ((self ** -1) * other).floor()
def vips_mod(self, other):
if isinstance(other, Vips.Image):
return self.remainder(other)
else:
return self.remainder_const(other)
def vips_pow(self, other):
if isinstance(other, Vips.Image):
return self.math2(other, Vips.OperationMath2.POW)
else:
return self.math2_const(other, Vips.OperationMath2.POW)
def vips_rpow(self, other):
return self.math2_const(other, Vips.OperationMath2.WOP)
def vips_lshift(self, other):
if isinstance(other, Vips.Image):
return self.boolean(other, Vips.OperationBoolean.LSHIFT)
else:
return self.boolean_const(other, Vips.OperationBoolean.LSHIFT)
def vips_rshift(self, other):
if isinstance(other, Vips.Image):
return self.boolean(other, Vips.OperationBoolean.RSHIFT)
else:
return self.boolean_const(other, Vips.OperationBoolean.RSHIFT)
def vips_and(self, other):
if isinstance(other, Vips.Image):
return self.boolean(other, Vips.OperationBoolean.AND)
else:
return self.boolean_const(other, Vips.OperationBoolean.AND)
def vips_or(self, other):
if isinstance(other, Vips.Image):
return self.boolean(other, Vips.OperationBoolean.OR)
else:
return self.boolean_const(other, Vips.OperationBoolean.OR)
def vips_xor(self, other):
if isinstance(other, Vips.Image):
return self.boolean(other, Vips.OperationBoolean.EOR)
else:
return self.boolean_const(other, Vips.OperationBoolean.EOR)
def vips_more(self, other):
if isinstance(other, Vips.Image):
return self.relational(other, Vips.OperationRelational.MORE)
else:
return self.relational_const(other, Vips.OperationRelational.MORE)
def vips_moreeq(self, other):
if isinstance(other, Vips.Image):
return self.relational(other, Vips.OperationRelational.MOREEQ)
else:
return self.relational_const(other, Vips.OperationRelational.MOREEQ)
def vips_less(self, other):
if isinstance(other, Vips.Image):
return self.relational(other, Vips.OperationRelational.LESS)
else:
return self.relational_const(other, Vips.OperationRelational.LESS)
def vips_lesseq(self, other):
if isinstance(other, Vips.Image):
return self.relational(other, Vips.OperationRelational.LESSEQ)
else:
return self.relational_const(other, Vips.OperationRelational.LESSEQ)
def vips_equal(self, other):
if isinstance(other, Vips.Image):
return self.relational(other, Vips.OperationRelational.EQUAL)
else:
return self.relational_const(other, Vips.OperationRelational.EQUAL)
def vips_notequal(self, other):
if isinstance(other, Vips.Image):
return self.relational(other, Vips.OperationRelational.NOTEQ)
else:
return self.relational_const(other, Vips.OperationRelational.NOTEQ)
def vips_neg(self):
return -1 * self
def vips_pos(self):
return self
def vips_abs(self):
return self.abs()
def vips_invert(self):
return self ^ -1
def vips_real(self):
return self.complexget(Vips.OperationComplexget.REAL)
def vips_imag(self):
return self.complexget(Vips.OperationComplexget.IMAG)
def vips_polar(self):
return self.complex(Vips.OperationComplex.POLAR)
def vips_rect(self):
return self.complex(Vips.OperationComplex.RECT)
def vips_conj(self):
return self.complex(Vips.OperationComplex.CONJ)
def vips_sin(self):
return self.math(Vips.OperationMath.SIN)
def vips_cos(self):
return self.math(Vips.OperationMath.COS)
def vips_tan(self):
return self.math(Vips.OperationMath.TAN)
def vips_asin(self):
return self.math(Vips.OperationMath.ASIN)
def vips_acos(self):
return self.math(Vips.OperationMath.ACOS)
def vips_atan(self):
return self.math(Vips.OperationMath.ATAN)
def vips_log(self):
return self.math(Vips.OperationMath.LOG)
def vips_log10(self):
return self.math(Vips.OperationMath.LOG10)
def vips_exp(self):
return self.math(Vips.OperationMath.EXP)
def vips_exp10(self):
return self.math(Vips.OperationMath.EXP10)
def vips_bandjoin2(self, other):
return Vips.Image.bandjoin([self, other])
# Search for all VipsOperation which don't have an input image object ... these
# become class methods
def vips_image_class_method(name, args, kwargs):
logging.debug('vips_image_class_method %s' % name)
# the first arg is the class we are called from ... drop it
args = tuple(list(args)[1::])
return _call_base(name, args, kwargs)
def define_class_methods(cls):
if not cls.is_abstract():
op = Vips.Operation.new(cls.name)
found = False
for prop in op.props:
flags = op.get_argument_flags(prop.name)
if flags & Vips.ArgumentFlags.INPUT and flags & Vips.ArgumentFlags.REQUIRED:
if GObject.type_is_a(vips_type_image, prop.value_type):
found = True
break
if not found:
gtype = Vips.type_find("VipsOperation", cls.name)
nickname = Vips.nickname_find(gtype)
logging.debug('adding %s as a class method' % nickname)
method = lambda *args, **kwargs: vips_image_class_method( nickname, args, kwargs)
setattr(Vips.Image, nickname, classmethod(method))
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':
define_class_methods(child)
define_class_methods(vips_type_operation)
# instance methods
Vips.Image.write_to_file = vips_image_write_to_file
Vips.Image.write_to_buffer = vips_image_write_to_buffer
# we can use Vips.Image.write_to_memory() directly
# a few useful things
Vips.Image.get_value = vips_get_value
Vips.Image.set_value = vips_set_value
Vips.Image.floor = vips_floor
Vips.Image.ceil = vips_ceil
Vips.Image.rint = vips_rint
Vips.Image.bandsplit = vips_bandsplit
Vips.Image.maxpos = vips_maxpos
Vips.Image.minpos = vips_minpos
Vips.Image.real = vips_real
Vips.Image.imag = vips_imag
Vips.Image.polar = vips_polar
Vips.Image.rect = vips_rect
Vips.Image.conj = vips_conj
Vips.Image.sin = vips_sin
Vips.Image.cos = vips_cos
Vips.Image.tan = vips_tan
Vips.Image.asin = vips_asin
Vips.Image.acos = vips_acos
Vips.Image.atan = vips_atan
Vips.Image.log = vips_log
Vips.Image.log10 = vips_log10
Vips.Image.exp = vips_exp
Vips.Image.exp10 = vips_exp10
Vips.Image.bandjoin2 = vips_bandjoin2
# operator overloads
Vips.Image.__getattr__ = vips_image_getattr
Vips.Image.__add__ = vips_add
Vips.Image.__radd__ = vips_add
Vips.Image.__sub__ = vips_sub
Vips.Image.__rsub__ = vips_rsub
Vips.Image.__mul__ = vips_mul
Vips.Image.__rmul__ = vips_mul
Vips.Image.__div__ = vips_div
Vips.Image.__rdiv__ = vips_rdiv
Vips.Image.__floordiv__ = vips_floordiv
Vips.Image.__rfloordiv__ = vips_rfloordiv
Vips.Image.__mod__ = vips_mod
Vips.Image.__pow__ = vips_pow
Vips.Image.__rpow__ = vips_rpow
Vips.Image.__abs__ = vips_abs
Vips.Image.__lshift__ = vips_lshift
Vips.Image.__rshift__ = vips_rshift
Vips.Image.__and__ = vips_and
Vips.Image.__rand__ = vips_and
Vips.Image.__or__ = vips_or
Vips.Image.__ror__ = vips_or
Vips.Image.__xor__ = vips_xor
Vips.Image.__rxor__ = vips_xor
Vips.Image.__neg__ = vips_neg
Vips.Image.__pos__ = vips_pos
Vips.Image.__invert__ = vips_invert
Vips.Image.__lt__ = vips_less
Vips.Image.__le__ = vips_lesseq
Vips.Image.__gt__ = vips_more
Vips.Image.__ge__ = vips_moreeq
Vips.Image.__eq__ = vips_equal
Vips.Image.__ne__ = vips_notequal
# the cast operators int(), long() and float() must return numeric types, so we
# can't define them for images

61
python/old/test.py
View File

@ -1,61 +0,0 @@
#!/usr/bin/python
import logging
import gc
import gobject
import vipsobject
import vipsimage
logging.basicConfig(level = logging.DEBUG)
# should be able to find vipsimage, hopefully
print gobject.type_from_name('VipsImage')
# test unref
for i in range (1,10):
a = vipsimage.VipsImage('/home/john/pics/healthygirl.jpg')
# should work
a = vipsimage.VipsImage('/home/john/pics/healthygirl.jpg')
print 'width =', a.width()
print 'height =', a.height()
print 'bands =', a.bands()
print 'format = %d - %s' % (a.format(),
vipsimage.VipsBandFormat.name(a.format()))
print 'coding = %d - %s' % (a.coding(),
vipsimage.VipsCoding.name(a.coding()))
print 'interpretation = %d - %s' % (a.interpretation(),
vipsimage.VipsInterpretation.name(a.interpretation()))
print 'xres =', a.xres()
print 'yres =', a.yres()
print 'xoffset =', a.xoffset()
print 'yoffset =', a.yoffset()
# should raise an error
try:
a = vipsimage.VipsImage('banana')
except vipsobject.VipsError, e:
print 'caught VipsError'
print '\tmessage =', e.message
print '\tdetail =', e.detail
# try calling a vips8 method
a = vipsimage.VipsImage('/home/john/pics/healthygirl.jpg')
b = vipsimage.VipsImage('/home/john/pics/babe.jpg')
c = a.add(b)
print 'c = ', c
c.write('/home/john/pics/x.v')
print 'starting shutdown ...'
del a
del b
del c
# sometimes have to do several GCs to get them all, not sure why
for i in range(10):
gc.collect ()
print 'shutdown!'

172
python/old/vipsimage.py
View File

@ -1,172 +0,0 @@
#!/usr/bin/python
"""This module wraps up libvips in a less awful interface.
Author: J.Cupitt
GNU LESSER GENERAL PUBLIC LICENSE
"""
import logging
import ctypes
import gobject
import vipsobject
# image enums
class VipsDemandStyle:
SMALLTILE = 0
FATSTRIP = 1
THINSTRIP = 2
ANY = 3
# turn 3 into 'ANY', handy for printing
# is there a clever way to define this in a base Enum class? I can't think
# of it
@staticmethod
def name(value):
return vipsobject.class_value(VipsDemandStyle, value)
class VipsInterpretation:
MULTIBAND = 0
B_W = 1
HISTOGRAM = 10
FOURIER = 24
XYZ = 12
LAB = 13
CMYK = 15
LABQ = 16
RGB = 17
UCS = 18
LCH = 19
LABS = 21
sRGB = 22
YXY = 23
RGB16 = 25
GREY16 = 26
@staticmethod
def name(value):
return vipsobject.class_value(VipsInterpretation, value)
class VipsBandFormat:
NOTSET = -1
UCHAR = 0
CHAR = 1
USHORT = 2
SHORT = 3
UINT = 4
INT = 5
FLOAT = 6
COMPLEX = 7
DOUBLE = 8,
DPCOMPLEX = 9
LAST = 10
@staticmethod
def name(value):
return vipsobject.class_value(VipsBandFormat, value)
class VipsCoding:
NONE = 0
LABQ = 2
RAD = 6
@staticmethod
def name(value):
return vipsobject.class_value(VipsCoding, value)
libvips = vipsobject.libvips
vips_image_new = libvips.vips_image_new
vips_image_new.restype = ctypes.c_void_p
vips_image_new.errcheck = vipsobject.check_pointer_return
vips_image_new_from_file = libvips.vips_image_new_from_file
vips_image_new_from_file.argtypes = [ctypes.c_char_p]
vips_image_new_from_file.restype = ctypes.c_void_p
vips_image_new_from_file.errcheck = vipsobject.check_pointer_return
vips_image_new_mode = libvips.vips_image_new_mode
vips_image_new_mode.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
vips_image_new_mode.restype = ctypes.c_void_p
vips_image_new_mode.errcheck = vipsobject.check_pointer_return
vips_image_write = libvips.vips_image_write
vips_image_write.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
vips_image_write.restype = ctypes.c_void_p
vips_image_write.errcheck = vipsobject.check_int_return
vips_image_get_xres = libvips.vips_image_get_xres
vips_image_get_xres.restype = ctypes.c_double;
vips_image_get_yres = libvips.vips_image_get_yres
vips_image_get_yres.restype = ctypes.c_double;
def vips_call_instance(self, name, args):
logging.debug('vipsimage: vips_call_instance name=%s, self=%s, args=%s' %
(name, self, args))
operation = vipsoperation.VipsOperation(name)
operation = vips_operation_new(name)
vipsobject.vips_object_print(operation)
vipsobject.vips_argument_map(operation,
vipsobject.VipsArgumentMapFn(show_args),None, None)
class VipsImage(vipsobject.VipsObject):
"""Manipulate a libvips image."""
def __init__(self, filename = None, mode = None):
logging.debug('vipsimage: init')
vipsobject.VipsObject.__init__(self)
if filename == None and mode == None:
self.vipsobject = vips_image_new()
elif filename != None and mode == None:
self.vipsobject = vips_image_new_from_file(filename)
else:
self.vipsobject = vips_image_new_mode(filename, mode)
logging.debug('vipsimage: made %s' % hex(self.vipsobject))
self.enable_finalize()
def __getattr__(self, name):
logging.debug('vipsimage: __getattr__ %s' % name)
return lambda *args: vips_call_instance(self, name, args)
def width(self):
return libvips.vips_image_get_width(self.vipsobject)
def height(self):
return libvips.vips_image_get_height(self.vipsobject)
def bands(self):
return libvips.vips_image_get_bands(self.vipsobject)
def format(self):
return libvips.vips_image_get_format(self.vipsobject)
def coding(self):
return libvips.vips_image_get_coding(self.vipsobject)
def interpretation(self):
return libvips.vips_image_get_interpretation(self.vipsobject)
def xres(self):
return vips_image_get_xres(self.vipsobject)
def yres(self):
return vips_image_get_yres(self.vipsobject)
def xoffset(self):
return libvips.vips_image_get_xoffset(self.vipsobject)
def yoffset(self):
return libvips.vips_image_get_yoffset(self.vipsobject)
def write(self, filename):
vips_image_write(self.vipsobject, filename)

104
python/old/vipsobject.py
View File

@ -1,104 +0,0 @@
#!/usr/bin/python
"""This module wraps up libvips in a less awful interface.
Wrap VipsObject.
Author: J.Cupitt
GNU LESSER GENERAL PUBLIC LICENSE
"""
import logging
import sys
import ctypes
import gobject
import finalizable
# .15 is 7.25+ with the new vips8 API
libvips = ctypes.CDLL('libvips.so.15')
libvips.vips_init(sys.argv[0])
vips_object_print = libvips.vips_object_print
vips_object_print.argtypes = [ctypes.c_void_p]
vips_object_print.restype = None
# in C:
# typedef void *(*VipsArgumentMapFn)( VipsObject *,
# GParamSpec *, VipsArgumentClass *, VipsArgumentInstance *,
# void *a, void *b );
VipsArgumentMapFn = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p, ctypes.c_void_p)
vips_argument_map = libvips.vips_argument_map
vips_argument_map.argtypes = [ctypes.c_void_p, VipsArgumentMapFn,
ctypes.c_void_p, ctypes.c_void_p]
vips_argument_map.restype = ctypes.c_void_p
g_param_spec_get_name = libvips.g_param_spec_get_name
g_param_spec_get_name.argtypes = [ctypes.c_void_p]
g_param_spec_get_name.restype = ctypes.c_char_p
# given a class and value, search for a class member with that value
# handy for enum classes, use to turn numbers to strings
def class_value(classobject, value):
for name in dir(classobject):
if getattr(classobject, name) == value:
return classobject.__name__ + '.' + name
return 'unknown'
class VipsError(Exception):
"""An error from libvips.
message -- a high-level description of the error
detail -- a string with some detailed diagnostics
"""
def __init__(self, message):
self.message = message
self.detail = vips_error_buffer()
libvips.vips_error_clear()
logging.debug('vipsobject: Error: %s %s', self.message, self.detail)
def __str__(self):
return '%s %s' % (self.message, self.detail)
# handy checkers, assign to errcheck
def check_int_return(result, func, args):
if result != 0:
raise VipsError('Error calling vips function %s.' % func.__name__)
return result
def check_pointer_return(result, func, args):
if result == None:
raise VipsError('Error calling vips function %s.' % func.__name__)
return result
vips_error_buffer = libvips.vips_error_buffer
vips_error_buffer.restype = ctypes.c_char_p
class VipsObject(finalizable.Finalizable):
"""Abstract base class for libvips."""
# attributes we finalize
ghost_attributes = ('vipsobject', )
def __finalize__(self):
logging.debug('vipsobject: __finalize__')
if self.vipsobject != None:
logging.debug('vipsobject: unref %s' % hex(self.vipsobject))
libvips.g_object_unref(self.vipsobject)
self.vipsobject = None
def enable_finalize(self):
self.bind_finalizer(*self.ghost_attributes)
def __init__(self):
logging.debug('vipsobject: init')
self.vipsobject = None

46
python/old/vipsoperation.py
View File

@ -1,46 +0,0 @@
#!/usr/bin/python
"""This module wraps up libvips in a less awful interface.
Author: J.Cupitt
GNU LESSER GENERAL PUBLIC LICENSE
"""
import logging
import ctypes
import gobject
import vipsobject
libvips = vipsobject.libvips
vips_operation_new = libvips.vips_operation_new
vips_operation_new.argtypes = [ctypes.c_char_p]
vips_operation_new.restype = ctypes.c_void_p
vips_operation_new.errcheck = vipsobject.check_pointer_return
def show_args(operation, pspec, arg_class, arg_instance, a, b):
name = vipsobject.g_param_spec_get_name(pspec)
def vips_call_instance(self, name, args):
logging.debug('vipsimage: vips_call_instance name=%s, self=%s, args=%s' %
(name, self, args))
operation = vips_operation_new(name)
vipsobject.vips_object_print(operation)
vipsobject.vips_argument_map(operation,
vipsobject.VipsArgumentMapFn(show_args),None, None)
class VipsOperation(vipsobject.VipsObject):
"""Call a libvips operation."""
def __init__(self, name):
logging.debug('vipsoperation: init %s', name)
vipsobject.VipsObject.__init__(self)
self.vipsobject = vips_operation_new(name)
self.enable_finalize()
def call

14
python/setup.py
View File

@ -1,14 +0,0 @@
#!/usr/bin/python
from distutils.core import setup
setup(name = 'vips8',
version = '7.28.0dev',
description = 'vips-8.x image processing library',
long_description = open('README.txt').read(),
license = 'LGPL'
author = 'John Cupitt',
author_email = 'jcupitt@gmail.com',
url = 'http://www.vips.ecs.soton.ac.uk',
requires = ['gi'],
packages = ['vips8'])

9
python/soak.sh
View File

@ -1,9 +0,0 @@
#!/bin/bash
export G_DEBUG=fatal-warnings
while true; do
if ! python test_colour.py TestColour.test_colourspace; then
exit
fi
done

2
swig/Makefile.am
View File

@ -2,4 +2,4 @@ SUBDIRS = \
vipsCC vipsCC
EXTRA_DIST = \ EXTRA_DIST = \
test README.txt

3
swig/README.txt Normal file
View File

@ -0,0 +1,3 @@
This is the old vips7 Python binding. Use the vips8 one in preference for new
projects.

4
tools/Makefile.am
View File

@ -23,11 +23,11 @@ bin_SCRIPTS = \
batch_rubber_sheet \ batch_rubber_sheet \
batch_crop \ batch_crop \
vipsprofile \ vipsprofile \
vips-7.41 vips-7.42
EXTRA_DIST = \ EXTRA_DIST = \
vipsprofile \ vipsprofile \
vips-7.41 \ vips-7.42 \
light_correct.in \ light_correct.in \
shrink_width.in \ shrink_width.in \
batch_image_convert.in \ batch_image_convert.in \

0
tools/vips-7.41 → tools/vips-7.42
View File

2
vipsCC.pc.in
View File

@ -4,7 +4,7 @@ libdir=@libdir@
includedir=@includedir@ includedir=@includedir@
Name: vipsCC Name: vipsCC
Description: C++ API for vips7 image processing library Description: deprecated C++ API for vips image processing library
Version: @VERSION@ Version: @VERSION@
Requires: vips = @VERSION@ Requires: vips = @VERSION@
Libs: -L${libdir} -lvipsCC Libs: -L${libdir} -lvipsCC