| // VIPS image wrapper |
| |
| /* |
| |
| This file is part of VIPS. |
| |
| VIPS is free software; you can redistribute it and/or modify |
| it under the terms of the GNU Lesser General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| |
| */ |
| |
| /* |
| |
| These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk |
| |
| */ |
| |
| #ifndef IM_VIMAGE_H |
| #define IM_VIMAGE_H |
| |
| /* SWIG includes this file directly rather than going through vipscpp.h ... so |
| * we have to define these macros here as well. |
| */ |
| #ifdef SWIG |
| # define VIPS_NAMESPACE_START namespace vips { |
| # define VIPS_NAMESPACE_END } |
| #endif /*SWIG*/ |
| |
| /* Don't include these when parsing for SWIG. |
| */ |
| #ifndef SWIG |
| # include <list> |
| # include <complex> |
| # include <vector> |
| #endif /*!SWIG*/ |
| |
| /* Wrap pointers to these, but we don't want to import all the old C API. Just |
| * declare them. |
| */ |
| extern "C" { |
| struct _VipsImage; |
| |
| /* Needed by Vargv, see below. |
| */ |
| struct im__function; |
| typedef void *im__object; |
| } |
| |
| VIPS_NAMESPACE_START |
| |
| /* A VIPS callback, our name for im_callback_fn. |
| */ |
| typedef int (*VCallback)( void *, void * ); |
| |
| /* VIPS image class. |
| * |
| * Slightly tricky: we have two sorts of sharing. Several VImage can share one |
| * refblock (while results are being returned from functions, for example), |
| * and several other refblocks can have IMAGEs which depend upon this IMAGE |
| * for their result. |
| */ |
| class VImage { |
| /* We'd like this to be protected so that user subclasses can define |
| * their own member wrappers. But sadly C++ doesn't work like that: |
| * subclasses of VImage can only refer to protected members via |
| * this->, which isn't what we need. Just make it public and hope no |
| * one touches it. |
| */ |
| public: |
| /* Doesn't need to be wrapped. |
| */ |
| #ifndef SWIG |
| // Count ref etc. in one of these. One for each open VIPS image. |
| struct refblock { |
| _VipsImage *im; // IMAGE pointer |
| int close_on_delete; // Set if we must im_close() |
| int nrefs; // Number of refs to us |
| std::list<refblock*> orefs; // Refs im makes |
| |
| // Construct/destruct |
| refblock(); |
| virtual ~refblock(); |
| |
| // Add a ref - this (output image) depends upon IMAGE in |
| void addref( refblock *in ); |
| |
| // Remove a ref |
| void removeref(); |
| |
| // Debugging |
| void debug_print(); |
| |
| // Linked list needs "==" -- use address equivalence |
| friend int operator==( const refblock &left, |
| const refblock &right ) { return( &left == &right ); } |
| }; |
| |
| refblock *_ref; |
| #endif /*!SWIG*/ |
| |
| public: |
| #ifdef DEBUG |
| /* All the refblocks in the world. |
| */ |
| static std::list<refblock*> all_refblock; |
| #endif /*DEBUG*/ |
| |
| /* Print all refblocks ... debugging. Compile with DEBUG to enable |
| * this. |
| */ |
| static void print_all(); |
| |
| /* Typedefs and enums we need. |
| */ |
| |
| // Type type |
| enum TType { |
| MULTIBAND = 0, |
| B_W = 1, |
| LUMINACE = 2, |
| XRAY = 3, |
| IR = 4, |
| YUV = 5, |
| RED_ONLY = 6, |
| GREEN_ONLY = 7, |
| BLUE_ONLY = 8, |
| POWER_SPECTRUM = 9, |
| HISTOGRAM = 10, |
| LUT = 11, |
| XYZ = 12, |
| LAB = 13, |
| CMC = 14, |
| CMYK = 15, |
| LABQ = 16, |
| RGB = 17, |
| UCS = 18, |
| LCH = 19, |
| LABS = 21, |
| sRGB = 22, |
| YXY = 23, |
| FOURIER = 24, |
| RGB16 = 25, |
| GREY16 = 26 |
| }; |
| |
| // Format type |
| enum TBandFmt { |
| FMTNOTSET = -1, |
| FMTUCHAR = 0, |
| FMTCHAR = 1, |
| FMTUSHORT = 2, |
| FMTSHORT = 3, |
| FMTUINT = 4, |
| FMTINT = 5, |
| FMTFLOAT = 6, |
| FMTCOMPLEX = 7, |
| FMTDOUBLE = 8, |
| FMTDPCOMPLEX = 9 |
| }; |
| |
| // Coding type |
| enum TCoding { |
| NOCODING = 0, |
| COLQUANT = 1, |
| LABPACK = 2, |
| LABPACK_COMPRESSED = 3, |
| RGB_COMPRESSED = 4, |
| LUM_COMPRESSED = 5, |
| RAD = 6 |
| }; |
| |
| // Compression type |
| enum TCompression { |
| NO_COMPRESSION = 0, |
| TCSF_COMPRESSION = 1, |
| JPEG_COMPRESSION = 2 |
| }; |
| |
| /* Start of wrappers for iofuncs. |
| */ |
| |
| // Plain constructors |
| VImage( const char *name, const char *mode = "r" ); |
| VImage( void *data, int width, int height, |
| int bands, TBandFmt format ); |
| VImage( _VipsImage *image ); |
| VImage(); |
| |
| // Convert to a disc file, eg: |
| // VImage fred = VImage::convert2disc( "im_jpeg2vips", |
| // "file.jpg", "temp.v" ); |
| // Runs im_jpeg2vips to the temp file, then opens that and returns |
| // it. Useful for opening very large files without using a lot of RAM. |
| // Now superceeded by the format API, though that's not yet wrapped in |
| // C++ |
| static VImage convert2disc( const char* convert, |
| const char* in, const char* disc ); |
| |
| // Copy constructor |
| VImage( const VImage &a ); |
| |
| // Assignment - delete old ref |
| VImage &operator=( const VImage &a ); |
| |
| // Destructor |
| virtual ~VImage() { _ref->removeref(); } |
| |
| // Extract underlying IMAGE* pointer |
| _VipsImage *image() const { return( _ref->im ); } |
| |
| // Extract underlying data pointer |
| void *data() const; |
| |
| // Write this to another VImage, to a file, or to a mem buffer |
| VImage write( VImage out ); |
| VImage write( const char *name ); |
| VImage write(); |
| |
| // Debugging ... print header fields |
| void debug_print(); |
| |
| // Projection functions to get header fields |
| int Xsize(); |
| int Ysize(); |
| int Bands(); |
| TBandFmt BandFmt(); |
| TCoding Coding(); |
| TType Type(); |
| float Xres(); |
| float Yres(); |
| int Length(); |
| TCompression Compression(); |
| short Level(); |
| int Xoffset(); |
| int Yoffset(); |
| |
| // Derived fields |
| const char *filename(); |
| const char *Hist(); |
| |
| // metadata |
| #ifndef SWIG |
| // base functionality |
| // we don't wrap GValue, so we can't wrap these for now |
| void meta_set( const char *field, GValue *value ); |
| void meta_get( const char *field, GValue *value_copy ); |
| #endif /*SWIG*/ |
| |
| // We can wrap these, fwiw |
| gboolean meta_remove( const char *field ); |
| GType meta_get_typeof( const char *field ); |
| |
| // convenience functions |
| int meta_get_int( const char *field ); |
| double meta_get_double( const char *field ); |
| const char *meta_get_string( const char *field ); |
| void *meta_get_area( const char *field ); |
| void *meta_get_blob( const char *field, size_t *length ) |
| throw( VError ); |
| |
| void meta_set( const char *field, int value ); |
| void meta_set( const char *field, double value ); |
| void meta_set( const char *field, const char *value ); |
| |
| #ifndef SWIG |
| // we don't wrap callbacks yet, so we can't wrap these for now |
| void meta_set( const char *field, |
| VCallback free_fn, void *value ) |
| throw( VError ); |
| void meta_set( const char *field, |
| VCallback free_fn, void *value, size_t length ) |
| throw( VError ); |
| #endif /*SWIG*/ |
| |
| // Set header fields |
| void initdesc( int, int, int, TBandFmt, TCoding, TType, |
| float = 1.0, float = 1.0, int = 0, int = 0 ); |
| |
| /* Insert automatically generated headers. |
| */ |
| #include "vipsc++.h" |
| |
| /* No point getting SWIG to wrap these ... we do this by hand later so we can |
| * handle things like "a + 12" correctly. |
| */ |
| #ifndef SWIG |
| // And some in-line operator equivalences done by hand |
| friend VImage operator+( VImage a, VImage b ) |
| { return( a.add( b ) ); } |
| friend VImage operator+( double a, VImage b ) |
| { return( b.lin( 1.0, a ) ); } |
| friend VImage operator+( VImage a, double b ) |
| { return( a.lin( 1.0, b ) ); } |
| |
| friend VImage operator-( VImage a, VImage b ) |
| { return( a.subtract( b ) ); } |
| friend VImage operator-( double a, VImage b ) |
| { return( b.lin( -1.0, a ) ); } |
| friend VImage operator-( VImage a, double b ) |
| { return( a.lin( 1.0, -b ) ); } |
| |
| friend VImage operator*( VImage a, VImage b ) |
| { return( a.multiply( b ) ); } |
| friend VImage operator*( double a, VImage b ) |
| { return( b.lin( a, 0.0 ) ); } |
| friend VImage operator*( VImage a, double b ) |
| { return( a.lin( b, 0.0 ) ); } |
| |
| friend VImage operator/( VImage a, VImage b ) |
| { return( a.divide( b ) ); } |
| friend VImage operator/( double a, VImage b ) |
| { return( b.pow( -1.0 ).lin( a, 0.0 ) ); } |
| friend VImage operator/( VImage a, double b ) |
| { return( a.lin( 1.0/b, 0.0 ) ); } |
| |
| friend VImage operator%( VImage a, VImage b ) |
| { return( a.remainder( b ) ); } |
| friend VImage operator%( VImage a, double b ) |
| { return( a.remainder( b ) ); } |
| |
| friend VImage operator<( VImage a, VImage b ) |
| { return( a.less( b ) ); } |
| friend VImage operator<( double a, VImage b ) |
| { return( b.more( a ) ); } |
| friend VImage operator<( VImage a, double b ) |
| { return( a.less( b ) ); } |
| |
| friend VImage operator<=( VImage a, VImage b ) |
| { return( a.lesseq( b ) ); } |
| friend VImage operator<=( double a, VImage b ) |
| { return( b.moreeq( a ) ); } |
| friend VImage operator<=( VImage a, double b ) |
| { return( a.lesseq( b ) ); } |
| |
| friend VImage operator>( VImage a, VImage b ) |
| { return( a.more( b ) ); } |
| friend VImage operator>( double a, VImage b ) |
| { return( b.less( a ) ); } |
| friend VImage operator>( VImage a, double b ) |
| { return( a.more( b ) ); } |
| |
| friend VImage operator>=( VImage a, VImage b ) |
| { return( a.moreeq( b ) ); } |
| friend VImage operator>=( double a, VImage b ) |
| { return( b.lesseq( a ) ); } |
| friend VImage operator>=( VImage a, double b ) |
| { return( a.moreeq( b ) ); } |
| |
| friend VImage operator==( VImage a, VImage b ) |
| { return( a.equal( b ) ); } |
| friend VImage operator==( double a, VImage b ) |
| { return( b.equal( a ) ); } |
| friend VImage operator==( VImage a, double b ) |
| { return( a.equal( b ) ); } |
| |
| friend VImage operator!=( VImage a, VImage b ) |
| { return( a.notequal( b ) ); } |
| friend VImage operator!=( double a, VImage b ) |
| { return( b.notequal( a ) ); } |
| friend VImage operator!=( VImage a, double b ) |
| { return( a.notequal( b ) ); } |
| |
| friend VImage operator&( VImage a, VImage b ) |
| { return( a.andimage( b ) ); } |
| friend VImage operator&( int a, VImage b ) |
| { return( b.andimage( a ) ); } |
| friend VImage operator&( VImage a, int b ) |
| { return( a.andimage( b ) ); } |
| |
| friend VImage operator|( VImage a, VImage b ) |
| { return( a.orimage( b ) ); } |
| friend VImage operator|( int a, VImage b ) |
| { return( b.orimage( a ) ); } |
| friend VImage operator|( VImage a, int b ) |
| { return( a.orimage( b ) ); } |
| |
| friend VImage operator^( VImage a, VImage b ) |
| { return( a.eorimage( b ) ); } |
| friend VImage operator^( int a, VImage b ) |
| { return( b.eorimage( a ) ); } |
| friend VImage operator^( VImage a, int b ) |
| { return( a.eorimage( b ) ); } |
| |
| friend VImage operator<<( VImage a, int b ) |
| { return( a.shiftleft( b ) ); } |
| friend VImage operator>>( VImage a, int b ) |
| { return( a.shiftright( b ) ); } |
| |
| friend VImage operator-( VImage a ) |
| { return( a * -1 ); } |
| |
| // Type conversion: VImage to VDMask and VIMask |
| operator VDMask() |
| { return( this->vips2mask() ); } |
| operator VIMask() |
| { return( VIMask( VDMask( *this ) ) ); } |
| #endif /*!SWIG*/ |
| }; |
| |
| /* Don't include these when parsing for SWIG. |
| */ |
| #ifndef SWIG |
| |
| /* Class wrapping up a vargv. Member function wrappers need this. It needs to |
| * be part of the public API in case people subclass VImage and add their own |
| * members. |
| */ |
| class Vargv { |
| // Function we are args to |
| im__function *fn; |
| |
| // Base of object vector |
| im__object *base; |
| |
| public: |
| Vargv( const char *name ); |
| ~Vargv(); |
| |
| // Reference to element of base |
| im__object &data( int i = 0 ) { return( base[i] ); }; |
| |
| // Invoke function |
| void call(); |
| }; |
| |
| #endif /*!SWIG*/ |
| |
| VIPS_NAMESPACE_END |
| |
| // Other VIPS protos we need |
| extern "C" { |
| extern int im_init_world( const char *argv0 ); |
| extern void im__print_all(); |
| extern void im_col_Lab2XYZ( |
| float, float, float, |
| float *, float *, float * ); |
| } |
| |
| #endif /*IM_VIMAGE_H*/ |