ruby-vips 0.1.1

data/ext/image_colour.h

@@ -0,0 +1,36 @@
+VALUE img_lab_to_lch(VALUE);
+VALUE img_lch_to_lab(VALUE);
+VALUE img_labq_to_xyz(VALUE);
+VALUE img_rad_to_float(VALUE);
+VALUE img_float_to_rad(VALUE);
+VALUE img_lch_to_ucs(VALUE);
+VALUE img_lab_to_labq(VALUE);
+VALUE img_lab_to_labs(VALUE);
+VALUE img_lab_to_xyz(VALUE);
+VALUE img_lab_to_xyz_temp(VALUE, VALUE, VALUE, VALUE);
+VALUE img_lab_to_ucs(VALUE);
+VALUE img_labq_to_lab(VALUE);
+VALUE img_labq_to_labs(VALUE);
+VALUE img_labs_to_labq(VALUE);
+VALUE img_labs_to_lab(VALUE);
+VALUE img_ucs_to_xyz(VALUE);
+VALUE img_ucs_to_lch(VALUE);
+VALUE img_ucs_to_lab(VALUE);
+VALUE img_xyz_to_lab(VALUE);
+VALUE img_xyz_to_lab_temp(VALUE, VALUE, VALUE, VALUE);
+VALUE img_xyz_to_ucs(VALUE);
+VALUE img_srgb_to_xyz(VALUE);
+VALUE img_xyz_to_srgb(VALUE);
+VALUE img_yxy_to_xyz(VALUE);
+VALUE img_xyz_to_yxy(VALUE);
+VALUE img_decmc_from_lab(VALUE, VALUE);
+VALUE img_de00_from_lab(VALUE, VALUE);
+VALUE img_de_from_xyz(VALUE, VALUE);
+VALUE img_de_from_lab(VALUE, VALUE);
+VALUE img_lab_morph(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+VALUE img_icc_transform(VALUE, VALUE, VALUE, VALUE);
+VALUE img_icc_import(VALUE, VALUE, VALUE);
+VALUE img_icc_import_embedded(VALUE, VALUE);
+VALUE img_icc_export_depth(VALUE, VALUE, VALUE, VALUE);
+VALUE img_icc_ac2rc(VALUE, VALUE, VALUE);
+void init_Image_colour();

data/ext/image_conversion.c

@@ -0,0 +1,863 @@
+#include "ruby_vips.h"
+#include "image.h"
+#include "mask.h"
+#include "header.h"
+
+static ID id_black, id_extend, id_repeat, id_mirror, id_white;
+
+/*
+ *  call-seq:
+ *     im.to_mask -> mask
+ *
+ *  Make a mask from an image. All images are cast to band format :DOUBLE
+ *  before processing. There are two cases for handling bands:
+ *
+ *  If the image has a single band, Image#to_mask will write a mask the same
+ *  size as the image.
+ *
+ *  If the image has more than one band, it must be one pixel high or wide. In
+ *  this case the output mask uses that axis to represent band values.
+ */
+
+VALUE
+img_to_mask(VALUE obj)
+{
+    vipsMask *msk;
+    VALUE mask = mask_alloc(cVIPSMask);
+	GetImg(obj, data, im);
+
+    Data_Get_Struct(mask, vipsMask, msk);
+
+    if (!(msk->dmask = im_vips2mask(im, "img_vips2mask")))
+        vips_lib_error();
+
+    return mask;
+}
+
+/*
+ *  call-seq:
+ *     im.dup -> image
+ *
+ *  Create a copy of an image.
+ */
+
+VALUE
+img_dup(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_copy);
+}
+
+/*
+ *  call-seq:
+ *     im.copy_swap -> image
+ *
+ *  Copy an image, swapping byte order between little and big endian. This
+ *  really does change image pixels and does not just alter the header.
+ */
+
+VALUE
+img_copy_swap(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_copy_swap);
+}
+
+/*
+ *  call-seq:
+ *     im.copy_native -> image
+ *
+ *  Copy an image to native order, that is, the order for the executing program.
+ */
+
+VALUE
+img_copy_native(VALUE obj, VALUE input_msb_first)
+{
+#if IM_MAJOR_VERSION > 7 || IM_MINOR_VERSION >= 22
+    vipsImg *in, *out;
+    int msb_first;
+
+    VALUE new = img_spawn(obj);
+
+    Data_Get_Struct(obj, vipsImg, in);
+    Data_Get_Struct(new, vipsImg, out);
+
+    msb_first = input_msb_first == Qtrue ? TRUE : FALSE;
+    if( im_copy_native(in->in, out->in, msb_first) )
+        vips_lib_error();
+
+    return new;
+#else
+    rb_raise(eVIPSError, "Your version of vips doesn't support this operation");
+#endif
+}
+
+/*
+ *  call-seq:
+ *     im.copy_file -> image
+ *
+ *  Copy an image to a disc file, then copy again to output. If the image is
+ *  already a disc file, just copy straight through.
+ *
+ *  The file is automatically deleted when <i>image</i> is closed.
+ */
+
+VALUE
+img_copy_file(VALUE obj)
+{
+    vipsImg *in, *out;
+
+    VALUE new = img_spawn(obj);
+
+    Data_Get_Struct(obj, vipsImg, in);
+    Data_Get_Struct(new, vipsImg, out);
+
+    if( im_copy_file(in->in, out->in) )
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.clip2fmt(fmt_symbol) -> image
+ *
+ *  Convert the image to <i>fmt_symbol</i> format. You can convert between any
+ *  pair of formats. Floats are truncated (not rounded). Out of range values are
+ *  clipped.
+ *
+ *  <i>fmt_symbol</i> can be any of: :NOTSET, :UCHAR, :CHAR, :USHORT, :SHORT,
+ *  :UINT, :INT, :FLOAT, :COMPLEX, :DOUBLE, :DPCOMPLEX.
+ */
+
+VALUE
+img_clip2fmt(VALUE obj, VALUE fmt)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_clip2fmt(im, im_new, header_id_to_band_fmt(SYM2ID(fmt))))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.scale -> image
+ *
+ *  Search the image for the maximum and minimum value, then return the image
+ *  as unsigned 8-bit, scaled so that the maximum value is 255 and the
+ *  minimum is zero.
+ */
+
+VALUE
+img_scale(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_scale);
+}
+
+/*
+ *  call-seq:
+ *     im.msb([band]) -> image
+ *
+ *  Turn any integer image to 8-bit unsigned char by discarding all but the most
+ *  significant byte. Signed values are converted to unsigned by adding 128.
+ *
+ *  This operator also works for LABQ coding.
+ *
+ *  If <i>band</i> is given, this will turn any integer image to a single-band'
+ *  8-bit unsigned char by discarding all but the most significant byte from the
+ *  selected band.
+ */
+
+VALUE
+img_msb(int argc, VALUE *argv, VALUE obj)
+{
+	VALUE v_num;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	rb_scan_args(argc, argv, "01", &v_num);
+
+	if (NIL_P(v_num)) {
+		if (im_msb(im, im_new))
+			vips_lib_error();
+	} else if (im_msb_band(im, im_new, NUM2INT(v_num)))
+		vips_lib_error();
+	
+	return new;
+}
+
+/*
+ *  call-seq:
+ *     im.c2amph -> image
+ *
+ *  Convert a complex image from rectangular to polar coordinates. Angles are
+ *  expressed in degrees.
+ */
+
+VALUE
+img_c2amph(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_c2amph);
+}
+
+/*
+ *  call-seq:
+ *     im.c2rect -> image
+ *
+ *  Convert a complex image from polar to rectangular coordinates. Angles are
+ *  expressed in degrees.
+ */
+
+VALUE
+img_c2rect(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_c2rect);
+}
+
+/*
+ *  call-seq:
+ *     im.ri2c(other_image) -> image
+ *
+ *  Compose two real images to make a complex image. If either image has band
+ *  format :DOUBLE, the output image is band format :DPCOMPLEX. Otherwise the
+ *  output image is :COMPLEX.
+ *
+ *  If the number of bands differs, one of the images must have one band. In
+ *  this case, an n-band image is formed from the one-band image by joining n
+ *  copies of the one-band image together, and then the two n-band images are
+ *  operated upon.
+ *
+ *  The two input images are cast up to the smallest common type.
+ */
+
+VALUE
+img_ri2c(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_ri2c);
+}
+
+/*
+ *  call-seq:
+ *     im.c2imag -> image
+ *
+ *  Extract the imaginary part of a complex image.
+ */
+
+VALUE
+img_c2imag(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_c2imag);
+}
+
+/*
+ *  call-seq:
+ *     im.c2real -> image
+ *
+ *  Extract the real part of a complex image.
+ */
+
+VALUE
+img_c2real(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_c2real);
+}
+
+/*
+ *  call-seq:
+ *     im.scaleps -> image
+ *
+ *  Scale a power spectrum. Transform with log10(1.0 + x ** 0.25)) + 0.5,
+ *  then scale so max == 255.
+ */
+
+VALUE
+img_scaleps(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_scaleps);
+}
+
+/*
+ *  call-seq:
+ *    im.falsecolour -> image
+ *
+ *  Turn a 1-band 8-bit image into a 3-band 8-bit image with a false colour
+ *  map. The map is supposed to make small differences in brightness more
+ *  obvious.
+ */
+
+VALUE
+img_falsecolour(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_falsecolour);
+}
+
+/*
+ *  call-seq:
+ *     Image.gaussnoise(width, height, mean, sigma) -> image
+ *
+ *  Make a one band float image of gaussian noise with the specified
+ *  distribution. The noise distribution is created by averaging 12 random
+ *  numbers with the appropriate weights.
+ */
+
+VALUE
+img_s_gaussnoise(VALUE obj, VALUE x, VALUE y, VALUE mean, VALUE sigma)
+{
+	OutPartial(new, data, im_new);
+
+    if (im_gaussnoise(im_new, NUM2INT(x), NUM2INT(y), NUM2DBL(mean),
+        NUM2DBL(sigma)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.black(width, height, bands) -> image
+ *
+ *  Make a black unsigned char image of a specified size.
+ */
+
+VALUE
+img_s_black(VALUE obj, VALUE width, VALUE height, VALUE bands)
+{
+	OutPartial(new, data, im_new);
+
+    if (im_black(im_new, NUM2INT(width), NUM2INT(height), NUM2DBL(bands)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.text(text, font, width, alignment, dpi) -> image
+ *
+ *  Draw the string <i>text</i> to an image. @out is a one-band 8-bit
+ *  unsigned char image, with 0 for no text and 255 for text. Values inbetween
+ *  are used for anti-aliasing.
+ *
+ *  <i>text</i> is the text to render as a UTF-8 string. It can contain Pango
+ *  markup, for example "&lt;i&gt;The&lt;/i&gt;Guardian".
+ *
+ *  <i>font</i> is the font to render with, selected by fontconfig. Examples
+ *  might be "sans 12" or perhaps "bitstream charter bold 10".
+ *
+ *  <i>width</i> is the maximum number of pixels across to draw within. If the
+ *  generated text is wider than this, it will wrap to a new line. In this
+ *  case, <i>alignment</i> can be used to set the alignment style for multi-line
+ *  text. 0 means left-align, 1 centre, 2 right-align.
+ *
+ *  <i>dpi</i> sets the resolution to render at. "sans 12" at 72 dpi draws
+ *  characters approximately 12 pixels high.
+ */
+
+VALUE
+img_s_text(VALUE obj, VALUE text, VALUE font, VALUE width,
+    VALUE alignment, VALUE dpi)
+{
+	OutPartial(new, data, im_new);
+
+    if (im_text(im_new, StringValuePtr(text), StringValuePtr(font),
+		NUM2INT(width), NUM2INT(alignment), NUM2INT(dpi)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.extract_band(band [,num_bands]) -> image
+ *
+ *  Extract the band given by <i>band</i> from the image. If <i>num_bands</i> is
+ *  given, extract that many bands. Bands number from zero.
+ *
+ *    im.extract_band(0, 2) # => new image with bands 0 & 1 from original.
+ *
+ *  Extracting bands outside the input image will trigger an error.
+ */
+
+VALUE
+img_extract_band(int argc, VALUE *argv, VALUE obj)
+{
+	VALUE v_start_band, v_num_bands;
+	int num_bands;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	rb_scan_args(argc, argv, "11", &v_start_band, &v_num_bands);
+	num_bands = NIL_P(v_num_bands) ? 1 : NUM2INT(v_num_bands);
+
+	if (im_extract_bands(im, im_new, NUM2INT(v_start_band), num_bands))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.extract_area(left, top, width, height)                    -> image
+ *     im.extract_area(left, top, width, height, band [,num_bands]) -> image
+ *
+ *  The first form will extract an area from an image.
+ *
+ *  The second form will extract an area and a number of bands from an image.
+ *  Bands number from zero. Extracting outside the input image will trigger an
+ *  error.
+ */
+
+VALUE
+img_extract_area(int argc, VALUE *argv, VALUE obj)
+{
+	VALUE v_left, v_top, v_width, v_height, v_start_band, v_num_bands;
+	int start_band, num_bands;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	rb_scan_args(argc, argv, "42", &v_left, &v_top, &v_width, &v_height,
+		&v_start_band, &v_num_bands);
+
+	/* Start band defaults to the first band */
+	start_band = NIL_P(v_start_band) ? 0 : NUM2INT(v_start_band);
+	
+	/* Number of bands defaults to all bands or the selected band.
+	 */
+	if (NIL_P(v_num_bands))
+		num_bands = NIL_P(v_start_band) ? im->Bands : 1;
+	else
+		num_bands = NUM2INT(v_num_bands);
+	
+    if (im_extract_areabands(im, im_new, NUM2INT(v_left), NUM2INT(v_top),
+        NUM2INT(v_width), NUM2INT(v_height), start_band, num_bands))
+        vips_lib_error();
+
+    return new;  
+}
+
+/*
+ *  call-seq:
+ *     im.embed(type_sym, x, y, width, height) -> image
+ *
+ *  The opposite of Image#extract: embed an image within a larger image.
+ *  <i>type_sym</i> controls what appears in the new pixels:
+ *
+ *  * :black - black pels (all bytes == 0)
+ *  * :extend - extend pels from image edge
+ *  * :repeat - repeat image
+ *  * :mirror - mirror image
+ *  * :white - white pixels (all bytes == 255)
+ */
+
+VALUE
+img_embed(VALUE obj, VALUE type_v, VALUE x, VALUE y, VALUE width, VALUE height)
+{
+    ID type_id = SYM2ID(type_v);
+    int type;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if      (type_id == id_black)  type = 0;
+    else if (type_id == id_extend) type = 1;
+    else if (type_id == id_repeat) type = 2;
+    else if (type_id == id_mirror) type = 3;
+    else if (type_id == id_white)  type = 4;
+    else
+        rb_raise(rb_eArgError, "Extend type must be :black, :extend, :repeat, :mirror, :white");
+
+    if (im_embed(im, im_new, type, NUM2INT(x), NUM2INT(y), NUM2INT(width),
+        NUM2INT(height)))
+        vips_lib_error();
+
+    return new;  
+}
+
+/*
+ *  call-seq:
+ *     im.bandjoin(other_image, ...) -> image
+ *
+ *  Join a set of images together, bandwise. If the images have n and m bands,
+ *  then the output image will have n + m bands, with the first n coming from
+ *  the first image and the last m from the second.
+ *
+ *  The images must be the same size. The input images are cast up to the
+ *  smallest common type.
+ */
+
+VALUE
+img_bandjoin(int argc, VALUE *argv, VALUE obj)
+{
+	vipsImg *im_t;
+    IMAGE **ins;
+    int i;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	if(argc == 0)
+		rb_raise(rb_eArgError, "Need at least one argument");
+
+    ins = IM_ARRAY(im_new, argc + 1, IMAGE*);
+	ins[0] = im;
+
+    for (i = 0; i < argc; i++) {
+		img_add_dep(data_new, argv[i]);
+        Data_Get_Struct(argv[i], vipsImg, im_t);
+        ins[i + 1] = im_t->in;
+    }
+
+    if (im_gbandjoin(ins, im_new, argc + 1))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.insert_noexpand(other_image, x, y) -> image
+ *
+ *  Insert one image into another. <i>other_image</i> is inserted into *self* at
+ *  position <i>x</i>, <i>y</i> relative to the top LH corner of *self*. The
+ *  output image is the same size as *self*. <i>other_image</i> is clipped
+ *  against the edges of *self*.
+ *
+ *  If the number of bands differs, one of the images must have one band. In
+ *  this case, an n-band image is formed from the one-band image by joining n
+ *  copies of the one-band image together, and then the two n-band images are
+ *  operated upon.
+ *
+ *  The two input images are cast up to the smallest common type.
+ */
+
+VALUE
+img_insert_noexpand(VALUE obj, VALUE obj2, VALUE x, VALUE y)
+{
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg2(obj, obj2, new, data_new, im_new);
+
+    if (im_insert_noexpand(im, im2, im_new, NUM2INT(x), NUM2INT(y)))
+        vips_lib_error();
+
+    return new;
+}
+
+static VALUE
+img_insert_one(VALUE obj, VALUE obj2, VALUE x, VALUE y)
+{
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg2(obj, obj2, new, data_new, im_new);
+
+    if (im_insert(im, im2, im_new, NUM2INT(x), NUM2INT(y)))
+        vips_lib_error();
+
+    return new;
+}
+
+static VALUE
+img_insertset(int argc, VALUE *argv, VALUE obj, VALUE obj2)
+{
+	int i, *x, *y;
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg2(obj, obj2, new, data_new, im_new);
+
+    x = IM_ARRAY(im_new, argc - 1, int);
+    y = IM_ARRAY(im_new, argc - 1, int);
+
+    for(i = 1; i < argc; i++) {
+        x[i] = NUM2INT(RARRAY_PTR(argv[i])[0]);
+        y[i] = NUM2INT(RARRAY_PTR(argv[i])[1]);
+    }
+
+    if( im_insertset(im, im2, im_new, argc - 1, x, y) )
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.insert(other_image, x, y)             -> image
+ *     im.insert(other_image, coordinates, ...) -> image
+ *
+ *  Insert <i>other_image</i> repeatedly into *self* at the positions listed in
+ *  the <i>coordinates</i> arrays. These arrays should contain x and y
+ *  coordinates:
+ *
+ *    im.insert(other_image, 100, 100) # => other_image inserted once at 100, 100
+ *    im.insert(other_image, [12, 20], [32, 22]) # => inserted twice at given coordinates
+ *  The output image is the same size as *self*. <i>other_image</i> is clipped
+ *  against the edges of *self*.
+ *
+ *  This operation is fast for large @n, but will use a memory buffer the size
+ *  of the output image. It's useful for things like making scatter plots.
+ *
+ *  If the number of bands differs, one of the images must have one band. In
+ *  this case, an n-band image is formed from the one-band image by joining n
+ *  copies of the one-band image together, and then the two n-band images are
+ *  operated upon.
+ *
+ *  The two input images are cast up to the smallest common type.
+ */
+
+VALUE
+img_insert(int argc, VALUE *argv, VALUE obj)
+{
+	VALUE obj2, x_or_ary, y_or_arys;
+
+	rb_scan_args(argc, argv, "2*", &obj2, &x_or_ary, &y_or_arys);
+
+	if (TYPE(x_or_ary) == T_ARRAY) {
+		if (!NIL_P(y_or_arys))
+			rb_ary_unshift(y_or_arys, x_or_ary);
+
+		return img_insertset(RARRAY_LEN(y_or_arys), RARRAY_PTR(y_or_arys), obj,
+			obj2);
+	}
+
+	if (RARRAY_LEN(y_or_arys) != 1)
+		rb_raise(rb_eArgError,
+			"Need two coordinates or an array of coordinates");
+
+	return img_insert_one(obj, obj2, x_or_ary, RARRAY_PTR(y_or_arys)[0]);
+}
+
+/*
+ *  call-seq:
+ *     im.lrjoin(other_image) -> image
+ *
+ *  Join *self* and <i>other_image</i> together, left-right. If one is taller
+ *  than the other, the output image will be as high as the smaller image.
+ *
+ *  If the number of bands differs, one of the images must have one band. In
+ *  this case, an n-band image is formed from the one-band image by joining n
+ *  copies of the one-band image together, and then the two n-band images are
+ *  operated upon.
+ *
+ *  The two input images are cast up to the smallest common type.
+ */
+
+VALUE
+img_lrjoin(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_lrjoin);
+}
+
+/*
+ *  call-seq:
+ *     im.tbjoin(other_image) -> image
+ *
+ *  Join *self* and <i>other_image</i> together, top-bottom. If one is taller
+ *  than the other, the output image will be as high as the smaller image.
+ *
+ *  If the number of bands differs, one of the images must have one band. In
+ *  this case, an n-band image is formed from the one-band image by joining n
+ *  copies of the one-band image together, and then the two n-band images are
+ *  operated upon.
+ *
+ *  The two input images are cast up to the smallest common type.
+ */
+
+VALUE
+img_tbjoin(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_tbjoin);
+}
+
+/*
+ *  call-seq:
+ *     im.replicate(across, down) -> image
+ *
+ *  Replicate an image <i>across</i> times horizontally <i>down</i> times
+ *  vertically.
+ */
+
+VALUE
+img_replicate(VALUE obj, VALUE across, VALUE down)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_replicate(im, im_new, NUM2INT(across), NUM2INT(down)))
+        vips_lib_error();
+
+    return new;  
+}
+
+/*
+ *  call-seq:
+ *     im.grid(tile_height, across, down) -> image
+ *
+ *  Chop a tall thin image up into a set of tiles, lay the tiles out in a grid.
+ *
+ *  *self* should be a very tall, thin image containing a list of smaller
+ *  images. Volumetric or time-sequence images are often laid out like this.
+ *  This image is chopped into a series of tiles, each <i>tile_height</i> pixels'
+ *  high and the width of *self*. The tiles are then rearranged into a grid
+ *  <i>across</i> tiles across and <i>down</i> tiles down in row-major order.
+ */
+
+VALUE
+img_grid(VALUE obj, VALUE tile_height, VALUE across, VALUE down)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_grid(im, im_new, NUM2INT(tile_height), NUM2INT(across),
+		NUM2INT(down)))
+        vips_lib_error();
+
+    return new;  
+}
+
+/*
+ *  call-seq:
+ *     im.wrap(x, y) -> image
+ *
+ *  Slice an image up and move the segments about so that the pixel that was
+ *  at 0, 0 is now at <i>x</i>, <i>y</i>.
+ */
+
+VALUE
+img_wrap(VALUE obj, VALUE x, VALUE y)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_wrap(im, im_new, NUM2INT(x), NUM2INT(y)))
+        vips_lib_error();
+
+    return new;  
+}
+
+/*
+ *  call-seq:
+ *     im.fliphor -> image
+ *
+ *  Flips an image left-right.
+ */
+
+VALUE
+img_fliphor(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_fliphor);
+}
+
+/*
+ *  call-seq:
+ *     im.flipver -> image
+ *
+ *  Flips an image top-bottom.
+ */
+
+VALUE
+img_flipver(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_flipver);
+}
+
+/*
+ *  call-seq:
+ *     im.rot90 -> image
+ *
+ *  Rotate an image 90 degrees.
+ */
+
+VALUE
+img_rot90(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_rot90);
+}
+
+/*
+ *  call-seq:
+ *     im.rot180 -> image
+ *
+ *  Rotate an image 180 degrees.
+ */
+
+VALUE
+img_rot180(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_rot180);
+}
+
+/*
+ *  call-seq:
+ *     im.rot270 -> image
+ *
+ *  Rotate an image 270 degrees.
+ */
+
+VALUE
+img_rot270(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_rot270);
+}
+
+/*
+ *  call-seq:
+ *     im.subsample(x [,y]) -> image
+ *
+ *  Subsample an image by an integer fraction. This is fast nearest-neighbour
+ *  shrink.
+ *
+ *  If only one integer is given the width and height are subsampled equally.
+ */
+
+VALUE
+img_subsample(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE x, y;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	rb_scan_args(argc, argv, "11", &x, &y);
+    if (NIL_P(y))
+        y = x;
+    
+    if (im_subsample(im, im_new, NUM2INT(x), NUM2INT(y)))
+        vips_lib_error();
+
+    return new;  
+}
+
+/*
+ *  call-seq:
+ *     im.zoom(x [,y]) -> image
+ *
+ *  Zoom an image by repeating pixels. This is fast nearest-neighbour
+ *  zoom.
+ *
+ *  If only one integer is given the width and height are zoomed equally.
+ */
+
+VALUE
+img_zoom(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE x, y;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	rb_scan_args(argc, argv, "11", &x, &y);
+    if (NIL_P(y))
+        y = x;
+
+    if (im_zoom(im, im_new, NUM2INT(x), NUM2INT(y)))
+        vips_lib_error();
+
+    return new;
+}
+
+void
+init_Image_conversion()
+{
+    id_black = rb_intern("black");
+    id_extend = rb_intern("extend");
+    id_repeat = rb_intern("repeat");
+    id_mirror = rb_intern("mirror");
+    id_white = rb_intern("white");
+}
+