VImage8.h

// 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., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301  USA
 
 */
 
/*
 
    These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk
 
 */
 
#ifndef VIPS_VIMAGE_H
#define VIPS_VIMAGE_H
 
#include <list>
#include <complex>
#include <vector>
 
#include <cstring>
 
#include <vips/vips.h>
 
VIPS_NAMESPACE_START
 
/* Small utility things.
 */
 
VIPS_CPLUSPLUS_API std::vector<double> to_vectorv(int n, ...);
VIPS_CPLUSPLUS_API std::vector<double> to_vector(double value);
VIPS_CPLUSPLUS_API std::vector<double> to_vector(int n, double array[]);
VIPS_CPLUSPLUS_API std::vector<double> negate(std::vector<double> value);
VIPS_CPLUSPLUS_API std::vector<double> invert(std::vector<double> value);
 
enum VSteal {
    NOSTEAL = 0,
    STEAL = 1
};
 
class VObject {
private:
    // can be NULL, see eg. VObject()
    VipsObject *vobject;
 
public:
    explicit 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));
 
#ifdef VIPS_DEBUG_VERBOSE
        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");
        }
#endif /*VIPS_DEBUG_VERBOSE*/
 
        if (!steal && vobject) {
#ifdef VIPS_DEBUG_VERBOSE
            printf("   reffing object\n");
#endif /*VIPS_DEBUG_VERBOSE*/
            g_object_ref(vobject);
        }
    }
 
    VObject() : vobject(nullptr)
    {
    }
 
    VObject(const VObject &a) : vobject(a.vobject)
    {
        g_assert(!vobject ||
            VIPS_IS_OBJECT(vobject));
 
#ifdef VIPS_DEBUG_VERBOSE
        printf("VObject copy constructor, obj = %p\n",
            vobject);
        printf("   reffing object\n");
#endif /*VIPS_DEBUG_VERBOSE*/
        if (vobject)
            g_object_ref(vobject);
    }
 
    // assignment ... we must delete the old ref
    VObject &
    operator=(const VObject &a)
    {
#ifdef VIPS_DEBUG_VERBOSE
        printf("VObject assignment\n");
        printf("   reffing %p\n", a.vobject);
        printf("   unreffing %p\n", vobject);
#endif /*VIPS_DEBUG_VERBOSE*/
 
        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
        if (a.vobject)
            g_object_ref(a.vobject);
        if (vobject)
            g_object_unref(vobject);
        vobject = a.vobject;
 
        return *this;
    }
 
    // this mustn't be virtual: we want this class to only be a pointer,
    // no vtable allowed
    ~VObject()
    {
#ifdef VIPS_DEBUG_VERBOSE
        printf("VObject destructor\n");
        printf("   unreffing %p\n", vobject);
#endif /*VIPS_DEBUG_VERBOSE*/
 
        g_assert(!vobject ||
            VIPS_IS_OBJECT(vobject));
 
        if (vobject)
            g_object_unref(vobject);
    }
 
    VipsObject *
    get_object() const
    {
        g_assert(!vobject ||
            VIPS_IS_OBJECT(vobject));
 
        return vobject;
    }
 
    bool
    is_null() const
    {
        return vobject == nullptr;
    }
};
 
class VIPS_CPLUSPLUS_API VImage;
class VIPS_CPLUSPLUS_API VInterpolate;
class VIPS_CPLUSPLUS_API VRegion;
class VIPS_CPLUSPLUS_API VSource;
class VIPS_CPLUSPLUS_API VTarget;
class VIPS_CPLUSPLUS_API VOption;
 
class VOption {
private:
    struct Pair {
        const char *name;
 
        // the thing we pass to and from our caller
        GValue value;
 
        // an input or output parameter ... we guess the direction
        // from the arg to set()
        bool input;
 
        // the pointer we write output values to
        union {
            bool *vbool;
            int *vint;
            double *vdouble;
            VImage *vimage;
            std::vector<double> *vvector;
            VipsBlob **vblob;
        };
 
        explicit Pair(const char *name) : name(name), value(G_VALUE_INIT),
                                          input(false), vimage(nullptr)
        {
        }
 
        ~Pair()
        {
            g_value_unset(&value);
        }
    };
 
    std::list<Pair *> options;
 
public:
    VOption() = default;
 
    virtual ~VOption();
 
    VOption *
    set(const char *name, bool value);
 
    VOption *
    set(const char *name, int value);
 
    VOption *
    set(const char *name, guint64 value);
 
    VOption *
    set(const char *name, double value);
 
    VOption *
    set(const char *name, const char *value);
 
    VOption *
    set(const char *name, const VObject value);
 
    VOption *
    set(const char *name, std::vector<int> value);
 
    VOption *
    set(const char *name, std::vector<double> value);
 
    VOption *
    set(const char *name, std::vector<VImage> value);
 
    VOption *
    set(const char *name, VipsBlob *value);
 
    VOption *
    set(const char *name, bool *value);
 
    VOption *
    set(const char *name, int *value);
 
    VOption *
    set(const char *name, double *value);
 
    VOption *
    set(const char *name, VImage *value);
 
    VOption *
    set(const char *name, std::vector<double> *value);
 
    VOption *
    set(const char *name, VipsBlob **blob);
 
    void
    set_operation(VipsOperation *operation);
 
    void
    get_operation(VipsOperation *operation);
};
 
class VImage : public VObject {
public:
    using VObject::is_null;
 
    explicit VImage(VipsImage *image, VSteal steal = STEAL)
        : VObject((VipsObject *) image, steal)
    {
    }
 
    VImage() : VObject(nullptr)
    {
    }
 
    VipsImage *
    get_image() const
    {
        return (VipsImage *) VObject::get_object();
    }
 
    int
    width() const
    {
        return vips_image_get_width(get_image());
    }
 
    int
    height() const
    {
        return vips_image_get_height(get_image());
    }
 
    int
    bands() const
    {
        return vips_image_get_bands(get_image());
    }
 
    VipsBandFormat
    format() const
    {
        return vips_image_get_format(get_image());
    }
 
    VipsCoding
    coding() const
    {
        return vips_image_get_coding(get_image());
    }
 
    VipsInterpretation
    interpretation() const
    {
        return vips_image_get_interpretation(get_image());
    }
 
    VipsInterpretation
    guess_interpretation() const
    {
        return vips_image_guess_interpretation(get_image());
    }
 
    double
    xres() const
    {
        return vips_image_get_xres(get_image());
    }
 
    double
    yres() const
    {
        return vips_image_get_yres(get_image());
    }
 
    int
    xoffset() const
    {
        return vips_image_get_xoffset(get_image());
    }
 
    int
    yoffset() const
    {
        return vips_image_get_yoffset(get_image());
    }
 
    bool
    has_alpha() const
    {
        return vips_image_hasalpha(get_image());
    }
 
    const char *
    filename() const
    {
        return vips_image_get_filename(get_image());
    }
 
    void
    inplace()
    {
        if (vips_image_inplace(this->get_image()))
            throw(VError());
    }
 
    const void *
    data() const
    {
        return vips_image_get_data(get_image());
    }
 
    void
    set(const char *field, int value)
    {
        vips_image_set_int(this->get_image(), field, value);
    }
 
    void
    set(const char *field, int *value, int n)
    {
        vips_image_set_array_int(this->get_image(), field, value, n);
    }
 
    void
    set(const char *field, std::vector<int> value)
    {
        vips_image_set_array_int(this->get_image(), field, &value[0],
            static_cast<int>(value.size()));
    }
 
    void
    set(const char *field, double *value, int n)
    {
        vips_image_set_array_double(this->get_image(), field, value, n);
    }
 
    void
    set(const char *field, std::vector<double> value)
    {
        vips_image_set_array_double(this->get_image(), field, &value[0],
            static_cast<int>(value.size()));
    }
 
    void
    set(const char *field, double value)
    {
        vips_image_set_double(this->get_image(), field, value);
    }
 
    void
    set(const char *field, const char *value)
    {
        vips_image_set_string(this->get_image(), field, value);
    }
 
    void
    set(const char *field,
        VipsCallbackFn free_fn, void *data, size_t length)
    {
        vips_image_set_blob(this->get_image(), field,
            free_fn, data, length);
    }
 
    GType
    get_typeof(const char *field) const
    {
        return vips_image_get_typeof(this->get_image(), field);
    }
 
    int
    get_int(const char *field) const
    {
        int value;
 
        if (vips_image_get_int(this->get_image(), field, &value))
            throw(VError());
 
        return value;
    }
 
    void
    get_array_int(const char *field, int **out, int *n) const
    {
        if (vips_image_get_array_int(this->get_image(),
                field, out, n))
            throw(VError());
    }
 
    std::vector<int>
    get_array_int(const char *field) const
    {
        int length;
        int *array;
 
        if (vips_image_get_array_int(this->get_image(),
                field, &array, &length))
            throw(VError());
 
        std::vector<int> vector(array, array + length);
 
        return vector;
    }
 
    void
    get_array_double(const char *field, double **out, int *n) const
    {
        if (vips_image_get_array_double(this->get_image(),
                field, out, n))
            throw(VError());
    }
 
    std::vector<double>
    get_array_double(const char *field) const
    {
        int length;
        double *array;
 
        if (vips_image_get_array_double(this->get_image(),
                field, &array, &length))
            throw(VError());
 
        std::vector<double> vector(array, array + length);
 
        return vector;
    }
 
    double
    get_double(const char *field) const
    {
        double value;
 
        if (vips_image_get_double(this->get_image(), field, &value))
            throw(VError());
 
        return value;
    }
 
    const char *
    get_string(const char *field) const
    {
        const char *value;
 
        if (vips_image_get_string(this->get_image(), field, &value))
            throw(VError());
 
        return value;
    }
 
    const void *
    get_blob(const char *field, size_t *length) const
    {
        const void *value;
 
        if (vips_image_get_blob(this->get_image(), field,
                &value, length))
            throw(VError());
 
        return value;
    }
 
    bool
    remove(const char *name) const
    {
        return vips_image_remove(get_image(), name);
    }
 
    static VOption *
    option()
    {
        return new VOption();
    }
 
    static void
    call_option_string(const char *operation_name,
        const char *option_string, VOption *options = nullptr);
 
    static void
    call(const char *operation_name, VOption *options = nullptr);
 
    static VImage
    new_memory()
    {
        return VImage(vips_image_new_memory());
    }
 
    static VImage
    new_temp_file(const char *file_format = ".v")
    {
        VipsImage *image;
 
        if (!(image = vips_image_new_temp_file(file_format)))
            throw(VError());
 
        return VImage(image);
    }
 
    static VImage
    new_from_file(const char *name, VOption *options = nullptr);
 
    static VImage
    new_from_buffer(const void *buf, size_t len,
        const char *option_string, VOption *options = nullptr);
 
    static VImage
    new_from_buffer(const std::string &buf,
        const char *option_string, VOption *options = nullptr);
 
    static VImage
    new_from_source(VSource source,
        const char *option_string, VOption *options = nullptr);
 
    static VImage
    new_from_memory(const void *data, size_t size,
        int width, int height, int bands, VipsBandFormat format)
    {
        VipsImage *image;
 
        if (!(image = vips_image_new_from_memory(data, size,
                  width, height, bands, format)))
            throw(VError());
 
        return VImage(image);
    }
 
    static VImage
    new_from_memory_copy(const void *data, size_t size,
        int width, int height, int bands, VipsBandFormat format)
    {
        VipsImage *image;
 
        if (!(image = vips_image_new_from_memory_copy(data, size,
                  width, height, bands, format)))
            throw(VError());
 
        return VImage(image);
    }
 
    static VImage
    new_from_memory_steal(const void *data, size_t size,
        int width, int height, int bands, VipsBandFormat format);
 
    static VImage
    new_matrix(int width, int height);
 
    static VImage
    new_matrix(int width, int height, double *array, int size)
    {
        VipsImage *image;
 
        if (!(image = vips_image_new_matrix_from_array(width, height,
                  array, size)))
            throw(VError());
 
        return VImage(image);
    }
 
    static VImage
    new_matrixv(int width, int height, ...);
 
    VImage
    new_from_image(std::vector<double> pixel) const
    {
        VipsImage *image;
 
        if (!(image = vips_image_new_from_image(this->get_image(),
                  &pixel[0], static_cast<int>(pixel.size()))))
            throw(VError());
 
        return VImage(image);
    }
 
    VImage
    new_from_image(double pixel) const
    {
        return new_from_image(to_vectorv(1, pixel));
    }
 
    VImage
    copy_memory() const
    {
        VipsImage *image;
 
        if (!(image = vips_image_copy_memory(this->get_image())))
            throw(VError());
 
        return VImage(image);
    }
 
    VImage write(VImage out) const;
 
    void write_to_file(const char *name, VOption *options = nullptr) const;
 
    void write_to_buffer(const char *suffix, void **buf, size_t *size,
        VOption *options = nullptr) const;
 
    void write_to_target(const char *suffix, VTarget target,
        VOption *options = nullptr) const;
 
    void *
    write_to_memory(size_t *size) const
    {
        void *result;
 
        if (!(result = vips_image_write_to_memory(this->get_image(),
                  size)))
            throw(VError());
 
        return result;
    }
 
    VRegion
    region() const;
 
    VRegion
    region(VipsRect *rect) const;
 
    VRegion
    region(int left, int top, int width, int height) const;
 
    VImage
    linear(double a, double b, VOption *options = nullptr) const
    {
        return this->linear(to_vector(a), to_vector(b),
            options);
    }
 
    VImage
    linear(std::vector<double> a, double b, VOption *options = nullptr) const
    {
        return this->linear(a, to_vector(b), options);
    }
 
    VImage
    linear(double a, std::vector<double> b, VOption *options = nullptr) const
    {
        return this->linear(to_vector(a), b, options);
    }
 
    std::vector<VImage> bandsplit(VOption *options = nullptr) const;
 
    VImage bandjoin(VImage other, VOption *options = nullptr) const;
 
    VImage
    bandjoin(double other, VOption *options = nullptr) const
    {
        return bandjoin(to_vector(other), options);
    }
 
    VImage
    bandjoin(std::vector<double> other, VOption *options = nullptr) const
    {
        return bandjoin_const(other, options);
    }
 
    VImage composite(VImage other, VipsBlendMode mode,
        VOption *options = nullptr) const;
 
    std::complex<double> minpos(VOption *options = nullptr) const;
 
    std::complex<double> maxpos(VOption *options = nullptr) const;
 
    VImage
    fliphor(VOption *options = nullptr) const
    {
        return flip(VIPS_DIRECTION_HORIZONTAL, options);
    }
 
    VImage
    flipver(VOption *options = nullptr) const
    {
        return flip(VIPS_DIRECTION_VERTICAL, options);
    }
 
    VImage
    rot90(VOption *options = nullptr) const
    {
        return rot(VIPS_ANGLE_D90, options);
    }
 
    VImage
    rot180(VOption *options = nullptr) const
    {
        return rot(VIPS_ANGLE_D180, options);
    }
 
    VImage
    rot270(VOption *options = nullptr) const
    {
        return rot(VIPS_ANGLE_D270, options);
    }
 
    VImage
    dilate(VImage mask, VOption *options = nullptr) const
    {
        return morph(mask, VIPS_OPERATION_MORPHOLOGY_DILATE,
            options);
    }
 
    VImage
    erode(VImage mask, VOption *options = nullptr) const
    {
        return morph(mask, VIPS_OPERATION_MORPHOLOGY_ERODE,
            options);
    }
 
    VImage
    median(int size = 3, VOption *options = nullptr) const
    {
        return rank(size, size, (size * size) / 2, options);
    }
 
    VImage
    floor(VOption *options = nullptr) const
    {
        return round(VIPS_OPERATION_ROUND_FLOOR, options);
    }
 
    VImage
    ceil(VOption *options = nullptr) const
    {
        return round(VIPS_OPERATION_ROUND_CEIL, options);
    }
 
    VImage
    rint(VOption *options = nullptr) const
    {
        return round(VIPS_OPERATION_ROUND_RINT, options);
    }
 
    VImage
    bandand(VOption *options = nullptr) const
    {
        return bandbool(VIPS_OPERATION_BOOLEAN_AND, options);
    }
 
    VImage
    bandor(VOption *options = nullptr) const
    {
        return bandbool(VIPS_OPERATION_BOOLEAN_OR, options);
    }
 
    VImage
    bandeor(VOption *options = nullptr) const
    {
        return bandbool(VIPS_OPERATION_BOOLEAN_EOR, options);
    }
 
    VImage
    real(VOption *options = nullptr) const
    {
        return complexget(VIPS_OPERATION_COMPLEXGET_REAL, options);
    }
 
    VImage
    imag(VOption *options = nullptr) const
    {
        return complexget(VIPS_OPERATION_COMPLEXGET_IMAG, options);
    }
 
    VImage
    polar(VOption *options = nullptr) const
    {
        return complex(VIPS_OPERATION_COMPLEX_POLAR, options);
    }
 
    VImage
    rect(VOption *options = nullptr) const
    {
        return complex(VIPS_OPERATION_COMPLEX_RECT, options);
    }
 
    VImage
    conj(VOption *options = nullptr) const
    {
        return complex(VIPS_OPERATION_COMPLEX_CONJ, options);
    }
 
    VImage
    sin(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_SIN, options);
    }
 
    VImage
    cos(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_COS, options);
    }
 
    VImage
    tan(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_TAN, options);
    }
 
    VImage
    asin(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_ASIN, options);
    }
 
    VImage
    acos(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_ACOS, options);
    }
 
    VImage
    atan(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_ATAN, options);
    }
 
    VImage
    sinh(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_SINH, options);
    }
 
    VImage
    cosh(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_COSH, options);
    }
 
    VImage
    tanh(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_TANH, options);
    }
 
    VImage
    asinh(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_ASINH, options);
    }
 
    VImage
    acosh(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_ACOSH, options);
    }
 
    VImage
    atanh(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_ATANH, options);
    }
 
    VImage
    log(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_LOG, options);
    }
 
    VImage
    log10(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_LOG10, options);
    }
 
    VImage
    exp(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_EXP, options);
    }
 
    VImage
    exp10(VOption *options = nullptr) const
    {
        return math(VIPS_OPERATION_MATH_EXP10, options);
    }
 
    VImage
    pow(VImage other, VOption *options = nullptr) const
    {
        return math2(other, VIPS_OPERATION_MATH2_POW, options);
    }
 
    VImage
    pow(double other, VOption *options = nullptr) const
    {
        return math2_const(VIPS_OPERATION_MATH2_POW,
            to_vector(other), options);
    }
 
    VImage
    pow(std::vector<double> other, VOption *options = nullptr) const
    {
        return math2_const(VIPS_OPERATION_MATH2_POW,
            other, options);
    }
 
    VImage
    wop(VImage other, VOption *options = nullptr) const
    {
        return math2(other, VIPS_OPERATION_MATH2_WOP, options);
    }
 
    VImage
    wop(double other, VOption *options = nullptr) const
    {
        return math2_const(VIPS_OPERATION_MATH2_WOP,
            to_vector(other), options);
    }
 
    VImage
    wop(std::vector<double> other, VOption *options = nullptr) const
    {
        return math2_const(VIPS_OPERATION_MATH2_WOP,
            other, options);
    }
 
    VImage
    atan2(VImage other, VOption *options = nullptr) const
    {
        return math2(other, VIPS_OPERATION_MATH2_ATAN2, options);
    }
 
    VImage
    atan2(double other, VOption *options = nullptr) const
    {
        return math2_const(VIPS_OPERATION_MATH2_ATAN2,
            to_vector(other), options);
    }
 
    VImage
    atan2(std::vector<double> other, VOption *options = nullptr) const
    {
        return math2_const(VIPS_OPERATION_MATH2_ATAN2,
            other, options);
    }
 
    VImage
    ifthenelse(std::vector<double> th, VImage el,
        VOption *options = nullptr) const
    {
        return ifthenelse(el.new_from_image(th), el, options);
    }
 
    VImage
    ifthenelse(VImage th, std::vector<double> el,
        VOption *options = nullptr) const
    {
        return ifthenelse(th, th.new_from_image(el), options);
    }
 
    VImage
    ifthenelse(std::vector<double> th, std::vector<double> el,
        VOption *options = nullptr) const
    {
        return ifthenelse(new_from_image(th), new_from_image(el),
            options);
    }
 
    VImage
    ifthenelse(double th, VImage el, VOption *options = nullptr) const
    {
        return ifthenelse(to_vector(th), el, options);
    }
 
    VImage
    ifthenelse(VImage th, double el, VOption *options = nullptr) const
    {
        return ifthenelse(th, to_vector(el), options);
    }
 
    VImage
    ifthenelse(double th, double el, VOption *options = nullptr) const
    {
        return ifthenelse(to_vector(th), to_vector(el),
            options);
    }
 
    void
    draw_circle(double ink, int cx, int cy, int radius, VOption *options = nullptr) const
    {
        return draw_circle(to_vector(ink), cx, cy, radius, options);
    }
 
    void
    draw_line(double ink, int x1, int y1, int x2, int y2, VOption *options = nullptr) const
    {
        return draw_line(to_vector(ink), x1, y1, x2, y2, options);
    }
 
    void
    draw_rect(double ink, int left, int top, int width, int height, VOption *options = nullptr) const
    {
        return draw_rect(to_vector(ink), left, top, width, height, options);
    }
 
    void
    draw_point(double ink, int x, int y, VOption *options = nullptr) const
    {
        return draw_rect(ink, x, y, 1, 1, options);
    }
 
    void
    draw_point(std::vector<double> ink, int x, int y, VOption *options = nullptr) const
    {
        return draw_rect(ink, x, y, 1, 1, options);
    }
 
    void
    draw_flood(double ink, int x, int y, VOption *options = nullptr) const
    {
        return draw_flood(to_vector(ink), x, y, options);
    }
 
    void
    draw_mask(double ink, VImage mask, int x, int y, VOption *options = nullptr) const
    {
        return draw_mask(to_vector(ink), mask, x, y, options);
    }
 
    static VImage thumbnail_buffer(void *buf, size_t len, int width, VOption *options = nullptr);
 
    // Operator overloads
 
    VImage operator[](int index) const;
 
    std::vector<double> operator()(int x, int y) const;
 
    friend VIPS_CPLUSPLUS_API VImage
    operator+(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator+(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator+(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator+(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator+(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage &
    operator+=(VImage &a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator+=(VImage &a, const double b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator+=(VImage &a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator-(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator-(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator-(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator-(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator-(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage &
    operator-=(VImage &a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator-=(VImage &a, const double b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator-=(VImage &a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator-(const VImage a);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator*(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator*(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator*(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator*(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator*(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage &
    operator*=(VImage &a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator*=(VImage &a, const double b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator*=(VImage &a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator/(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator/(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator/(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator/(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator/(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage &
    operator/=(VImage &a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator/=(VImage &a, const double b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator/=(VImage &a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator%(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator%(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator%(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage &
    operator%=(VImage &a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator%=(VImage &a, const double b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator%=(VImage &a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator<(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator<(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator<(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator<(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator<(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator<=(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator<=(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator<=(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator<=(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator<=(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator>(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator>(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator>(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator>(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator>(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator>=(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator>=(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator>=(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator>=(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator>=(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator==(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator==(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator==(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator==(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator==(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator!=(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator!=(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator!=(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator!=(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator!=(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator&(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator&(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator&(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator&(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator&(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage &
    operator&=(VImage &a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator&=(VImage &a, const double b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator&=(VImage &a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator|(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator|(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator|(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator|(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator|(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage &
    operator|=(VImage &a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator|=(VImage &a, const double b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator|=(VImage &a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator^(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator^(const double a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator^(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator^(const std::vector<double> a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator^(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage &
    operator^=(VImage &a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator^=(VImage &a, const double b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator^=(VImage &a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator<<(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator<<(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator<<(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage &
    operator<<=(VImage &a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator<<=(VImage &a, const double b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator<<=(VImage &a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage
    operator>>(const VImage a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage
    operator>>(const VImage a, const double b);
    friend VIPS_CPLUSPLUS_API VImage
    operator>>(const VImage a, const std::vector<double> b);
 
    friend VIPS_CPLUSPLUS_API VImage &
    operator>>=(VImage &a, const VImage b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator>>=(VImage &a, const double b);
    friend VIPS_CPLUSPLUS_API VImage &
    operator>>=(VImage &a, const std::vector<double> b);
 
    // Compat operations
 
    static VImage
    new_from_memory_steal(void *data, size_t size,
        int width, int height, int bands, VipsBandFormat format);
 
    G_DEPRECATED_FOR(rawsave_target)
    void rawsave_fd(int fd, VOption *options = nullptr) const;
 
    /* Automatically generated members.
     *
     * Rebuild with:
     *
     *  meson compile -Cbuild vips-operators-header
     *
     * Then delete from here to the end of the class and paste in
     * vips-operators.h. We could just #include "vips-operators.h", but
     * that confuses doxygen.
     */
 
    // headers for vips operations
    // this file is generated automatically, do not edit!
    // clang-format off
 
    VImage CMC2LCh(VOption *options = nullptr) const;
 
    VImage CMYK2XYZ(VOption *options = nullptr) const;
 
    VImage HSV2sRGB(VOption *options = nullptr) const;
 
    VImage LCh2CMC(VOption *options = nullptr) const;
 
    VImage LCh2Lab(VOption *options = nullptr) const;
 
    VImage Lab2LCh(VOption *options = nullptr) const;
 
    VImage Lab2LabQ(VOption *options = nullptr) const;
 
    VImage Lab2LabS(VOption *options = nullptr) const;
 
    VImage Lab2XYZ(VOption *options = nullptr) const;
 
    VImage LabQ2Lab(VOption *options = nullptr) const;
 
    VImage LabQ2LabS(VOption *options = nullptr) const;
 
    VImage LabQ2sRGB(VOption *options = nullptr) const;
 
    VImage LabS2Lab(VOption *options = nullptr) const;
 
    VImage LabS2LabQ(VOption *options = nullptr) const;
 
    VImage XYZ2CMYK(VOption *options = nullptr) const;
 
    VImage XYZ2Lab(VOption *options = nullptr) const;
 
    VImage XYZ2Yxy(VOption *options = nullptr) const;
 
    VImage XYZ2scRGB(VOption *options = nullptr) const;
 
    VImage Yxy2XYZ(VOption *options = nullptr) const;
 
    VImage abs(VOption *options = nullptr) const;
 
    VImage add(VImage right, VOption *options = nullptr) const;
 
    VImage addalpha(VOption *options = nullptr) const;
 
    VImage affine(std::vector<double> matrix, VOption *options = nullptr) const;
 
    static VImage analyzeload(const char *filename, VOption *options = nullptr);
 
    static VImage arrayjoin(std::vector<VImage> in, VOption *options = nullptr);
 
    VImage autorot(VOption *options = nullptr) const;
 
    double avg(VOption *options = nullptr) const;
 
    VImage bandbool(VipsOperationBoolean boolean, VOption *options = nullptr) const;
 
    VImage bandfold(VOption *options = nullptr) const;
 
    static VImage bandjoin(std::vector<VImage> in, VOption *options = nullptr);
 
    VImage bandjoin_const(std::vector<double> c, VOption *options = nullptr) const;
 
    VImage bandmean(VOption *options = nullptr) const;
 
    static VImage bandrank(std::vector<VImage> in, VOption *options = nullptr);
 
    VImage bandunfold(VOption *options = nullptr) const;
 
    static VImage black(int width, int height, VOption *options = nullptr);
 
    VImage boolean(VImage right, VipsOperationBoolean boolean, VOption *options = nullptr) const;
 
    VImage boolean_const(VipsOperationBoolean boolean, std::vector<double> c, VOption *options = nullptr) const;
 
    VImage buildlut(VOption *options = nullptr) const;
 
    VImage byteswap(VOption *options = nullptr) const;
 
    G_DEPRECATED
    VImage cache(VOption *options = nullptr) const;
 
    VImage canny(VOption *options = nullptr) const;
 
    VImage case_image(std::vector<VImage> cases, VOption *options = nullptr) const;
 
    VImage cast(VipsBandFormat format, VOption *options = nullptr) const;
 
    VImage clamp(VOption *options = nullptr) const;
 
    VImage colourspace(VipsInterpretation space, VOption *options = nullptr) const;
 
    VImage compass(VImage mask, VOption *options = nullptr) const;
 
    VImage complex(VipsOperationComplex cmplx, VOption *options = nullptr) const;
 
    VImage complex2(VImage right, VipsOperationComplex2 cmplx, VOption *options = nullptr) const;
 
    VImage complexform(VImage right, VOption *options = nullptr) const;
 
    VImage complexget(VipsOperationComplexget get, VOption *options = nullptr) const;
 
    static VImage composite(std::vector<VImage> in, std::vector<int> mode, VOption *options = nullptr);
 
    VImage composite2(VImage overlay, VipsBlendMode mode, VOption *options = nullptr) const;
 
    VImage conv(VImage mask, VOption *options = nullptr) const;
 
    VImage conva(VImage mask, VOption *options = nullptr) const;
 
    VImage convasep(VImage mask, VOption *options = nullptr) const;
 
    VImage convf(VImage mask, VOption *options = nullptr) const;
 
    VImage convi(VImage mask, VOption *options = nullptr) const;
 
    VImage convsep(VImage mask, VOption *options = nullptr) const;
 
    VImage copy(VOption *options = nullptr) const;
 
    double countlines(VipsDirection direction, VOption *options = nullptr) const;
 
    VImage crop(int left, int top, int width, int height, VOption *options = nullptr) const;
 
    static VImage csvload(const char *filename, VOption *options = nullptr);
 
    static VImage csvload_source(VSource source, VOption *options = nullptr);
 
    void csvsave(const char *filename, VOption *options = nullptr) const;
 
    void csvsave_target(VTarget target, VOption *options = nullptr) const;
 
    VImage dE00(VImage right, VOption *options = nullptr) const;
 
    VImage dE76(VImage right, VOption *options = nullptr) const;
 
    VImage dECMC(VImage right, VOption *options = nullptr) const;
 
    double deviate(VOption *options = nullptr) const;
 
    VImage divide(VImage right, VOption *options = nullptr) const;
 
    void draw_circle(std::vector<double> ink, int cx, int cy, int radius, VOption *options = nullptr) const;
 
    void draw_flood(std::vector<double> ink, int x, int y, VOption *options = nullptr) const;
 
    void draw_image(VImage sub, int x, int y, VOption *options = nullptr) const;
 
    void draw_line(std::vector<double> ink, int x1, int y1, int x2, int y2, VOption *options = nullptr) const;
 
    void draw_mask(std::vector<double> ink, VImage mask, int x, int y, VOption *options = nullptr) const;
 
    void draw_rect(std::vector<double> ink, int left, int top, int width, int height, VOption *options = nullptr) const;
 
    void draw_smudge(int left, int top, int width, int height, VOption *options = nullptr) const;
 
    void dzsave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *dzsave_buffer(VOption *options = nullptr) const;
 
    void dzsave_target(VTarget target, VOption *options = nullptr) const;
 
    VImage embed(int x, int y, int width, int height, VOption *options = nullptr) const;
 
    VImage extract_area(int left, int top, int width, int height, VOption *options = nullptr) const;
 
    VImage extract_band(int band, VOption *options = nullptr) const;
 
    static VImage eye(int width, int height, VOption *options = nullptr);
 
    VImage falsecolour(VOption *options = nullptr) const;
 
    VImage fastcor(VImage ref, VOption *options = nullptr) const;
 
    VImage fill_nearest(VOption *options = nullptr) const;
 
    int find_trim(int *top, int *width, int *height, VOption *options = nullptr) const;
 
    static VImage fitsload(const char *filename, VOption *options = nullptr);
 
    static VImage fitsload_source(VSource source, VOption *options = nullptr);
 
    void fitssave(const char *filename, VOption *options = nullptr) const;
 
    VImage flatten(VOption *options = nullptr) const;
 
    VImage flip(VipsDirection direction, VOption *options = nullptr) const;
 
    VImage float2rad(VOption *options = nullptr) const;
 
    static VImage fractsurf(int width, int height, double fractal_dimension, VOption *options = nullptr);
 
    VImage freqmult(VImage mask, VOption *options = nullptr) const;
 
    VImage fwfft(VOption *options = nullptr) const;
 
    VImage gamma(VOption *options = nullptr) const;
 
    VImage gaussblur(double sigma, VOption *options = nullptr) const;
 
    static VImage gaussmat(double sigma, double min_ampl, VOption *options = nullptr);
 
    static VImage gaussnoise(int width, int height, VOption *options = nullptr);
 
    std::vector<double> getpoint(int x, int y, VOption *options = nullptr) const;
 
    static VImage gifload(const char *filename, VOption *options = nullptr);
 
    static VImage gifload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage gifload_source(VSource source, VOption *options = nullptr);
 
    void gifsave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *gifsave_buffer(VOption *options = nullptr) const;
 
    void gifsave_target(VTarget target, VOption *options = nullptr) const;
 
    VImage globalbalance(VOption *options = nullptr) const;
 
    VImage gravity(VipsCompassDirection direction, int width, int height, VOption *options = nullptr) const;
 
    static VImage grey(int width, int height, VOption *options = nullptr);
 
    VImage grid(int tile_height, int across, int down, VOption *options = nullptr) const;
 
    static VImage heifload(const char *filename, VOption *options = nullptr);
 
    static VImage heifload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage heifload_source(VSource source, VOption *options = nullptr);
 
    void heifsave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *heifsave_buffer(VOption *options = nullptr) const;
 
    void heifsave_target(VTarget target, VOption *options = nullptr) const;
 
    VImage hist_cum(VOption *options = nullptr) const;
 
    double hist_entropy(VOption *options = nullptr) const;
 
    VImage hist_equal(VOption *options = nullptr) const;
 
    VImage hist_find(VOption *options = nullptr) const;
 
    VImage hist_find_indexed(VImage index, VOption *options = nullptr) const;
 
    VImage hist_find_ndim(VOption *options = nullptr) const;
 
    bool hist_ismonotonic(VOption *options = nullptr) const;
 
    VImage hist_local(int width, int height, VOption *options = nullptr) const;
 
    VImage hist_match(VImage ref, VOption *options = nullptr) const;
 
    VImage hist_norm(VOption *options = nullptr) const;
 
    VImage hist_plot(VOption *options = nullptr) const;
 
    VImage hough_circle(VOption *options = nullptr) const;
 
    VImage hough_line(VOption *options = nullptr) const;
 
    VImage icc_export(VOption *options = nullptr) const;
 
    VImage icc_import(VOption *options = nullptr) const;
 
    VImage icc_transform(const char *output_profile, VOption *options = nullptr) const;
 
    static VImage identity(VOption *options = nullptr);
 
    VImage ifthenelse(VImage in1, VImage in2, VOption *options = nullptr) const;
 
    VImage insert(VImage sub, int x, int y, VOption *options = nullptr) const;
 
    VImage invert(VOption *options = nullptr) const;
 
    VImage invertlut(VOption *options = nullptr) const;
 
    VImage invfft(VOption *options = nullptr) const;
 
    VImage join(VImage in2, VipsDirection direction, VOption *options = nullptr) const;
 
    static VImage jp2kload(const char *filename, VOption *options = nullptr);
 
    static VImage jp2kload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage jp2kload_source(VSource source, VOption *options = nullptr);
 
    void jp2ksave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *jp2ksave_buffer(VOption *options = nullptr) const;
 
    void jp2ksave_target(VTarget target, VOption *options = nullptr) const;
 
    static VImage jpegload(const char *filename, VOption *options = nullptr);
 
    static VImage jpegload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage jpegload_source(VSource source, VOption *options = nullptr);
 
    void jpegsave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *jpegsave_buffer(VOption *options = nullptr) const;
 
    void jpegsave_mime(VOption *options = nullptr) const;
 
    void jpegsave_target(VTarget target, VOption *options = nullptr) const;
 
    static VImage jxlload(const char *filename, VOption *options = nullptr);
 
    static VImage jxlload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage jxlload_source(VSource source, VOption *options = nullptr);
 
    void jxlsave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *jxlsave_buffer(VOption *options = nullptr) const;
 
    void jxlsave_target(VTarget target, VOption *options = nullptr) const;
 
    VImage labelregions(VOption *options = nullptr) const;
 
    VImage linear(std::vector<double> a, std::vector<double> b, VOption *options = nullptr) const;
 
    VImage linecache(VOption *options = nullptr) const;
 
    static VImage logmat(double sigma, double min_ampl, VOption *options = nullptr);
 
    static VImage magickload(const char *filename, VOption *options = nullptr);
 
    static VImage magickload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    void magicksave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *magicksave_buffer(VOption *options = nullptr) const;
 
    VImage mapim(VImage index, VOption *options = nullptr) const;
 
    VImage maplut(VImage lut, VOption *options = nullptr) const;
 
    static VImage mask_butterworth(int width, int height, double order, double frequency_cutoff, double amplitude_cutoff, VOption *options = nullptr);
 
    static VImage mask_butterworth_band(int width, int height, double order, double frequency_cutoff_x, double frequency_cutoff_y, double radius, double amplitude_cutoff, VOption *options = nullptr);
 
    static VImage mask_butterworth_ring(int width, int height, double order, double frequency_cutoff, double amplitude_cutoff, double ringwidth, VOption *options = nullptr);
 
    static VImage mask_fractal(int width, int height, double fractal_dimension, VOption *options = nullptr);
 
    static VImage mask_gaussian(int width, int height, double frequency_cutoff, double amplitude_cutoff, VOption *options = nullptr);
 
    static VImage mask_gaussian_band(int width, int height, double frequency_cutoff_x, double frequency_cutoff_y, double radius, double amplitude_cutoff, VOption *options = nullptr);
 
    static VImage mask_gaussian_ring(int width, int height, double frequency_cutoff, double amplitude_cutoff, double ringwidth, VOption *options = nullptr);
 
    static VImage mask_ideal(int width, int height, double frequency_cutoff, VOption *options = nullptr);
 
    static VImage mask_ideal_band(int width, int height, double frequency_cutoff_x, double frequency_cutoff_y, double radius, VOption *options = nullptr);
 
    static VImage mask_ideal_ring(int width, int height, double frequency_cutoff, double ringwidth, VOption *options = nullptr);
 
    VImage match(VImage sec, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, VOption *options = nullptr) const;
 
    VImage math(VipsOperationMath math, VOption *options = nullptr) const;
 
    VImage math2(VImage right, VipsOperationMath2 math2, VOption *options = nullptr) const;
 
    VImage math2_const(VipsOperationMath2 math2, std::vector<double> c, VOption *options = nullptr) const;
 
    static VImage matload(const char *filename, VOption *options = nullptr);
 
    VImage matrixinvert(VOption *options = nullptr) const;
 
    static VImage matrixload(const char *filename, VOption *options = nullptr);
 
    static VImage matrixload_source(VSource source, VOption *options = nullptr);
 
    VImage matrixmultiply(VImage right, VOption *options = nullptr) const;
 
    void matrixprint(VOption *options = nullptr) const;
 
    void matrixsave(const char *filename, VOption *options = nullptr) const;
 
    void matrixsave_target(VTarget target, VOption *options = nullptr) const;
 
    double max(VOption *options = nullptr) const;
 
    VImage maxpair(VImage right, VOption *options = nullptr) const;
 
    VImage measure(int h, int v, VOption *options = nullptr) const;
 
    VImage merge(VImage sec, VipsDirection direction, int dx, int dy, VOption *options = nullptr) const;
 
    double min(VOption *options = nullptr) const;
 
    VImage minpair(VImage right, VOption *options = nullptr) const;
 
    VImage morph(VImage mask, VipsOperationMorphology morph, VOption *options = nullptr) const;
 
    VImage mosaic(VImage sec, VipsDirection direction, int xref, int yref, int xsec, int ysec, VOption *options = nullptr) const;
 
    VImage mosaic1(VImage sec, VipsDirection direction, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, VOption *options = nullptr) const;
 
    VImage msb(VOption *options = nullptr) const;
 
    VImage multiply(VImage right, VOption *options = nullptr) const;
 
    static VImage niftiload(const char *filename, VOption *options = nullptr);
 
    static VImage niftiload_source(VSource source, VOption *options = nullptr);
 
    void niftisave(const char *filename, VOption *options = nullptr) const;
 
    static VImage openexrload(const char *filename, VOption *options = nullptr);
 
    static VImage openslideload(const char *filename, VOption *options = nullptr);
 
    static VImage openslideload_source(VSource source, VOption *options = nullptr);
 
    static VImage pdfload(const char *filename, VOption *options = nullptr);
 
    static VImage pdfload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage pdfload_source(VSource source, VOption *options = nullptr);
 
    int percent(double percent, VOption *options = nullptr) const;
 
    static VImage perlin(int width, int height, VOption *options = nullptr);
 
    VImage phasecor(VImage in2, VOption *options = nullptr) const;
 
    static VImage pngload(const char *filename, VOption *options = nullptr);
 
    static VImage pngload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage pngload_source(VSource source, VOption *options = nullptr);
 
    void pngsave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *pngsave_buffer(VOption *options = nullptr) const;
 
    void pngsave_target(VTarget target, VOption *options = nullptr) const;
 
    static VImage ppmload(const char *filename, VOption *options = nullptr);
 
    static VImage ppmload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage ppmload_source(VSource source, VOption *options = nullptr);
 
    void ppmsave(const char *filename, VOption *options = nullptr) const;
 
    void ppmsave_target(VTarget target, VOption *options = nullptr) const;
 
    VImage premultiply(VOption *options = nullptr) const;
 
    VImage prewitt(VOption *options = nullptr) const;
 
    VImage profile(VImage *rows, VOption *options = nullptr) const;
 
    static VipsBlob *profile_load(const char *name, VOption *options = nullptr);
 
    VImage project(VImage *rows, VOption *options = nullptr) const;
 
    VImage quadratic(VImage coeff, VOption *options = nullptr) const;
 
    VImage rad2float(VOption *options = nullptr) const;
 
    static VImage radload(const char *filename, VOption *options = nullptr);
 
    static VImage radload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage radload_source(VSource source, VOption *options = nullptr);
 
    void radsave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *radsave_buffer(VOption *options = nullptr) const;
 
    void radsave_target(VTarget target, VOption *options = nullptr) const;
 
    VImage rank(int width, int height, int index, VOption *options = nullptr) const;
 
    static VImage rawload(const char *filename, int width, int height, int bands, VOption *options = nullptr);
 
    void rawsave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *rawsave_buffer(VOption *options = nullptr) const;
 
    void rawsave_target(VTarget target, VOption *options = nullptr) const;
 
    VImage recomb(VImage m, VOption *options = nullptr) const;
 
    VImage reduce(double hshrink, double vshrink, VOption *options = nullptr) const;
 
    VImage reduceh(double hshrink, VOption *options = nullptr) const;
 
    VImage reducev(double vshrink, VOption *options = nullptr) const;
 
    VImage relational(VImage right, VipsOperationRelational relational, VOption *options = nullptr) const;
 
    VImage relational_const(VipsOperationRelational relational, std::vector<double> c, VOption *options = nullptr) const;
 
    VImage remainder(VImage right, VOption *options = nullptr) const;
 
    VImage remainder_const(std::vector<double> c, VOption *options = nullptr) const;
 
    VImage remosaic(const char *old_str, const char *new_str, VOption *options = nullptr) const;
 
    VImage replicate(int across, int down, VOption *options = nullptr) const;
 
    VImage resize(double scale, VOption *options = nullptr) const;
 
    VImage rot(VipsAngle angle, VOption *options = nullptr) const;
 
    VImage rot45(VOption *options = nullptr) const;
 
    VImage rotate(double angle, VOption *options = nullptr) const;
 
    VImage round(VipsOperationRound round, VOption *options = nullptr) const;
 
    VImage sRGB2HSV(VOption *options = nullptr) const;
 
    VImage sRGB2scRGB(VOption *options = nullptr) const;
 
    VImage scRGB2BW(VOption *options = nullptr) const;
 
    VImage scRGB2XYZ(VOption *options = nullptr) const;
 
    VImage scRGB2sRGB(VOption *options = nullptr) const;
 
    VImage scale(VOption *options = nullptr) const;
 
    VImage scharr(VOption *options = nullptr) const;
 
    static VImage sdf(int width, int height, VipsSdfShape shape, VOption *options = nullptr);
 
    VImage sequential(VOption *options = nullptr) const;
 
    VImage sharpen(VOption *options = nullptr) const;
 
    VImage shrink(double hshrink, double vshrink, VOption *options = nullptr) const;
 
    VImage shrinkh(int hshrink, VOption *options = nullptr) const;
 
    VImage shrinkv(int vshrink, VOption *options = nullptr) const;
 
    VImage sign(VOption *options = nullptr) const;
 
    VImage similarity(VOption *options = nullptr) const;
 
    static VImage sines(int width, int height, VOption *options = nullptr);
 
    VImage smartcrop(int width, int height, VOption *options = nullptr) const;
 
    VImage sobel(VOption *options = nullptr) const;
 
    VImage spcor(VImage ref, VOption *options = nullptr) const;
 
    VImage spectrum(VOption *options = nullptr) const;
 
    VImage stats(VOption *options = nullptr) const;
 
    VImage stdif(int width, int height, VOption *options = nullptr) const;
 
    VImage subsample(int xfac, int yfac, VOption *options = nullptr) const;
 
    VImage subtract(VImage right, VOption *options = nullptr) const;
 
    static VImage sum(std::vector<VImage> in, VOption *options = nullptr);
 
    static VImage svgload(const char *filename, VOption *options = nullptr);
 
    static VImage svgload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage svgload_source(VSource source, VOption *options = nullptr);
 
    static VImage switch_image(std::vector<VImage> tests, VOption *options = nullptr);
 
    static void system(const char *cmd_format, VOption *options = nullptr);
 
    static VImage text(const char *text, VOption *options = nullptr);
 
    static VImage thumbnail(const char *filename, int width, VOption *options = nullptr);
 
    static VImage thumbnail_buffer(VipsBlob *buffer, int width, VOption *options = nullptr);
 
    VImage thumbnail_image(int width, VOption *options = nullptr) const;
 
    static VImage thumbnail_source(VSource source, int width, VOption *options = nullptr);
 
    static VImage tiffload(const char *filename, VOption *options = nullptr);
 
    static VImage tiffload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage tiffload_source(VSource source, VOption *options = nullptr);
 
    void tiffsave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *tiffsave_buffer(VOption *options = nullptr) const;
 
    void tiffsave_target(VTarget target, VOption *options = nullptr) const;
 
    VImage tilecache(VOption *options = nullptr) const;
 
    static VImage tonelut(VOption *options = nullptr);
 
    VImage transpose3d(VOption *options = nullptr) const;
 
    VImage unpremultiply(VOption *options = nullptr) const;
 
    static VImage vipsload(const char *filename, VOption *options = nullptr);
 
    static VImage vipsload_source(VSource source, VOption *options = nullptr);
 
    void vipssave(const char *filename, VOption *options = nullptr) const;
 
    void vipssave_target(VTarget target, VOption *options = nullptr) const;
 
    static VImage webpload(const char *filename, VOption *options = nullptr);
 
    static VImage webpload_buffer(VipsBlob *buffer, VOption *options = nullptr);
 
    static VImage webpload_source(VSource source, VOption *options = nullptr);
 
    void webpsave(const char *filename, VOption *options = nullptr) const;
 
    VipsBlob *webpsave_buffer(VOption *options = nullptr) const;
 
    void webpsave_mime(VOption *options = nullptr) const;
 
    void webpsave_target(VTarget target, VOption *options = nullptr) const;
 
    static VImage worley(int width, int height, VOption *options = nullptr);
 
    VImage wrap(VOption *options = nullptr) const;
 
    static VImage xyz(int width, int height, VOption *options = nullptr);
 
    static VImage zone(int width, int height, VOption *options = nullptr);
 
    VImage zoom(int xfac, int yfac, VOption *options = nullptr) const;
};
 
VIPS_NAMESPACE_END
 
#endif /*VIPS_VIMAGE_H*/