ruby-vips 0.3.14 → 1.0.0

data/ext/image_conversion.h

@@ -1,38 +0,0 @@
-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_tile_cache(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

@@ -1,368 +0,0 @@
-#include "ruby_vips.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

@@ -1,13 +0,0 @@
-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

@@ -1,740 +0,0 @@
-#include "ruby_vips.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 ATLEAST_VIPS( 7, 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;
-}