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


 

    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!


 

    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);

 

    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_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 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*/