ruby-vips 0.1.1

data/ext/image_mosaicing.h

@@ -0,0 +1,14 @@
+VALUE img_lrmerge(int, VALUE*, VALUE);
+VALUE img_tbmerge(int, VALUE*, VALUE);
+VALUE img_lrmerge1(int, VALUE*, VALUE);
+VALUE img_tbmerge1(int, VALUE*, VALUE);
+VALUE img_lrmosaic(int, VALUE*, VALUE);
+VALUE img_tbmosaic(int, VALUE*, VALUE);
+VALUE img_lrmosaic1(int, VALUE*, VALUE);
+VALUE img_tbmosaic1(int, VALUE*, VALUE);
+VALUE img_global_balance(VALUE, VALUE);
+VALUE img_global_balancef(VALUE, VALUE);
+VALUE img_correl(VALUE, VALUE, VALUE, VALUE, VALUE,	VALUE, VALUE, VALUE);
+VALUE img_remosaic(VALUE, VALUE, VALUE);
+VALUE img_align_bands(VALUE);
+VALUE img_maxpos_subpel(VALUE);

data/ext/image_relational.c

@@ -0,0 +1,386 @@
+#include "ruby_vips.h"
+#include "image.h"
+#include "image_relational.h"
+
+static VALUE
+img_equal_const(int argc, VALUE *argv, VALUE obj)
+{
+    double *c;
+    int i;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	c = IM_ARRAY(im_new, argc, double);
+
+	for(i = 0; i < argc; i++)
+		c[i] = NUM2DBL(argv[i]);
+
+	if (im_equal_vec(im, im_new, argc, c))
+		vips_lib_error();
+
+	return new;
+}
+
+static VALUE
+img_equal_img(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_equal);
+}
+
+/*
+ *  call-seq:
+ *     im.equal(other_image)   -> image
+ *     im.equal(constant, ...) -> image
+ * 
+ *  In the first form, this operation calculates *self* == <i>other_image</i>
+ *  (image element equals image element) and writes the result to the output
+ *  image.
+ *
+ *  In the second form, this operation calculates *self* == <i>constant</i>
+ *  (image element equals constant array) and writes the result to the output
+ *  image.
+ */
+
+VALUE
+img_equal(int argc, VALUE *argv, VALUE obj)
+{
+	if (argc < 1)
+		rb_raise(rb_eArgError, "Need at least one argument.");
+
+	if (TYPE(argv[0]) == T_FLOAT || TYPE(argv[0]) == T_FIXNUM)
+		return img_equal_const(argc, argv, obj);
+	else if (argc != 1)
+		rb_raise(rb_eArgError, "Need constants or one image.");
+
+	return img_equal_img(obj, argv[0]);
+}
+
+static VALUE
+img_notequal_const(int argc, VALUE *argv, VALUE obj)
+{
+    double *c;
+    int i;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	c = IM_ARRAY(im_new, argc, double);
+
+	for(i = 0; i < argc; i++)
+		c[i] = NUM2DBL(argv[i]);
+
+	if (im_notequal_vec(im, im_new, argc, c))
+		vips_lib_error();
+
+	return new;
+}
+
+static VALUE
+img_notequal_img(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_notequal);
+}
+
+/*
+ *  call-seq:
+ *     im.notequal(other_image)   -> image
+ *     im.notequal(constant, ...) -> image
+ *
+ *  In the first form, this operation calculates *self* != <i>other_image</i>
+ *  (image element equals image element) and writes the result to the output
+ *  image.
+ *
+ *  In the second form, this operation calculates *self* != <i>constant</i>
+ *  (image element equals constant array) and writes the result to the output
+ *  image.
+ */
+
+VALUE
+img_notequal(int argc, VALUE *argv, VALUE obj)
+{
+	if (argc < 1)
+		rb_raise(rb_eArgError, "Need at least one argument.");
+
+	if (TYPE(argv[0]) == T_FLOAT || TYPE(argv[0]) == T_FIXNUM)
+		return img_notequal_const(argc, argv, obj);
+	else if (argc != 1)
+		rb_raise(rb_eArgError, "Need constants or one image.");
+
+	return img_notequal_img(obj, argv[0]);
+}
+
+static VALUE
+img_less_const(int argc, VALUE *argv, VALUE obj)
+{
+    double *c;
+    int i;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	c = IM_ARRAY(im_new, argc, double);
+
+	for(i = 0; i < argc; i++)
+		c[i] = NUM2DBL(argv[i]);
+
+	if (im_less_vec(im, im_new, argc, c))
+		vips_lib_error();
+
+	return new;
+}
+
+static VALUE
+img_less_img(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_less);
+}
+
+/*
+ *  call-seq:
+ *     im.less(other_image)   -> image
+ *     im.less(constant, ...) -> image
+ *
+ *  In the first form, this operation calculates *self* < <i>other_image</i>
+ *  (image element equals image element) and writes the result to the output
+ *  image.
+ *
+ *  In the second form, this operation calculates *self* < <i>constant</i>
+ *  (image element equals constant array) and writes the result to the output
+ *  image.
+ */
+
+VALUE
+img_less(int argc, VALUE *argv, VALUE obj)
+{
+	if (argc < 1)
+		rb_raise(rb_eArgError, "Need at least one argument.");
+
+	if (TYPE(argv[0]) == T_FLOAT || TYPE(argv[0]) == T_FIXNUM)
+		return img_less_const(argc, argv, obj);
+	else if (argc != 1)
+		rb_raise(rb_eArgError, "Need constants or one image.");
+
+	return img_less_img(obj, argv[0]);
+}
+
+static VALUE
+img_lesseq_const(int argc, VALUE *argv, VALUE obj)
+{
+    double *c;
+    int i;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	c = IM_ARRAY(im_new, argc, double);
+
+	for(i = 0; i < argc; i++)
+		c[i] = NUM2DBL(argv[i]);
+
+	if (im_lesseq_vec(im, im_new, argc, c))
+		vips_lib_error();
+
+	return new;
+}
+
+static VALUE
+img_lesseq_img(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_lesseq);
+}
+
+/*
+ *  call-seq:
+ *     im.lesseq(other_image)   -> image
+ *     im.lesseq(constant, ...) -> image
+ *
+ *  In the first form, this operation calculates *self* <= <i>other_image</i>
+ *  (image element equals image element) and writes the result to the output
+ *  image.
+ *
+ *  In the second form, this operation calculates *self* <= <i>constant</i>
+ *  (image element equals constant array) and writes the result to the output
+ *  image.
+ */
+
+VALUE
+img_lesseq(int argc, VALUE *argv, VALUE obj)
+{
+	if (argc < 1)
+		rb_raise(rb_eArgError, "Need at least one argument.");
+
+	if (TYPE(argv[0]) == T_FLOAT || TYPE(argv[0]) == T_FIXNUM)
+		return img_lesseq_const(argc, argv, obj);
+	else if (argc != 1)
+		rb_raise(rb_eArgError, "Need constants or one image.");
+
+	return img_lesseq_img(obj, argv[0]);
+}
+
+static VALUE
+img_more_const(int argc, VALUE *argv, VALUE obj)
+{
+    double *c;
+    int i;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	c = IM_ARRAY(im_new, argc, double);
+
+	for(i = 0; i < argc; i++)
+		c[i] = NUM2DBL(argv[i]);
+
+	if (im_more_vec(im, im_new, argc, c))
+		vips_lib_error();
+
+	return new;
+}
+
+static VALUE
+img_more_img(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_more);
+}
+
+/*
+ *  call-seq:
+ *     im.more(other_image)   -> image
+ *     im.more(constant, ...) -> image
+ *
+ *  In the first form, this operation calculates *self* > <i>other_image</i>
+ *  (image element equals image element) and writes the result to the output
+ *  image.
+ *
+ *  In the second form, this operation calculates *self* > <i>constant</i>
+ *  (image element equals constant array) and writes the result to the output
+ *  image.
+ */
+
+VALUE
+img_more(int argc, VALUE *argv, VALUE obj)
+{
+	if (argc < 1)
+		rb_raise(rb_eArgError, "Need at least one argument.");
+
+	if (TYPE(argv[0]) == T_FLOAT || TYPE(argv[0]) == T_FIXNUM)
+		return img_more_const(argc, argv, obj);
+	else if (argc != 1)
+		rb_raise(rb_eArgError, "Need constants or one image.");
+
+	return img_more_img(obj, argv[0]);
+}
+
+static VALUE
+img_moreeq_const(int argc, VALUE *argv, VALUE obj)
+{
+    double *c;
+    int i;
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+	c = IM_ARRAY(im_new, argc, double);
+
+	for(i = 0; i < argc; i++)
+		c[i] = NUM2DBL(argv[i]);
+
+	if (im_moreeq_vec(im, im_new, argc, c))
+		vips_lib_error();
+
+	return new;
+}
+
+static VALUE
+img_moreeq_img(VALUE obj, VALUE obj2)
+{
+	RUBY_VIPS_BINARY(im_moreeq);
+}
+
+/*
+ *  call-seq:
+ *     im.moreeq(other_image)   -> image
+ *     im.moreeq(constant, ...) -> image
+ *
+ *  In the first form, this operation calculates *self* >= <i>other_image</i>
+ *  (image element equals image element) and writes the result to the output
+ *  image.
+ *
+ *  In the second form, this operation calculates *self* >= <i>constant</i>
+ *  (image element equals constant array) and writes the result to the output
+ *  image.
+ */
+
+VALUE
+img_moreeq(int argc, VALUE *argv, VALUE obj)
+{
+	if (argc < 1)
+		rb_raise(rb_eArgError, "Need at least one argument.");
+
+	if (TYPE(argv[0]) == T_FLOAT || TYPE(argv[0]) == T_FIXNUM)
+		return img_moreeq_const(argc, argv, obj);
+	else if (argc != 1)
+		rb_raise(rb_eArgError, "Need constants or one image.");
+
+	return img_moreeq_img(obj, argv[0]);
+}
+
+/*
+ *  call-seq:
+ *     im.ifthenelse(a_image, b_image) -> image
+ *
+ *  This operation scans the condition image *self* and uses it to select pixels
+ *  from either the then image <i>a_image</i> or the else image <i>b_image</i>.
+ *  Non-zero means <i>a_image</i>, 0 means <i>b_image</i>.
+ *
+ *  Any image can have either 1 band or n bands, where n is the same for all
+ *  the non-1-band images. Single band images are then effectively copied to
+ *  make n-band images.
+ *
+ *  Images <i>a_image</i> and <i>b_image</i> are cast up to the smallest common
+ *  format.
+ *
+ *  Images <i>a_image</i> and <i>b_image</i> must match exactly in size.
+ */
+
+VALUE
+img_ifthenelse(VALUE obj, VALUE obj2, VALUE obj3)
+{
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	GetImg(obj3, data3, im3);
+	OutImg3(obj, obj2, obj3, new, data_new, im_new);
+
+    if (im_ifthenelse(im, im2, im3, im_new))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.blend(a_image, b_image) -> image
+ *
+ *  This operation scans the condition image *self* (which must be unsigned
+ *  char) and uses it to blend pixels from either the then image <i>a_image</i>
+ *  or the else image <i>b_image</i>. 255 means <i>a_image</i> only, 0 means
+ *  <i>b_image</i> only, and intermediate values are a mixture.
+ *
+ *  Any image can have either 1 band or n bands, where n is the same for all
+ *  the non-1-band images. Single band images are then effectively copied to
+ *  make n-band images.
+ *
+ *  Images <i>a_image</i> and <i>b_image</i> are cast up to the smallest common
+ *  format.
+ *
+ *  Images <i>a_image</i> and <i>b_image</i> must match exactly in size.
+ */
+
+VALUE
+img_blend(VALUE obj, VALUE obj2, VALUE obj3)
+{
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	GetImg(obj3, data3, im3);
+	OutImg3(obj, obj2, obj3, new, data_new, im_new);
+
+    if (im_blend(im, im2, im3, im_new))
+        vips_lib_error();
+
+    return new;
+}

data/ext/image_relational.h

@@ -0,0 +1,8 @@
+VALUE img_equal(int , VALUE*, VALUE);
+VALUE img_notequal(int , VALUE*, VALUE);
+VALUE img_less(int , VALUE*, VALUE);
+VALUE img_lesseq(int , VALUE*, VALUE);
+VALUE img_more(int , VALUE*, VALUE);
+VALUE img_moreeq(int , VALUE*, VALUE);
+VALUE img_ifthenelse(VALUE , VALUE , VALUE);
+VALUE img_blend(VALUE , VALUE , VALUE);

data/ext/image_resample.c

@@ -0,0 +1,253 @@
+#include "ruby_vips.h"
+#include "image.h"
+#include "interpolator.h"
+#include "header.h"
+#include "image_resample.h"
+
+/*
+ *  call-seq:
+ *     im.affinei(interpolator, a, b, c, d, dx, dy)                 -> image
+ *     im.affinei(interpolator, a, b, c, d, dx, dy, ox, oy, ow, oh) -> image
+ *
+ *  Applies an affine transformation on *self*. *self* many have any number of
+ *  bands, be any size, and have any non-complex type.
+ *
+ *  The transformation is described by <i>a</i>, <i>b</i>, <i>c</i>, <i>d</i>,
+ *  <i>dx</i>, <i>dy</i>. The point (x,y) in
+ *  the input is mapped onto point (X,Y) in the output by
+ *
+ *    X = a * x + b * y + dx
+ *    Y = c * x + d * y + dy
+ *
+ *  In the first form, the entire image is transformed. In the second form, the
+ *  area of the output image given by <i>ow</i>, <i>oh</i>, <i>ox</i>, <i>oy</i>
+ *  is generated. (0,0) is the position of the transformed top-left-hand corner
+ *  of the input image.
+ *
+ *  Points are generated using the supplied interpolator.
+ */
+
+VALUE
+img_affinei(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE interpolator, a, b, c, d, dx, dy, ox, oy, ow, oh;
+    VipsInterpolate *itrp_vips;
+
+    rb_scan_args(argc, argv, "74", &interpolator, &a, &b, &c, &d, &dx, &dy, &ox,
+        &oy, &ow, &oh);
+
+    itrp_vips = interp_lookup(interpolator);
+    GetImg(obj, data, im);
+    OutImg(obj, new, data_new, im_new);
+
+    if (NIL_P(ox)) {
+        if (im_affinei_all(im, im_new, itrp_vips,
+            NUM2DBL(a), NUM2DBL(b), NUM2DBL(c), NUM2DBL(d),
+            NUM2DBL(dx), NUM2DBL(dy)))
+            vips_lib_error();
+    } else {
+        if (NIL_P(oh))
+            rb_raise(rb_eArgError, "If you supply any output parameters, you have to supply them all");
+
+        if (im_affinei(im, im_new, itrp_vips,
+            NUM2DBL(a), NUM2DBL(b), NUM2DBL(c), NUM2DBL(d),
+            NUM2DBL(dx), NUM2DBL(dy),
+            NUM2INT(ox), NUM2INT(oy), NUM2INT(ow), NUM2INT(oh)))
+        vips_lib_error();
+    }
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.affinei_resize(interpolator, x [,y]) -> image
+ *
+ *  Applies an affine resize using the supplied interpolator. If <i>y</i> is
+ *  ommitted then the aspect ratio of *self* will be maintained.
+ */
+
+VALUE
+img_affinei_resize(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE interpolator, x_scale, y_scale;
+    VipsInterpolate *itrp_vips;
+
+    rb_scan_args(argc, argv, "21", &interpolator, &x_scale, &y_scale);
+
+    GetImg(obj, data, im);
+    OutImg(obj, new, data_new, im_new);
+
+    itrp_vips = interp_lookup(interpolator);
+
+    if (NIL_P(y_scale))
+        y_scale = x_scale;
+
+    if (im_affinei_all(im, im_new, itrp_vips, NUM2DBL(x_scale), 0, 0,
+        NUM2DBL(y_scale), 0, 0))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.stretch3(dx [,dy]) -> image
+ *
+ *  Stretches the input image by 3% horizontally, and displaces it by
+ *  <i>dx</i>/<i>dy</i>. It uses bi-cubic interpolation, but runs quickly. It
+ *  works only for unsigned short images.
+ *
+ *  This function is part of the MARC acquisition software, but is generally
+ *  useful for squaring up the pixels in images from the Kontron ProgRes camera
+ *  range.
+ */
+
+VALUE
+img_stretch3(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE dx, dy;
+
+    rb_scan_args(argc, argv, "11", &dx, &dy);
+    if (NIL_P(dy))
+        dy = dx;
+
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_stretch3(im, im_new, NUM2DBL(dx), NUM2DBL(dy)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.shrink(width_ratio [,height_ratio]) -> image
+ *
+ *  Shrink *self* by <i>width_ratio</i> along the horizontal and
+ *  <i>height_ratio</i> along the vertical direction. If <i>height_ratio</i> is
+ *  not given, it uses <i>width_ratio</i>. The function does not perform
+ *  subpixel interpolation and therefore the resultant image can present
+ *  aliasing especially for small x and y factors. Any size image, any
+ *  non-complex type, any number of bands.
+ */
+
+VALUE
+img_shrink(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE width_ratio, height_ratio;
+
+    rb_scan_args(argc, argv, "11", &width_ratio, &height_ratio);
+    if (NIL_P(height_ratio))
+        height_ratio = width_ratio;
+
+    GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_shrink(im, im_new, NUM2DBL(width_ratio), NUM2DBL(height_ratio)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.rightshift_size(xshift, yshift, fmt) -> image
+ *
+ *  Decreases the size of an integer type image by a power-of-two factor, very
+ *  quickly, by summing the values of adjacent pixels. The sum is shifted to
+ *  produce output of the specified band format.
+ *
+ *  <i>xshift</i> and <i>yshift</i> are positive and give the base-two
+ *  logarithms of the scale factors.
+ *
+ *  If the input image is a signed type, then the band format must be one of
+ *  :CHAR, :SHORT or :INT.  If it is an unsigned type, then the band format must
+ *  be one of :UCHAR, :USHORT or :UINT.
+ */
+
+VALUE
+img_rightshift_size(VALUE obj, VALUE xshift, VALUE yshift, VALUE fmt)
+{
+	GetImg(obj, data, im);
+	OutImg(obj, new, data_new, im_new);
+
+    if(im_rightshift_size(im, im_new, NUM2DBL(xshift), NUM2DBL(yshift),
+		header_id_to_band_fmt(SYM2ID(fmt))))
+        vips_lib_error();
+
+    return new;
+}
+
+
+/*
+ *  call-seq:
+ *     im.match_linear(other_image, xr1, yr1, xs1, ys1, xr2, yr2, xs2,
+ *       ys2) -> image
+ *
+ *  Works exactly as Image#match_linear_search, but does not attempt to
+ *  correlate to correct your tie points. It can thus be used for any angle and
+ *  any scale, but you must be far more careful in your selection.
+ */
+
+VALUE
+img_match_linear(VALUE obj, VALUE obj2,
+    VALUE xr1, VALUE yr1, VALUE xs1, VALUE ys1,
+    VALUE xr2, VALUE yr2, VALUE xs2, VALUE ys2)
+{
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_match_linear(im, im2, im_new,
+        NUM2INT(xr1), NUM2INT(yr1), NUM2INT(xs1), NUM2INT(ys1),
+        NUM2INT(xr2), NUM2INT(yr2), NUM2INT(xs2), NUM2INT(ys2)))
+        vips_lib_error();
+
+    return new;
+}
+
+/*
+ *  call-seq:
+ *     im.match_linear_search(other_image, xr1, yr1, xs1, ys1, xr2, yr2, xs2,
+ *       ys2, hwindowsize, hsearchsize) -> image
+ *
+ *  Attempts to transform sec to make it match ref. The transformation is
+ *  linear, that is, it only involves scale, rotate and translate.
+ *
+ *  Requires a pair of tie points to fix the parameters of its transformation.
+ *  You should pick points as far apart as possible to increase accuracy. It
+ *  will search the area in the image around each tie point for a good fit, so
+ *  your selection of points need not be exact. WARNING! This searching process
+ *  will fail for rotations of more than about 10 degrees or for scales of more
+ *  than about 10 percent.
+ *
+ *  The best you can hope for is < 1 pixel error, since the command does not
+ *  attempt sub-pixel correlation.
+ *
+ *  <i>hwindowsize</i> and <i>hsearchsize</i> set the size of the area to be
+ *  searched: we recommend values of 5 and 14.
+ *
+ *  The output image is positioned and clipped so that you can immediately
+ *  subtract it from orig to obtain pixel difference images.
+ */
+
+VALUE
+img_match_linear_search(VALUE obj, VALUE obj2,
+    VALUE xr1, VALUE yr1, VALUE xs1, VALUE ys1,
+    VALUE xr2, VALUE yr2, VALUE xs2, VALUE ys2,
+    VALUE hwindowsize, VALUE hsearchsize)
+{
+	GetImg(obj, data, im);
+	GetImg(obj2, data2, im2);
+	OutImg(obj, new, data_new, im_new);
+
+    if (im_match_linear_search(im, im2, im_new,
+        NUM2INT(xr1), NUM2INT(yr1), NUM2INT(xs1), NUM2INT(ys1),
+        NUM2INT(xr2), NUM2INT(yr2), NUM2INT(xs2), NUM2INT(ys2),
+        NUM2INT(hwindowsize), NUM2INT(hsearchsize)))
+        vips_lib_error();
+
+    return new;
+}