carray 1.1.4 → 1.1.5

data/ext/imagemap/test/test.rb

@@ -0,0 +1,23 @@
+require 'carray'
+
+#sc = ImageMap::ColorScale.pm3d(13,10,14,256,:interpolation => false)
+#sc = ImageMap::ColorScale.GMT("GMT_globe.cpt")
+#sc.set_range(0..Math::PI)
+#sc.set_upper_color(127,127,127)
+#sc.set_lower_color(127,127,127)
+#sc.set_mask_color( 127,127,127)
+
+ca = CArray.float(640, 480)
+ca[:i,nil].scale!(-0.1, Math::PI+0.1)
+ca.mask = 0
+ca.mask[90..110,90..110] = 1
+
+if true
+  im = ImageMap.create(ca, sc)
+  require 'carray/RMagick'
+  il = Magick::Image.new_from_ca(im)
+  il.display
+else
+  im = ImageMap.display(ca, sc)
+end
+

data/ext/imagemap/test/test_image.rb

@@ -0,0 +1,42 @@
+require 'carray'
+require 'carray/image_map'
+require 'benchmark'
+
+lon = CArray.float(37).span!(-90..180)
+lat = CArray.float(12).span!(0..90)
+
+u = lon[:%,lat.dim0]
+v = lat[lon.dim0,:%]
+val = u.rad.sin! + v.rad 
+
+image = ImageMap.new(CA_DOUBLE, [600, 600]) { -9999 }
+
+image.set_xrange(-103..103)
+image.set_yrange(-103..103)
+
+Benchmark.bm do |o|
+  o.report {
+    image.warp(val, u, v, :grid=>"point", :gradation => true) {
+      |_u,_v,_x,_y|
+      _x[] = (100 - _v/3) * _u.rad.cos!
+      _y[] = (100 - _v/3) * _u.rad.sin!
+    }
+  }
+end
+
+#image.draw_line(0, 0, 0, 90, 0)
+image.line(0, 0, 0, 90, 0)
+
+poly = CArray.float(4,2) {[[-90,90],[0,0],[45,45],[0,90]]}
+
+image.polyline(poly[nil,1],poly[nil,0], 0)
+
+image[:lt, -9998] = UNDEF
+
+#sc = nil
+#sc = ImageMap::ColorScale.pm3d(11,7,22,12)
+sc = ColorScale.GMT("GMT_polar.cpt")
+#sc.set_mask_color(64,64,64)
+sc.set_range(nil, nil)
+
+ImageMap.display(image, sc)

data/ext/imagemap/test/test_line.rb

@@ -0,0 +1,14 @@
+require 'carray'
+require 'carray/image_map'
+
+p img = ImageMap.new(CA_INT8, [200,200]) {0}
+p img.class
+
+gx = CArray.float(2,2) { [[10,30],
+                          [10,30]] }
+gy = CArray.float(2,2) { [[10,10],
+                          [80,50]] }
+
+img.fill_rectangle(gy, gx, 255)
+
+img.display_by_magick

data/ext/imagemap/test/test_rotate.rb

@@ -0,0 +1,17 @@
+require "carray"
+
+img = ImageMap.new(:int16, [300, 300]) {0}
+img.set_xrange 0...300
+img.set_yrange 0...300
+
+data = CArray.int16(16,16).seq!
+
+x = CArray.float(16).seq![16,:%]
+y = CArray.float(16).seq!.reverse![:%,16]
+
+img.warp(data, x, y, :grid=>"area0", :gradation=>false) {|gx,gy,ix,iy|
+  ix[] = 8*(gy+gx) + 24
+  iy[] = 8*(gy-gx) + 150
+}
+
+img.as_uint8.display_by_magick

data/ext/imagemap/test/test_triangle.rb

@@ -0,0 +1,20 @@
+require 'carray'
+
+image  = CArray.float(200, 200) { nan }
+
+y = CArray.float(2,2){[50,50, 65,100]}
+x = CArray.float(2,2){[70,100,50,90]}
+z = CArray.float(2,2){[30,40, 50,20]}
+ImageMap::Image.draw_rectangle_gradation(image, y, x, z)
+
+#image.draw_line(y[0], x[0], y[1], x[1])
+#image.draw_line(y[1], x[1], y[2], x[2])
+#image.draw_line(y[2], x[2], y[0], x[0])
+#image.draw_line(y[2], x[2], y[0], x[0])
+
+image.mask = image.is_nan
+
+sc = ImageMap::ColorScale.pm3d(13,6,10)
+
+ImageMap.display(image, sc)
+

data/ext/imagemap/test/test_warp.rb

@@ -0,0 +1,26 @@
+require 'carray'
+
+lon = CArray.float(121).span!(-180..180)
+lat = CArray.float(12).span!(0..90)
+p val = CArray.uint16(121,12).seq!.quantize(256)
+
+img = ImageMap.uint16(600,600) { 9999 }
+
+img.warp(val, lon[:%,lat.dim0], lat[lon.dim0,:%], 
+         :grid=>"area0", :gradation=>false) { |u,v,x,y|
+  x[] = (100 - v/2) * u.rad.cos!
+  y[] = (100 - v/2) * u.rad.sin!
+  x.mul!(2).add!(300)
+  y.mul!(2).add!(300)
+}
+
+img[:eq,9999] = UNDEF
+
+RGB = CA.struct{ uint8 :r,:g,:b }
+rgb = CArray.new(RGB, [255,3])
+rgb["r"].seq!
+
+out = rgb.project(img)
+
+out.display_by_magick("rgb")
+

data/ext/mathfunc/carray_mathfunc.c

@@ -0,0 +1,321 @@
+/* ---------------------------------------------------------------------------
+
+  carray/mathfunc/carray_mathfunc.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 "carray.h"
+#include <math.h>
+
+#ifdef HAVE_TGMATH_H
+#include <tgmath.h>
+#endif
+
+/* ----------------------------------------------------------------------- */
+
+static void
+mathfunc_deg_360 (void *p0, void *p1)
+{
+  double a = *(double*) p1;
+  double fa = a / 360.0;
+  if ( a >= 0 ) {
+    *(double*) p0 = (fa - floor(fa)) * 360.0;
+  }
+  else {
+    *(double*) p0 = (fa - ceil(fa) + 1) * 360.0;
+  }
+}
+
+static VALUE 
+rb_ca_deg_360 (VALUE self)
+{
+  return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_deg_360, self);
+}
+
+static VALUE 
+rb_ca_deg_360_bang (VALUE self)
+{
+  volatile VALUE out;
+  out = ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_deg_360, self);
+  rb_funcall(self, rb_intern("[]="), 1, out);
+  return self;
+}
+
+static VALUE
+rb_num_deg_360 (VALUE self)
+{
+  double v0, v1 = NUM2DBL(self);
+  mathfunc_deg_360(&v0, &v1);
+  return rb_float_new(v0);
+}
+
+/* ----------------------------------------------------------------------- */
+
+static void
+mathfunc_deg_180 (void *p0, void *p1)
+{
+  double a = *(double*) p1, b;
+  double fa = (a+180.0) / 360.0;
+  if ( a >= 0 ) {
+    b = (fa - floor(fa)) * 360.0 - 180;
+  }
+  else {
+    b = (fa - ceil(fa)) * 360.0 - 180;
+  }
+  if ( b <= -180 ) {
+    b += 360.0;
+  }
+  *(double*) p0 = b;
+}
+
+static VALUE 
+rb_ca_deg_180 (VALUE self)
+{
+  return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_deg_180, self);
+}
+
+static VALUE 
+rb_ca_deg_180_bang (VALUE self)
+{
+  volatile VALUE out;
+  out = ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_deg_180, self);
+  rb_funcall(self, rb_intern("[]="), 1, out);
+  return self;
+}
+
+static VALUE
+rb_num_deg_180 (VALUE self)
+{
+  double v0, v1 = NUM2DBL(self);
+  mathfunc_deg_180(&v0, &v1);
+  return rb_float_new(v0);
+}
+
+/* ----------------------------------------------------------------------- */
+
+static void
+mathfunc_rad_2pi (void *p0, void *p1)
+{
+  double a = *(double*) p1;
+  double fa = a / (2*M_PI);
+  if ( a >= 0 ) {
+    *(double*) p0 = (fa - floor(fa)) * 2*M_PI;
+  }
+  else {
+    *(double*) p0 = (fa - ceil(fa) + 1) * 2*M_PI;
+  }
+}
+
+static VALUE 
+rb_ca_rad_2pi (VALUE self)
+{
+  return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_rad_2pi, self);
+}
+
+static VALUE 
+rb_ca_rad_2pi_bang (VALUE self)
+{
+  volatile VALUE out;
+  out = ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_rad_2pi, self);
+  rb_funcall(self, rb_intern("[]="), 1, out);
+  return self;
+}
+
+static VALUE
+rb_num_rad_2pi (VALUE self)
+{
+  double v0, v1 = NUM2DBL(self);
+  mathfunc_rad_2pi(&v0, &v1);
+  return rb_float_new(v0);
+}
+
+/* ----------------------------------------------------------------------- */
+
+static void
+mathfunc_rad_pi (void *p0, void *p1)
+{
+  double a = *(double*) p1, b;
+  double fa = (a+M_PI) / (2*M_PI);
+  if ( a >= 0 ) {
+    b = (fa - floor(fa)) * 2*M_PI - M_PI;
+  }
+  else {
+    b = (fa - ceil(fa)) * 2*M_PI - M_PI;
+  }
+  if ( b <= -M_PI ) {
+    b += 2*M_PI;
+  }
+  *(double*) p0 = b;
+}
+
+static VALUE 
+rb_ca_rad_pi (VALUE self)
+{
+  return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_rad_pi, self);
+}
+
+static VALUE 
+rb_ca_rad_pi_bang (VALUE self)
+{
+  volatile VALUE out;
+  out = ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_rad_pi, self);
+  rb_funcall(self, rb_intern("[]="), 1, out);
+  return self;
+}
+
+static VALUE
+rb_num_rad_pi (VALUE self)
+{
+  double v0, v1 = NUM2DBL(self);
+  mathfunc_rad_pi(&v0, &v1);
+  return rb_float_new(v0);
+}
+
+/* ----------------------------------------------------------------------- */
+
+static void
+mathfunc_sph_to_xyz (void *p0, void *p1, void *p2, void *p3, void *p4, void *p5)
+{
+  double r = *(double*)p3, theta = *(double*)p4, phi = *(double*)p5;
+  *(double*) p0 = r * sin(theta) * cos(phi);
+  *(double*) p1 = r * sin(theta) * sin(phi);
+  *(double*) p2 = r * cos(theta);
+}
+
+static VALUE 
+rb_camath_sph_to_xyz (VALUE mod, VALUE rx1, VALUE rx2, VALUE rx3)
+{
+  return ca_call_cfunc_3_3(CA_DOUBLE, CA_DOUBLE, CA_DOUBLE, CA_DOUBLE, CA_DOUBLE, CA_DOUBLE,
+                             mathfunc_sph_to_xyz, rx1, rx2, rx3);
+}
+
+/* ----------------------------------------------------------------------- */
+
+static void
+mathfunc_xyz_to_sph (void *p0, void *p1, void *p2, void *p3, void *p4, void *p5)
+{
+#ifdef HAVE_ATAN2
+  double x = *(double*)p3, y = *(double*)p4, z = *(double*)p5;
+  double r;
+  *(double*) p0 = r = sqrt(x*x+y*y+z*z);
+  *(double*) p1 = acos(z/r);
+  *(double*) p2 = atan2(y, x);
+#else
+  rb_raise(rb_eRuntimeError, "atan2 is not defined");
+#endif
+}
+
+static VALUE 
+rb_camath_xyz_to_sph (VALUE mod, VALUE rx1, VALUE rx2, VALUE rx3)
+{
+  return ca_call_cfunc_3_3(CA_DOUBLE, CA_DOUBLE, CA_DOUBLE, CA_DOUBLE, CA_DOUBLE, CA_DOUBLE,
+                             mathfunc_xyz_to_sph, rx1, rx2, rx3);
+}
+
+/* ----------------------------------------------------------------------- */
+
+static void
+mathfunc_atan2 (void *p0, void *p1, void *p2)
+{
+#ifdef HAVE_ATAN2
+  *(double*)p0 = atan2(*(double*)p1, *(double*)p2);
+#else
+  rb_raise(rb_eRuntimeError, "atan2 is not defined");
+#endif
+}
+
+static VALUE 
+rb_camath_atan2 (VALUE mod, VALUE rx1, VALUE rx2)
+{
+  return ca_call_cfunc_1_2(CA_DOUBLE, CA_DOUBLE, CA_DOUBLE, 
+                             mathfunc_atan2, rx1, rx2);
+}
+
+/* ----------------------------------------------------------------------- */
+
+static void
+mathfunc_hypot (void *p0, void *p1, void *p2)
+{
+#ifdef HAVE_HYPOT
+  *(double *)p0 = hypot(*(double*)p1, *(double*)p2);
+#else
+  rb_raise(rb_eRuntimeError, "hypot is not defined");
+#endif
+}
+
+static VALUE 
+rb_camath_hypot (VALUE mod, VALUE rx1, VALUE rx2)
+{
+  return ca_call_cfunc_1_2(CA_DOUBLE, CA_DOUBLE, CA_DOUBLE, 
+                             mathfunc_hypot, rx1, rx2);
+}
+
+/* ----------------------------------------------------------------------- */
+
+static void
+mathfunc_lgamma (void *p0, void *p1)
+{
+#ifdef HAVE_LGAMMA
+  *(double *)p0 = lgamma(*(double*)p1);
+#else
+  rb_raise(rb_eRuntimeError, "lgamma is not defined ");
+#endif
+}
+
+static VALUE
+rb_camath_lgamma (VALUE mod, VALUE rx1)
+{
+  return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_lgamma, rx1);
+}
+
+/* ----------------------------------------------------------------------- */
+
+static void
+mathfunc_expm1 (void *p0, void *p1)
+{
+#ifdef HAVE_EXP1M
+  *(double *)p0 = expm1(*(double*)p1);
+#else
+  rb_raise(rb_eRuntimeError, "expm1 is not defined ");
+#endif
+}
+
+static VALUE
+rb_camath_expm1 (VALUE mod, VALUE rx1)
+{
+  return ca_call_cfunc_1_1(CA_DOUBLE, CA_DOUBLE, mathfunc_expm1, rx1);
+}
+
+void
+Init_carray_mathfunc ()
+{
+  rb_define_method(rb_cCArray, "deg_360", rb_ca_deg_360, 0);
+  rb_define_method(rb_cCArray, "deg_360!", rb_ca_deg_360_bang, 0);
+  rb_define_method(rb_cCArray, "deg_180", rb_ca_deg_180, 0);
+  rb_define_method(rb_cCArray, "deg_180!", rb_ca_deg_180_bang, 0);
+  rb_define_method(rb_cCArray, "rad_2pi", rb_ca_rad_2pi, 0);
+  rb_define_method(rb_cCArray, "rad_2pi!", rb_ca_rad_2pi_bang, 0);
+  rb_define_method(rb_cCArray, "rad_pi", rb_ca_rad_pi, 0);
+  rb_define_method(rb_cCArray, "rad_pi!", rb_ca_rad_pi_bang, 0);
+
+  rb_define_module_function(rb_mCAMath, "spherical_to_xyz", rb_camath_sph_to_xyz, 3);
+  rb_define_module_function(rb_mCAMath, "xyz_to_spherical", rb_camath_xyz_to_sph, 3);
+
+  rb_define_module_function(rb_mCAMath, "atan2", rb_camath_atan2, 2);
+  rb_define_module_function(rb_mCAMath, "hypot", rb_camath_hypot, 2);
+
+  rb_define_module_function(rb_mCAMath, "lgamma",  rb_camath_lgamma, 1);
+  rb_define_module_function(rb_mCAMath, "expm1",   rb_camath_expm1, 1);
+
+  rb_define_method(rb_cNumeric, "deg_360", rb_num_deg_360, 0);
+  rb_define_method(rb_cNumeric, "deg_180", rb_num_deg_180, 0);
+  rb_define_method(rb_cNumeric, "rad_2pi", rb_num_rad_2pi, 0);
+  rb_define_method(rb_cNumeric, "rad_pi", rb_num_rad_pi, 0);
+}