ruby-vips 0.1.1

data/ext/image_conversion.h

@@ -0,0 +1,37 @@
+VALUE img_to_mask(VALUE);
+VALUE img_dup(VALUE);
+VALUE img_copy_swap(VALUE);
+VALUE img_copy_native(VALUE, VALUE);
+VALUE img_copy_file(VALUE);
+VALUE img_clip2fmt(VALUE, VALUE);
+VALUE img_scale(VALUE);
+VALUE img_msb(int, VALUE*, VALUE);
+VALUE img_c2amph(VALUE);
+VALUE img_c2rect(VALUE);
+VALUE img_ri2c(VALUE, VALUE);
+VALUE img_c2imag(VALUE);
+VALUE img_c2real(VALUE);
+VALUE img_scaleps(VALUE);
+VALUE img_falsecolour(VALUE);
+VALUE img_s_gaussnoise(VALUE, VALUE, VALUE, VALUE, VALUE);
+VALUE img_s_black(VALUE, VALUE, VALUE, VALUE);
+VALUE img_s_text(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+VALUE img_extract_band(int, VALUE*, VALUE);
+VALUE img_extract_area(int, VALUE*, VALUE);
+VALUE img_embed(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+VALUE img_bandjoin(int, VALUE *argv, VALUE);
+VALUE img_insert_noexpand(VALUE, VALUE, VALUE, VALUE);
+VALUE img_insert(int, VALUE *argv, VALUE);
+VALUE img_lrjoin(VALUE, VALUE);
+VALUE img_tbjoin(VALUE, VALUE);
+VALUE img_replicate(VALUE, VALUE, VALUE);
+VALUE img_grid(VALUE, VALUE, VALUE, VALUE);
+VALUE img_wrap(VALUE, VALUE, VALUE);
+VALUE img_fliphor(VALUE);
+VALUE img_flipver(VALUE);
+VALUE img_rot90(VALUE);
+VALUE img_rot180(VALUE);
+VALUE img_rot270(VALUE);
+VALUE img_subsample(int, VALUE*, VALUE);
+VALUE img_zoom(int, VALUE*, VALUE);
+void init_Image_conversion();

data/ext/image_convolution.c

@@ -0,0 +1,371 @@
+#include "ruby_vips.h"
+#include "image.h"
+#include "mask.h"
+#include "image_convolution.h"
+
+/*
+ *  call-seq:
+ *     im.conv(mask) -> image
+ *
+ *  Convolve *self* with <i>mask</i>. The output image always has the same band format
+ *  as *self*. Non-complex images only.
+ *
+ *  Each output pixel is calculated as sigma[i]{pixel[i] * <i>mask</i>[i]} /
+ *  scale + offset, where scale and offset are part of <i>mask</i>. For integer
+ *  *self*, the division by scale includes round-to-nearest.
+ *
+ *  <i>mask</i> can be an array in which case scale defaults to 1 and offset
+ *  defaults to zero. <i>mask</i> can also be a Mask object.
+ */
+
+VALUE
+img_conv(VALUE obj, VALUE m)
+{
+    DOUBLEMASK *dmask;
+    INTMASK *imask;
+
+    GetImg(obj, data, im);
+	OutImg2(obj, m, new, data_new, im_new);
+
+    mask_arg2mask(m, &imask, &dmask);
+
+    if (imask) {
+        if (im_conv(im, im_new, imask))
+            vips_lib_error();
+    } else if (im_conv_f(im, im_new, dmask))
+        vips_lib_error();
+
+    return new;
+}   
+
+/*
+ *  call-seq:
+ *     im.convsep(mask) -> image
+ *
+ *  Perform a separable convolution of *self* with <i>mask</i> using integer
+ *  arithmetic.
+ *
+ *  <i>mask</i> must be 1xn or nx1 elements.
+ *
+ *  The output image always has the same band format as *self*. Non-complex
+ *  images only.
+ *
+ *  The image is convolved twice: once with <i>mask</i> and then again with
+ *  <i>mask</i> rotated by 90 degrees. This is much faster for certain types of
+ *  mask (gaussian blur, for example) than doing a full 2D convolution.
+ *
+ *  Each output pixel is calculated as sigma[i]{pixel[i] * <i>mask</i>[i]} /
+ *  scale + offset, where scale and offset are part of <i>mask</i>. For integer
+ *  *self*, the division by scale includes round-to-nearest.
+ *
+ *  <i>mask</i> can be an array in which case scale defaults to 1 and offset
+ *  defaults to zero. <i>mask</i> can also be a Mask object.
+ */
+
+VALUE
+img_convsep(VALUE obj, VALUE mask)
+{
+    DOUBLEMASK *dmask;
+    INTMASK *imask;
+
+	GetImg(obj, data, im);
+	OutImg2(obj, mask, new, data_new, im_new);
+
+    mask_arg2mask(mask, &imask, &dmask);
+
+    if(imask) {
+        if (im_convsep(im, im_new, imask))
+            vips_lib_error();
+    } else if (im_convsep_f(im, im_new, dmask))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.compass(mask) -> image
+ *
+ *  *self* is convolved 8 times with <i>mask</i>, each time <i>mask</i> is
+ *  rotated by 45 degrees. Each output pixel is the largest absolute value of
+ *  the 8 convolutions.
+ *
+ *  <i>mask</i> can be an array or a Mask object.
+ */
+
+VALUE
+img_compass(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_compass(im, im_new, imask))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.gradient(mask) -> image
+ *
+ *  *self* is convolved with <i>mask</i> and with <i>mask</i> after a 90 degree
+ *  rotation. The result is the sum of the absolute value of the two
+ *  convolutions.
+ *
+ *  <i>mask</i> can be an array or a Mask object.
+ */
+
+VALUE
+img_gradient(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_gradient(im, im_new, imask) )
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.lindetect(mask) -> image
+ *
+ *  *self* is convolved four times with @mask, each time @mask is rotated by 45
+ *  degrees. Each output pixel is the largest absolute value of the four
+ *  convolutions.
+ *
+ *  <i>mask</i> can be an array or a Mask object.
+ */
+
+VALUE
+img_lindetect(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_lindetect(im, im_new, imask))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.sharpen(mask_size, x1, y2, y3, m1, m2) -> image
+ *
+ *  Selectively sharpen the L channel of a LAB image. Works for :LABQ coding and
+ *  LABS images.
+ *
+ *  The operation performs a gaussian blur of size <i>mask_size</i> and
+ *  subtract from *self* to generate a high-frequency signal. This signal is
+ *  passed through a lookup table formed from the five parameters and added back
+ *  to *self*.
+ *
+ *
+ *  For printing, we recommend the following settings:
+ *
+ *    mask_size == 7
+ *    x1 == 1.5
+ *    y2 == 20         (don't brighten by more than 20 L*)
+ *    y3 == 50         (can darken by up to 50 L*)
+ *
+ *    m1 == 1          (some sharpening in flat areas)
+ *    m2 == 2          (more sharpening in jaggy areas)
+ *
+ *  If you want more or less sharpening, we suggest you just change the
+ *  <i>m1</i> and <i>m2</i> parameters.
+ *
+ *  The <i>mask_size</i> parameter changes the width of the fringe and can be
+ *  adjusted according to the output printing resolution. As an approximate
+ *  guideline, use 3 for 4 pixels/mm (CRT display resolution), 5 for 8
+ *  pixels/mm, 7 for 12 pixels/mm and 9 for 16 pixels/mm (300 dpi == 12
+ *  pixels/mm). These figures refer to the image raster, not the half-tone
+ *  resolution.
+ */
+
+VALUE
+img_sharpen(VALUE obj, VALUE mask_size, VALUE x1, VALUE y2, VALUE y3, VALUE m1,
+    VALUE m2)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_sharpen(im, im_new, NUM2INT(mask_size), NUM2DBL(x1), NUM2DBL(y2),
+		NUM2DBL(y3), NUM2DBL(m1), NUM2DBL(m2)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.grad_x -> image
+ *
+ *  Find horizontal differences between adjacent pixels.
+ *
+ *  Generates an image where the value of each pixel is the difference between
+ *  it and the pixel to its right. The output has the same height as the input
+ *  and one pixel less width. One-band integer formats only. The result is
+ *  always band format :INT.
+ *
+ *  This operation is much faster than (though equivalent to) Image#conv with
+ *  the mask [[-1, 1]].
+ */
+
+VALUE
+img_grad_x(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_grad_x);
+}
+
+/*
+ *  call-seq:
+ *     im.grad_y -> image
+ *
+ *  Find vertical differences between adjacent pixels.
+ *
+ *  Generates an image where the value of each pixel is the difference between
+ *  it and the pixel below it. The output has the same width as the input
+ *  and one pixel less height. One-band integer formats only. The result is
+ *  always band format :INT.
+ *
+ *  This operation is much faster than (though equivalent to) Image#conv with
+ *  the mask [[-1], [1]].
+ */
+
+VALUE
+img_grad_y(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_grad_y);
+}
+
+/*
+ *  call-seq:
+ *     im.fastcor(other_image) -> image
+ *
+ *  Calculate a fast correlation surface.
+ *
+ *  <i>other_image</i> is placed at every position in *self* and the sum of
+ *  squares of differences calculated. One-band, 8-bit unsigned images only. The
+ *  output image is always band format :UINT. <i>other_image</i> must be smaller
+ *  than or equal to *self*. The output image is the same size as the input.
+ */
+
+VALUE
+img_fastcor(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_fastcor);
+}
+
+/*
+ *  call-seq:
+ *     im.spcor(other_image) -> image
+ *
+ *  Calculate a correlation surface.
+ *
+ *  <i>other_image</i> is placed at every position in *self* and the correlation
+ *  coefficient calculated. One-band, 8 or 16-bit images only. *self* and
+ *  <i>other_image</i> must have the same band format.. The output image is
+ *  always band format :FLOAT. <i>other_image</i> must be smaller than or equal
+ *  to *self*. The output image is the same size as *self*.
+ *
+ *  The correlation coefficient is calculated as:
+ *
+ *            sumij (ref(i,j)-mean(ref))(inkl(i,j)-mean(inkl))
+ *   c(k,l) = ------------------------------------------------
+ *            sqrt(sumij (ref(i,j)-mean(ref))^2) *
+ *                        sqrt(sumij (inkl(i,j)-mean(inkl))^2)
+ *
+ *  where inkl is the area of *self* centred at position (k,l).
+ *
+ *  from Niblack "An Introduction to Digital Image Processing", Prentice/Hall,
+ *  pp 138.
+ */
+
+VALUE
+img_spcor(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_spcor);
+}
+
+/*
+ *  call-seq:
+ *     im.gradcor(other_image) -> image
+ *
+ *  Calculate a correlation surface.
+ *
+ *  <i>other_image</i> is placed at every position in *self* and a correlation
+ *  coefficient calculated. One-band, integer images only. *self* and
+ *  <i>other_image</i> must have the same band format. The output image is
+ *  always band format :FLOAT. <i>other_image</i> must be smaller than *self*.
+ *  The output image is the same size as the input.
+ *
+ *  The method takes the gradient images of the two images then takes the
+ *  dot-product correlation of the two vector images. The vector expression of
+ *  this method is my (tcv) own creation. It is equivalent to the complex-number
+ *  method of:
+ *
+ *  ARGYRIOU, V. et al. 2003. Estimation of sub-pixel motion using gradient
+ *  cross correlation. Electronics Letters, 39 (13).
+ */
+
+VALUE
+img_gradcor(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_gradcor);
+}
+
+/*
+ *  call-seq:
+ *    im.contrast_surface(half_win_size, spacing) -> image
+ *
+ *  Generate an image where the value of each pixel represents the contrast
+ *  within a window of half_win_size from the corresponsing point in the input
+ *  image. Sub-sample by a factor of spacing.
+ */
+
+VALUE
+img_contrast_surface(VALUE obj, VALUE half_win_size, VALUE spacing)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_contrast_surface(im, im_new, NUM2INT(half_win_size),
+		NUM2INT(spacing)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *    im.addgnoise(sigma) -> image
+ *
+ *  Add gaussian noise with mean 0 and variance sigma to *self*. The noise is
+ *  generated by averaging 12 random numbers, see page 78, PIETGEN, 1989.
+ */
+
+VALUE
+img_addgnoise(VALUE obj, VALUE sigma)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_addgnoise(im, im_new, NUM2INT(sigma)))
+        vips_lib_error();
+
+    return new;
+}

data/ext/image_convolution.h

@@ -0,0 +1,13 @@
+VALUE img_conv(VALUE, VALUE);
+VALUE img_convsep(VALUE, VALUE);
+VALUE img_compass(VALUE, VALUE);
+VALUE img_gradient(VALUE, VALUE);
+VALUE img_lindetect(VALUE, VALUE);
+VALUE img_sharpen(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+VALUE img_grad_x(VALUE);
+VALUE img_grad_y(VALUE);
+VALUE img_fastcor(VALUE, VALUE);
+VALUE img_spcor(VALUE, VALUE);
+VALUE img_gradcor(VALUE, VALUE);
+VALUE img_contrast_surface(VALUE, VALUE, VALUE);
+VALUE img_addgnoise(VALUE, VALUE);

data/ext/image_freq_filt.c

@@ -0,0 +1,742 @@
+#include "ruby_vips.h"
+#include "image.h"
+#include "image_freq_filt.h"
+
+/*
+ *  call-seq:
+ *     im.fwfft -> image
+ *
+ *  Transform an image to Fourier space.
+ *
+ *  VIPS uses the fftw3 or fftw2 Fourier transform libraries if possible. If
+ *  they were not available when VIPS was built, it falls back to its own
+ *  FFT functions which are slow and only work for square images whose sides
+ *  are a power of two.
+ */
+
+VALUE
+img_fwfft(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_fwfft);
+}
+
+/*
+ *  call-seq:
+ *     im.invfft -> image
+ *
+ *  Transform an image from Fourier space to real space. The result is complex.
+ *  If you are OK with a real result, use Image#invfftr instead, it's quicker.
+ *
+ *  VIPS uses the fftw3 or fftw2 Fourier transform libraries if possible. If
+ *  they were not available when VIPS was built, it falls back to its own FFT
+ *  functions which are slow and only work for square images whose sides are a
+ *  power of two.
+ */
+
+VALUE
+img_invfft(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_invfft);
+}
+
+/*
+ *  call-seq:
+ *     im.rotquad -> image
+ *
+ *  Rotate the quadrants of the image so that the point that was at the
+ *  top-left is now in the centre. Handy for moving Fourier images to optical
+ *  space.
+ */
+
+VALUE
+img_rotquad(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_rotquad);
+}
+
+/*
+ *  call-seq:
+ *     im.invfftr -> image
+ *
+ *  Transform an image from Fourier space to real space, giving a real result.
+ *  This is faster than Image#invfft, which gives a complex result.
+ *
+ *  VIPS uses the fftw3 or fftw2 Fourier transform libraries if possible. If
+ *  they were not available when VIPS was built, it falls back to it's own
+ *  FFT functions which are slow and only work for square images whose sides
+ *  are a power of two.
+ */
+
+VALUE
+img_invfftr(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_invfftr);
+}
+
+#if IM_MAJOR_VERSION > 7 || IM_MINOR_VERSION >= 22
+
+/*
+ *  call-seq:
+ *     Image.fmask_ideal_lowpass(x, y, frequency_cutoff) -> image
+ *
+ *  This operation creates a one-band float image of the size <i>x</i> by
+ *  <i>y</i>. The image must be square, and the sides must be a power of two.
+ *  The image has values in the range [0, 1] and is typically used for
+ *  multiplying against  frequency domain images to filter them.
+ *
+ *  All masks are created with the DC component at (0, 0), so you might want to
+ *  rotate the quadrants with im_rotquad() before viewing. The DC pixel always
+ *  has the value 1.0.
+ *
+ *  Unless noted below, all parameters are expressed as percentages, scaled to
+ *  [0, 1].
+ *
+ *  * High-pass, low-pass masks: A high pass filter mask filters the low
+ *    frequencies while allowing the high frequencies to get through.
+ *    The reverse happens with a low pass filter mask.
+ *
+ *  * Ring-pass, ring-reject masks: A ring filter passes or rejects a range of
+ *    frequencies. The range is specified by the <i>frequency_cutoff</i> and
+ *    the <i>width</i>.
+ *
+ *  * Band-pass, band-reject masks: These masks are used to pass or remove
+ *    spatial frequencies around a given frequency. The position of the
+ *    frequency to pass or remove is given by <i>frequency_cutoffx</i> and
+ *    <i>frequency_cutoffy</i>. The size of the region around the point is
+ *    given by <i>radius</i>.
+ *
+ *  * Ideal filters: These filters pass or reject frequencies with a sharp
+ *    cutoff at the transition.
+ *
+ *  * Butterworth filters: These filters use a Butterworth function to separate
+ *    the frequencies (see Gonzalez and Wintz, Digital Image Processing, 1987).
+ *    The shape of the curve is controlled by <i>order</i>: higher values give
+ *    a sharper transition.
+ *
+ *  * Gaussian filters: These filters have a smooth Gaussian shape,
+ *    controlled by <i>amplitude_cutoff</i>.
+ */
+
+VALUE
+img_s_fmask_ideal_highpass(VALUE obj, VALUE x, VALUE y, VALUE frequency_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im, NUM2INT(x), NUM2INT(y), VIPS_MASK_IDEAL_HIGHPASS,
+		NUM2DBL(frequency_cutoff)))
+        vips_lib_error();
+
+    return new;	
+}
+
+/*
+ *  call-seq:
+ *    Image.fmask_ideal_lowpass(x, y, frequency_cutoff) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ *
+ */
+
+VALUE
+img_s_fmask_ideal_lowpass(VALUE obj, VALUE x, VALUE y, VALUE frequency_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im, NUM2INT(x), NUM2INT(y),
+		VIPS_MASK_IDEAL_LOWPASS, NUM2DBL(frequency_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_butterworth_highpass(x, y, order, frequency_cutoff,
+ *       amplitude_cutoff) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_butterworth_highpass(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoff, VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_BUTTERWORTH_HIGHPASS, NUM2DBL(order),
+		NUM2DBL(frequency_cutoff), NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_butterworth_lowpass(x, y, order, frequency_cutoff,
+ *       amplitude_cutoff)
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_butterworth_lowpass(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoff, VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_BUTTERWORTH_LOWPASS, NUM2DBL(order),
+		NUM2DBL(frequency_cutoff), NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_gauss_highpass(x, y, frequency_cutoff, amplitude_cutoff) ->
+ *       image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_gauss_highpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_GAUSS_HIGHPASS,
+		NUM2DBL(frequency_cutoff), NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_gauss_lowpass(x, y, frequency_cutoff, amplitude_cutoff) ->
+ *       image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_gauss_lowpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_GAUSS_LOWPASS,
+		NUM2DBL(frequency_cutoff), NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_ideal_ringpass(x, y, frequency_cutoff, width) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_ideal_ringpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE width)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_IDEAL_RINGPASS,
+		NUM2DBL(frequency_cutoff), NUM2DBL(width)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_ideal_ringreject(x, y, frequency_cutoff, width) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_ideal_ringreject(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE width)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_IDEAL_RINGREJECT,
+		NUM2DBL(frequency_cutoff), NUM2DBL(width)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_butterworth_ringpass(x, y, order, frequency_cutoff,
+ *       width, amplitude_cutoff) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_butterworth_ringpass(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoff, VALUE width, VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_BUTTERWORTH_RINGPASS,
+		NUM2DBL(order), NUM2DBL(frequency_cutoff), NUM2DBL(width),
+		NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_butterworth_ringreject(x, y, order, frequency_cutoff,
+ *       width, amplitude_cutoff) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_butterworth_ringreject(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoff, VALUE width, VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_BUTTERWORTH_RINGREJECT,
+		NUM2DBL(order), NUM2DBL(frequency_cutoff), NUM2DBL(width),
+		NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_gauss_ringpass(x, y, frequency_cutoff, width,
+ *       amplitude_cutoff) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_gauss_ringpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE width, VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_GAUSS_RINGPASS,
+		NUM2DBL(frequency_cutoff), NUM2DBL(width), NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_gauss_ringreject(x, y, frequency_cutoff, width,
+ *       amplitude_cutoff) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_gauss_ringreject(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE width, VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_GAUSS_RINGREJECT,
+		NUM2DBL(frequency_cutoff), NUM2DBL(width), NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_ideal_bandpass(x, y, frequency_cutoffx, frequency_cutoffy,
+ *       radius) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_ideal_bandpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_IDEAL_BANDPASS,
+		NUM2DBL(frequency_cutoffx), NUM2DBL(frequency_cutoffy),
+		NUM2DBL(radius)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_ideal_bandreject(x, y, frequency_cutoffx, frequency_cutoffy,
+ *       radius)
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_ideal_bandreject(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_IDEAL_BANDREJECT,
+		NUM2DBL(frequency_cutoffx), NUM2DBL(frequency_cutoffy),
+		NUM2DBL(radius)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_butterworth_bandpass(x, y, order, frequency_cutoffx,
+ *       frequency_cutoffy, radius, amplitude_cutoff) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_butterworth_bandpass(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius,
+	VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_BUTTERWORTH_BANDPASS,
+		NUM2DBL(order), NUM2DBL(frequency_cutoffx), NUM2DBL(frequency_cutoffy),
+		NUM2DBL(radius), NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_butterworth_bandreject(x, y, order, frequency_cutoffx,
+ *       frequency_cutoffy, radius, amplitude_cutoff) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_butterworth_bandreject(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius,
+	VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_BUTTERWORTH_BANDREJECT,
+		NUM2DBL(order), NUM2DBL(frequency_cutoffx), NUM2DBL(frequency_cutoffy),
+		NUM2DBL(radius), NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_gaus_bandpass(x, y, frequency_cutoffx, frequency_cutoffy,
+ *       radius, amplitude_cutoff) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_gauss_bandpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius,
+	VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_GAUSS_BANDPASS,
+		NUM2DBL(frequency_cutoffx), NUM2DBL(frequency_cutoffy), NUM2DBL(radius),
+		NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_gauss_bandreject, x, y, frequency_cutoffx, frequency_cutoffy,
+ *       radius, amplitude_cutoff) -> image
+ *
+ *  See Image.fmask_ideal_highpass
+ */
+
+VALUE
+img_s_fmask_gauss_bandreject(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius,
+	VALUE amplitude_cutoff)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_GAUSS_BANDREJECT,
+		NUM2DBL(frequency_cutoffx), NUM2DBL(frequency_cutoffy), NUM2DBL(radius),
+		NUM2DBL(amplitude_cutoff)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     Image.fmask_fractal_flt(x, y, fractal_dimension) -> image
+ *
+ *  This mask is handy for filtering images of gaussian noise in order to create
+ *  surfaces of a given fractal dimension. @fractal_dimension should be between
+ *  2 and 3.
+ */
+
+VALUE
+img_s_fmask_fractal_flt(VALUE obj, VALUE x, VALUE y,
+	VALUE fractal_dimension)
+{
+	OutPartial(new, data, im);
+
+    if (im_create_fmask(im,
+		NUM2INT(x), NUM2INT(y), VIPS_MASK_FRACTAL_FLT,
+		NUM2DBL(fractal_dimension)))
+        vips_lib_error();
+
+    return new;	
+}
+
+#else
+
+VALUE
+img_s_fmask_ideal_highpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_ideal_lowpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_butterworth_highpass(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoff, VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_butterworth_lowpass(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoff, VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_gauss_highpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_gauss_lowpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_ideal_ringpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE width)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_ideal_ringreject(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE width)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_butterworth_ringpass(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoff, VALUE width, VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_butterworth_ringreject(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoff, VALUE width, VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_gauss_ringpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE width, VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_gauss_ringreject(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoff, VALUE width, VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_ideal_bandpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_ideal_bandreject(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_butterworth_bandpass(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius,
+	VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_butterworth_bandreject(VALUE obj, VALUE x, VALUE y,
+	VALUE order, VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius,
+	VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_gauss_bandpass(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius,
+	VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_gauss_bandreject(VALUE obj, VALUE x, VALUE y,
+	VALUE frequency_cutoffx, VALUE frequency_cutoffy, VALUE radius,
+	VALUE amplitude_cutoff)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+VALUE
+img_s_fmask_fractal_flt(VALUE obj, VALUE x, VALUE y,
+	VALUE fractal_dimension)
+{
+    rb_raise(eVIPSError, "Operation not supported with your version of VIPS.");
+}
+
+#endif
+
+/*
+ *  call-seq:
+ *     im.freqflt(other_image) -> image
+ *
+ *  Filter an image in Fourier space.
+ *
+ *  *self* is transformed to Fourier space, multipled with <i>other_image</i>,
+ *  then transformed back to real space. If *self* is already a complex image,
+ *  just multiply then inverse transform.
+ */
+
+VALUE
+img_freqflt(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_freqflt);
+}
+
+/*
+ *  call-seq:
+ *     im.disp_ps -> image
+ *
+ *  Make a displayable (ie. 8-bit unsigned int) power spectrum.
+ *
+ *  If *self* is non-complex, it is transformed to Fourier space. Then the
+ *  absolute value is passed through Image#scaleps, and Image#rotquad.
+ */
+
+VALUE
+img_disp_ps(VALUE obj)
+{
+	RUBY_VIPS_UNARY(im_disp_ps);
+}
+
+/*
+ *  call-seq:
+ *     im.phasecor_fft(other_image) -> image
+ *
+ *  Convert the two input images to Fourier space, calculate phase-correlation,
+ *  back to real space.
+ */
+
+VALUE
+img_phasecor_fft(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_phasecor_fft);
+}
+
+/*
+ *  call-seq:
+ *     Image.fractsurf(size, frd) -> image
+ *
+ *  Generate an image of size <i>size</i> and fractal dimension <i>frd</i>. The
+ *  dimension should be between 2 and 3.
+ */
+
+VALUE
+img_s_fractsurf(VALUE obj, VALUE size, VALUE frd)
+{
+	OutPartial(new, data, im);
+
+    if (im_fractsurf(im, NUM2INT(size), NUM2DBL(frd)))
+        vips_lib_error();
+
+    return new;
+}