python-vipscc 8.4.5-1build1 / usr / lib / python2.7 / dist-packages / vipsCC / VImage.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('vimagemodule', [dirname(__file__)])
        except ImportError:
            import vimagemodule
            return vimagemodule
        if fp is not None:
            try:
                _mod = imp.load_module('vimagemodule', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    vimagemodule = swig_import_helper()
    del swig_import_helper
else:
    import vimagemodule
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = vimagemodule.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return vimagemodule.SwigPyIterator_value(self)

    def incr(self, n=1):
        return vimagemodule.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return vimagemodule.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return vimagemodule.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return vimagemodule.SwigPyIterator_equal(self, x)

    def copy(self):
        return vimagemodule.SwigPyIterator_copy(self)

    def next(self):
        return vimagemodule.SwigPyIterator_next(self)

    def __next__(self):
        return vimagemodule.SwigPyIterator___next__(self)

    def previous(self):
        return vimagemodule.SwigPyIterator_previous(self)

    def advance(self, n):
        return vimagemodule.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return vimagemodule.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return vimagemodule.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return vimagemodule.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return vimagemodule.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return vimagemodule.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return vimagemodule.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = vimagemodule.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

import VError
import VMask
import VDisplay
class IntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return vimagemodule.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return vimagemodule.IntVector___nonzero__(self)

    def __bool__(self):
        return vimagemodule.IntVector___bool__(self)

    def __len__(self):
        return vimagemodule.IntVector___len__(self)

    def __getslice__(self, i, j):
        return vimagemodule.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return vimagemodule.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return vimagemodule.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return vimagemodule.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return vimagemodule.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return vimagemodule.IntVector___setitem__(self, *args)

    def pop(self):
        return vimagemodule.IntVector_pop(self)

    def append(self, x):
        return vimagemodule.IntVector_append(self, x)

    def empty(self):
        return vimagemodule.IntVector_empty(self)

    def size(self):
        return vimagemodule.IntVector_size(self)

    def swap(self, v):
        return vimagemodule.IntVector_swap(self, v)

    def begin(self):
        return vimagemodule.IntVector_begin(self)

    def end(self):
        return vimagemodule.IntVector_end(self)

    def rbegin(self):
        return vimagemodule.IntVector_rbegin(self)

    def rend(self):
        return vimagemodule.IntVector_rend(self)

    def clear(self):
        return vimagemodule.IntVector_clear(self)

    def get_allocator(self):
        return vimagemodule.IntVector_get_allocator(self)

    def pop_back(self):
        return vimagemodule.IntVector_pop_back(self)

    def erase(self, *args):
        return vimagemodule.IntVector_erase(self, *args)

    def __init__(self, *args):
        this = vimagemodule.new_IntVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return vimagemodule.IntVector_push_back(self, x)

    def front(self):
        return vimagemodule.IntVector_front(self)

    def back(self):
        return vimagemodule.IntVector_back(self)

    def assign(self, n, x):
        return vimagemodule.IntVector_assign(self, n, x)

    def resize(self, *args):
        return vimagemodule.IntVector_resize(self, *args)

    def insert(self, *args):
        return vimagemodule.IntVector_insert(self, *args)

    def reserve(self, n):
        return vimagemodule.IntVector_reserve(self, n)

    def capacity(self):
        return vimagemodule.IntVector_capacity(self)
    __swig_destroy__ = vimagemodule.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = vimagemodule.IntVector_swigregister
IntVector_swigregister(IntVector)

class DoubleVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return vimagemodule.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return vimagemodule.DoubleVector___nonzero__(self)

    def __bool__(self):
        return vimagemodule.DoubleVector___bool__(self)

    def __len__(self):
        return vimagemodule.DoubleVector___len__(self)

    def __getslice__(self, i, j):
        return vimagemodule.DoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return vimagemodule.DoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return vimagemodule.DoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return vimagemodule.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return vimagemodule.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return vimagemodule.DoubleVector___setitem__(self, *args)

    def pop(self):
        return vimagemodule.DoubleVector_pop(self)

    def append(self, x):
        return vimagemodule.DoubleVector_append(self, x)

    def empty(self):
        return vimagemodule.DoubleVector_empty(self)

    def size(self):
        return vimagemodule.DoubleVector_size(self)

    def swap(self, v):
        return vimagemodule.DoubleVector_swap(self, v)

    def begin(self):
        return vimagemodule.DoubleVector_begin(self)

    def end(self):
        return vimagemodule.DoubleVector_end(self)

    def rbegin(self):
        return vimagemodule.DoubleVector_rbegin(self)

    def rend(self):
        return vimagemodule.DoubleVector_rend(self)

    def clear(self):
        return vimagemodule.DoubleVector_clear(self)

    def get_allocator(self):
        return vimagemodule.DoubleVector_get_allocator(self)

    def pop_back(self):
        return vimagemodule.DoubleVector_pop_back(self)

    def erase(self, *args):
        return vimagemodule.DoubleVector_erase(self, *args)

    def __init__(self, *args):
        this = vimagemodule.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return vimagemodule.DoubleVector_push_back(self, x)

    def front(self):
        return vimagemodule.DoubleVector_front(self)

    def back(self):
        return vimagemodule.DoubleVector_back(self)

    def assign(self, n, x):
        return vimagemodule.DoubleVector_assign(self, n, x)

    def resize(self, *args):
        return vimagemodule.DoubleVector_resize(self, *args)

    def insert(self, *args):
        return vimagemodule.DoubleVector_insert(self, *args)

    def reserve(self, n):
        return vimagemodule.DoubleVector_reserve(self, n)

    def capacity(self):
        return vimagemodule.DoubleVector_capacity(self)
    __swig_destroy__ = vimagemodule.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = vimagemodule.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class ImageVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ImageVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ImageVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return vimagemodule.ImageVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return vimagemodule.ImageVector___nonzero__(self)

    def __bool__(self):
        return vimagemodule.ImageVector___bool__(self)

    def __len__(self):
        return vimagemodule.ImageVector___len__(self)

    def __getslice__(self, i, j):
        return vimagemodule.ImageVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return vimagemodule.ImageVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return vimagemodule.ImageVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return vimagemodule.ImageVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return vimagemodule.ImageVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return vimagemodule.ImageVector___setitem__(self, *args)

    def pop(self):
        return vimagemodule.ImageVector_pop(self)

    def append(self, x):
        return vimagemodule.ImageVector_append(self, x)

    def empty(self):
        return vimagemodule.ImageVector_empty(self)

    def size(self):
        return vimagemodule.ImageVector_size(self)

    def swap(self, v):
        return vimagemodule.ImageVector_swap(self, v)

    def begin(self):
        return vimagemodule.ImageVector_begin(self)

    def end(self):
        return vimagemodule.ImageVector_end(self)

    def rbegin(self):
        return vimagemodule.ImageVector_rbegin(self)

    def rend(self):
        return vimagemodule.ImageVector_rend(self)

    def clear(self):
        return vimagemodule.ImageVector_clear(self)

    def get_allocator(self):
        return vimagemodule.ImageVector_get_allocator(self)

    def pop_back(self):
        return vimagemodule.ImageVector_pop_back(self)

    def erase(self, *args):
        return vimagemodule.ImageVector_erase(self, *args)

    def __init__(self, *args):
        this = vimagemodule.new_ImageVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return vimagemodule.ImageVector_push_back(self, x)

    def front(self):
        return vimagemodule.ImageVector_front(self)

    def back(self):
        return vimagemodule.ImageVector_back(self)

    def assign(self, n, x):
        return vimagemodule.ImageVector_assign(self, n, x)

    def resize(self, *args):
        return vimagemodule.ImageVector_resize(self, *args)

    def insert(self, *args):
        return vimagemodule.ImageVector_insert(self, *args)

    def reserve(self, n):
        return vimagemodule.ImageVector_reserve(self, n)

    def capacity(self):
        return vimagemodule.ImageVector_capacity(self)
    __swig_destroy__ = vimagemodule.delete_ImageVector
    __del__ = lambda self: None
ImageVector_swigregister = vimagemodule.ImageVector_swigregister
ImageVector_swigregister(ImageVector)


def init(*args):
    return vimagemodule.init(*args)
init = vimagemodule.init

def thread_shutdown():
    return vimagemodule.thread_shutdown()
thread_shutdown = vimagemodule.thread_shutdown

def shutdown():
    return vimagemodule.shutdown()
shutdown = vimagemodule.shutdown
class VImage(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VImage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VImage, name)
    __repr__ = _swig_repr
    __swig_getmethods__["print_all"] = lambda x: vimagemodule.VImage_print_all
    if _newclass:
        print_all = staticmethod(vimagemodule.VImage_print_all)
    MULTIBAND = vimagemodule.VImage_MULTIBAND
    B_W = vimagemodule.VImage_B_W
    LUMINACE = vimagemodule.VImage_LUMINACE
    XRAY = vimagemodule.VImage_XRAY
    IR = vimagemodule.VImage_IR
    YUV = vimagemodule.VImage_YUV
    RED_ONLY = vimagemodule.VImage_RED_ONLY
    GREEN_ONLY = vimagemodule.VImage_GREEN_ONLY
    BLUE_ONLY = vimagemodule.VImage_BLUE_ONLY
    POWER_SPECTRUM = vimagemodule.VImage_POWER_SPECTRUM
    HISTOGRAM = vimagemodule.VImage_HISTOGRAM
    LUT = vimagemodule.VImage_LUT
    XYZ = vimagemodule.VImage_XYZ
    LAB = vimagemodule.VImage_LAB
    CMC = vimagemodule.VImage_CMC
    CMYK = vimagemodule.VImage_CMYK
    LABQ = vimagemodule.VImage_LABQ
    RGB = vimagemodule.VImage_RGB
    UCS = vimagemodule.VImage_UCS
    LCH = vimagemodule.VImage_LCH
    LABS = vimagemodule.VImage_LABS
    sRGB = vimagemodule.VImage_sRGB
    YXY = vimagemodule.VImage_YXY
    FOURIER = vimagemodule.VImage_FOURIER
    RGB16 = vimagemodule.VImage_RGB16
    GREY16 = vimagemodule.VImage_GREY16
    FMTNOTSET = vimagemodule.VImage_FMTNOTSET
    FMTUCHAR = vimagemodule.VImage_FMTUCHAR
    FMTCHAR = vimagemodule.VImage_FMTCHAR
    FMTUSHORT = vimagemodule.VImage_FMTUSHORT
    FMTSHORT = vimagemodule.VImage_FMTSHORT
    FMTUINT = vimagemodule.VImage_FMTUINT
    FMTINT = vimagemodule.VImage_FMTINT
    FMTFLOAT = vimagemodule.VImage_FMTFLOAT
    FMTCOMPLEX = vimagemodule.VImage_FMTCOMPLEX
    FMTDOUBLE = vimagemodule.VImage_FMTDOUBLE
    FMTDPCOMPLEX = vimagemodule.VImage_FMTDPCOMPLEX
    NOCODING = vimagemodule.VImage_NOCODING
    COLQUANT = vimagemodule.VImage_COLQUANT
    LABPACK = vimagemodule.VImage_LABPACK
    LABPACK_COMPRESSED = vimagemodule.VImage_LABPACK_COMPRESSED
    RGB_COMPRESSED = vimagemodule.VImage_RGB_COMPRESSED
    LUM_COMPRESSED = vimagemodule.VImage_LUM_COMPRESSED
    RAD = vimagemodule.VImage_RAD
    NO_COMPRESSION = vimagemodule.VImage_NO_COMPRESSION
    TCSF_COMPRESSION = vimagemodule.VImage_TCSF_COMPRESSION
    JPEG_COMPRESSION = vimagemodule.VImage_JPEG_COMPRESSION
    __swig_getmethods__["convert2disc"] = lambda x: vimagemodule.VImage_convert2disc
    if _newclass:
        convert2disc = staticmethod(vimagemodule.VImage_convert2disc)

    def __init__(self, *args):
        this = vimagemodule.new_VImage(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __assign__(self, a):
        return vimagemodule.VImage___assign__(self, a)
    __swig_destroy__ = vimagemodule.delete_VImage
    __del__ = lambda self: None

    def image(self):
        return vimagemodule.VImage_image(self)

    def data(self):
        return vimagemodule.VImage_data(self)

    def write(self, *args):
        return vimagemodule.VImage_write(self, *args)

    def debug_print(self):
        return vimagemodule.VImage_debug_print(self)

    def Xsize(self):
        return vimagemodule.VImage_Xsize(self)

    def Ysize(self):
        return vimagemodule.VImage_Ysize(self)

    def Bands(self):
        return vimagemodule.VImage_Bands(self)

    def BandFmt(self):
        return vimagemodule.VImage_BandFmt(self)

    def Coding(self):
        return vimagemodule.VImage_Coding(self)

    def Type(self):
        return vimagemodule.VImage_Type(self)

    def Xres(self):
        return vimagemodule.VImage_Xres(self)

    def Yres(self):
        return vimagemodule.VImage_Yres(self)

    def Length(self):
        return vimagemodule.VImage_Length(self)

    def Compression(self):
        return vimagemodule.VImage_Compression(self)

    def Level(self):
        return vimagemodule.VImage_Level(self)

    def Xoffset(self):
        return vimagemodule.VImage_Xoffset(self)

    def Yoffset(self):
        return vimagemodule.VImage_Yoffset(self)

    def filename(self):
        return vimagemodule.VImage_filename(self)

    def Hist(self):
        return vimagemodule.VImage_Hist(self)

    def hough_circle(self, scale, min_radius, max_radius):
        return vimagemodule.VImage_hough_circle(self, scale, min_radius, max_radius)

    def meta_remove(self, field):
        return vimagemodule.VImage_meta_remove(self, field)

    def meta_get_typeof(self, field):
        return vimagemodule.VImage_meta_get_typeof(self, field)

    def meta_get_int(self, field):
        return vimagemodule.VImage_meta_get_int(self, field)

    def meta_get_double(self, field):
        return vimagemodule.VImage_meta_get_double(self, field)

    def meta_get_string(self, field):
        return vimagemodule.VImage_meta_get_string(self, field)

    def meta_get_area(self, field):
        return vimagemodule.VImage_meta_get_area(self, field)

    def meta_get_blob(self, field, length):
        return vimagemodule.VImage_meta_get_blob(self, field, length)

    def meta_set(self, *args):
        return vimagemodule.VImage_meta_set(self, *args)

    def initdesc(self, arg2, arg3, arg4, arg5, arg6, arg7, arg8=1.0, arg9=1.0, arg10=0, arg11=0):
        return vimagemodule.VImage_initdesc(self, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)

    def abs(self):
        return vimagemodule.VImage_abs(self)

    def acos(self):
        return vimagemodule.VImage_acos(self)

    def add(self, add_in2):
        return vimagemodule.VImage_add(self, add_in2)

    def asin(self):
        return vimagemodule.VImage_asin(self)

    def atan(self):
        return vimagemodule.VImage_atan(self)

    def avg(self):
        return vimagemodule.VImage_avg(self)

    def point(self, point_interpolate, point_x, point_y, point_band):
        return vimagemodule.VImage_point(self, point_interpolate, point_x, point_y, point_band)

    def point_bilinear(self, point_bilinear_x, point_bilinear_y, point_bilinear_band):
        return vimagemodule.VImage_point_bilinear(self, point_bilinear_x, point_bilinear_y, point_bilinear_band)

    def bandmean(self):
        return vimagemodule.VImage_bandmean(self)

    def ceil(self):
        return vimagemodule.VImage_ceil(self)

    def cos(self):
        return vimagemodule.VImage_cos(self)

    def cross_phase(self, cross_phase_in2):
        return vimagemodule.VImage_cross_phase(self, cross_phase_in2)

    def deviate(self):
        return vimagemodule.VImage_deviate(self)

    def divide(self, divide_in2):
        return vimagemodule.VImage_divide(self, divide_in2)

    def exp10(self):
        return vimagemodule.VImage_exp10(self)

    def expn(self, *args):
        return vimagemodule.VImage_expn(self, *args)

    def exp(self):
        return vimagemodule.VImage_exp(self)

    def floor(self):
        return vimagemodule.VImage_floor(self)

    def invert(self):
        return vimagemodule.VImage_invert(self)
    __swig_getmethods__["linreg"] = lambda x: vimagemodule.VImage_linreg
    if _newclass:
        linreg = staticmethod(vimagemodule.VImage_linreg)

    def lin(self, *args):
        return vimagemodule.VImage_lin(self, *args)

    def log10(self):
        return vimagemodule.VImage_log10(self)

    def log(self):
        return vimagemodule.VImage_log(self)

    def max(self):
        return vimagemodule.VImage_max(self)

    def maxpos(self):
        return vimagemodule.VImage_maxpos(self)

    def maxpos_avg(self):
        return vimagemodule.VImage_maxpos_avg(self)

    def measure(self, measure_x, measure_y, measure_w, measure_h, measure_h_patches, measure_v_patches):
        return vimagemodule.VImage_measure(self, measure_x, measure_y, measure_w, measure_h, measure_h_patches, measure_v_patches)

    def min(self):
        return vimagemodule.VImage_min(self)

    def minpos(self):
        return vimagemodule.VImage_minpos(self)

    def multiply(self, multiply_in2):
        return vimagemodule.VImage_multiply(self, multiply_in2)

    def pow(self, *args):
        return vimagemodule.VImage_pow(self, *args)

    def recomb(self, recomb_matrix):
        return vimagemodule.VImage_recomb(self, recomb_matrix)

    def remainder(self, *args):
        return vimagemodule.VImage_remainder(self, *args)

    def rint(self):
        return vimagemodule.VImage_rint(self)

    def sign(self):
        return vimagemodule.VImage_sign(self)

    def sin(self):
        return vimagemodule.VImage_sin(self)

    def stats(self):
        return vimagemodule.VImage_stats(self)

    def subtract(self, subtract_in2):
        return vimagemodule.VImage_subtract(self, subtract_in2)

    def tan(self):
        return vimagemodule.VImage_tan(self)

    def greyc(self, greyc_iterations, greyc_amplitude, greyc_sharpness, greyc_anisotropy, greyc_alpha, greyc_sigma, greyc_dl, greyc_da, greyc_gauss_prec, greyc_interpolation, greyc_fast_approx):
        return vimagemodule.VImage_greyc(self, greyc_iterations, greyc_amplitude, greyc_sharpness, greyc_anisotropy, greyc_alpha, greyc_sigma, greyc_dl, greyc_da, greyc_gauss_prec, greyc_interpolation, greyc_fast_approx)

    def greyc_mask(self, greyc_mask_mask, greyc_mask_iterations, greyc_mask_amplitude, greyc_mask_sharpness, greyc_mask_anisotropy, greyc_mask_alpha, greyc_mask_sigma, greyc_mask_dl, greyc_mask_da, greyc_mask_gauss_prec, greyc_mask_interpolation, greyc_mask_fast_approx):
        return vimagemodule.VImage_greyc_mask(self, greyc_mask_mask, greyc_mask_iterations, greyc_mask_amplitude, greyc_mask_sharpness, greyc_mask_anisotropy, greyc_mask_alpha, greyc_mask_sigma, greyc_mask_dl, greyc_mask_da, greyc_mask_gauss_prec, greyc_mask_interpolation, greyc_mask_fast_approx)

    def LCh2Lab(self):
        return vimagemodule.VImage_LCh2Lab(self)

    def LCh2UCS(self):
        return vimagemodule.VImage_LCh2UCS(self)

    def Lab2LCh(self):
        return vimagemodule.VImage_Lab2LCh(self)

    def Lab2LabQ(self):
        return vimagemodule.VImage_Lab2LabQ(self)

    def Lab2LabS(self):
        return vimagemodule.VImage_Lab2LabS(self)

    def Lab2UCS(self):
        return vimagemodule.VImage_Lab2UCS(self)

    def Lab2XYZ(self):
        return vimagemodule.VImage_Lab2XYZ(self)

    def Lab2XYZ_temp(self, Lab2XYZ_temp_X0, Lab2XYZ_temp_Y0, Lab2XYZ_temp_Z0):
        return vimagemodule.VImage_Lab2XYZ_temp(self, Lab2XYZ_temp_X0, Lab2XYZ_temp_Y0, Lab2XYZ_temp_Z0)

    def Lab2disp(self, Lab2disp_disp):
        return vimagemodule.VImage_Lab2disp(self, Lab2disp_disp)

    def LabQ2LabS(self):
        return vimagemodule.VImage_LabQ2LabS(self)

    def LabQ2Lab(self):
        return vimagemodule.VImage_LabQ2Lab(self)

    def LabQ2XYZ(self):
        return vimagemodule.VImage_LabQ2XYZ(self)

    def LabQ2disp(self, LabQ2disp_disp):
        return vimagemodule.VImage_LabQ2disp(self, LabQ2disp_disp)

    def LabS2LabQ(self):
        return vimagemodule.VImage_LabS2LabQ(self)

    def LabS2Lab(self):
        return vimagemodule.VImage_LabS2Lab(self)

    def UCS2LCh(self):
        return vimagemodule.VImage_UCS2LCh(self)

    def UCS2Lab(self):
        return vimagemodule.VImage_UCS2Lab(self)

    def UCS2XYZ(self):
        return vimagemodule.VImage_UCS2XYZ(self)

    def XYZ2Lab(self):
        return vimagemodule.VImage_XYZ2Lab(self)

    def XYZ2Lab_temp(self, XYZ2Lab_temp_X0, XYZ2Lab_temp_Y0, XYZ2Lab_temp_Z0):
        return vimagemodule.VImage_XYZ2Lab_temp(self, XYZ2Lab_temp_X0, XYZ2Lab_temp_Y0, XYZ2Lab_temp_Z0)

    def XYZ2UCS(self):
        return vimagemodule.VImage_XYZ2UCS(self)

    def XYZ2Yxy(self):
        return vimagemodule.VImage_XYZ2Yxy(self)

    def XYZ2disp(self, XYZ2disp_disp):
        return vimagemodule.VImage_XYZ2disp(self, XYZ2disp_disp)

    def XYZ2sRGB(self):
        return vimagemodule.VImage_XYZ2sRGB(self)

    def Yxy2XYZ(self):
        return vimagemodule.VImage_Yxy2XYZ(self)

    def dE00_fromLab(self, dE00_fromLab_in2):
        return vimagemodule.VImage_dE00_fromLab(self, dE00_fromLab_in2)

    def dECMC_fromLab(self, dECMC_fromLab_in2):
        return vimagemodule.VImage_dECMC_fromLab(self, dECMC_fromLab_in2)

    def dECMC_fromdisp(self, dECMC_fromdisp_in2, dECMC_fromdisp_disp):
        return vimagemodule.VImage_dECMC_fromdisp(self, dECMC_fromdisp_in2, dECMC_fromdisp_disp)

    def dE_fromLab(self, dE_fromLab_in2):
        return vimagemodule.VImage_dE_fromLab(self, dE_fromLab_in2)

    def dE_fromXYZ(self, dE_fromXYZ_in2):
        return vimagemodule.VImage_dE_fromXYZ(self, dE_fromXYZ_in2)

    def dE_fromdisp(self, dE_fromdisp_in2, dE_fromdisp_disp):
        return vimagemodule.VImage_dE_fromdisp(self, dE_fromdisp_in2, dE_fromdisp_disp)

    def disp2Lab(self, disp2Lab_disp):
        return vimagemodule.VImage_disp2Lab(self, disp2Lab_disp)

    def disp2XYZ(self, disp2XYZ_disp):
        return vimagemodule.VImage_disp2XYZ(self, disp2XYZ_disp)

    def float2rad(self):
        return vimagemodule.VImage_float2rad(self)

    def icc_ac2rc(self, icc_ac2rc_profile):
        return vimagemodule.VImage_icc_ac2rc(self, icc_ac2rc_profile)

    def icc_export_depth(self, icc_export_depth_depth, icc_export_depth_output_profile, icc_export_depth_intent):
        return vimagemodule.VImage_icc_export_depth(self, icc_export_depth_depth, icc_export_depth_output_profile, icc_export_depth_intent)

    def icc_import(self, icc_import_input_profile, icc_import_intent):
        return vimagemodule.VImage_icc_import(self, icc_import_input_profile, icc_import_intent)

    def icc_import_embedded(self, icc_import_embedded_intent):
        return vimagemodule.VImage_icc_import_embedded(self, icc_import_embedded_intent)

    def icc_transform(self, icc_transform_input_profile, icc_transform_output_profile, icc_transform_intent):
        return vimagemodule.VImage_icc_transform(self, icc_transform_input_profile, icc_transform_output_profile, icc_transform_intent)

    def lab_morph(self, lab_morph_greyscale, lab_morph_L_offset, lab_morph_L_scale, lab_morph_a_scale, lab_morph_b_scale):
        return vimagemodule.VImage_lab_morph(self, lab_morph_greyscale, lab_morph_L_offset, lab_morph_L_scale, lab_morph_a_scale, lab_morph_b_scale)

    def rad2float(self):
        return vimagemodule.VImage_rad2float(self)

    def sRGB2XYZ(self):
        return vimagemodule.VImage_sRGB2XYZ(self)
    __swig_getmethods__["gaussnoise"] = lambda x: vimagemodule.VImage_gaussnoise
    if _newclass:
        gaussnoise = staticmethod(vimagemodule.VImage_gaussnoise)

    def bandjoin(self, bandjoin_in2):
        return vimagemodule.VImage_bandjoin(self, bandjoin_in2)
    __swig_getmethods__["black"] = lambda x: vimagemodule.VImage_black
    if _newclass:
        black = staticmethod(vimagemodule.VImage_black)

    def c2amph(self):
        return vimagemodule.VImage_c2amph(self)

    def c2imag(self):
        return vimagemodule.VImage_c2imag(self)

    def c2real(self):
        return vimagemodule.VImage_c2real(self)

    def c2rect(self):
        return vimagemodule.VImage_c2rect(self)

    def clip2fmt(self, clip2fmt_ofmt):
        return vimagemodule.VImage_clip2fmt(self, clip2fmt_ofmt)

    def copy(self):
        return vimagemodule.VImage_copy(self)

    def copy_file(self):
        return vimagemodule.VImage_copy_file(self)

    def copy_morph(self, copy_morph_Bands, copy_morph_BandFmt, copy_morph_Coding):
        return vimagemodule.VImage_copy_morph(self, copy_morph_Bands, copy_morph_BandFmt, copy_morph_Coding)

    def copy_swap(self):
        return vimagemodule.VImage_copy_swap(self)

    def copy_set(self, copy_set_Type, copy_set_Xres, copy_set_Yres, copy_set_Xoffset, copy_set_Yoffset):
        return vimagemodule.VImage_copy_set(self, copy_set_Type, copy_set_Xres, copy_set_Yres, copy_set_Xoffset, copy_set_Yoffset)

    def extract_area(self, extract_area_left, extract_area_top, extract_area_width, extract_area_height):
        return vimagemodule.VImage_extract_area(self, extract_area_left, extract_area_top, extract_area_width, extract_area_height)

    def extract_areabands(self, extract_areabands_left, extract_areabands_top, extract_areabands_width, extract_areabands_height, extract_areabands_band, extract_areabands_nbands):
        return vimagemodule.VImage_extract_areabands(self, extract_areabands_left, extract_areabands_top, extract_areabands_width, extract_areabands_height, extract_areabands_band, extract_areabands_nbands)

    def extract_band(self, extract_band_band):
        return vimagemodule.VImage_extract_band(self, extract_band_band)

    def extract_bands(self, extract_bands_band, extract_bands_nbands):
        return vimagemodule.VImage_extract_bands(self, extract_bands_band, extract_bands_nbands)

    def extract(self, extract_left, extract_top, extract_width, extract_height, extract_band):
        return vimagemodule.VImage_extract(self, extract_left, extract_top, extract_width, extract_height, extract_band)

    def falsecolour(self):
        return vimagemodule.VImage_falsecolour(self)

    def fliphor(self):
        return vimagemodule.VImage_fliphor(self)

    def flipver(self):
        return vimagemodule.VImage_flipver(self)
    __swig_getmethods__["gbandjoin"] = lambda x: vimagemodule.VImage_gbandjoin
    if _newclass:
        gbandjoin = staticmethod(vimagemodule.VImage_gbandjoin)

    def grid(self, grid_tile_height, grid_across, grid_down):
        return vimagemodule.VImage_grid(self, grid_tile_height, grid_across, grid_down)

    def insert(self, *args):
        return vimagemodule.VImage_insert(self, *args)

    def insert_noexpand(self, insert_noexpand_sub, insert_noexpand_x, insert_noexpand_y):
        return vimagemodule.VImage_insert_noexpand(self, insert_noexpand_sub, insert_noexpand_x, insert_noexpand_y)

    def embed(self, embed_type, embed_x, embed_y, embed_width, embed_height):
        return vimagemodule.VImage_embed(self, embed_type, embed_x, embed_y, embed_width, embed_height)

    def lrjoin(self, lrjoin_in2):
        return vimagemodule.VImage_lrjoin(self, lrjoin_in2)

    def msb(self):
        return vimagemodule.VImage_msb(self)

    def msb_band(self, msb_band_band):
        return vimagemodule.VImage_msb_band(self, msb_band_band)

    def replicate(self, replicate_across, replicate_down):
        return vimagemodule.VImage_replicate(self, replicate_across, replicate_down)

    def ri2c(self, ri2c_in2):
        return vimagemodule.VImage_ri2c(self, ri2c_in2)

    def rot180(self):
        return vimagemodule.VImage_rot180(self)

    def rot270(self):
        return vimagemodule.VImage_rot270(self)

    def rot90(self):
        return vimagemodule.VImage_rot90(self)

    def scale(self):
        return vimagemodule.VImage_scale(self)

    def scaleps(self):
        return vimagemodule.VImage_scaleps(self)

    def subsample(self, subsample_xshrink, subsample_yshrink):
        return vimagemodule.VImage_subsample(self, subsample_xshrink, subsample_yshrink)

    def system(self, system_command):
        return vimagemodule.VImage_system(self, system_command)

    def system_image(self, system_image_in_format, system_image_out_format, system_image_command, system_image_log):
        return vimagemodule.VImage_system_image(self, system_image_in_format, system_image_out_format, system_image_command, system_image_log)

    def tbjoin(self, tbjoin_in2):
        return vimagemodule.VImage_tbjoin(self, tbjoin_in2)
    __swig_getmethods__["text"] = lambda x: vimagemodule.VImage_text
    if _newclass:
        text = staticmethod(vimagemodule.VImage_text)

    def wrap(self, wrap_x, wrap_y):
        return vimagemodule.VImage_wrap(self, wrap_x, wrap_y)

    def zoom(self, zoom_xfac, zoom_yfac):
        return vimagemodule.VImage_zoom(self, zoom_xfac, zoom_yfac)

    def aconvsep(self, aconvsep_matrix, aconvsep_n_layers):
        return vimagemodule.VImage_aconvsep(self, aconvsep_matrix, aconvsep_n_layers)

    def aconv(self, aconv_matrix, aconv_n_layers, aconv_cluster):
        return vimagemodule.VImage_aconv(self, aconv_matrix, aconv_n_layers, aconv_cluster)

    def addgnoise(self, addgnoise_sigma):
        return vimagemodule.VImage_addgnoise(self, addgnoise_sigma)

    def compass(self, compass_matrix):
        return vimagemodule.VImage_compass(self, compass_matrix)

    def contrast_surface(self, contrast_surface_half_win_size, contrast_surface_spacing):
        return vimagemodule.VImage_contrast_surface(self, contrast_surface_half_win_size, contrast_surface_spacing)

    def conv(self, *args):
        return vimagemodule.VImage_conv(self, *args)

    def convsep(self, *args):
        return vimagemodule.VImage_convsep(self, *args)

    def fastcor(self, fastcor_in2):
        return vimagemodule.VImage_fastcor(self, fastcor_in2)

    def gradcor(self, gradcor_in2):
        return vimagemodule.VImage_gradcor(self, gradcor_in2)

    def gradient(self, gradient_matrix):
        return vimagemodule.VImage_gradient(self, gradient_matrix)

    def grad_x(self):
        return vimagemodule.VImage_grad_x(self)

    def grad_y(self):
        return vimagemodule.VImage_grad_y(self)

    def lindetect(self, lindetect_matrix):
        return vimagemodule.VImage_lindetect(self, lindetect_matrix)

    def sharpen(self, sharpen_mask_size, sharpen_x1, sharpen_y2, sharpen_y3, sharpen_m1, sharpen_m2):
        return vimagemodule.VImage_sharpen(self, sharpen_mask_size, sharpen_x1, sharpen_y2, sharpen_y3, sharpen_m1, sharpen_m2)

    def spcor(self, spcor_in2):
        return vimagemodule.VImage_spcor(self, spcor_in2)

    def argb2rgba(self):
        return vimagemodule.VImage_argb2rgba(self)

    def flood_copy(self, flood_copy_start_x, flood_copy_start_y, flood_copy_ink):
        return vimagemodule.VImage_flood_copy(self, flood_copy_start_x, flood_copy_start_y, flood_copy_ink)

    def flood_blob_copy(self, flood_blob_copy_start_x, flood_blob_copy_start_y, flood_blob_copy_ink):
        return vimagemodule.VImage_flood_blob_copy(self, flood_blob_copy_start_x, flood_blob_copy_start_y, flood_blob_copy_ink)

    def flood_other_copy(self, flood_other_copy_mark, flood_other_copy_start_x, flood_other_copy_start_y, flood_other_copy_serial):
        return vimagemodule.VImage_flood_other_copy(self, flood_other_copy_mark, flood_other_copy_start_x, flood_other_copy_start_y, flood_other_copy_serial)

    def clip(self):
        return vimagemodule.VImage_clip(self)

    def c2ps(self):
        return vimagemodule.VImage_c2ps(self)

    def resize_linear(self, resize_linear_X, resize_linear_Y):
        return vimagemodule.VImage_resize_linear(self, resize_linear_X, resize_linear_Y)

    def cmulnorm(self, cmulnorm_in2):
        return vimagemodule.VImage_cmulnorm(self, cmulnorm_in2)

    def fav4(self, fav4_in2, fav4_in3, fav4_in4):
        return vimagemodule.VImage_fav4(self, fav4_in2, fav4_in3, fav4_in4)

    def gadd(self, gadd_a, gadd_b, gadd_in2, gadd_c):
        return vimagemodule.VImage_gadd(self, gadd_a, gadd_b, gadd_in2, gadd_c)

    def icc_export(self, icc_export_output_profile, icc_export_intent):
        return vimagemodule.VImage_icc_export(self, icc_export_output_profile, icc_export_intent)

    def litecor(self, litecor_white, litecor_clip, litecor_factor):
        return vimagemodule.VImage_litecor(self, litecor_white, litecor_clip, litecor_factor)

    def affine(self, affine_a, affine_b, affine_c, affine_d, affine_dx, affine_dy, affine_x, affine_y, affine_w, affine_h):
        return vimagemodule.VImage_affine(self, affine_a, affine_b, affine_c, affine_d, affine_dx, affine_dy, affine_x, affine_y, affine_w, affine_h)

    def clip2c(self):
        return vimagemodule.VImage_clip2c(self)

    def clip2cm(self):
        return vimagemodule.VImage_clip2cm(self)

    def clip2d(self):
        return vimagemodule.VImage_clip2d(self)

    def clip2dcm(self):
        return vimagemodule.VImage_clip2dcm(self)

    def clip2f(self):
        return vimagemodule.VImage_clip2f(self)

    def clip2i(self):
        return vimagemodule.VImage_clip2i(self)

    def convsub(self, convsub_matrix, convsub_xskip, convsub_yskip):
        return vimagemodule.VImage_convsub(self, convsub_matrix, convsub_xskip, convsub_yskip)

    def convf(self, convf_matrix):
        return vimagemodule.VImage_convf(self, convf_matrix)

    def convsepf(self, convsepf_matrix):
        return vimagemodule.VImage_convsepf(self, convsepf_matrix)

    def clip2s(self):
        return vimagemodule.VImage_clip2s(self)

    def clip2ui(self):
        return vimagemodule.VImage_clip2ui(self)

    def clip2us(self):
        return vimagemodule.VImage_clip2us(self)

    def slice(self, slice_thresh1, slice_thresh2):
        return vimagemodule.VImage_slice(self, slice_thresh1, slice_thresh2)

    def segment(self):
        return vimagemodule.VImage_segment(self)

    def thresh(self, thresh_threshold):
        return vimagemodule.VImage_thresh(self, thresh_threshold)

    def convf_raw(self, convf_raw_matrix):
        return vimagemodule.VImage_convf_raw(self, convf_raw_matrix)

    def conv_raw(self, conv_raw_matrix):
        return vimagemodule.VImage_conv_raw(self, conv_raw_matrix)

    def contrast_surface_raw(self, contrast_surface_raw_half_win_size, contrast_surface_raw_spacing):
        return vimagemodule.VImage_contrast_surface_raw(self, contrast_surface_raw_half_win_size, contrast_surface_raw_spacing)

    def convsepf_raw(self, convsepf_raw_matrix):
        return vimagemodule.VImage_convsepf_raw(self, convsepf_raw_matrix)

    def convsep_raw(self, convsep_raw_matrix):
        return vimagemodule.VImage_convsep_raw(self, convsep_raw_matrix)

    def fastcor_raw(self, fastcor_raw_in2):
        return vimagemodule.VImage_fastcor_raw(self, fastcor_raw_in2)

    def gradcor_raw(self, gradcor_raw_in2):
        return vimagemodule.VImage_gradcor_raw(self, gradcor_raw_in2)

    def spcor_raw(self, spcor_raw_in2):
        return vimagemodule.VImage_spcor_raw(self, spcor_raw_in2)

    def lhisteq_raw(self, lhisteq_raw_width, lhisteq_raw_height):
        return vimagemodule.VImage_lhisteq_raw(self, lhisteq_raw_width, lhisteq_raw_height)

    def stdif_raw(self, stdif_raw_a, stdif_raw_m0, stdif_raw_b, stdif_raw_s0, stdif_raw_xw, stdif_raw_yw):
        return vimagemodule.VImage_stdif_raw(self, stdif_raw_a, stdif_raw_m0, stdif_raw_b, stdif_raw_s0, stdif_raw_xw, stdif_raw_yw)

    def rank_raw(self, rank_raw_xsize, rank_raw_ysize, rank_raw_n):
        return vimagemodule.VImage_rank_raw(self, rank_raw_xsize, rank_raw_ysize, rank_raw_n)

    def dilate_raw(self, dilate_raw_mask):
        return vimagemodule.VImage_dilate_raw(self, dilate_raw_mask)

    def erode_raw(self, erode_raw_mask):
        return vimagemodule.VImage_erode_raw(self, erode_raw_mask)

    def similarity_area(self, similarity_area_a, similarity_area_b, similarity_area_dx, similarity_area_dy, similarity_area_x, similarity_area_y, similarity_area_w, similarity_area_h):
        return vimagemodule.VImage_similarity_area(self, similarity_area_a, similarity_area_b, similarity_area_dx, similarity_area_dy, similarity_area_x, similarity_area_y, similarity_area_w, similarity_area_h)

    def similarity(self, similarity_a, similarity_b, similarity_dx, similarity_dy):
        return vimagemodule.VImage_similarity(self, similarity_a, similarity_b, similarity_dx, similarity_dy)
    __swig_getmethods__["mask2vips"] = lambda x: vimagemodule.VImage_mask2vips
    if _newclass:
        mask2vips = staticmethod(vimagemodule.VImage_mask2vips)

    def vips2mask(self):
        return vimagemodule.VImage_vips2mask(self)

    def insertplace(self, *args):
        return vimagemodule.VImage_insertplace(self, *args)

    def circle(self, circle_cx, circle_cy, circle_radius, circle_intensity):
        return vimagemodule.VImage_circle(self, circle_cx, circle_cy, circle_radius, circle_intensity)

    def andimage(self, *args):
        return vimagemodule.VImage_andimage(self, *args)

    def orimage(self, *args):
        return vimagemodule.VImage_orimage(self, *args)

    def eorimage(self, *args):
        return vimagemodule.VImage_eorimage(self, *args)

    def shiftleft(self, *args):
        return vimagemodule.VImage_shiftleft(self, *args)

    def shiftright(self, *args):
        return vimagemodule.VImage_shiftright(self, *args)

    def blend(self, blend_in1, blend_in2):
        return vimagemodule.VImage_blend(self, blend_in1, blend_in2)

    def equal(self, *args):
        return vimagemodule.VImage_equal(self, *args)

    def ifthenelse(self, ifthenelse_in1, ifthenelse_in2):
        return vimagemodule.VImage_ifthenelse(self, ifthenelse_in1, ifthenelse_in2)

    def less(self, *args):
        return vimagemodule.VImage_less(self, *args)

    def lesseq(self, *args):
        return vimagemodule.VImage_lesseq(self, *args)

    def more(self, *args):
        return vimagemodule.VImage_more(self, *args)

    def moreeq(self, *args):
        return vimagemodule.VImage_moreeq(self, *args)

    def notequal(self, *args):
        return vimagemodule.VImage_notequal(self, *args)

    def quadratic(self, quadratic_coeff):
        return vimagemodule.VImage_quadratic(self, quadratic_coeff)
    __swig_getmethods__["csv2vips"] = lambda x: vimagemodule.VImage_csv2vips
    if _newclass:
        csv2vips = staticmethod(vimagemodule.VImage_csv2vips)
    __swig_getmethods__["fits2vips"] = lambda x: vimagemodule.VImage_fits2vips
    if _newclass:
        fits2vips = staticmethod(vimagemodule.VImage_fits2vips)
    __swig_getmethods__["jpeg2vips"] = lambda x: vimagemodule.VImage_jpeg2vips
    if _newclass:
        jpeg2vips = staticmethod(vimagemodule.VImage_jpeg2vips)
    __swig_getmethods__["magick2vips"] = lambda x: vimagemodule.VImage_magick2vips
    if _newclass:
        magick2vips = staticmethod(vimagemodule.VImage_magick2vips)
    __swig_getmethods__["png2vips"] = lambda x: vimagemodule.VImage_png2vips
    if _newclass:
        png2vips = staticmethod(vimagemodule.VImage_png2vips)
    __swig_getmethods__["exr2vips"] = lambda x: vimagemodule.VImage_exr2vips
    if _newclass:
        exr2vips = staticmethod(vimagemodule.VImage_exr2vips)
    __swig_getmethods__["ppm2vips"] = lambda x: vimagemodule.VImage_ppm2vips
    if _newclass:
        ppm2vips = staticmethod(vimagemodule.VImage_ppm2vips)
    __swig_getmethods__["analyze2vips"] = lambda x: vimagemodule.VImage_analyze2vips
    if _newclass:
        analyze2vips = staticmethod(vimagemodule.VImage_analyze2vips)
    __swig_getmethods__["tiff2vips"] = lambda x: vimagemodule.VImage_tiff2vips
    if _newclass:
        tiff2vips = staticmethod(vimagemodule.VImage_tiff2vips)

    def vips2csv(self, vips2csv_filename):
        return vimagemodule.VImage_vips2csv(self, vips2csv_filename)

    def vips2dz(self, vips2dz_out):
        return vimagemodule.VImage_vips2dz(self, vips2dz_out)

    def vips2jpeg(self, vips2jpeg_out):
        return vimagemodule.VImage_vips2jpeg(self, vips2jpeg_out)

    def vips2mimejpeg(self, vips2mimejpeg_qfac):
        return vimagemodule.VImage_vips2mimejpeg(self, vips2mimejpeg_qfac)

    def vips2png(self, vips2png_out):
        return vimagemodule.VImage_vips2png(self, vips2png_out)

    def vips2ppm(self, vips2ppm_filename):
        return vimagemodule.VImage_vips2ppm(self, vips2ppm_filename)

    def vips2tiff(self, vips2tiff_out):
        return vimagemodule.VImage_vips2tiff(self, vips2tiff_out)
    __swig_getmethods__["create_fmask"] = lambda x: vimagemodule.VImage_create_fmask
    if _newclass:
        create_fmask = staticmethod(vimagemodule.VImage_create_fmask)

    def disp_ps(self):
        return vimagemodule.VImage_disp_ps(self)

    def flt_image_freq(self, flt_image_freq_type, flt_image_freq_p1, flt_image_freq_p2, flt_image_freq_p3, flt_image_freq_p4, flt_image_freq_p5):
        return vimagemodule.VImage_flt_image_freq(self, flt_image_freq_type, flt_image_freq_p1, flt_image_freq_p2, flt_image_freq_p3, flt_image_freq_p4, flt_image_freq_p5)
    __swig_getmethods__["fractsurf"] = lambda x: vimagemodule.VImage_fractsurf
    if _newclass:
        fractsurf = staticmethod(vimagemodule.VImage_fractsurf)

    def freqflt(self, freqflt_mask):
        return vimagemodule.VImage_freqflt(self, freqflt_mask)

    def fwfft(self):
        return vimagemodule.VImage_fwfft(self)

    def rotquad(self):
        return vimagemodule.VImage_rotquad(self)

    def invfft(self):
        return vimagemodule.VImage_invfft(self)

    def phasecor_fft(self, phasecor_fft_in2):
        return vimagemodule.VImage_phasecor_fft(self, phasecor_fft_in2)

    def invfftr(self):
        return vimagemodule.VImage_invfftr(self)

    def gammacorrect(self, gammacorrect_exponent):
        return vimagemodule.VImage_gammacorrect(self, gammacorrect_exponent)

    def heq(self, heq_band_number):
        return vimagemodule.VImage_heq(self, heq_band_number)

    def hist(self, hist_band_number):
        return vimagemodule.VImage_hist(self, hist_band_number)

    def histcum(self):
        return vimagemodule.VImage_histcum(self)

    def histeq(self):
        return vimagemodule.VImage_histeq(self)

    def hist_indexed(self, hist_indexed_value):
        return vimagemodule.VImage_hist_indexed(self, hist_indexed_value)

    def histgr(self, histgr_band_number):
        return vimagemodule.VImage_histgr(self, histgr_band_number)

    def histnD(self, histnD_bins):
        return vimagemodule.VImage_histnD(self, histnD_bins)

    def histnorm(self):
        return vimagemodule.VImage_histnorm(self)

    def histplot(self):
        return vimagemodule.VImage_histplot(self)

    def histspec(self, histspec_ref):
        return vimagemodule.VImage_histspec(self, histspec_ref)

    def hsp(self, hsp_ref):
        return vimagemodule.VImage_hsp(self, hsp_ref)
    __swig_getmethods__["identity"] = lambda x: vimagemodule.VImage_identity
    if _newclass:
        identity = staticmethod(vimagemodule.VImage_identity)
    __swig_getmethods__["identity_ushort"] = lambda x: vimagemodule.VImage_identity_ushort
    if _newclass:
        identity_ushort = staticmethod(vimagemodule.VImage_identity_ushort)

    def ismonotonic(self):
        return vimagemodule.VImage_ismonotonic(self)

    def lhisteq(self, lhisteq_width, lhisteq_height):
        return vimagemodule.VImage_lhisteq(self, lhisteq_width, lhisteq_height)

    def mpercent(self, mpercent_percent):
        return vimagemodule.VImage_mpercent(self, mpercent_percent)
    __swig_getmethods__["invertlut"] = lambda x: vimagemodule.VImage_invertlut
    if _newclass:
        invertlut = staticmethod(vimagemodule.VImage_invertlut)
    __swig_getmethods__["buildlut"] = lambda x: vimagemodule.VImage_buildlut
    if _newclass:
        buildlut = staticmethod(vimagemodule.VImage_buildlut)

    def maplut(self, maplut_lut):
        return vimagemodule.VImage_maplut(self, maplut_lut)

    def project(self, project_vout):
        return vimagemodule.VImage_project(self, project_vout)

    def stdif(self, stdif_a, stdif_m0, stdif_b, stdif_s0, stdif_xw, stdif_yw):
        return vimagemodule.VImage_stdif(self, stdif_a, stdif_m0, stdif_b, stdif_s0, stdif_xw, stdif_yw)

    def tone_analyse(self, tone_analyse_Ps, tone_analyse_Pm, tone_analyse_Ph, tone_analyse_S, tone_analyse_M, tone_analyse_H):
        return vimagemodule.VImage_tone_analyse(self, tone_analyse_Ps, tone_analyse_Pm, tone_analyse_Ph, tone_analyse_S, tone_analyse_M, tone_analyse_H)
    __swig_getmethods__["tone_build"] = lambda x: vimagemodule.VImage_tone_build
    if _newclass:
        tone_build = staticmethod(vimagemodule.VImage_tone_build)
    __swig_getmethods__["tone_build_range"] = lambda x: vimagemodule.VImage_tone_build_range
    if _newclass:
        tone_build_range = staticmethod(vimagemodule.VImage_tone_build_range)

    def tone_map(self, tone_map_lut):
        return vimagemodule.VImage_tone_map(self, tone_map_lut)

    def draw_circle(self, draw_circle_cx, draw_circle_cy, draw_circle_radius, draw_circle_fill, draw_circle_ink):
        return vimagemodule.VImage_draw_circle(self, draw_circle_cx, draw_circle_cy, draw_circle_radius, draw_circle_fill, draw_circle_ink)

    def draw_rect(self, draw_rect_left, draw_rect_top, draw_rect_width, draw_rect_height, draw_rect_fill, draw_rect_ink):
        return vimagemodule.VImage_draw_rect(self, draw_rect_left, draw_rect_top, draw_rect_width, draw_rect_height, draw_rect_fill, draw_rect_ink)

    def draw_line(self, draw_line_x1, draw_line_y1, draw_line_x2, draw_line_y2, draw_line_ink):
        return vimagemodule.VImage_draw_line(self, draw_line_x1, draw_line_y1, draw_line_x2, draw_line_y2, draw_line_ink)

    def draw_point(self, draw_point_x, draw_point_y, draw_point_ink):
        return vimagemodule.VImage_draw_point(self, draw_point_x, draw_point_y, draw_point_ink)

    def draw_smudge(self, draw_smudge_left, draw_smudge_top, draw_smudge_width, draw_smudge_height):
        return vimagemodule.VImage_draw_smudge(self, draw_smudge_left, draw_smudge_top, draw_smudge_width, draw_smudge_height)

    def draw_flood(self, draw_flood_x, draw_flood_y, draw_flood_ink):
        return vimagemodule.VImage_draw_flood(self, draw_flood_x, draw_flood_y, draw_flood_ink)

    def draw_flood_blob(self, draw_flood_blob_x, draw_flood_blob_y, draw_flood_blob_ink):
        return vimagemodule.VImage_draw_flood_blob(self, draw_flood_blob_x, draw_flood_blob_y, draw_flood_blob_ink)

    def draw_flood_other(self, draw_flood_other_test, draw_flood_other_x, draw_flood_other_y, draw_flood_other_serial):
        return vimagemodule.VImage_draw_flood_other(self, draw_flood_other_test, draw_flood_other_x, draw_flood_other_y, draw_flood_other_serial)

    def draw_image(self, draw_image_sub, draw_image_x, draw_image_y):
        return vimagemodule.VImage_draw_image(self, draw_image_sub, draw_image_x, draw_image_y)

    def draw_mask(self, draw_mask_mask, draw_mask_x, draw_mask_y, draw_mask_ink):
        return vimagemodule.VImage_draw_mask(self, draw_mask_mask, draw_mask_x, draw_mask_y, draw_mask_ink)

    def line(self, *args):
        return vimagemodule.VImage_line(self, *args)
    __swig_getmethods__["binfile"] = lambda x: vimagemodule.VImage_binfile
    if _newclass:
        binfile = staticmethod(vimagemodule.VImage_binfile)

    def cache(self, cache_tile_width, cache_tile_height, cache_max_tiles):
        return vimagemodule.VImage_cache(self, cache_tile_width, cache_tile_height, cache_max_tiles)

    def getext(self):
        return vimagemodule.VImage_getext(self)

    def header_get_typeof(self, header_get_typeof_field):
        return vimagemodule.VImage_header_get_typeof(self, header_get_typeof_field)

    def header_int(self, header_int_field):
        return vimagemodule.VImage_header_int(self, header_int_field)

    def header_double(self, header_double_field):
        return vimagemodule.VImage_header_double(self, header_double_field)

    def header_string(self, header_string_field):
        return vimagemodule.VImage_header_string(self, header_string_field)

    def history_get(self):
        return vimagemodule.VImage_history_get(self)

    def printdesc(self):
        return vimagemodule.VImage_printdesc(self)

    def cntlines(self, cntlines_direction):
        return vimagemodule.VImage_cntlines(self, cntlines_direction)

    def dilate(self, dilate_mask):
        return vimagemodule.VImage_dilate(self, dilate_mask)

    def rank(self, rank_xsize, rank_ysize, rank_n):
        return vimagemodule.VImage_rank(self, rank_xsize, rank_ysize, rank_n)
    __swig_getmethods__["rank_image"] = lambda x: vimagemodule.VImage_rank_image
    if _newclass:
        rank_image = staticmethod(vimagemodule.VImage_rank_image)
    __swig_getmethods__["maxvalue"] = lambda x: vimagemodule.VImage_maxvalue
    if _newclass:
        maxvalue = staticmethod(vimagemodule.VImage_maxvalue)

    def label_regions(self):
        return vimagemodule.VImage_label_regions(self)

    def zerox(self, zerox_flag):
        return vimagemodule.VImage_zerox(self, zerox_flag)

    def erode(self, erode_mask):
        return vimagemodule.VImage_erode(self, erode_mask)

    def profile(self, profile_direction):
        return vimagemodule.VImage_profile(self, profile_direction)

    def align_bands(self):
        return vimagemodule.VImage_align_bands(self)

    def correl(self, correl_sec, correl_xref, correl_yref, correl_xsec, correl_ysec, correl_hwindowsize, correl_hsearchsize):
        return vimagemodule.VImage_correl(self, correl_sec, correl_xref, correl_yref, correl_xsec, correl_ysec, correl_hwindowsize, correl_hsearchsize)

    def _find_lroverlap(self, _find_lroverlap_sec, _find_lroverlap_bandno, _find_lroverlap_xr, _find_lroverlap_yr, _find_lroverlap_xs, _find_lroverlap_ys, _find_lroverlap_halfcorrelation, _find_lroverlap_halfarea):
        return vimagemodule.VImage__find_lroverlap(self, _find_lroverlap_sec, _find_lroverlap_bandno, _find_lroverlap_xr, _find_lroverlap_yr, _find_lroverlap_xs, _find_lroverlap_ys, _find_lroverlap_halfcorrelation, _find_lroverlap_halfarea)

    def _find_tboverlap(self, _find_tboverlap_sec, _find_tboverlap_bandno, _find_tboverlap_xr, _find_tboverlap_yr, _find_tboverlap_xs, _find_tboverlap_ys, _find_tboverlap_halfcorrelation, _find_tboverlap_halfarea):
        return vimagemodule.VImage__find_tboverlap(self, _find_tboverlap_sec, _find_tboverlap_bandno, _find_tboverlap_xr, _find_tboverlap_yr, _find_tboverlap_xs, _find_tboverlap_ys, _find_tboverlap_halfcorrelation, _find_tboverlap_halfarea)

    def global_balance(self, global_balance_gamma):
        return vimagemodule.VImage_global_balance(self, global_balance_gamma)

    def global_balancef(self, global_balancef_gamma):
        return vimagemodule.VImage_global_balancef(self, global_balancef_gamma)

    def lrmerge(self, lrmerge_sec, lrmerge_dx, lrmerge_dy, lrmerge_mwidth):
        return vimagemodule.VImage_lrmerge(self, lrmerge_sec, lrmerge_dx, lrmerge_dy, lrmerge_mwidth)

    def lrmerge1(self, lrmerge1_sec, lrmerge1_xr1, lrmerge1_yr1, lrmerge1_xs1, lrmerge1_ys1, lrmerge1_xr2, lrmerge1_yr2, lrmerge1_xs2, lrmerge1_ys2, lrmerge1_mwidth):
        return vimagemodule.VImage_lrmerge1(self, lrmerge1_sec, lrmerge1_xr1, lrmerge1_yr1, lrmerge1_xs1, lrmerge1_ys1, lrmerge1_xr2, lrmerge1_yr2, lrmerge1_xs2, lrmerge1_ys2, lrmerge1_mwidth)

    def lrmosaic(self, lrmosaic_sec, lrmosaic_bandno, lrmosaic_xr, lrmosaic_yr, lrmosaic_xs, lrmosaic_ys, lrmosaic_halfcorrelation, lrmosaic_halfarea, lrmosaic_balancetype, lrmosaic_mwidth):
        return vimagemodule.VImage_lrmosaic(self, lrmosaic_sec, lrmosaic_bandno, lrmosaic_xr, lrmosaic_yr, lrmosaic_xs, lrmosaic_ys, lrmosaic_halfcorrelation, lrmosaic_halfarea, lrmosaic_balancetype, lrmosaic_mwidth)

    def lrmosaic1(self, lrmosaic1_sec, lrmosaic1_bandno, lrmosaic1_xr1, lrmosaic1_yr1, lrmosaic1_xs1, lrmosaic1_ys1, lrmosaic1_xr2, lrmosaic1_yr2, lrmosaic1_xs2, lrmosaic1_ys2, lrmosaic1_halfcorrelation, lrmosaic1_halfarea, lrmosaic1_balancetype, lrmosaic1_mwidth):
        return vimagemodule.VImage_lrmosaic1(self, lrmosaic1_sec, lrmosaic1_bandno, lrmosaic1_xr1, lrmosaic1_yr1, lrmosaic1_xs1, lrmosaic1_ys1, lrmosaic1_xr2, lrmosaic1_yr2, lrmosaic1_xs2, lrmosaic1_ys2, lrmosaic1_halfcorrelation, lrmosaic1_halfarea, lrmosaic1_balancetype, lrmosaic1_mwidth)

    def match_linear(self, match_linear_sec, match_linear_xref1, match_linear_yref1, match_linear_xsec1, match_linear_ysec1, match_linear_xref2, match_linear_yref2, match_linear_xsec2, match_linear_ysec2):
        return vimagemodule.VImage_match_linear(self, match_linear_sec, match_linear_xref1, match_linear_yref1, match_linear_xsec1, match_linear_ysec1, match_linear_xref2, match_linear_yref2, match_linear_xsec2, match_linear_ysec2)

    def match_linear_search(self, match_linear_search_sec, match_linear_search_xref1, match_linear_search_yref1, match_linear_search_xsec1, match_linear_search_ysec1, match_linear_search_xref2, match_linear_search_yref2, match_linear_search_xsec2, match_linear_search_ysec2, match_linear_search_hwindowsize, match_linear_search_hsearchsize):
        return vimagemodule.VImage_match_linear_search(self, match_linear_search_sec, match_linear_search_xref1, match_linear_search_yref1, match_linear_search_xsec1, match_linear_search_ysec1, match_linear_search_xref2, match_linear_search_yref2, match_linear_search_xsec2, match_linear_search_ysec2, match_linear_search_hwindowsize, match_linear_search_hsearchsize)

    def maxpos_subpel(self):
        return vimagemodule.VImage_maxpos_subpel(self)

    def remosaic(self, remosaic_old_str, remosaic_new_str):
        return vimagemodule.VImage_remosaic(self, remosaic_old_str, remosaic_new_str)

    def tbmerge(self, tbmerge_sec, tbmerge_dx, tbmerge_dy, tbmerge_mwidth):
        return vimagemodule.VImage_tbmerge(self, tbmerge_sec, tbmerge_dx, tbmerge_dy, tbmerge_mwidth)

    def tbmerge1(self, tbmerge1_sec, tbmerge1_xr1, tbmerge1_yr1, tbmerge1_xs1, tbmerge1_ys1, tbmerge1_xr2, tbmerge1_yr2, tbmerge1_xs2, tbmerge1_ys2, tbmerge1_mwidth):
        return vimagemodule.VImage_tbmerge1(self, tbmerge1_sec, tbmerge1_xr1, tbmerge1_yr1, tbmerge1_xs1, tbmerge1_ys1, tbmerge1_xr2, tbmerge1_yr2, tbmerge1_xs2, tbmerge1_ys2, tbmerge1_mwidth)

    def tbmosaic(self, tbmosaic_sec, tbmosaic_bandno, tbmosaic_xr, tbmosaic_yr, tbmosaic_xs, tbmosaic_ys, tbmosaic_halfcorrelation, tbmosaic_halfarea, tbmosaic_balancetype, tbmosaic_mwidth):
        return vimagemodule.VImage_tbmosaic(self, tbmosaic_sec, tbmosaic_bandno, tbmosaic_xr, tbmosaic_yr, tbmosaic_xs, tbmosaic_ys, tbmosaic_halfcorrelation, tbmosaic_halfarea, tbmosaic_balancetype, tbmosaic_mwidth)

    def tbmosaic1(self, tbmosaic1_sec, tbmosaic1_bandno, tbmosaic1_xr1, tbmosaic1_yr1, tbmosaic1_xs1, tbmosaic1_ys1, tbmosaic1_xr2, tbmosaic1_yr2, tbmosaic1_xs2, tbmosaic1_ys2, tbmosaic1_halfcorrelation, tbmosaic1_halfarea, tbmosaic1_balancetype, tbmosaic1_mwidth):
        return vimagemodule.VImage_tbmosaic1(self, tbmosaic1_sec, tbmosaic1_bandno, tbmosaic1_xr1, tbmosaic1_yr1, tbmosaic1_xs1, tbmosaic1_ys1, tbmosaic1_xr2, tbmosaic1_yr2, tbmosaic1_xs2, tbmosaic1_ys2, tbmosaic1_halfcorrelation, tbmosaic1_halfarea, tbmosaic1_balancetype, tbmosaic1_mwidth)

    def benchmark(self):
        return vimagemodule.VImage_benchmark(self)

    def benchmark2(self):
        return vimagemodule.VImage_benchmark2(self)

    def benchmarkn(self, benchmarkn_n):
        return vimagemodule.VImage_benchmarkn(self, benchmarkn_n)
    __swig_getmethods__["eye"] = lambda x: vimagemodule.VImage_eye
    if _newclass:
        eye = staticmethod(vimagemodule.VImage_eye)
    __swig_getmethods__["grey"] = lambda x: vimagemodule.VImage_grey
    if _newclass:
        grey = staticmethod(vimagemodule.VImage_grey)
    __swig_getmethods__["feye"] = lambda x: vimagemodule.VImage_feye
    if _newclass:
        feye = staticmethod(vimagemodule.VImage_feye)
    __swig_getmethods__["fgrey"] = lambda x: vimagemodule.VImage_fgrey
    if _newclass:
        fgrey = staticmethod(vimagemodule.VImage_fgrey)
    __swig_getmethods__["fzone"] = lambda x: vimagemodule.VImage_fzone
    if _newclass:
        fzone = staticmethod(vimagemodule.VImage_fzone)
    __swig_getmethods__["make_xy"] = lambda x: vimagemodule.VImage_make_xy
    if _newclass:
        make_xy = staticmethod(vimagemodule.VImage_make_xy)
    __swig_getmethods__["sines"] = lambda x: vimagemodule.VImage_sines
    if _newclass:
        sines = staticmethod(vimagemodule.VImage_sines)
    __swig_getmethods__["zone"] = lambda x: vimagemodule.VImage_zone
    if _newclass:
        zone = staticmethod(vimagemodule.VImage_zone)

    def rightshift_size(self, rightshift_size_xshift, rightshift_size_yshift, rightshift_size_band_fmt):
        return vimagemodule.VImage_rightshift_size(self, rightshift_size_xshift, rightshift_size_yshift, rightshift_size_band_fmt)

    def shrink(self, shrink_xfac, shrink_yfac):
        return vimagemodule.VImage_shrink(self, shrink_xfac, shrink_yfac)

    def stretch3(self, stretch3_xdisp, stretch3_ydisp):
        return vimagemodule.VImage_stretch3(self, stretch3_xdisp, stretch3_ydisp)

    def affinei(self, affinei_interpolate, affinei_a, affinei_b, affinei_c, affinei_d, affinei_dx, affinei_dy, affinei_x, affinei_y, affinei_w, affinei_h):
        return vimagemodule.VImage_affinei(self, affinei_interpolate, affinei_a, affinei_b, affinei_c, affinei_d, affinei_dx, affinei_dy, affinei_x, affinei_y, affinei_w, affinei_h)

    def affinei_all(self, affinei_all_interpolate, affinei_all_a, affinei_all_b, affinei_all_c, affinei_all_d, affinei_all_dx, affinei_all_dy):
        return vimagemodule.VImage_affinei_all(self, affinei_all_interpolate, affinei_all_a, affinei_all_b, affinei_all_c, affinei_all_d, affinei_all_dx, affinei_all_dy)
    __swig_getmethods__["video_test"] = lambda x: vimagemodule.VImage_video_test
    if _newclass:
        video_test = staticmethod(vimagemodule.VImage_video_test)
    __swig_getmethods__["video_v4l1"] = lambda x: vimagemodule.VImage_video_v4l1
    if _newclass:
        video_v4l1 = staticmethod(vimagemodule.VImage_video_v4l1)

    def tobuffer(self):
        return vimagemodule.VImage_tobuffer(self)
    __swig_getmethods__["frombuffer"] = lambda x: vimagemodule.VImage_frombuffer
    if _newclass:
        frombuffer = staticmethod(vimagemodule.VImage_frombuffer)

    def tostring(self):
        return vimagemodule.VImage_tostring(self)
    __swig_getmethods__["fromstring"] = lambda x: vimagemodule.VImage_fromstring
    if _newclass:
        fromstring = staticmethod(vimagemodule.VImage_fromstring)
VImage_swigregister = vimagemodule.VImage_swigregister
VImage_swigregister(VImage)

def VImage_print_all():
    return vimagemodule.VImage_print_all()
VImage_print_all = vimagemodule.VImage_print_all

def VImage_convert2disc(convert, arg3, disc):
    return vimagemodule.VImage_convert2disc(convert, arg3, disc)
VImage_convert2disc = vimagemodule.VImage_convert2disc

def VImage_linreg(linreg_ins, linreg_xs):
    return vimagemodule.VImage_linreg(linreg_ins, linreg_xs)
VImage_linreg = vimagemodule.VImage_linreg

def VImage_gaussnoise(gaussnoise_xsize, gaussnoise_ysize, gaussnoise_mean, gaussnoise_sigma):
    return vimagemodule.VImage_gaussnoise(gaussnoise_xsize, gaussnoise_ysize, gaussnoise_mean, gaussnoise_sigma)
VImage_gaussnoise = vimagemodule.VImage_gaussnoise

def VImage_black(black_x_size, black_y_size, black_bands):
    return vimagemodule.VImage_black(black_x_size, black_y_size, black_bands)
VImage_black = vimagemodule.VImage_black

def VImage_gbandjoin(gbandjoin_in):
    return vimagemodule.VImage_gbandjoin(gbandjoin_in)
VImage_gbandjoin = vimagemodule.VImage_gbandjoin

def VImage_text(text_text, text_font, text_width, text_alignment, text_dpi):
    return vimagemodule.VImage_text(text_text, text_font, text_width, text_alignment, text_dpi)
VImage_text = vimagemodule.VImage_text

def VImage_mask2vips(mask2vips_input):
    return vimagemodule.VImage_mask2vips(mask2vips_input)
VImage_mask2vips = vimagemodule.VImage_mask2vips

def VImage_csv2vips(csv2vips_filename):
    return vimagemodule.VImage_csv2vips(csv2vips_filename)
VImage_csv2vips = vimagemodule.VImage_csv2vips

def VImage_fits2vips(fits2vips_in):
    return vimagemodule.VImage_fits2vips(fits2vips_in)
VImage_fits2vips = vimagemodule.VImage_fits2vips

def VImage_jpeg2vips(jpeg2vips_in):
    return vimagemodule.VImage_jpeg2vips(jpeg2vips_in)
VImage_jpeg2vips = vimagemodule.VImage_jpeg2vips

def VImage_magick2vips(magick2vips_in):
    return vimagemodule.VImage_magick2vips(magick2vips_in)
VImage_magick2vips = vimagemodule.VImage_magick2vips

def VImage_png2vips(png2vips_in):
    return vimagemodule.VImage_png2vips(png2vips_in)
VImage_png2vips = vimagemodule.VImage_png2vips

def VImage_exr2vips(exr2vips_in):
    return vimagemodule.VImage_exr2vips(exr2vips_in)
VImage_exr2vips = vimagemodule.VImage_exr2vips

def VImage_ppm2vips(ppm2vips_filename):
    return vimagemodule.VImage_ppm2vips(ppm2vips_filename)
VImage_ppm2vips = vimagemodule.VImage_ppm2vips

def VImage_analyze2vips(analyze2vips_filename):
    return vimagemodule.VImage_analyze2vips(analyze2vips_filename)
VImage_analyze2vips = vimagemodule.VImage_analyze2vips

def VImage_tiff2vips(tiff2vips_in):
    return vimagemodule.VImage_tiff2vips(tiff2vips_in)
VImage_tiff2vips = vimagemodule.VImage_tiff2vips

def VImage_create_fmask(create_fmask_width, create_fmask_height, create_fmask_type, create_fmask_p1, create_fmask_p2, create_fmask_p3, create_fmask_p4, create_fmask_p5):
    return vimagemodule.VImage_create_fmask(create_fmask_width, create_fmask_height, create_fmask_type, create_fmask_p1, create_fmask_p2, create_fmask_p3, create_fmask_p4, create_fmask_p5)
VImage_create_fmask = vimagemodule.VImage_create_fmask

def VImage_fractsurf(fractsurf_size, fractsurf_dimension):
    return vimagemodule.VImage_fractsurf(fractsurf_size, fractsurf_dimension)
VImage_fractsurf = vimagemodule.VImage_fractsurf

def VImage_identity(identity_nbands):
    return vimagemodule.VImage_identity(identity_nbands)
VImage_identity = vimagemodule.VImage_identity

def VImage_identity_ushort(identity_ushort_nbands, identity_ushort_size):
    return vimagemodule.VImage_identity_ushort(identity_ushort_nbands, identity_ushort_size)
VImage_identity_ushort = vimagemodule.VImage_identity_ushort

def VImage_invertlut(invertlut_measures, invertlut_lut_size):
    return vimagemodule.VImage_invertlut(invertlut_measures, invertlut_lut_size)
VImage_invertlut = vimagemodule.VImage_invertlut

def VImage_buildlut(buildlut_xyes):
    return vimagemodule.VImage_buildlut(buildlut_xyes)
VImage_buildlut = vimagemodule.VImage_buildlut

def VImage_tone_build(tone_build_Lb, tone_build_Lw, tone_build_Ps, tone_build_Pm, tone_build_Ph, tone_build_S, tone_build_M, tone_build_H):
    return vimagemodule.VImage_tone_build(tone_build_Lb, tone_build_Lw, tone_build_Ps, tone_build_Pm, tone_build_Ph, tone_build_S, tone_build_M, tone_build_H)
VImage_tone_build = vimagemodule.VImage_tone_build

def VImage_tone_build_range(tone_build_range_in_max, tone_build_range_out_max, tone_build_range_Lb, tone_build_range_Lw, tone_build_range_Ps, tone_build_range_Pm, tone_build_range_Ph, tone_build_range_S, tone_build_range_M, tone_build_range_H):
    return vimagemodule.VImage_tone_build_range(tone_build_range_in_max, tone_build_range_out_max, tone_build_range_Lb, tone_build_range_Lw, tone_build_range_Ps, tone_build_range_Pm, tone_build_range_Ph, tone_build_range_S, tone_build_range_M, tone_build_range_H)
VImage_tone_build_range = vimagemodule.VImage_tone_build_range

def VImage_binfile(binfile_filename, binfile_width, binfile_height, binfile_bands, binfile_offset):
    return vimagemodule.VImage_binfile(binfile_filename, binfile_width, binfile_height, binfile_bands, binfile_offset)
VImage_binfile = vimagemodule.VImage_binfile

def VImage_rank_image(rank_image_in, rank_image_index):
    return vimagemodule.VImage_rank_image(rank_image_in, rank_image_index)
VImage_rank_image = vimagemodule.VImage_rank_image

def VImage_maxvalue(maxvalue_in):
    return vimagemodule.VImage_maxvalue(maxvalue_in)
VImage_maxvalue = vimagemodule.VImage_maxvalue

def VImage_eye(eye_xsize, eye_ysize, eye_factor):
    return vimagemodule.VImage_eye(eye_xsize, eye_ysize, eye_factor)
VImage_eye = vimagemodule.VImage_eye

def VImage_grey(grey_xsize, grey_ysize):
    return vimagemodule.VImage_grey(grey_xsize, grey_ysize)
VImage_grey = vimagemodule.VImage_grey

def VImage_feye(feye_xsize, feye_ysize, feye_factor):
    return vimagemodule.VImage_feye(feye_xsize, feye_ysize, feye_factor)
VImage_feye = vimagemodule.VImage_feye

def VImage_fgrey(fgrey_xsize, fgrey_ysize):
    return vimagemodule.VImage_fgrey(fgrey_xsize, fgrey_ysize)
VImage_fgrey = vimagemodule.VImage_fgrey

def VImage_fzone(fzone_size):
    return vimagemodule.VImage_fzone(fzone_size)
VImage_fzone = vimagemodule.VImage_fzone

def VImage_make_xy(make_xy_xsize, make_xy_ysize):
    return vimagemodule.VImage_make_xy(make_xy_xsize, make_xy_ysize)
VImage_make_xy = vimagemodule.VImage_make_xy

def VImage_sines(sines_xsize, sines_ysize, sines_horfreq, sines_verfreq):
    return vimagemodule.VImage_sines(sines_xsize, sines_ysize, sines_horfreq, sines_verfreq)
VImage_sines = vimagemodule.VImage_sines

def VImage_zone(zone_size):
    return vimagemodule.VImage_zone(zone_size)
VImage_zone = vimagemodule.VImage_zone

def VImage_video_test(video_test_brightness, video_test_error):
    return vimagemodule.VImage_video_test(video_test_brightness, video_test_error)
VImage_video_test = vimagemodule.VImage_video_test

def VImage_video_v4l1(video_v4l1_device, video_v4l1_channel, video_v4l1_brightness, video_v4l1_colour, video_v4l1_contrast, video_v4l1_hue, video_v4l1_ngrabs):
    return vimagemodule.VImage_video_v4l1(video_v4l1_device, video_v4l1_channel, video_v4l1_brightness, video_v4l1_colour, video_v4l1_contrast, video_v4l1_hue, video_v4l1_ngrabs)
VImage_video_v4l1 = vimagemodule.VImage_video_v4l1

def VImage_frombuffer(buffer, width, height, bands, format):
    return vimagemodule.VImage_frombuffer(buffer, width, height, bands, format)
VImage_frombuffer = vimagemodule.VImage_frombuffer

def VImage_fromstring(buffer, width, height, bands, format):
    return vimagemodule.VImage_fromstring(buffer, width, height, bands, format)
VImage_fromstring = vimagemodule.VImage_fromstring


def im_init_world(argv0):
    return vimagemodule.im_init_world(argv0)
im_init_world = vimagemodule.im_init_world

def vips_thread_shutdown():
    return vimagemodule.vips_thread_shutdown()
vips_thread_shutdown = vimagemodule.vips_thread_shutdown

def im__print_all():
    return vimagemodule.im__print_all()
im__print_all = vimagemodule.im__print_all

def im_col_Lab2XYZ(arg1, arg2, arg3, arg4, arg5, arg6):
    return vimagemodule.im_col_Lab2XYZ(arg1, arg2, arg3, arg4, arg5, arg6)
im_col_Lab2XYZ = vimagemodule.im_col_Lab2XYZ

# try to guess a PIL mode string from a VIPS image
def PIL_mode_from_vips (vim):
  if vim.Bands () == 3 and vim.BandFmt () == VImage.FMTUCHAR:
    return 'RGB'
  elif vim.Bands () == 4 and vim.BandFmt () == VImage.FMTUCHAR and vim.Type () == VImage.RGB:
    return 'RGBA'
  elif vim.Bands () == 4 and vim.BandFmt () == VImage.FMTUCHAR and vim.Type () == VImage.CMYK:
    return 'CMYK'
  elif vim.Bands () == 1 and vim.BandFmt () == VImage.FMTUCHAR:
    return 'L'
  elif vim.Bands () == 1 and vim.BandFmt () == VImage.FMTINT:
    return 'I'
  elif vim.Bands () == 1 and vim.BandFmt () == VImage.FMTFLOAT:
    return 'F'
  elif vim.Bands () == 2 and vim.BandFmt () == VImage.FMTUCHAR:
    return 'LA'
  else:
    raise ValueError ('unsupported vips -> pil image')

# return vips (bands, format, type) for a PIL mode
def vips_from_PIL_mode (mode):
  if mode == 'RGB':
    return (3, VImage.FMTUCHAR, VImage.RGB)
  elif mode == 'RGBA':
    return (4, VImage.FMTUCHAR, VImage.RGB)
  elif mode == 'CMYK':
    return (4, VImage.FMTUCHAR, VImage.CMYK)
  elif mode == 'L':
    return (1, VImage.FMTUCHAR, VImage.B_W)
  elif mode == 'I':
    return (1, VImage.FMTINT, VImage.B_W)
  elif mode == 'F':
    return (1, VImage.FMTFLOAT, VImage.B_W)
  elif mode == 'LA':
    return (2, VImage.FMTUCHAR, VImage.B_W)
  else:
    raise ValueError ('unsupported pil -> vips image')

# This file is compatible with both classic and new-style classes.