// bodies for vips operations
// this file is generated automatically, do not edit!
// clang-format off

VImage
VImage::CMC2LCh(VOption *options) const
{
	VImage out;

	call("CMC2LCh", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::CMYK2XYZ(VOption *options) const
{
	VImage out;

	call("CMYK2XYZ", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::HSV2sRGB(VOption *options) const
{
	VImage out;

	call("HSV2sRGB", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::LCh2CMC(VOption *options) const
{
	VImage out;

	call("LCh2CMC", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::LCh2Lab(VOption *options) const
{
	VImage out;

	call("LCh2Lab", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::Lab2LCh(VOption *options) const
{
	VImage out;

	call("Lab2LCh", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::Lab2LabQ(VOption *options) const
{
	VImage out;

	call("Lab2LabQ", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::Lab2LabS(VOption *options) const
{
	VImage out;

	call("Lab2LabS", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::Lab2XYZ(VOption *options) const
{
	VImage out;

	call("Lab2XYZ", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::LabQ2Lab(VOption *options) const
{
	VImage out;

	call("LabQ2Lab", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::LabQ2LabS(VOption *options) const
{
	VImage out;

	call("LabQ2LabS", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::LabQ2sRGB(VOption *options) const
{
	VImage out;

	call("LabQ2sRGB", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::LabS2Lab(VOption *options) const
{
	VImage out;

	call("LabS2Lab", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::LabS2LabQ(VOption *options) const
{
	VImage out;

	call("LabS2LabQ", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::Oklab2Oklch(VOption *options) const
{
	VImage out;

	call("Oklab2Oklch", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::Oklab2XYZ(VOption *options) const
{
	VImage out;

	call("Oklab2XYZ", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::Oklch2Oklab(VOption *options) const
{
	VImage out;

	call("Oklch2Oklab", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::XYZ2CMYK(VOption *options) const
{
	VImage out;

	call("XYZ2CMYK", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::XYZ2Lab(VOption *options) const
{
	VImage out;

	call("XYZ2Lab", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::XYZ2Oklab(VOption *options) const
{
	VImage out;

	call("XYZ2Oklab", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::XYZ2Yxy(VOption *options) const
{
	VImage out;

	call("XYZ2Yxy", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::XYZ2scRGB(VOption *options) const
{
	VImage out;

	call("XYZ2scRGB", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::Yxy2XYZ(VOption *options) const
{
	VImage out;

	call("Yxy2XYZ", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::abs(VOption *options) const
{
	VImage out;

	call("abs", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::add(VImage right, VOption *options) const
{
	VImage out;

	call("add", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

VImage
VImage::addalpha(VOption *options) const
{
	VImage out;

	call("addalpha", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::affine(std::vector<double> matrix, VOption *options) const
{
	VImage out;

	call("affine", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("matrix", matrix));

	return out;
}

VImage
VImage::analyzeload(const char *filename, VOption *options)
{
	VImage out;

	call("analyzeload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::arrayjoin(std::vector<VImage> in, VOption *options)
{
	VImage out;

	call("arrayjoin", (options ? options : VImage::option())
			->set("out", &out)
			->set("in", in));

	return out;
}

VImage
VImage::autorot(VOption *options) const
{
	VImage out;

	call("autorot", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

double
VImage::avg(VOption *options) const
{
	double out;

	call("avg", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::bandbool(VipsOperationBoolean boolean, VOption *options) const
{
	VImage out;

	call("bandbool", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("boolean", boolean));

	return out;
}

VImage
VImage::bandfold(VOption *options) const
{
	VImage out;

	call("bandfold", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::bandjoin(std::vector<VImage> in, VOption *options)
{
	VImage out;

	call("bandjoin", (options ? options : VImage::option())
			->set("out", &out)
			->set("in", in));

	return out;
}

VImage
VImage::bandjoin_const(std::vector<double> c, VOption *options) const
{
	VImage out;

	call("bandjoin_const", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("c", c));

	return out;
}

VImage
VImage::bandmean(VOption *options) const
{
	VImage out;

	call("bandmean", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::bandrank(std::vector<VImage> in, VOption *options)
{
	VImage out;

	call("bandrank", (options ? options : VImage::option())
			->set("out", &out)
			->set("in", in));

	return out;
}

VImage
VImage::bandunfold(VOption *options) const
{
	VImage out;

	call("bandunfold", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::black(int width, int height, VOption *options)
{
	VImage out;

	call("black", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::boolean(VImage right, VipsOperationBoolean boolean, VOption *options) const
{
	VImage out;

	call("boolean", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right)
			->set("boolean", boolean));

	return out;
}

VImage
VImage::boolean_const(VipsOperationBoolean boolean, std::vector<double> c, VOption *options) const
{
	VImage out;

	call("boolean_const", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("boolean", boolean)
			->set("c", c));

	return out;
}

VImage
VImage::buildlut(VOption *options) const
{
	VImage out;

	call("buildlut", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::byteswap(VOption *options) const
{
	VImage out;

	call("byteswap", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::cache(VOption *options) const
{
	VImage out;

	call("cache", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::canny(VOption *options) const
{
	VImage out;

	call("canny", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::case_image(std::vector<VImage> cases, VOption *options) const
{
	VImage out;

	call("case", (options ? options : VImage::option())
			->set("index", *this)
			->set("out", &out)
			->set("cases", cases));

	return out;
}

VImage
VImage::cast(VipsBandFormat format, VOption *options) const
{
	VImage out;

	call("cast", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("format", format));

	return out;
}

VImage
VImage::clamp(VOption *options) const
{
	VImage out;

	call("clamp", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::colourspace(VipsInterpretation space, VOption *options) const
{
	VImage out;

	call("colourspace", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("space", space));

	return out;
}

VImage
VImage::compass(VImage mask, VOption *options) const
{
	VImage out;

	call("compass", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("mask", mask));

	return out;
}

VImage
VImage::complex(VipsOperationComplex cmplx, VOption *options) const
{
	VImage out;

	call("complex", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("cmplx", cmplx));

	return out;
}

VImage
VImage::complex2(VImage right, VipsOperationComplex2 cmplx, VOption *options) const
{
	VImage out;

	call("complex2", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right)
			->set("cmplx", cmplx));

	return out;
}

VImage
VImage::complexform(VImage right, VOption *options) const
{
	VImage out;

	call("complexform", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

VImage
VImage::complexget(VipsOperationComplexget get, VOption *options) const
{
	VImage out;

	call("complexget", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("get", get));

	return out;
}

VImage
VImage::composite(std::vector<VImage> in, std::vector<int> mode, VOption *options)
{
	VImage out;

	call("composite", (options ? options : VImage::option())
			->set("out", &out)
			->set("in", in)
			->set("mode", mode));

	return out;
}

VImage
VImage::composite2(VImage overlay, VipsBlendMode mode, VOption *options) const
{
	VImage out;

	call("composite2", (options ? options : VImage::option())
			->set("base", *this)
			->set("out", &out)
			->set("overlay", overlay)
			->set("mode", mode));

	return out;
}

VImage
VImage::conv(VImage mask, VOption *options) const
{
	VImage out;

	call("conv", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("mask", mask));

	return out;
}

VImage
VImage::conva(VImage mask, VOption *options) const
{
	VImage out;

	call("conva", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("mask", mask));

	return out;
}

VImage
VImage::convasep(VImage mask, VOption *options) const
{
	VImage out;

	call("convasep", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("mask", mask));

	return out;
}

VImage
VImage::convf(VImage mask, VOption *options) const
{
	VImage out;

	call("convf", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("mask", mask));

	return out;
}

VImage
VImage::convi(VImage mask, VOption *options) const
{
	VImage out;

	call("convi", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("mask", mask));

	return out;
}

VImage
VImage::convsep(VImage mask, VOption *options) const
{
	VImage out;

	call("convsep", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("mask", mask));

	return out;
}

VImage
VImage::copy(VOption *options) const
{
	VImage out;

	call("copy", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

double
VImage::countlines(VipsDirection direction, VOption *options) const
{
	double nolines;

	call("countlines", (options ? options : VImage::option())
			->set("in", *this)
			->set("nolines", &nolines)
			->set("direction", direction));

	return nolines;
}

VImage
VImage::crop(int left, int top, int width, int height, VOption *options) const
{
	VImage out;

	call("crop", (options ? options : VImage::option())
			->set("input", *this)
			->set("out", &out)
			->set("left", left)
			->set("top", top)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::csvload(const char *filename, VOption *options)
{
	VImage out;

	call("csvload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::csvload_source(VSource source, VOption *options)
{
	VImage out;

	call("csvload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::csvsave(const char *filename, VOption *options) const
{
	call("csvsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

void
VImage::csvsave_target(VTarget target, VOption *options) const
{
	call("csvsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::dE00(VImage right, VOption *options) const
{
	VImage out;

	call("dE00", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

VImage
VImage::dE76(VImage right, VOption *options) const
{
	VImage out;

	call("dE76", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

VImage
VImage::dECMC(VImage right, VOption *options) const
{
	VImage out;

	call("dECMC", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

VImage
VImage::dcrawload(const char *filename, VOption *options)
{
	VImage out;

	call("dcrawload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::dcrawload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("dcrawload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::dcrawload_source(VSource source, VOption *options)
{
	VImage out;

	call("dcrawload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

double
VImage::deviate(VOption *options) const
{
	double out;

	call("deviate", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::divide(VImage right, VOption *options) const
{
	VImage out;

	call("divide", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

void
VImage::draw_circle(std::vector<double> ink, int cx, int cy, int radius, VOption *options) const
{
	call("draw_circle", (options ? options : VImage::option())
			->set("image", *this)
			->set("ink", ink)
			->set("cx", cx)
			->set("cy", cy)
			->set("radius", radius));
}

void
VImage::draw_flood(std::vector<double> ink, int x, int y, VOption *options) const
{
	call("draw_flood", (options ? options : VImage::option())
			->set("image", *this)
			->set("ink", ink)
			->set("x", x)
			->set("y", y));
}

void
VImage::draw_image(VImage sub, int x, int y, VOption *options) const
{
	call("draw_image", (options ? options : VImage::option())
			->set("image", *this)
			->set("sub", sub)
			->set("x", x)
			->set("y", y));
}

void
VImage::draw_line(std::vector<double> ink, int x1, int y1, int x2, int y2, VOption *options) const
{
	call("draw_line", (options ? options : VImage::option())
			->set("image", *this)
			->set("ink", ink)
			->set("x1", x1)
			->set("y1", y1)
			->set("x2", x2)
			->set("y2", y2));
}

void
VImage::draw_mask(std::vector<double> ink, VImage mask, int x, int y, VOption *options) const
{
	call("draw_mask", (options ? options : VImage::option())
			->set("image", *this)
			->set("ink", ink)
			->set("mask", mask)
			->set("x", x)
			->set("y", y));
}

void
VImage::draw_rect(std::vector<double> ink, int left, int top, int width, int height, VOption *options) const
{
	call("draw_rect", (options ? options : VImage::option())
			->set("image", *this)
			->set("ink", ink)
			->set("left", left)
			->set("top", top)
			->set("width", width)
			->set("height", height));
}

void
VImage::draw_smudge(int left, int top, int width, int height, VOption *options) const
{
	call("draw_smudge", (options ? options : VImage::option())
			->set("image", *this)
			->set("left", left)
			->set("top", top)
			->set("width", width)
			->set("height", height));
}

void
VImage::dzsave(const char *filename, VOption *options) const
{
	call("dzsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::dzsave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("dzsave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::dzsave_target(VTarget target, VOption *options) const
{
	call("dzsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::embed(int x, int y, int width, int height, VOption *options) const
{
	VImage out;

	call("embed", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("x", x)
			->set("y", y)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::extract_area(int left, int top, int width, int height, VOption *options) const
{
	VImage out;

	call("extract_area", (options ? options : VImage::option())
			->set("input", *this)
			->set("out", &out)
			->set("left", left)
			->set("top", top)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::extract_band(int band, VOption *options) const
{
	VImage out;

	call("extract_band", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("band", band));

	return out;
}

VImage
VImage::eye(int width, int height, VOption *options)
{
	VImage out;

	call("eye", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::falsecolour(VOption *options) const
{
	VImage out;

	call("falsecolour", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::fastcor(VImage ref, VOption *options) const
{
	VImage out;

	call("fastcor", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("ref", ref));

	return out;
}

VImage
VImage::fill_nearest(VOption *options) const
{
	VImage out;

	call("fill_nearest", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

int
VImage::find_trim(int *top, int *width, int *height, VOption *options) const
{
	int left;

	call("find_trim", (options ? options : VImage::option())
			->set("in", *this)
			->set("left", &left)
			->set("top", top)
			->set("width", width)
			->set("height", height));

	return left;
}

VImage
VImage::fitsload(const char *filename, VOption *options)
{
	VImage out;

	call("fitsload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::fitsload_source(VSource source, VOption *options)
{
	VImage out;

	call("fitsload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::fitssave(const char *filename, VOption *options) const
{
	call("fitssave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VImage
VImage::flatten(VOption *options) const
{
	VImage out;

	call("flatten", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::flip(VipsDirection direction, VOption *options) const
{
	VImage out;

	call("flip", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("direction", direction));

	return out;
}

VImage
VImage::float2rad(VOption *options) const
{
	VImage out;

	call("float2rad", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::fractsurf(int width, int height, double fractal_dimension, VOption *options)
{
	VImage out;

	call("fractsurf", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("fractal_dimension", fractal_dimension));

	return out;
}

VImage
VImage::freqmult(VImage mask, VOption *options) const
{
	VImage out;

	call("freqmult", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("mask", mask));

	return out;
}

VImage
VImage::fwfft(VOption *options) const
{
	VImage out;

	call("fwfft", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::gamma(VOption *options) const
{
	VImage out;

	call("gamma", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::gaussblur(double sigma, VOption *options) const
{
	VImage out;

	call("gaussblur", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("sigma", sigma));

	return out;
}

VImage
VImage::gaussmat(double sigma, double min_ampl, VOption *options)
{
	VImage out;

	call("gaussmat", (options ? options : VImage::option())
			->set("out", &out)
			->set("sigma", sigma)
			->set("min_ampl", min_ampl));

	return out;
}

VImage
VImage::gaussnoise(int width, int height, VOption *options)
{
	VImage out;

	call("gaussnoise", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

std::vector<double>
VImage::getpoint(int x, int y, VOption *options) const
{
	std::vector<double> out_array;

	call("getpoint", (options ? options : VImage::option())
			->set("in", *this)
			->set("out_array", &out_array)
			->set("x", x)
			->set("y", y));

	return out_array;
}

VImage
VImage::gifload(const char *filename, VOption *options)
{
	VImage out;

	call("gifload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::gifload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("gifload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::gifload_source(VSource source, VOption *options)
{
	VImage out;

	call("gifload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::gifsave(const char *filename, VOption *options) const
{
	call("gifsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::gifsave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("gifsave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::gifsave_target(VTarget target, VOption *options) const
{
	call("gifsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::globalbalance(VOption *options) const
{
	VImage out;

	call("globalbalance", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::gravity(VipsCompassDirection direction, int width, int height, VOption *options) const
{
	VImage out;

	call("gravity", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("direction", direction)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::grey(int width, int height, VOption *options)
{
	VImage out;

	call("grey", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::grid(int tile_height, int across, int down, VOption *options) const
{
	VImage out;

	call("grid", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("tile_height", tile_height)
			->set("across", across)
			->set("down", down));

	return out;
}

VImage
VImage::heifload(const char *filename, VOption *options)
{
	VImage out;

	call("heifload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::heifload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("heifload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::heifload_source(VSource source, VOption *options)
{
	VImage out;

	call("heifload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::heifsave(const char *filename, VOption *options) const
{
	call("heifsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::heifsave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("heifsave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::heifsave_target(VTarget target, VOption *options) const
{
	call("heifsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::hist_cum(VOption *options) const
{
	VImage out;

	call("hist_cum", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

double
VImage::hist_entropy(VOption *options) const
{
	double out;

	call("hist_entropy", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::hist_equal(VOption *options) const
{
	VImage out;

	call("hist_equal", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::hist_find(VOption *options) const
{
	VImage out;

	call("hist_find", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::hist_find_indexed(VImage index, VOption *options) const
{
	VImage out;

	call("hist_find_indexed", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("index", index));

	return out;
}

VImage
VImage::hist_find_ndim(VOption *options) const
{
	VImage out;

	call("hist_find_ndim", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

bool
VImage::hist_ismonotonic(VOption *options) const
{
	bool monotonic;

	call("hist_ismonotonic", (options ? options : VImage::option())
			->set("in", *this)
			->set("monotonic", &monotonic));

	return monotonic;
}

VImage
VImage::hist_local(int width, int height, VOption *options) const
{
	VImage out;

	call("hist_local", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::hist_match(VImage ref, VOption *options) const
{
	VImage out;

	call("hist_match", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("ref", ref));

	return out;
}

VImage
VImage::hist_norm(VOption *options) const
{
	VImage out;

	call("hist_norm", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::hist_plot(VOption *options) const
{
	VImage out;

	call("hist_plot", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::hough_circle(VOption *options) const
{
	VImage out;

	call("hough_circle", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::hough_line(VOption *options) const
{
	VImage out;

	call("hough_line", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::icc_export(VOption *options) const
{
	VImage out;

	call("icc_export", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::icc_import(VOption *options) const
{
	VImage out;

	call("icc_import", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::icc_transform(const char *output_profile, VOption *options) const
{
	VImage out;

	call("icc_transform", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("output_profile", output_profile));

	return out;
}

VImage
VImage::identity(VOption *options)
{
	VImage out;

	call("identity", (options ? options : VImage::option())
			->set("out", &out));

	return out;
}

VImage
VImage::ifthenelse(VImage in1, VImage in2, VOption *options) const
{
	VImage out;

	call("ifthenelse", (options ? options : VImage::option())
			->set("cond", *this)
			->set("out", &out)
			->set("in1", in1)
			->set("in2", in2));

	return out;
}

VImage
VImage::insert(VImage sub, int x, int y, VOption *options) const
{
	VImage out;

	call("insert", (options ? options : VImage::option())
			->set("main", *this)
			->set("out", &out)
			->set("sub", sub)
			->set("x", x)
			->set("y", y));

	return out;
}

VImage
VImage::invert(VOption *options) const
{
	VImage out;

	call("invert", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::invertlut(VOption *options) const
{
	VImage out;

	call("invertlut", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::invfft(VOption *options) const
{
	VImage out;

	call("invfft", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::join(VImage in2, VipsDirection direction, VOption *options) const
{
	VImage out;

	call("join", (options ? options : VImage::option())
			->set("in1", *this)
			->set("out", &out)
			->set("in2", in2)
			->set("direction", direction));

	return out;
}

VImage
VImage::jp2kload(const char *filename, VOption *options)
{
	VImage out;

	call("jp2kload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::jp2kload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("jp2kload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::jp2kload_source(VSource source, VOption *options)
{
	VImage out;

	call("jp2kload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::jp2ksave(const char *filename, VOption *options) const
{
	call("jp2ksave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::jp2ksave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("jp2ksave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::jp2ksave_target(VTarget target, VOption *options) const
{
	call("jp2ksave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::jpegload(const char *filename, VOption *options)
{
	VImage out;

	call("jpegload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::jpegload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("jpegload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::jpegload_source(VSource source, VOption *options)
{
	VImage out;

	call("jpegload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::jpegsave(const char *filename, VOption *options) const
{
	call("jpegsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::jpegsave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("jpegsave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::jpegsave_mime(VOption *options) const
{
	call("jpegsave_mime", (options ? options : VImage::option())
			->set("in", *this));
}

void
VImage::jpegsave_target(VTarget target, VOption *options) const
{
	call("jpegsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::jxlload(const char *filename, VOption *options)
{
	VImage out;

	call("jxlload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::jxlload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("jxlload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::jxlload_source(VSource source, VOption *options)
{
	VImage out;

	call("jxlload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::jxlsave(const char *filename, VOption *options) const
{
	call("jxlsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::jxlsave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("jxlsave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::jxlsave_target(VTarget target, VOption *options) const
{
	call("jxlsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::labelregions(VOption *options) const
{
	VImage mask;

	call("labelregions", (options ? options : VImage::option())
			->set("in", *this)
			->set("mask", &mask));

	return mask;
}

VImage
VImage::linear(std::vector<double> a, std::vector<double> b, VOption *options) const
{
	VImage out;

	call("linear", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("a", a)
			->set("b", b));

	return out;
}

VImage
VImage::linecache(VOption *options) const
{
	VImage out;

	call("linecache", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::logmat(double sigma, double min_ampl, VOption *options)
{
	VImage out;

	call("logmat", (options ? options : VImage::option())
			->set("out", &out)
			->set("sigma", sigma)
			->set("min_ampl", min_ampl));

	return out;
}

VImage
VImage::magickload(const char *filename, VOption *options)
{
	VImage out;

	call("magickload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::magickload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("magickload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::magickload_source(VSource source, VOption *options)
{
	VImage out;

	call("magickload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::magicksave(const char *filename, VOption *options) const
{
	call("magicksave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::magicksave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("magicksave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

VImage
VImage::mapim(VImage index, VOption *options) const
{
	VImage out;

	call("mapim", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("index", index));

	return out;
}

VImage
VImage::maplut(VImage lut, VOption *options) const
{
	VImage out;

	call("maplut", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("lut", lut));

	return out;
}

VImage
VImage::mask_butterworth(int width, int height, double order, double frequency_cutoff, double amplitude_cutoff, VOption *options)
{
	VImage out;

	call("mask_butterworth", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("order", order)
			->set("frequency_cutoff", frequency_cutoff)
			->set("amplitude_cutoff", amplitude_cutoff));

	return out;
}

VImage
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)
{
	VImage out;

	call("mask_butterworth_band", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("order", order)
			->set("frequency_cutoff_x", frequency_cutoff_x)
			->set("frequency_cutoff_y", frequency_cutoff_y)
			->set("radius", radius)
			->set("amplitude_cutoff", amplitude_cutoff));

	return out;
}

VImage
VImage::mask_butterworth_ring(int width, int height, double order, double frequency_cutoff, double amplitude_cutoff, double ringwidth, VOption *options)
{
	VImage out;

	call("mask_butterworth_ring", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("order", order)
			->set("frequency_cutoff", frequency_cutoff)
			->set("amplitude_cutoff", amplitude_cutoff)
			->set("ringwidth", ringwidth));

	return out;
}

VImage
VImage::mask_fractal(int width, int height, double fractal_dimension, VOption *options)
{
	VImage out;

	call("mask_fractal", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("fractal_dimension", fractal_dimension));

	return out;
}

VImage
VImage::mask_gaussian(int width, int height, double frequency_cutoff, double amplitude_cutoff, VOption *options)
{
	VImage out;

	call("mask_gaussian", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("frequency_cutoff", frequency_cutoff)
			->set("amplitude_cutoff", amplitude_cutoff));

	return out;
}

VImage
VImage::mask_gaussian_band(int width, int height, double frequency_cutoff_x, double frequency_cutoff_y, double radius, double amplitude_cutoff, VOption *options)
{
	VImage out;

	call("mask_gaussian_band", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("frequency_cutoff_x", frequency_cutoff_x)
			->set("frequency_cutoff_y", frequency_cutoff_y)
			->set("radius", radius)
			->set("amplitude_cutoff", amplitude_cutoff));

	return out;
}

VImage
VImage::mask_gaussian_ring(int width, int height, double frequency_cutoff, double amplitude_cutoff, double ringwidth, VOption *options)
{
	VImage out;

	call("mask_gaussian_ring", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("frequency_cutoff", frequency_cutoff)
			->set("amplitude_cutoff", amplitude_cutoff)
			->set("ringwidth", ringwidth));

	return out;
}

VImage
VImage::mask_ideal(int width, int height, double frequency_cutoff, VOption *options)
{
	VImage out;

	call("mask_ideal", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("frequency_cutoff", frequency_cutoff));

	return out;
}

VImage
VImage::mask_ideal_band(int width, int height, double frequency_cutoff_x, double frequency_cutoff_y, double radius, VOption *options)
{
	VImage out;

	call("mask_ideal_band", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("frequency_cutoff_x", frequency_cutoff_x)
			->set("frequency_cutoff_y", frequency_cutoff_y)
			->set("radius", radius));

	return out;
}

VImage
VImage::mask_ideal_ring(int width, int height, double frequency_cutoff, double ringwidth, VOption *options)
{
	VImage out;

	call("mask_ideal_ring", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("frequency_cutoff", frequency_cutoff)
			->set("ringwidth", ringwidth));

	return out;
}

VImage
VImage::match(VImage sec, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, VOption *options) const
{
	VImage out;

	call("match", (options ? options : VImage::option())
			->set("ref", *this)
			->set("out", &out)
			->set("sec", sec)
			->set("xr1", xr1)
			->set("yr1", yr1)
			->set("xs1", xs1)
			->set("ys1", ys1)
			->set("xr2", xr2)
			->set("yr2", yr2)
			->set("xs2", xs2)
			->set("ys2", ys2));

	return out;
}

VImage
VImage::math(VipsOperationMath math, VOption *options) const
{
	VImage out;

	call("math", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("math", math));

	return out;
}

VImage
VImage::math2(VImage right, VipsOperationMath2 math2, VOption *options) const
{
	VImage out;

	call("math2", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right)
			->set("math2", math2));

	return out;
}

VImage
VImage::math2_const(VipsOperationMath2 math2, std::vector<double> c, VOption *options) const
{
	VImage out;

	call("math2_const", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("math2", math2)
			->set("c", c));

	return out;
}

VImage
VImage::matload(const char *filename, VOption *options)
{
	VImage out;

	call("matload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::matrixinvert(VOption *options) const
{
	VImage out;

	call("matrixinvert", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::matrixload(const char *filename, VOption *options)
{
	VImage out;

	call("matrixload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::matrixload_source(VSource source, VOption *options)
{
	VImage out;

	call("matrixload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

VImage
VImage::matrixmultiply(VImage right, VOption *options) const
{
	VImage out;

	call("matrixmultiply", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

void
VImage::matrixprint(VOption *options) const
{
	call("matrixprint", (options ? options : VImage::option())
			->set("in", *this));
}

void
VImage::matrixsave(const char *filename, VOption *options) const
{
	call("matrixsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

void
VImage::matrixsave_target(VTarget target, VOption *options) const
{
	call("matrixsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

double
VImage::max(VOption *options) const
{
	double out;

	call("max", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::maxpair(VImage right, VOption *options) const
{
	VImage out;

	call("maxpair", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

VImage
VImage::measure(int h, int v, VOption *options) const
{
	VImage out;

	call("measure", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("h", h)
			->set("v", v));

	return out;
}

VImage
VImage::merge(VImage sec, VipsDirection direction, int dx, int dy, VOption *options) const
{
	VImage out;

	call("merge", (options ? options : VImage::option())
			->set("ref", *this)
			->set("out", &out)
			->set("sec", sec)
			->set("direction", direction)
			->set("dx", dx)
			->set("dy", dy));

	return out;
}

double
VImage::min(VOption *options) const
{
	double out;

	call("min", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::minpair(VImage right, VOption *options) const
{
	VImage out;

	call("minpair", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

VImage
VImage::morph(VImage mask, VipsOperationMorphology morph, VOption *options) const
{
	VImage out;

	call("morph", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("mask", mask)
			->set("morph", morph));

	return out;
}

VImage
VImage::mosaic(VImage sec, VipsDirection direction, int xref, int yref, int xsec, int ysec, VOption *options) const
{
	VImage out;

	call("mosaic", (options ? options : VImage::option())
			->set("ref", *this)
			->set("out", &out)
			->set("sec", sec)
			->set("direction", direction)
			->set("xref", xref)
			->set("yref", yref)
			->set("xsec", xsec)
			->set("ysec", ysec));

	return out;
}

VImage
VImage::mosaic1(VImage sec, VipsDirection direction, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, VOption *options) const
{
	VImage out;

	call("mosaic1", (options ? options : VImage::option())
			->set("ref", *this)
			->set("out", &out)
			->set("sec", sec)
			->set("direction", direction)
			->set("xr1", xr1)
			->set("yr1", yr1)
			->set("xs1", xs1)
			->set("ys1", ys1)
			->set("xr2", xr2)
			->set("yr2", yr2)
			->set("xs2", xs2)
			->set("ys2", ys2));

	return out;
}

VImage
VImage::msb(VOption *options) const
{
	VImage out;

	call("msb", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::multiply(VImage right, VOption *options) const
{
	VImage out;

	call("multiply", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

VImage
VImage::niftiload(const char *filename, VOption *options)
{
	VImage out;

	call("niftiload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::niftiload_source(VSource source, VOption *options)
{
	VImage out;

	call("niftiload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::niftisave(const char *filename, VOption *options) const
{
	call("niftisave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VImage
VImage::openexrload(const char *filename, VOption *options)
{
	VImage out;

	call("openexrload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::openslideload(const char *filename, VOption *options)
{
	VImage out;

	call("openslideload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::openslideload_source(VSource source, VOption *options)
{
	VImage out;

	call("openslideload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

VImage
VImage::pdfload(const char *filename, VOption *options)
{
	VImage out;

	call("pdfload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::pdfload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("pdfload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::pdfload_source(VSource source, VOption *options)
{
	VImage out;

	call("pdfload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

int
VImage::percent(double percent, VOption *options) const
{
	int threshold;

	call("percent", (options ? options : VImage::option())
			->set("in", *this)
			->set("threshold", &threshold)
			->set("percent", percent));

	return threshold;
}

VImage
VImage::perlin(int width, int height, VOption *options)
{
	VImage out;

	call("perlin", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::phasecor(VImage in2, VOption *options) const
{
	VImage out;

	call("phasecor", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("in2", in2));

	return out;
}

VImage
VImage::pngload(const char *filename, VOption *options)
{
	VImage out;

	call("pngload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::pngload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("pngload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::pngload_source(VSource source, VOption *options)
{
	VImage out;

	call("pngload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::pngsave(const char *filename, VOption *options) const
{
	call("pngsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::pngsave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("pngsave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::pngsave_target(VTarget target, VOption *options) const
{
	call("pngsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::ppmload(const char *filename, VOption *options)
{
	VImage out;

	call("ppmload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::ppmload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("ppmload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::ppmload_source(VSource source, VOption *options)
{
	VImage out;

	call("ppmload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::ppmsave(const char *filename, VOption *options) const
{
	call("ppmsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

void
VImage::ppmsave_target(VTarget target, VOption *options) const
{
	call("ppmsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::premultiply(VOption *options) const
{
	VImage out;

	call("premultiply", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::prewitt(VOption *options) const
{
	VImage out;

	call("prewitt", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::profile(VImage *rows, VOption *options) const
{
	VImage columns;

	call("profile", (options ? options : VImage::option())
			->set("in", *this)
			->set("columns", &columns)
			->set("rows", rows));

	return columns;
}

VipsBlob *
VImage::profile_load(const char *name, VOption *options)
{
	VipsBlob *profile;

	call("profile_load", (options ? options : VImage::option())
			->set("profile", &profile)
			->set("name", name));

	return profile;
}

VImage
VImage::project(VImage *rows, VOption *options) const
{
	VImage columns;

	call("project", (options ? options : VImage::option())
			->set("in", *this)
			->set("columns", &columns)
			->set("rows", rows));

	return columns;
}

VImage
VImage::quadratic(VImage coeff, VOption *options) const
{
	VImage out;

	call("quadratic", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("coeff", coeff));

	return out;
}

VImage
VImage::rad2float(VOption *options) const
{
	VImage out;

	call("rad2float", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::radload(const char *filename, VOption *options)
{
	VImage out;

	call("radload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::radload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("radload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::radload_source(VSource source, VOption *options)
{
	VImage out;

	call("radload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::radsave(const char *filename, VOption *options) const
{
	call("radsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::radsave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("radsave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::radsave_target(VTarget target, VOption *options) const
{
	call("radsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::rank(int width, int height, int index, VOption *options) const
{
	VImage out;

	call("rank", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("index", index));

	return out;
}

VImage
VImage::rawload(const char *filename, int width, int height, int bands, VOption *options)
{
	VImage out;

	call("rawload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename)
			->set("width", width)
			->set("height", height)
			->set("bands", bands));

	return out;
}

void
VImage::rawsave(const char *filename, VOption *options) const
{
	call("rawsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::rawsave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("rawsave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::rawsave_target(VTarget target, VOption *options) const
{
	call("rawsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::recomb(VImage m, VOption *options) const
{
	VImage out;

	call("recomb", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("m", m));

	return out;
}

VImage
VImage::reduce(double hshrink, double vshrink, VOption *options) const
{
	VImage out;

	call("reduce", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("hshrink", hshrink)
			->set("vshrink", vshrink));

	return out;
}

VImage
VImage::reduceh(double hshrink, VOption *options) const
{
	VImage out;

	call("reduceh", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("hshrink", hshrink));

	return out;
}

VImage
VImage::reducev(double vshrink, VOption *options) const
{
	VImage out;

	call("reducev", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("vshrink", vshrink));

	return out;
}

VImage
VImage::relational(VImage right, VipsOperationRelational relational, VOption *options) const
{
	VImage out;

	call("relational", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right)
			->set("relational", relational));

	return out;
}

VImage
VImage::relational_const(VipsOperationRelational relational, std::vector<double> c, VOption *options) const
{
	VImage out;

	call("relational_const", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("relational", relational)
			->set("c", c));

	return out;
}

VImage
VImage::remainder(VImage right, VOption *options) const
{
	VImage out;

	call("remainder", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

VImage
VImage::remainder_const(std::vector<double> c, VOption *options) const
{
	VImage out;

	call("remainder_const", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("c", c));

	return out;
}

VImage
VImage::remosaic(const char *old_str, const char *new_str, VOption *options) const
{
	VImage out;

	call("remosaic", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("old_str", old_str)
			->set("new_str", new_str));

	return out;
}

VImage
VImage::replicate(int across, int down, VOption *options) const
{
	VImage out;

	call("replicate", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("across", across)
			->set("down", down));

	return out;
}

VImage
VImage::resize(double scale, VOption *options) const
{
	VImage out;

	call("resize", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("scale", scale));

	return out;
}

VImage
VImage::rot(VipsAngle angle, VOption *options) const
{
	VImage out;

	call("rot", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("angle", angle));

	return out;
}

VImage
VImage::rot45(VOption *options) const
{
	VImage out;

	call("rot45", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::rotate(double angle, VOption *options) const
{
	VImage out;

	call("rotate", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("angle", angle));

	return out;
}

VImage
VImage::round(VipsOperationRound round, VOption *options) const
{
	VImage out;

	call("round", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("round", round));

	return out;
}

VImage
VImage::sRGB2HSV(VOption *options) const
{
	VImage out;

	call("sRGB2HSV", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::sRGB2scRGB(VOption *options) const
{
	VImage out;

	call("sRGB2scRGB", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::scRGB2BW(VOption *options) const
{
	VImage out;

	call("scRGB2BW", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::scRGB2XYZ(VOption *options) const
{
	VImage out;

	call("scRGB2XYZ", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::scRGB2sRGB(VOption *options) const
{
	VImage out;

	call("scRGB2sRGB", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::scale(VOption *options) const
{
	VImage out;

	call("scale", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::scharr(VOption *options) const
{
	VImage out;

	call("scharr", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::sdf(int width, int height, VipsSdfShape shape, VOption *options)
{
	VImage out;

	call("sdf", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height)
			->set("shape", shape));

	return out;
}

VImage
VImage::sequential(VOption *options) const
{
	VImage out;

	call("sequential", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::sharpen(VOption *options) const
{
	VImage out;

	call("sharpen", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::shrink(double hshrink, double vshrink, VOption *options) const
{
	VImage out;

	call("shrink", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("hshrink", hshrink)
			->set("vshrink", vshrink));

	return out;
}

VImage
VImage::shrinkh(int hshrink, VOption *options) const
{
	VImage out;

	call("shrinkh", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("hshrink", hshrink));

	return out;
}

VImage
VImage::shrinkv(int vshrink, VOption *options) const
{
	VImage out;

	call("shrinkv", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("vshrink", vshrink));

	return out;
}

VImage
VImage::sign(VOption *options) const
{
	VImage out;

	call("sign", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::similarity(VOption *options) const
{
	VImage out;

	call("similarity", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::sines(int width, int height, VOption *options)
{
	VImage out;

	call("sines", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::smartcrop(int width, int height, VOption *options) const
{
	VImage out;

	call("smartcrop", (options ? options : VImage::option())
			->set("input", *this)
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::sobel(VOption *options) const
{
	VImage out;

	call("sobel", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::spcor(VImage ref, VOption *options) const
{
	VImage out;

	call("spcor", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("ref", ref));

	return out;
}

VImage
VImage::spectrum(VOption *options) const
{
	VImage out;

	call("spectrum", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::stats(VOption *options) const
{
	VImage out;

	call("stats", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::stdif(int width, int height, VOption *options) const
{
	VImage out;

	call("stdif", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::subsample(int xfac, int yfac, VOption *options) const
{
	VImage out;

	call("subsample", (options ? options : VImage::option())
			->set("input", *this)
			->set("out", &out)
			->set("xfac", xfac)
			->set("yfac", yfac));

	return out;
}

VImage
VImage::subtract(VImage right, VOption *options) const
{
	VImage out;

	call("subtract", (options ? options : VImage::option())
			->set("left", *this)
			->set("out", &out)
			->set("right", right));

	return out;
}

VImage
VImage::sum(std::vector<VImage> in, VOption *options)
{
	VImage out;

	call("sum", (options ? options : VImage::option())
			->set("out", &out)
			->set("in", in));

	return out;
}

VImage
VImage::svgload(const char *filename, VOption *options)
{
	VImage out;

	call("svgload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::svgload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("svgload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::svgload_source(VSource source, VOption *options)
{
	VImage out;

	call("svgload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

VImage
VImage::switch_image(std::vector<VImage> tests, VOption *options)
{
	VImage out;

	call("switch", (options ? options : VImage::option())
			->set("out", &out)
			->set("tests", tests));

	return out;
}

void
VImage::system(const char *cmd_format, VOption *options)
{
	call("system", (options ? options : VImage::option())
			->set("cmd_format", cmd_format));
}

VImage
VImage::text(const char *text, VOption *options)
{
	VImage out;

	call("text", (options ? options : VImage::option())
			->set("out", &out)
			->set("text", text));

	return out;
}

VImage
VImage::thumbnail(const char *filename, int width, VOption *options)
{
	VImage out;

	call("thumbnail", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename)
			->set("width", width));

	return out;
}

VImage
VImage::thumbnail_buffer(VipsBlob *buffer, int width, VOption *options)
{
	VImage out;

	call("thumbnail_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer)
			->set("width", width));

	return out;
}

VImage
VImage::thumbnail_image(int width, VOption *options) const
{
	VImage out;

	call("thumbnail_image", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out)
			->set("width", width));

	return out;
}

VImage
VImage::thumbnail_source(VSource source, int width, VOption *options)
{
	VImage out;

	call("thumbnail_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source)
			->set("width", width));

	return out;
}

VImage
VImage::tiffload(const char *filename, VOption *options)
{
	VImage out;

	call("tiffload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::tiffload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("tiffload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::tiffload_source(VSource source, VOption *options)
{
	VImage out;

	call("tiffload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::tiffsave(const char *filename, VOption *options) const
{
	call("tiffsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::tiffsave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("tiffsave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::tiffsave_target(VTarget target, VOption *options) const
{
	call("tiffsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::tilecache(VOption *options) const
{
	VImage out;

	call("tilecache", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::tonelut(VOption *options)
{
	VImage out;

	call("tonelut", (options ? options : VImage::option())
			->set("out", &out));

	return out;
}

VImage
VImage::transpose3d(VOption *options) const
{
	VImage out;

	call("transpose3d", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::uhdr2scRGB(VOption *options) const
{
	VImage out;

	call("uhdr2scRGB", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::uhdrload(const char *filename, VOption *options)
{
	VImage out;

	call("uhdrload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::uhdrload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("uhdrload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::uhdrload_source(VSource source, VOption *options)
{
	VImage out;

	call("uhdrload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::uhdrsave(const char *filename, VOption *options) const
{
	call("uhdrsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::uhdrsave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("uhdrsave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::uhdrsave_target(VTarget target, VOption *options) const
{
	call("uhdrsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::unpremultiply(VOption *options) const
{
	VImage out;

	call("unpremultiply", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::vipsload(const char *filename, VOption *options)
{
	VImage out;

	call("vipsload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::vipsload_source(VSource source, VOption *options)
{
	VImage out;

	call("vipsload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::vipssave(const char *filename, VOption *options) const
{
	call("vipssave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

void
VImage::vipssave_target(VTarget target, VOption *options) const
{
	call("vipssave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::webpload(const char *filename, VOption *options)
{
	VImage out;

	call("webpload", (options ? options : VImage::option())
			->set("out", &out)
			->set("filename", filename));

	return out;
}

VImage
VImage::webpload_buffer(VipsBlob *buffer, VOption *options)
{
	VImage out;

	call("webpload_buffer", (options ? options : VImage::option())
			->set("out", &out)
			->set("buffer", buffer));

	return out;
}

VImage
VImage::webpload_source(VSource source, VOption *options)
{
	VImage out;

	call("webpload_source", (options ? options : VImage::option())
			->set("out", &out)
			->set("source", source));

	return out;
}

void
VImage::webpsave(const char *filename, VOption *options) const
{
	call("webpsave", (options ? options : VImage::option())
			->set("in", *this)
			->set("filename", filename));
}

VipsBlob *
VImage::webpsave_buffer(VOption *options) const
{
	VipsBlob *buffer;

	call("webpsave_buffer", (options ? options : VImage::option())
			->set("in", *this)
			->set("buffer", &buffer));

	return buffer;
}

void
VImage::webpsave_mime(VOption *options) const
{
	call("webpsave_mime", (options ? options : VImage::option())
			->set("in", *this));
}

void
VImage::webpsave_target(VTarget target, VOption *options) const
{
	call("webpsave_target", (options ? options : VImage::option())
			->set("in", *this)
			->set("target", target));
}

VImage
VImage::worley(int width, int height, VOption *options)
{
	VImage out;

	call("worley", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::wrap(VOption *options) const
{
	VImage out;

	call("wrap", (options ? options : VImage::option())
			->set("in", *this)
			->set("out", &out));

	return out;
}

VImage
VImage::xyz(int width, int height, VOption *options)
{
	VImage out;

	call("xyz", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::zone(int width, int height, VOption *options)
{
	VImage out;

	call("zone", (options ? options : VImage::option())
			->set("out", &out)
			->set("width", width)
			->set("height", height));

	return out;
}

VImage
VImage::zoom(int xfac, int yfac, VOption *options) const
{
	VImage out;

	call("zoom", (options ? options : VImage::option())
			->set("input", *this)
			->set("out", &out)
			->set("xfac", xfac)
			->set("yfac", yfac));

	return out;
}
