ruby-vips 0.1.1

data/ext/image_histograms_lut.h

@@ -0,0 +1,28 @@
+VALUE img_histgr(int, VALUE*, VALUE);
+VALUE img_histnd(VALUE, VALUE);
+VALUE img_hist_indexed(VALUE, VALUE);
+VALUE img_s_identity(VALUE, VALUE);
+VALUE img_s_identity_ushort(VALUE, VALUE, VALUE);
+VALUE img_s_invertlut(VALUE, VALUE, VALUE);
+VALUE img_s_buildlut(VALUE, VALUE);
+VALUE img_project(VALUE);
+VALUE img_histnorm(VALUE);
+VALUE img_histcum(VALUE);
+VALUE img_histeq(VALUE);
+VALUE img_histspec(VALUE, VALUE);
+VALUE img_maplut(VALUE, VALUE);
+VALUE img_histplot(VALUE);
+VALUE img_monotonic_p(VALUE);
+VALUE img_hist(int, VALUE*, VALUE);
+VALUE img_hsp(VALUE, VALUE);
+VALUE img_gammacorrect(VALUE, VALUE);
+VALUE img_mpercent_hist(VALUE, VALUE);
+VALUE img_mpercent(VALUE, VALUE);
+VALUE img_heq(int, VALUE*, VALUE);
+VALUE img_lhisteq(VALUE, VALUE, VALUE);
+VALUE img_stdif(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+VALUE img_s_tone_build_range(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE,
+	VALUE, VALUE, VALUE, VALUE);
+VALUE img_s_tone_build(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE,
+	VALUE);
+VALUE img_tone_analyze(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);

data/ext/image_morphology.c

@@ -0,0 +1,330 @@
+#include "ruby_vips.h"
+#include "image.h"
+#include "mask.h"
+#include "image_morphology.h"
+
+/*
+ *  call-seq:
+ *     im.dilate(mask) -> image
+ *
+ *  Dilates *self*, according to <i>mask</i>. The output image is the same size
+ *  as the input. Sets pixels in the output if *any* part of the mask matches.
+ *
+ *  *self* must be a one channel binary image ie. with pixels that are either 0
+ *  (black) or 255 (white). This method assume that *self* contains white
+ *  objects against a black background.
+ *
+ *  <i>mask</i> can be a two-dimensional array or a Mask object. All mask values
+ *  must be integers or this method will raise an exception.
+ *
+ *  Mask coefficients can be either 0 (for object) or 255 (for background) or
+ *  128 (for do not care). The mask should have odd length sides and the origin
+ *  of the mask is at location (mask_columns/2, mask_rows/2) integer division.
+ *
+ *  Based on the book "Fundamentals of Digital Image Processing" by A.  Jain,
+ *  pp 384-388, Prentice-Hall, 1989.
+ */
+
+VALUE
+img_dilate(VALUE obj, VALUE mask)
+{
+    INTMASK *imask;
+
+	GetImg(obj, data, im);
+	OutImg2(obj, mask, new, data_new, im_new);
+
+    mask_arg2mask(mask, &imask, NULL);
+
+    if (im_dilate(im, im_new, imask))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.erode(mask) -> image
+ *
+ *  Erodes *self*, according to <i>mask</i>. The output image is the same size
+ *  as the input. Sets pixels in the output if *all* part of the mask matches.
+ *
+ *  *self* must be a one channel binary image ie. with pixels that are either 0
+ *  (black) or 255 (white). This method assume that *self* contains white
+ *  objects against a black background.
+ *
+ *  <i>mask</i> can be a two-dimensional array or a Mask object. All mask values
+ *  must be integers or this method will raise an exception.
+ *
+ *  Mask coefficients can be either 0 (for object) or 255 (for background) or
+ *  128 (for do not care). The mask should have odd length sides and the origin
+ *  of the mask is at location (mask_columns/2, mask_rows/2) integer division.
+ *
+ *  Based on the book "Fundamentals of Digital Image Processing" by A.  Jain,
+ *  pp 384-388, Prentice-Hall, 1989.
+ */
+
+VALUE
+img_erode(VALUE obj, VALUE mask)
+{
+    INTMASK *imask;
+
+	GetImg(obj, data, im);
+	OutImg2(obj, mask, new, data_new, im_new);
+
+    mask_arg2mask(mask, &imask, NULL);
+
+    if (im_erode(im, im_new, imask))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.rank(xsize, ysize, n) -> image
+ *
+ *  Does rank filtering on an image. A window of size <i>xsize</i> by
+ *  <i>ysize</i> is passed over the image. At each position, the pixels inside
+ *  the window are sorted into ascending order and the pixel at the <i>n</i>th
+ *  position is output. <i>n</i> numbers from 0.
+ *
+ *  It works for any non-complex image type, with any number of bands. The input
+ *  is expanded by copying edge pixels before performing the operation so that
+ *  the output image has the same size as *self*. Edge pixels in the output
+ *  image are therefore only approximate.
+ */
+
+VALUE
+img_rank(VALUE obj, VALUE xsize, VALUE ysize, VALUE order)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_rank(im, im_new, NUM2INT(xsize), NUM2INT(ysize), NUM2INT(order)))
+        vips_lib_error();
+
+    return new;
+}
+
+VALUE
+img_rank_image_internal(int argc, VALUE *argv, VALUE obj, int index)
+{
+	vipsImg *im_t;
+    IMAGE **ins;
+    int i;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    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_rank_image(ins, im_new, argc + 1, index))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.rank_image(index, other_image, ...)
+ *
+ *  Sorts the input images pixel-wise, then outputs an image in which each pixel
+ *  is selected from the sorted list by <i>index</i> parameter. For example, if
+ *  <i>index</i> is zero, then each output pixel will be the minimum of all the
+ *  corresponding input pixels.
+ *
+ *  It works for any uncoded, non-complex image type. All input images must
+ *  match in size, format, and number of bands.
+ */
+
+VALUE
+img_rank_image(int argc, VALUE *argv, VALUE obj)
+{
+	VALUE index, *images;
+	if (argc < 2)
+		rb_raise(rb_eArgError, "Need an index and at least one image");
+
+	index = argv[0];
+	images = RARRAY_PTR(rb_ary_new4(argc - 1, argv + 1));
+
+	return img_rank_image_internal(argc - 1, images, obj, NUM2INT(index));
+}
+
+/*
+ *  call-seq:
+ *     im.maxvalue(other_image, ...) -> image
+ *
+ *  Sorts the input images pixel-wise, then outputs an image in which each pixel
+ *  is the maximum from the input pixels.
+ *
+ *  It works for any uncoded, non-complex image type. All input images must
+ *  match in size, format, and number of bands.
+ */
+
+VALUE
+img_maxvalue(int argc, VALUE *argv, VALUE obj)
+{
+	img_rank_image_internal(argc, argv, obj, argc - 1);
+}
+
+static VALUE
+img_cntlines(VALUE obj, int flag) {
+    double nolines;
+	GetImg(obj, data, im);
+    
+    if (im_cntlines(im, &nolines, flag))
+        vips_lib_error();
+
+    return DBL2NUM(nolines);
+}
+
+/*
+ *  call-seq:
+ *     im.cntlines_h -> number
+ *
+ *  Calculates the number of transitions between black and white for the
+ *  horizontal direction of an image. black is < 128, and white is >= 128.
+ *
+ *  Returns the mean of the result. Input should be binary one channel.
+ */
+
+VALUE
+img_cntlines_h(VALUE obj) {
+	return img_cntlines(obj, 0);
+}
+
+/*
+ *  call-seq:
+ *     im.cntlines_v -> number
+ *
+ *  Calculates the number of transitions between black and white for the
+ *  vertical direction of an image. black is < 128, and white is >= 128.
+ *
+ *  Returns the mean of the result. Input should be binary one channel.
+ */
+
+VALUE
+img_cntlines_v(VALUE obj) {
+	return img_cntlines(obj, 1);
+}
+
+static VALUE
+img_zerox(VALUE obj, int flag)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_zerox(im, im_new, flag))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.zerox_pos -> image
+ *
+ * Detects the +ve edges of zero crossings of *self*. Works on integer images.
+ * The output image is byte with zero crossing set to 255 and all other values
+ * set to zero.
+ */
+
+VALUE
+img_zerox_pos(VALUE obj)
+{
+    return img_zerox(obj, 1);
+}
+
+/*
+ *  call-seq:
+ *     im.zerox_neg -> image
+ *
+ * Detects the -ve edges of zero crossings of *self*. Works on integer images.
+ * The output image is byte with zero crossing set to 255 and all other values
+ * set to zero.
+ */
+
+VALUE
+img_zerox_neg(VALUE obj)
+{
+    return img_zerox(obj, -1);
+}
+
+static VALUE
+img_profile(VALUE obj, int dir)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_profile(im, im_new, dir))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.profile_h -> image
+ *
+ *  For each horizontal line, find the position of the first non-zero pixel from
+ *  the left. Output is USHORT with width = 1 and height = input height.
+ */
+
+VALUE
+img_profile_h(VALUE obj)
+{
+	return img_profile(obj, 1);
+}
+
+/*
+ *  call-seq:
+ *     im.profile_v -> image
+ *
+ *  For each vertical line, find the position of the first non-zero pixel from
+ *  the top. Output is USHORT with width = input width and height = 1.
+ */
+
+VALUE
+img_profile_v(VALUE obj)
+{
+	return img_profile(obj, 0);
+}
+
+/*
+ *  call-seq:
+ *     im.label_regions -> image, segments
+ *
+ *  *self* is repeatedly scanned and regions of 4-connected pixels with the same
+ *  pixel value found. Every time a region is discovered, those pixels are
+ *  marked in the output image with a unique serial number. Once all pixels have
+ *  been labelled, the operation returns, returning an an image and
+ *  <i>segments</i>, the number of discrete regions which were detected.
+ *
+ *  The output image is always a 1-band image with band format :UINT, and of the
+ *  same dimensions as *self*.
+ *
+ *  This operation is useful for, for example, blob counting. You can use the
+ *  morphological operators to detect and isolate a series of objects, then use
+ *  this method to number them all.
+ *
+ *  Use Image#histindexed to (for example) find blob coordinates.
+ */
+
+VALUE
+img_label_regions(VALUE obj)
+{
+	int segments;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_label_regions(im, im_new, &segments))
+        vips_lib_error();
+
+    return rb_ary_new3(2, new, segments);
+}

data/ext/image_morphology.h

@@ -0,0 +1,13 @@
+VALUE img_dilate(VALUE, VALUE);
+VALUE img_erode(VALUE, VALUE);
+VALUE img_rank(VALUE, VALUE, VALUE, VALUE);
+VALUE img_rank_image_internal(int, VALUE*, VALUE, int);
+VALUE img_rank_image(int, VALUE*, VALUE);
+VALUE img_maxvalue(int, VALUE*, VALUE);
+VALUE img_cntlines_h(VALUE);
+VALUE img_cntlines_v(VALUE);
+VALUE img_zerox_pos(VALUE);
+VALUE img_zerox_neg(VALUE);
+VALUE img_profile_h(VALUE);
+VALUE img_profile_v(VALUE);
+VALUE img_label_regions(VALUE);

data/ext/image_mosaicing.c

@@ -0,0 +1,556 @@
+#include "ruby_vips.h"
+#include "image.h"
+#include "image_mosaicing.h"
+
+ID id_match_left, id_match_right, id_match_both, id_match_none;
+
+/*
+ *  call-seq:
+ *     im.lrmerge(other_image, dx, dy [,mwidth]) -> image
+ *
+ *  Merge *self* as the reference image and <i>other_image</i> as the secondary
+ *  image according to the values <i>dx</i> and <i>dy</i>. <i>dx</i> and
+ *  <i>dy</i> give the displacement of <i>other_image</i> relative to *self*.
+ *  The result is written to the output image.
+ *
+ *  The program carries out a smooth merge using a raised cosine function.
+ *  Works for any image type, including LABPACK.
+ *
+ *  Pixels are treated with the value zero as "transparent", that is, zero
+ *  pixels in the overlap area do not contribute to the merge. This makes it
+ *  possible to join non-rectangular images.
+ *
+ *  The "mwidth" parameter limits the maximum width of the blend area. If not
+ *  given, the width will be unlimited.
+ */
+
+VALUE
+img_lrmerge(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE obj2, dx, dy, mwidth_v;
+    int mwidth = -1;
+
+    rb_scan_args(argc, argv, "31", &obj2, &dx, &dy, &mwidth_v);
+    if (!NIL_P(mwidth_v))
+        mwidth = NUM2INT(mwidth_v);
+
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg2(obj, obj2, new, data_new, im_new);
+
+    if (im_lrmerge(im, im2, im_new, NUM2INT(dx), NUM2INT(dy), mwidth))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.tbmerge(other_image, dx, dy [,mheight]) -> image
+ *
+ *  see Image#lrmerge .
+ */
+
+VALUE
+img_tbmerge(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE obj2, dx, dy, mwidth_v;
+    int mwidth = -1;
+
+    rb_scan_args(argc, argv, "31", &obj2, &dx, &dy, &mwidth_v);
+    if (!NIL_P(mwidth_v))
+        mwidth = NUM2INT(mwidth_v);
+
+    GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg2(obj, obj2, new, data_new, im_new);
+
+    if (im_tbmerge(im, im2, im_new, NUM2INT(dx), NUM2INT(dy), mwidth))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.lrmerge1(other_image, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2
+ *       [,mwidth]) -> image
+ * 
+ * 1st order left-right merge.
+ */
+
+VALUE
+img_lrmerge1(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE obj2, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, mwidth_v;
+    int mwidth = -1;
+
+    rb_scan_args(argc, argv, "91", &obj2, &xr1, &yr1, &xs1, &ys1, &xr2, &yr2,
+        &xs2, &ys2, &mwidth_v);
+    if (!NIL_P(mwidth_v))
+        mwidth = NUM2INT(mwidth_v);
+
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg2(obj, obj2, new, data_new, im_new);
+
+    if (im_lrmerge1(im, im2, im_new, NUM2INT(xr1), NUM2INT(yr1), NUM2INT(xs1),
+		NUM2INT(ys1), NUM2INT(xr2), NUM2INT(yr2), NUM2INT(xs2),	NUM2INT(ys2),
+		mwidth))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.tbmerge1(other_image, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2
+ *       [,mheight]) -> image
+ *
+ * 1st order top-bottom merge.
+ */
+
+VALUE
+img_tbmerge1(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE obj2, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2, mwidth_v;
+    int mwidth = -1;
+
+    rb_scan_args(argc, argv, "91", &obj2, &xr1, &yr1, &xs1, &ys1, &xr2, &yr2,
+        &xs2, &ys2, &mwidth_v);
+    if (!NIL_P(mwidth_v))
+        mwidth = NUM2INT(mwidth_v);
+
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg2(obj, obj2, new, data_new, im_new);
+
+    if (im_tbmerge1(im, im2, im_new, NUM2INT(xr1), NUM2INT(yr1), NUM2INT(xs1),
+		NUM2INT(ys1), NUM2INT(xr2), NUM2INT(yr2), NUM2INT(xs2), NUM2INT(ys2),
+		mwidth))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.lrmosaic(other_image, band, xref, yref, xsec, ysec,
+ *       halfcorrelation=5, halfarea=14 [,balancetype] [,mwidth]) -> image
+ *
+ *  Mosaic *self* and <i>other_image</i> left-right.
+ *
+ *  In order to carry out mosaicing, the coordinates of one tie point are
+ *  required.  The tie point is expected to be in the overlapping area and has
+ *  coordinates (<i>xref</i>, <i>yref</i>) on *self*, and (<i>xsec</i>,
+ *  <i>ysec</i>) on <i>other_image</i>. The tie-point is not used as a start
+ *  point for the search, but is used to specify the overlap of the two images.
+ *
+ *  The function splits the overlap area into three parts (top, middle and
+ *  bottom) and searches t*self* in each part for the 20 best high contrast
+ *  points. These 60 points are then searched for in <i>other_image</i>, giving
+ *  a set of 60 possible corrected vectors.
+ *
+ *  A straight line is fitted through the 60 vectors, and points discarded which
+ *  lie a significant distance from the line. The line is then refitted to the
+ *  remaining points, and the process repeated until either all remaining points
+ *  lie on a straight line, or too many points have been discarded.
+ *
+ *  If a good straight line fit is found, *self* and <i>other_image</i> are
+ *  joined. If no fit was found, the function fails with an error message. Note
+ *  that this function detects rotation: if the straight line found requires
+ *  <i>other_image</i> to be rotated, it also fails with an error message.
+ *
+ *  <i>halfcorrelationsize</i> - sets the size of the fragments of *self* for
+ *  which the function searches sec. The actual window will be of size
+ *  2 * <i>halfcorrelationsize</i> + 1. We recommend a value of 5.
+ *
+ *  <i>halfareasize</i> - sets the size of the area of sec that is searched. The
+ *  The actual area searched will be of size 2 * <i>halfareasize</i> + 1. We
+ *  recommend a value of 14.
+ *
+ *  <i>balancetype</i> - sets the style of the balancing the functions perform.
+ *  Balancing finds the average value of pixels in the overlap area, and scales
+ *  the left and right images so as to make the images match in average overlap.
+ *
+ *  * :balance_none - no balancing.
+ *  * :balance_left - keep the left image unadjusted and adjust the contrast of
+ *    the right image to match the left.
+ *  * :balance_right - keep the right image unadjusted and scale the left image
+ *    to match it.
+ *  * :balance_both - adjust the contrast of both the left and right images to
+ *    bring both averages to a middle value. The middle value chosen is weighted
+ *    by the number of pixels in each image: large images will be adjusted less
+ *    than small images.
+ *
+ *  Balancing is useful for mosaicing frames from photographic or video sources
+ *  where exact colour control is impossible and exposure varies from frame to
+ *  frame. Balancing is only allowed for uncoded uchar images.
+ * 
+ *  The <i>mwidth</i> parameter sets the maximum blend width, see Image#lrmerge.
+ */
+
+VALUE
+img_lrmosaic(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE obj2, bandno, xref, yref, xsec, ysec, halfcorrelation_v, halfarea_v,
+        balancetype_v, mwidth_v;
+    ID balancetype_id;
+    int mwidth = -1, halfcorrelation = 5, halfarea = 14, balancetype = 0;
+
+    rb_scan_args(argc, argv, "64", &obj2, &bandno, &xref, &yref, &xsec, &ysec,
+        &halfcorrelation_v, &halfarea_v, &balancetype_v, &mwidth_v);
+
+    if (!NIL_P(halfcorrelation_v))
+        halfcorrelation = NUM2INT(halfcorrelation_v);
+
+    if (!NIL_P(halfarea_v))
+        halfarea = NUM2INT(halfarea_v);
+
+    if (!NIL_P(balancetype_v)) {
+        balancetype_id = SYM2ID(balancetype_v);
+ if (balancetype_id == id_match_none) balancetype = 0;
+ else if (balancetype_id == id_match_left) balancetype = 1;
+        else if (balancetype_id == id_match_right) balancetype = 2;
+        else if (balancetype_id == id_match_both) balancetype = 3;
+        else
+            rb_raise(rb_eArgError, "Balance type must be nil, :match_left, :match_right, or :match_both");
+    }
+
+    if (!NIL_P(mwidth_v))
+        mwidth = NUM2INT(mwidth_v);
+
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg2(obj, obj2, new, data_new, im_new);
+
+    if (im_lrmosaic(im, im2, im_new, NUM2INT(bandno), NUM2INT(xref),
+		NUM2INT(yref), NUM2INT(xsec), NUM2INT(ysec), NUM2INT(halfcorrelation),
+		NUM2INT(halfarea), NUM2INT(balancetype), NUM2INT(mwidth)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.tbmosaic(other_image, band, xref, yref, xsec, ysec,
+ *       halfcorrelation=5, halfarea=14 [,balancetype] [,mheight]) -> image
+ *
+ *  Mosaic *self* and <i>other_image</i> top-bottom.
+ *
+ *  See Image#lrmosaic .
+ */
+
+VALUE
+img_tbmosaic(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE obj2, bandno, xref, yref, xsec, ysec, halfcorrelation_v, halfarea_v,
+        balancetype_v, mwidth_v;
+    ID balancetype_id;
+    int mwidth = -1, halfcorrelation = 5, halfarea = 14, balancetype = 0;
+
+    rb_scan_args(argc, argv, "64", &obj2, &bandno, &xref, &yref, &xsec, &ysec,
+        &halfcorrelation_v, &halfarea_v, &balancetype_v, &mwidth_v);
+
+    if (!NIL_P(halfcorrelation_v))
+        halfcorrelation = NUM2INT(halfcorrelation_v);
+
+    if (!NIL_P(halfarea_v))
+        halfarea = NUM2INT(halfarea_v);
+
+    if (!NIL_P(balancetype_v)) {
+        balancetype_id = SYM2ID(balancetype_v);
+
+        if (balancetype_id == id_match_left) balancetype = 1;
+        else if (balancetype_id == id_match_right) balancetype = 2;
+        else if (balancetype_id == id_match_both) balancetype = 3;
+        else
+            rb_raise(rb_eArgError, "Balance type must be nil, :match_left, :match_right, or :match_both");
+    }
+
+    if (!NIL_P(mwidth_v))
+        mwidth = NUM2INT(mwidth_v);
+
+    GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg2(obj, obj2, new, data_new, im_new);
+
+    if (im_tbmosaic(im, im2, im_new, NUM2INT(bandno), NUM2INT(xref),
+        NUM2INT(yref), NUM2INT(xsec), NUM2INT(ysec), halfcorrelation, halfarea,
+        balancetype, mwidth))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.lrmosaic1(other_image, band, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2,
+ *       halfcorrelation=5, halfarea=14 [,balancetype] [,mwidth]) -> image
+ *
+ *  1st order left-right mosaic.
+ */
+
+VALUE
+img_lrmosaic1(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE obj2, bandno, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2,
+        halfcorrelation_v, halfarea_v, balancetype_v, mwidth_v;
+    ID balancetype_id;
+    int mwidth = -1, halfcorrelation = 5, halfarea = 14, balancetype = 0;
+
+    rb_scan_args(argc, argv, "95", &obj2, &bandno, &xr1, &yr1, &xs1, &ys1, &xr2,
+        &yr2, &xs2, &ys2, &halfcorrelation_v, &halfarea_v, &balancetype_v,
+        &mwidth_v);
+    
+    if (argc < 10)
+        rb_raise(rb_eArgError, "Need at least 10 arguments.");
+
+    if (!NIL_P(halfcorrelation_v))
+        halfcorrelation = NUM2INT(halfcorrelation_v);
+
+    if (!NIL_P(halfarea_v))
+        halfarea = NUM2INT(halfarea_v);
+
+    if (!NIL_P(balancetype_v)) {
+        balancetype_id = SYM2ID(balancetype_v);
+
+        if (balancetype_id == id_match_left) balancetype = 1;
+        else if (balancetype_id == id_match_right) balancetype = 2;
+        else if (balancetype_id == id_match_both) balancetype = 3;
+        else
+            rb_raise(rb_eArgError, "Balance type must be nil, :match_left, :match_right, or :match_both");
+    }
+
+    if (!NIL_P(mwidth_v))
+        mwidth = NUM2INT(mwidth_v);
+
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg2(obj, obj2, new, data_new, im_new);
+
+    if (im_lrmosaic1(im, im2, im_new, NUM2INT(bandno), NUM2INT(xr1),
+		NUM2INT(yr1), NUM2INT(xs1), NUM2INT(ys1), NUM2INT(xr2), NUM2INT(yr2),
+		NUM2INT(xs2), NUM2INT(ys2), halfcorrelation, halfarea, balancetype,
+        mwidth))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.tbmosaic1(other_image, band, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2,
+ *       halfcorrelation=5, halfarea=14 [,balancetype] [,mheight]) -> image
+ *
+ *  1st order top-bottom mosaic.
+ */
+
+VALUE
+img_tbmosaic1(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE obj2, bandno, xr1, yr1, xs1, ys1, xr2, yr2, xs2, ys2,
+        halfcorrelation_v, halfarea_v, balancetype_v, mwidth_v;
+    ID balancetype_id;
+    int mwidth = -1, halfcorrelation = 5, halfarea = 14, balancetype = 0;
+
+    rb_scan_args(argc, argv, "95", &obj2, &bandno, &xr1, &yr1, &xs1, &ys1, &xr2,
+        &yr2, &xs2, &ys2, &halfcorrelation_v, &halfarea_v, &balancetype_v,
+        &mwidth_v);
+
+    if (argc < 10)
+        rb_raise(rb_eArgError, "Need at least 10 arguments.");
+
+    if (!NIL_P(halfcorrelation_v))
+        halfcorrelation = NUM2INT(halfcorrelation_v);
+
+    if (!NIL_P(halfarea_v))
+        halfarea = NUM2INT(halfarea_v);
+
+    if (!NIL_P(balancetype_v)) {
+        balancetype_id = SYM2ID(balancetype_v);
+
+        if (balancetype_id == id_match_left) balancetype = 1;
+        else if (balancetype_id == id_match_right) balancetype = 2;
+        else if (balancetype_id == id_match_both) balancetype = 3;
+        else
+            rb_raise(rb_eArgError, "Balance type must be nil, :match_left, :match_right, or :match_both");
+    }
+
+    if (!NIL_P(mwidth_v))
+        mwidth = NUM2INT(mwidth_v);
+
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg2(obj, obj2, new, data_new, im_new);
+
+    if (im_tbmosaic1(im, im2, im_new, NUM2INT(bandno), NUM2INT(xr1),
+		NUM2INT(yr1), NUM2INT(xs1), NUM2INT(ys1), NUM2INT(xr2), NUM2INT(yr2),
+		NUM2INT(xs2), NUM2INT(ys2), halfcorrelation, halfarea, balancetype,
+        mwidth))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.global_balance(gamma) -> image
+ *
+ *  Takes an image assembled with the mosaicing functions, take it apart, and
+ *  reassemble it, globally optimising the image balance. This is useful for
+ *  assembling image mosaics from sources where the exposure is uncontrolled and
+ *  may vary from tile to tile --- such as video, or photographic sources.
+ *
+ *  The function finds a set of factors, one for each of the input images, and
+ *  scales each image by its factor before reassembling. The factors are chosen
+ *  so as to minimise the average grey-level difference between neighboring
+ *  images at their overlaps.  Trivial overlaps (where the width and height of
+ *  the overlap are both less than 20 pixels) are ignored.
+ *
+ *  The <i>gamma</i> parameter is the gamma of the image input system. It is
+ *  used during brightness adjustment. Set to 1.0 to disable gamma, to 1.6 for a
+ *  typical IR vidicon camera, or 2.3 for a typical video camera.
+ *
+ *  It relies on information left by the mosaicing functions in ".desc" files.
+ *  If the ".desc" file of the input image has been corrupted, or is strangely
+ *  complicated, or if any of the original input images have been moved or
+ *  deleted, the function can fail.
+ *
+ *  The function will fail for mosaics larger than about 7 by 7 frames, since it
+ *  will run out of file descriptors (UNIX sets a limit of 256 per process). To
+ *  balance larger mosaics, just assemble them in 7x7 sections, balancing and
+ *  saving each part in turn, before loading, assembling and balancing the final
+ *  image. The function can also fail if there are significant mosaicing errors.
+ */
+
+VALUE
+img_global_balance(VALUE obj, VALUE gamma)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_global_balance(im, im_new, NUM2DBL(gamma)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.global_balancef(gamma) -> image
+ *
+ *  Works as Image#global_balance, but outputs a float rather than a uchar
+ *  image. This lets you adjust the range of the image manually, if the
+ *  automatically-found scales are causing burn-out.
+ */
+
+VALUE
+img_global_balancef(VALUE obj, VALUE gamma)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_global_balancef(im, im_new, NUM2DBL(gamma)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.correl(other_image, xref, yref, xsec, ysec, hwindowsize,
+ *       hsearchsize) -> correlation, x, y
+ *
+ *  Find position of <i>other_image</i> within *self*. Search around point
+ *  <i>xsec</i>, <i>ysec</i> for the best match for the area around <i>xref</i>,
+ *  <i>yref</i>. Search an area of size <i>hsearchsize</i> for an of size
+ *  <i>hwindowsize</i>.
+ *
+ *  Return a new value for xsec, ysec and the correlation at that point.
+ */
+
+VALUE
+img_correl(VALUE obj, VALUE obj2, VALUE xref, VALUE yref, VALUE xsec,
+	VALUE ysec, VALUE hwindowsize, VALUE hsearchsize)
+{
+    int x, y;
+	double correlation;
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+
+    if (im_correl(im, im2, NUM2INT(xref), NUM2INT(yref), NUM2INT(xsec),
+		NUM2INT(ysec), NUM2INT(hwindowsize), NUM2INT(hsearchsize), &correlation,
+		&x, &y))
+        vips_lib_error();
+
+    return rb_ary_new3(3, DBL2NUM(correlation), INT2NUM(x), INT2NUM(y));
+}
+
+/*
+ *  call-seq:
+ *     im.align_bands -> image
+ *
+ *  Brute force align the bands of an image.
+ */
+
+VALUE
+img_align_bands(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_align_bands);
+}
+
+/*
+ *  call-seq:
+ *     im.maxpos_subpel -> x, y
+ *
+ *  This function implements "Extension of Phase Correlation to Subpixel
+ *  Registration" by H. Foroosh, from IEEE trans. Im. Proc. 11(3), 2002.
+ *
+ *  If the best three matches in the correlation are aranged:
+ *
+ *    02   or   01
+ *    1         2
+ *
+ *  then we return a subpixel match using the ratio of correlations in the
+ *  vertical and horizontal dimension.
+ *
+ *  ( xs[0], ys[0] ) is the best integer alignment
+ *  ( xs[ use_x ], ys[ use_x ] ) is equal in y and (+/-)1 off in x
+ *  ( xs[ use_y ], ys[ use_y ] ) is equal in x and (+/-)1 off in y
+ *
+ *  Alternatively if the best four matches in the correlation are aranged in
+ *  a square:
+ *
+ *    01  or  03  or  02  or  03
+ *    32      12      31      21
+ *
+ *  then we return a subpixel match weighting with the sum the two on each
+ *  side over the sum of all four, but only if all four of them are very
+ *  close to the best, and the fifth is nowhere near.
+ *
+ *  This alternative method is not described by Foroosh, but is often the
+ *  case where the match is close to n-and-a-half pixels in both dimensions.
+ */
+
+VALUE
+img_maxpos_subpel(VALUE obj)
+{
+    double x, y;
+	GetImg(obj, data, im);
+
+    if (im_maxpos_subpel(im, &x, &y))
+        vips_lib_error();
+
+    return rb_ary_new3(2, DBL2NUM(x), INT2NUM(y));
+}
+
+void
+init_Image_mosaicing(void)
+{
+ id_match_none = rb_intern("match_none");
+    id_match_left = rb_intern("match_left");
+    id_match_right = rb_intern("match_right");
+    id_match_both = rb_intern("match_both");
+}