carray 1.1.4 → 1.1.5

data/ext/fortio/ruby_fortio.c

@@ -0,0 +1,182 @@
+/* ---------------------------------------------------------------------------
+
+  carray/carray_fortio.c
+
+  This file is part of Ruby/CArray extension library.
+  You can redistribute it and/or modify it under the terms of
+  the Ruby Licence.
+
+  Copyright (C) 2005 Hiroki Motoyoshi
+
+---------------------------------------------------------------------------- */
+
+#include "ruby.h"
+#include <math.h>
+
+static int
+read_F (char *buf, int buflen, int scale, int length, int prec, double *a)
+{
+  char fmt[128];
+  int status;
+  if ( ! strchr(buf, '.') ) {
+    int tmp = 0;
+    snprintf(fmt, 128, "%%%i", length);
+    status = sscanf(buf, fmt, &tmp);
+    *a = tmp * pow(10, -prec);
+  }
+  else {
+    snprintf(fmt, 128, "%%%i.%if", length, prec);     
+    status = sscanf(buf, fmt, a);
+  }
+  return status;
+}
+
+static VALUE
+rb_ff_read_F (VALUE mod, VALUE vbuffer, VALUE vscale, VALUE vlength, VALUE vprec)
+{
+  double val;
+  int status;
+  status = read_F(StringValuePtr(vbuffer), RSTRING_LEN(vbuffer),
+                  NUM2INT(vscale), NUM2INT(vlength), NUM2INT(vprec), &val);
+  if ( ! status ) {
+    rb_raise(rb_eRuntimeError, "invalid string for F descriptor");
+  }
+  return rb_float_new(val);
+}
+
+static int
+write_F (char *buf, int buflen, int plus, int scale, int length, int prec, double a)
+{
+  char fmt[128];
+  if ( plus ) {
+    snprintf(fmt, 128, "%%+%i.%if", length, prec);
+  }
+  else {
+    snprintf(fmt, 128, "%%%i.%if", length, prec);
+  }
+  if ( scale == 0 ) {
+    return snprintf(buf, buflen, fmt, a);
+  }
+  else {
+    return snprintf(buf, buflen, fmt, a * pow(10, scale));
+  }
+}
+
+static VALUE
+rb_ff_write_F (VALUE mod, VALUE vsign, VALUE vscale, VALUE vlength, VALUE vprec, VALUE va)
+{
+  int length = NUM2INT(vlength);
+  char buf[256];
+  if ( length > 255 ) {
+    rb_raise(rb_eRuntimeError, "too long decimal format for FortranFormat");
+  }
+  write_F(buf, 255, 
+             RTEST(vsign), NUM2INT(vscale), length, NUM2INT(vprec),  NUM2DBL(va));
+  return rb_str_new2(buf);
+}
+
+
+static int
+write_E (char *buf, int buflen, int plus, int scale, int length, int prec, int iexp, double a)
+{
+  char fmt[128];
+  int prec0;
+  int e, sign = 1;
+  prec0 = ( 1 - scale < 0 ) ? prec - scale + 1 : prec;
+  sign = 1;
+  if ( a < 0 ) {
+    e = floor(log10(-a))+1;
+    sign = -1;
+  }
+  if ( a > 0 ) {
+    e = floor(log10(a))+1;      
+  }
+  else {
+    e = 0;
+  }
+  if ( prec0 == 0 ) {
+    if ( plus ) {
+      snprintf(fmt, 128, "%%+%i.0f.E%%+0%ii", length-iexp-3, iexp+1);
+    }
+    else {
+      snprintf(fmt, 128, "%%%i.0f.E%%+0%ii", length-iexp-3, iexp+1);
+    }
+  }
+  else {
+    if ( plus ) {
+      snprintf(fmt, 128, "%%+%i.%ifE%%+0%ii", length-iexp-2, prec0, iexp+1);
+    }
+    else {
+      snprintf(fmt, 128, "%%%i.%ifE%%+0%ii", length-iexp-2, prec0, iexp+1);
+    }
+  }
+  return snprintf(buf, buflen, fmt, sign * a * pow(10,scale-e), e-scale);
+}
+
+static VALUE
+rb_ff_write_E (VALUE mod, VALUE vsign, VALUE vscale, VALUE vlength, VALUE vprec, VALUE vexp, VALUE va)
+{
+  int length = NUM2INT(vlength);
+  int iexp   = NIL_P(vexp) ? 2 : NUM2INT(vexp);
+  char buf[256];
+  if ( length > 255 ) {
+    rb_raise(rb_eRuntimeError, "too long decimal format for FortranFormat");
+  }
+  write_E(buf, 255, 
+             RTEST(vsign), NUM2INT(vscale), length, NUM2INT(vprec), iexp, NUM2DBL(va));
+  return rb_str_new2(buf);
+}
+
+static int
+write_GF (char *buf, int buflen, int plus, int length, int prec, int iexp, double a)
+{
+  int e;
+  if ( a < 0 ) {
+    e = floor(log10(-a))+1;
+  }
+  if ( a > 0 ) {
+    e = floor(log10(a))+1;      
+  }
+  else {
+    e = 0;
+  }
+  write_E(buf, 255, plus, e, length, prec-1, iexp, a);
+  memset(buf+(length-iexp-2), ' ', iexp+2);
+  return 1;
+}
+
+static VALUE
+rb_ff_write_G (VALUE mod, VALUE vsign, VALUE vscale, VALUE vlength, VALUE vprec, VALUE vexp, VALUE va)
+{
+  int length = NUM2INT(vlength);
+  int iprec  = NUM2INT(vprec);
+  int iexp   = NIL_P(vexp) ? 2 : NUM2INT(vexp);
+  double val = NUM2DBL(va);
+  char buf[256];
+  if ( length > 255 ) {
+    rb_raise(rb_eRuntimeError, "too long decimal format for FortranFormat");
+  }
+  if ( ( fabs(val) <= 0.1 ) ||
+       ( fabs(val) >= pow(10, iprec) ) ) {
+    write_E(buf, 255, 
+            RTEST(vsign), NUM2INT(vscale), length, iprec, iexp, val);
+  }
+  else {
+    write_GF(buf, 255, RTEST(vsign), length, iprec, iexp, val);
+  }
+  return rb_str_new2(buf);
+}
+
+void
+Init_fortio_ext ()
+{
+  VALUE rb_cFF = rb_define_class("FortranFormat", rb_cObject);
+  rb_define_singleton_method(rb_cFF, "read_F",  rb_ff_read_F,  4);
+  rb_define_singleton_method(rb_cFF, "write_F", rb_ff_write_F, 5);
+  rb_define_singleton_method(rb_cFF, "write_E", rb_ff_write_E, 6);
+  rb_define_singleton_method(rb_cFF, "write_G", rb_ff_write_G, 6);
+}
+
+
+
+

data/ext/fortio/test/test_H.rb

@@ -0,0 +1,5 @@
+require "fortio"
+
+p FortranFormat.new("((5(5Hhello)$))")
+
+puts fortran_format("(2(5(5Hhello))$)")

data/ext/fortio/test/test_T.rb

@@ -0,0 +1,7 @@
+require "fortio"
+
+fortran_format_write(STDOUT, "(TR12,A1)", "a")
+fortran_format_write(STDOUT, "(TR12,A1,TL5,A1,TL3,A1)", "a", "b", "c")
+fortran_format_write(STDOUT, "(TR12,A1,T5,A1,T3,A1)", "a", "b", "c")
+
+p FortranFormat.new("(A12)")

data/ext/fortio/test/test_fortran_format.rb

@@ -0,0 +1,86 @@
+require 'fortio'
+
+include Math
+
+#F77 = "ifort"
+F77 = "gfortran"
+#F77 = "g95"
+#F77 = "g77"
+
+def f77_compile_and_run (source)
+  output = nil
+  begin
+    open("test.f", "w") { |io|
+      io.write(source)
+    }
+    system("#{F77} test.f")
+    output = `./a.out`.chomp
+  ensure
+    File.unlink("test.f")
+    File.unlink("a.out")
+  end
+end
+
+[
+ ["F12.3",    10.0,        nil],
+ ["2F12.3",   [10.0,11.0], nil],
+ ["E12.2",    10.0,        nil],
+ ["2E12.2",   [10.0,11.0], nil],
+ ["2PE12.2",  10.0,        nil],
+ ["2P2E12.2", [10.0,11.0], nil],
+ ["2G12.2",   [10.0,11.0], nil],
+ ["2PG12.2",  10.0,        nil],
+ ["2PG12.2E3",10.0,        nil],
+ ["2PG12.2",  1234567890.0,        nil],
+ ["2PG12.2E3",1234567890.0,        nil],
+ # ---
+ ["F15.8",    PI, "#{PI}D0"],
+ ["E15.8",    PI, "#{PI}D0"],
+ ["2PE15.8",  PI, "#{PI}D0"],
+ # ---
+ ["F10.8",    PI, "#{PI}D0"],
+ ["E10.8",    PI, "#{PI}D0"],
+ ["2PE10.8",  PI, "#{PI}D0"],
+ # ---
+ ["I4.3",     123456,     nil],
+ ["I6.5",     123,        nil],
+ ["I6.5",     123,        nil],
+ ["I7.6",     123456,     nil],
+ ["I6",       123456,     nil],
+ # ---
+ ["SPI6",      123456,    nil],
+ ["SPI7",      123456,    nil],
+ ["SPF12.4",   123456.0,  nil],
+ ["SPE12.4E3", 123456.0,  nil],
+ ["SPG12.4E3", 123456.0,  nil],
+ ["SPG12.4E3", 123.0,     nil],
+ ["TR2SPSG12.4E3", 123.0, nil],
+ # ---
+ ["L1",        true,     ".TRUE."],
+ ["L1",        false,    ".FALSE."],
+ ["L2",        true,     ".TRUE."],
+ ["L2",        false,    ".FALSE."],
+ ["L4",        true,     ".TRUE."],
+ ["L4",        false,    ".FALSE."],
+ # ---
+ ["A1",        "a",     "'a'"],
+ ["A2",        "ab",    "'ab'"],
+ ["5Hhello",   nil,  nil],
+ # ---
+ ["/",        "\n",     ""],
+ ["2/",        "\n\n",     ""],
+].each do |fmt, rval, fval|
+  fort_out = f77_compile_and_run %{
+      write(6, '(#{fmt})') #{[fval||rval||[]].flatten.join(',')}
+      end
+  }
+  ruby_out = fortran_format(fmt+"$", *rval)
+  puts "-------------------------------------------------------------"
+  printf("format         : %s\n", fmt)
+  printf("fortran input  : %s\n", [fval||rval].flatten.join(','))
+  printf("ruby input     : %s\n", [rval].flatten.join(","))
+  printf("fortran output : %s\n", fort_out.inspect)
+  printf("ruby output    : %s\n", ruby_out.inspect)
+  printf("comparison     : %s\n", fort_out == ruby_out)
+end
+

data/ext/fortio/test/test_namelist.rb

@@ -0,0 +1,25 @@
+require "fortio"
+require "pp"
+
+text =<<END
+aaaa bbbb cccc
+dddd eeee ffff
+&name
+ c=30.d0,
+ a=10.d0,
+ b=20.d0,
+ d(1:3) = 1,2,3
+ &end
+&foo
+ c=10.d+32,
+ a=50.d0,
+ b=90.d0,
+ d(1:5) = 3*4,,3
+ e="hello""world!"
+ &end
+END
+
+pp nml = fortran_namelist_read(text, "name", {:d=>CArray.int(3)})
+pp nml = fortran_namelist_read(text, "foo", {:d=>CArray.int(5)})
+
+puts fortran_namelist("bar", nml)

data/ext/fortio/test/test_sequential.rb

@@ -0,0 +1,13 @@
+require "fortio"
+
+fs = FortranSequential.open("test.dat", "w", :endian=>"big")
+rec = fs.record
+rec.write("d4l", [1.2, 2008, 6, 21, 9])
+fs.close
+
+fs = FortranSequential.open("test.dat", "r", :endian=>"big")
+rec = fs.record
+p rec.read("d4l")
+fs.close
+
+File.unlink("test.dat")

data/ext/fortio/test/test_sequential2.rb

@@ -0,0 +1,13 @@
+require "fortio"
+
+a = CArray.float(3).seq!
+
+fortran_sequential_open("test.dat", "w") { |io|
+  io.write(a)
+}
+
+fortran_sequential_open("test.dat") { |io|
+  p io.read.unpack("e3")
+}
+
+File.unlink("test.dat")

data/ext/fortio/work/test.rb

@@ -0,0 +1,10 @@
+require "carray"
+
+text =<<END
+  1  2  3  4
+  5  6  7  8
+END
+
+ca = CArray.from_fortran_format("2I3,2F3.0/2F3.0,2I3", text)
+
+ca.to_fortran_format("2I3,1P,2E10.2E3", STDOUT)

data/ext/fortio/work/test_e.rb

@@ -0,0 +1,19 @@
+require "fortio"
+
+p f = FortranFormat("4(2P,3E6.2E4,2I2.1)$")
+p f.count_args
+p fortran_format("2P,E10.2E4,$", 0.000012345)
+p f = FortranFormat("2(E10.2E4,',')")
+p fortran_format("2(E10.2E4,',')", 0.000012345, 2.0)
+p f = FortranFormat('2(-2PG15.5 4X2(I2)/)')
+puts fortran_format(f, 3.1415926,2,4, 2.71828,3,5)
+
+p f = FortranFormat('3P,4(G15.5/)')
+p f.count_args
+puts fortran_format(f, 0.1, 0.11, 10**5-1, 10**5)
+
+p f = FortranFormat('A10,"""\'|\'"""')
+p f.count_args
+puts fortran_format(f, "hello")
+
+puts fortran_format_read("12345", "F5.2")

data/ext/fortio/work/test_ep.rb

@@ -0,0 +1,10 @@
+require "fortio"
+
+fmt200 = FortranFormat.new("(3pe13.6,-2p2e13.6)")
+
+p fortran_format_write("", fmt200, *[0.000123456]*3)
+
+p text = fortran_format_write("", "3pf10.5", 3)
+p fortran_format_read(text, "3pf10.5")
+
+p fortran_format_write("", "g13.5", 893)

data/ext/fortio/work/test_parse.rb

@@ -0,0 +1,12 @@
+require "carray"
+require "fortio"
+
+head = "    1440   721    0.00   90.00  0.2500 31 0.18712E+00 0.44215E-01 0.35660E-01 0.30406E-01 0.34569E-01 0.17713E-01 0.25666E-01 0.26762E-01 0.10912E-01 0.10623E-01 0.62775E-02 0.66029E-02 0.11870E+00 0.47465E-02 0.86580E-01 0.33813E-02 0.10799E+00 0.22265E-02 0.76236E-01 0.65007E-01 0.51308E-01 0.58308E-01 0.43458E-01 0.21357E-01 0.89651E-02 0.10000E-01 0.10000E-01 0.10000E-01 0.10000E-01 0.10000E-02 0.10000E+01"
+
+ffp = FortranFormat.new('2X,2i6,2f8.2,f8.4,i3,31e12.5')
+p list = ffp.read(head)
+ffp.write(test="", *list)
+
+p head 
+p test
+p head == test

data/ext/imagemap/carray_imagemap.c

@@ -0,0 +1,495 @@
+/* ---------------------------------------------------------------------------
+
+  carray/carray_imagemap.c
+
+  This file is part of Ruby/CArray extension library.
+  You can redistribute it and/or modify it under the terms of
+  the Ruby Licence.
+
+  Copyright (C) 2005 Hiroki Motoyoshi
+
+---------------------------------------------------------------------------- */
+
+#include "carray.h"
+#include <math.h>
+
+#define ca_ptr_1d(ap, i)      \
+  ca_ptr_at_addr((ap), (i))
+#define ca_ptr_2d(ap, i, j)   \
+  ca_ptr_at_addr((ap), ((CArray*)(ap))->dim[1]*(i) + (j))
+#define ca_ptr_3d(ap, i, j, k)    \
+  ca_ptr_at_addr(ap,            \
+   ((CArray*)(ap))->dim[2]*( ((CArray*)(ap))->dim[1]*(i) + (j) ) + (k))
+
+#define ca_ref_1d(type, ap, i)      \
+  (*(type*) ca_ptr_at_addr((ap), (i)))
+#define ca_ref_2d(type, ap, i, j)   \
+  (*(type*) ca_ptr_at_addr((ap), ((CArray*)(ap))->dim[1]*(i) + (j)))
+#define ca_ref_3d(type, ap, i, j, k)    \
+  (*(type*) ca_ptr_at_addr(ap,            \
+   ((CArray*)(ap))->dim[2]*( ((CArray*)(ap))->dim[1]*(i) + (j) ) + (k)))
+
+#define CA_REF(ca, i, j) ca_ref_2d(int8_t, (ca), (i), (j))
+
+#define round(x) (int)(((x)>0) ? floor((x)+0.5) : ((x)<0) ? ceil((x)-0.5) : 0)
+
+static void
+draw_linex (CArray *ca, float x0, float y0, float x1, float y1, char *ptr)
+{
+  float x, y;
+  int ix, iy;
+  int dim0 = ca->dim[0];
+  int dim1 = ca->dim[1];
+  float a = (y1-y0)/(x1-x0);
+  for (x=x0; x<x1; x+=1) {
+    y = a*(x-x0)+y0;
+    ix = round(x);
+    iy = round(y);
+    if ( ix < 0 || ix >= dim0 || iy < 0 || iy >= dim1 ) {
+      continue;
+    }
+    memcpy(ca_ptr_2d(ca, ix, iy), ptr, ca->bytes);
+  }
+}
+
+static void
+draw_liney (CArray *ca, float x0, float y0, float x1, float y1, char *ptr)
+{
+  float x, y;
+  int ix, iy;
+  int dim0 = ca->dim[0];
+  int dim1 = ca->dim[1];
+  float a = (x1-x0)/(y1-y0);
+  for (y=y0; y<y1; y+=1) {
+    x = a*(y-y0)+x0;
+    ix = round(x);
+    iy = round(y);
+    if ( ix < 0 || ix >= dim0 || iy < 0 || iy >= dim1 ) {
+      continue;
+    }
+    memcpy(ca_ptr_2d(ca, ix, iy), ptr, ca->bytes);
+  }
+}
+
+void
+draw_line (CArray *ca, float x0, float y0, float x1, float y1, char *ptr)
+{
+  if ( fabs(y1-y0) < fabs(x1-x0) ) {
+    if ( x1 > x0 ) {
+      draw_linex(ca, x0, y0, x1, y1, ptr);
+    }
+    else if ( x1 < x0 ) {
+      draw_linex(ca, x1, y1, x0, y0, ptr);
+    }
+  }
+  else {
+    if ( y1 > y0 ) {
+      draw_liney(ca, x0, y0, x1, y1, ptr);
+    }
+    else if ( y1 < y0 ) {
+      draw_liney(ca, x1, y1, x0, y0, ptr);
+    }
+  }
+}
+
+static VALUE
+rb_img_draw_line (VALUE self, 
+                  VALUE vx0, VALUE vy0, VALUE vx1, VALUE vy1, volatile VALUE vz)
+{
+  CArray *ca, *cz;
+
+  Data_Get_Struct(self, CArray, ca);
+  cz = ca_wrap_readonly(vz, ca->data_type);
+
+  ca_attach(ca);
+
+  draw_line(ca, NUM2DBL(vx0), NUM2DBL(vy0), NUM2DBL(vx1), NUM2DBL(vy1), cz->ptr);
+
+  ca_detach(ca);
+
+  return Qnil;
+}
+
+/*
+  def self.fill_rect2(image, x, y, val)
+    xmin, xmax = x.min, x.max
+    ymin, ymax = y.min, y.max
+    img = CArray.int8(xmax.round-xmin.round+1, ymax.round-ymin.round+1) { 0 }
+    if (xmax + img.dim0 >= image.dim0 ) or 
+        (xmin < 0 ) or 
+        (ymax + img.dim1 >= image.dim1) or 
+        (ymin < 0)
+      return
+    end
+    subimg = image[[xmin.round,img.dim0],[ymin.round,img.dim1]]
+    gx = x-xmin.round
+    gy = y-ymin.round
+    img.draw_box(gx, gy)
+    img.fill_out()
+    subimg[img] = val
+  end
+*/
+
+static void
+fill_rect (CArray *image, float x[4], float y[4], char *ptr)
+{
+  CArray *mask;
+  float xmin, xmax, ymin, ymax;
+  float gx[4], gy[4];
+  int32_t dim[2];
+  int32_t i, j, ixmin, iymin, ixmax, iymax;
+  char  one = 1;
+
+  xmin = x[0];
+  xmax = x[0];
+  ymin = y[0];
+  ymax = y[0];
+
+  for (i=1; i<4; i++) {
+    if ( isnan(x[i]) || isnan(y[i]) )
+      return;
+    if ( x[i] < xmin ) {
+      xmin = x[i];
+    }
+    if ( x[i] > xmax ) {
+      xmax = x[i];
+    }
+    if ( y[i] < ymin ) {
+      ymin = y[i];
+    }
+    if ( y[i] > ymax ) {
+      ymax = y[i];
+    }
+  }
+
+  ixmin = (int32_t) floor(xmin);
+  iymin = (int32_t) floor(ymin);
+
+  ixmax = (int32_t) ceil(xmax) + 1;
+  iymax = (int32_t) ceil(ymax) + 1;
+
+  dim[0] = ixmax - ixmin + 1;
+  dim[1] = iymax - iymin + 1;
+
+  mask = carray_new(CA_BOOLEAN, 2, dim, 0, NULL);
+  memset(mask->ptr, 0, mask->elements);
+
+  for (i=0; i<4; i++) {
+    gx[i] = x[i] - ixmin + 1;
+    gy[i] = y[i] - iymin + 1;
+  }
+
+  draw_line(mask, gx[0], gy[0], gx[1], gy[1], &one);
+  draw_line(mask, gx[1], gy[1], gx[3], gy[3], &one);
+  draw_line(mask, gx[3], gy[3], gx[2], gy[2], &one);
+  draw_line(mask, gx[2], gy[2], gx[0], gy[0], &one);
+
+  for (i=0; i<dim[0]; i++) {
+    for (j=0; j<dim[1]; j++) {
+      if ( CA_REF(mask,i,j) ) {
+        break;
+      }
+      CA_REF(mask,i,j) = -1;
+    }
+    for (j=dim[1]-1; j>=0; j--) {
+      if ( CA_REF(mask,i,j) ) {
+        break;
+      }
+      CA_REF(mask,i,j) = -1;
+    }
+  }
+
+  for (i=0; i<dim[0]; i++) {
+    if ( ixmin+i < 0 || ixmin+i >= image->dim[0] )
+      continue;
+    for (j=0; j<dim[1]; j++) 
+      if ( CA_REF(mask,i,j) >= 0 ) {
+        if ( iymin+j < 0 || iymin+j >= image->dim[1] ) {
+          continue;
+        }
+        memcpy(ca_ptr_2d(image, ixmin+i, iymin+j), ptr, image->bytes);
+      }
+  }
+
+  ca_free(mask);
+}
+
+
+static VALUE
+rb_im_fill_rect (VALUE self, 
+     VALUE vimg, 
+     volatile VALUE vx, volatile VALUE vy, volatile VALUE vval)
+{
+  CArray *image, *val, *cx, *cy;
+
+  Data_Get_Struct(vimg, CArray, image);
+  Data_Get_Struct(vx, CArray, cx);
+  Data_Get_Struct(vy, CArray, cy);
+
+  cx  = ca_wrap_readonly(vx, CA_FLOAT);
+  cy  = ca_wrap_readonly(vy, CA_FLOAT);
+  val = ca_wrap_readonly(vval, image->data_type);
+
+  ca_attach_n(3, cx, cy, val);
+
+  fill_rect(image, (float*)cx->ptr, (float*)cy->ptr, val->ptr);
+
+  ca_detach_n(3, cx, cy, val);
+
+  return Qnil;
+}
+
+void
+draw_hline_gradation (CArray *image, int iy, 
+          float x0, float x1, float z0, float z1);
+
+static VALUE
+rb_img_draw_hline_gradation (VALUE self, VALUE viy,
+           VALUE vx0, VALUE vx1, VALUE vz0, VALUE vz1)
+{
+  CArray *image;
+
+  Data_Get_Struct(self, CArray, image);
+
+  draw_hline_gradation(image, NUM2INT(viy),
+           NUM2DBL(vx0), NUM2DBL(vx1), NUM2DBL(vz0), NUM2DBL(vz1));
+
+  return Qnil;
+}
+
+void
+draw_triangle_gradation (CArray *image, float y[3], float x[3], float z[3]);
+
+static VALUE
+rb_img_draw_triangle_gradation (VALUE self, 
+        VALUE vy, VALUE vx, VALUE vz)
+{
+  CArray *image;
+  float y[3], x[3], z[3];
+  int i;
+
+  Data_Get_Struct(self, CArray, image);
+
+  for (i=0; i<3; i++) {
+    y[i] = NUM2DBL(rb_ary_entry(vy, i));
+    x[i] = NUM2DBL(rb_ary_entry(vx, i));
+    z[i] = NUM2DBL(rb_ary_entry(vz, i));
+  }
+
+  draw_triangle_gradation(image, y, x, z);
+
+  return Qnil;
+}
+
+void
+fill_rectangle (CArray *image, float y[4], float x[4], char *ptr);
+
+static VALUE
+rb_img_fill_rectangle (VALUE self, 
+           volatile VALUE vy, volatile VALUE vx, volatile VALUE vz)
+{
+  CArray *image, *cy, *cx, *cz;
+
+  Data_Get_Struct(self, CArray, image);
+
+  cy = ca_wrap_readonly(vy, CA_FLOAT);
+  cx = ca_wrap_readonly(vx, CA_FLOAT);
+  cz = ca_wrap_readonly(vz, image->data_type);
+
+  if ( cy->elements != 4 || cx->elements != 4 ) {
+    rb_raise(rb_eRuntimeError, "invalid size of y or x");
+  }
+
+  ca_attach_n(4, image, cy, cx, cz);
+
+  fill_rectangle(image, (float*)cy->ptr, (float*)cx->ptr, cz->ptr);
+
+  ca_detach_n(4, image, cy, cx, cz);
+
+  return Qnil;
+}
+
+void
+fill_rectangle_image (CArray *image, CArray *cy, CArray *cx, CArray *cv);
+
+static VALUE
+rb_img_fill_rectangle_image (VALUE self, 
+          volatile VALUE vy, volatile VALUE vx, volatile VALUE vz)
+{
+  CArray *image, *cy, *cx, *cz;
+
+  Data_Get_Struct(self, CArray, image);
+
+  cy = ca_wrap_readonly(vy, CA_FLOAT);
+  cx = ca_wrap_readonly(vx, CA_FLOAT);
+  cz = ca_wrap_readonly(vz, image->data_type);
+
+  ca_attach_n(4, image, cy, cx, cz);
+
+  fill_rectangle_image(image, cy, cx, cz);
+
+  ca_sync(image);
+
+  ca_detach_n(4, image, cy, cx, cz);
+
+  return Qnil;
+}
+
+void
+fill_rectangle_grid (CArray *image, CArray *cy, CArray *cx, CArray *cv);
+
+static VALUE
+rb_img_fill_rectangle_grid (VALUE self, 
+     volatile VALUE vy, volatile VALUE vx, volatile VALUE vz)
+{
+  CArray *image, *cy, *cx, *cz;
+
+  Data_Get_Struct(self, CArray, image);
+
+  cy = ca_wrap_readonly(vy, CA_FLOAT);
+  cx = ca_wrap_readonly(vx, CA_FLOAT);
+  cz = ca_wrap_readonly(vz, image->data_type);
+
+  ca_attach_n(4, image, cy, cx, cz);
+
+  fill_rectangle_grid(image, cy, cx, cz);
+
+  ca_detach_n(4, image, cy, cx, cz);
+
+  return Qnil;
+}
+
+void
+draw_rectangle_gradation (CArray *image, float y[4], float x[4], float z[4]);
+
+static VALUE
+rb_img_draw_rectangle_gradation (VALUE self, 
+          volatile VALUE vy, volatile VALUE vx, volatile VALUE vz)
+{
+  CArray *image, *cy, *cx, *cz;
+
+  Data_Get_Struct(self, CArray, image);
+
+  cy = ca_wrap_readonly(vy, CA_FLOAT);
+  cx = ca_wrap_readonly(vx, CA_FLOAT);
+  cz = ca_wrap_readonly(vz, CA_FLOAT);
+
+  if ( cy->elements != 4 || cx->elements != 4 || cz->elements != 4) {
+    rb_raise(rb_eRuntimeError, "invalid size of y or x or z");
+  }
+
+  ca_attach_n(4, image, cy, cx, cz);
+
+  draw_rectangle_gradation(image, 
+         (float*)cy->ptr, (float*)cx->ptr, (float*)cz->ptr);
+
+  ca_detach_n(4, image, cy, cx, cz);
+
+  return Qnil;
+}
+
+void
+draw_rectangle_gradation_grid (CArray *image, 
+             CArray *cy, CArray *cx, CArray *cv);
+
+static VALUE
+rb_img_draw_rectangle_gradation_grid (VALUE self, 
+                     volatile VALUE vy, volatile VALUE vx, volatile VALUE vz)
+{
+  CArray *image, *cy, *cx, *cz;
+
+  Data_Get_Struct(self, CArray, image);
+
+  cy = ca_wrap_readonly(vy, CA_FLOAT);
+  cx = ca_wrap_readonly(vx, CA_FLOAT);
+  cz = ca_wrap_readonly(vz, image->data_type);
+
+  ca_attach_n(4, image, cy, cx, cz);
+
+  draw_rectangle_gradation_grid(image, cy, cx, cz);
+
+  ca_detach_n(4, image, cy, cx, cz);
+
+  return Qnil;
+}
+
+void
+draw_points (CArray *image, 
+       CArray *cy, CArray *cx, CArray *cz);
+
+static VALUE
+rb_img_draw_points (VALUE self, 
+                    volatile VALUE vy, volatile VALUE vx, volatile VALUE vz)
+{
+  CArray *image, *cy, *cx, *cz;
+
+  Data_Get_Struct(self, CArray, image);
+
+  cy = ca_wrap_readonly(vy, CA_FLOAT);
+  cx = ca_wrap_readonly(vx, CA_FLOAT);
+  cz = ca_wrap_readonly(vz, image->data_type);
+
+  ca_attach_n(4, image, cy, cx, cz);
+
+  draw_points(image, cy, cx, cz);
+
+  ca_detach_n(4, image, cy, cx, cz);
+
+  return Qnil;
+}
+
+void
+draw_polyline (CArray *image, 
+         CArray *cy, CArray *cx, char *ptr);
+
+static VALUE
+rb_img_draw_polyline (VALUE self, 
+          volatile VALUE vy, volatile VALUE vx, volatile VALUE vz)
+{
+  CArray *image, *cy, *cx, *cz;
+
+  Data_Get_Struct(self, CArray, image);
+
+  cy = ca_wrap_readonly(vy, CA_FLOAT);
+  cx = ca_wrap_readonly(vx, CA_FLOAT);
+  cz = ca_wrap_readonly(vz, image->data_type);
+
+  ca_attach_n(4, image, cy, cx, cz);
+
+  draw_polyline(image, cy, cx, cz->ptr);
+
+  ca_detach_n(4, image, cy, cx, cz);
+
+  return Qnil;
+}
+
+void
+Init_carray_imagemap ()
+{
+  VALUE rb_cImage = rb_const_get(rb_cObject, rb_intern("ImageMap"));
+  
+  rb_define_singleton_method(rb_cImage, "fill_rect", rb_im_fill_rect, 4);
+
+  rb_define_method(rb_cImage, "fill_rectangle", 
+                         rb_img_fill_rectangle, 3);
+  rb_define_method(rb_cImage, "fill_rectangle_image", 
+                         rb_img_fill_rectangle_image, 3);
+  rb_define_method(rb_cImage, "fill_rectangle_grid", 
+                         rb_img_fill_rectangle_grid, 3);
+
+  rb_define_method(rb_cImage, "draw_line", rb_img_draw_line, 5);
+  rb_define_method(rb_cImage, "draw_hline_gradation", 
+                            rb_img_draw_hline_gradation, 5);
+  rb_define_method(rb_cImage, "draw_triangle_gradation", 
+                         rb_img_draw_triangle_gradation, 3);
+  rb_define_method(rb_cImage, "draw_rectangle_gradation", 
+                         rb_img_draw_rectangle_gradation, 3);
+  rb_define_method(rb_cImage, "draw_rectangle_gradation_grid", 
+                       rb_img_draw_rectangle_gradation_grid, 3);
+
+  rb_define_method(rb_cImage, "draw_points", rb_img_draw_points, 3);
+  rb_define_method(rb_cImage, "draw_polyline", rb_img_draw_polyline, 3);
+
+}
+
+