proj4r 1.0.0

data/rb_proj.c

@@ -0,0 +1,357 @@
+#include "ruby.h"
+#include "rb_proj4r.h"
+
+VALUE rb_cProj;
+
+static void 
+free_proj (Proj *proj)
+{
+  if ( proj->ref )
+    pj_free(proj->ref);
+  free(proj);
+}
+
+static VALUE
+rb_proj_s_allocate (VALUE klass)
+{
+  Proj *proj;
+  return Data_Make_Struct(klass, Proj, 0, free_proj, proj);
+}
+
+static VALUE
+rb_proj_initialize (VALUE self, VALUE args)
+{
+  Proj *proj;
+  PJ *ref;
+
+  Check_Type(args, T_STRING);
+
+  if ( ! ( ref = pj_init_plus(StringValuePtr(args)) ) ) 
+    rb_raise(rb_eRuntimeError, "%s", pj_strerrno(pj_errno));
+
+  Data_Get_Struct(self, Proj, proj);
+  proj->ref = ref;
+
+  /*  rb_ivar_set(self, rb_intern("@definition"), args); */
+
+  return Qnil;
+}
+
+static VALUE
+rb_proj_definition (VALUE self)
+{
+  Proj *proj;
+  char *def;
+  Data_Get_Struct(self, Proj, proj);
+  def = pj_get_def(proj->ref, 0);
+  if ( def ) {
+    return rb_str_new2(def);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+static VALUE
+rb_proj_descr (VALUE self)
+{
+  Proj *proj;
+  Data_Get_Struct(self, Proj, proj);
+  if ( proj->ref->descr ) {
+    return rb_str_new2(proj->ref->descr);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+static VALUE
+rb_proj_catalog_name (VALUE self)
+{
+  Proj *proj;
+  Data_Get_Struct(self, Proj, proj);
+  if ( proj->ref->catalog_name ) {
+    return rb_str_new2(proj->ref->catalog_name);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+static VALUE
+rb_proj_def_size (VALUE self)
+{
+  Proj *proj;
+  Data_Get_Struct(self, Proj, proj);
+  if ( proj->ref->def_size ) {
+    return rb_str_new2(proj->ref->def_size);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+static VALUE
+rb_proj_def_shape (VALUE self)
+{
+  Proj *proj;
+  Data_Get_Struct(self, Proj, proj);
+  if ( proj->ref->def_shape ) {
+    return rb_str_new2(proj->ref->def_shape);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+static VALUE
+rb_proj_a (VALUE self)
+{
+  Proj *proj;
+  Data_Get_Struct(self, Proj, proj);
+	return rb_float_new(proj->ref->a);
+}
+
+static VALUE
+rb_proj_f (VALUE self)
+{
+  Proj *proj;
+	double es;
+  Data_Get_Struct(self, Proj, proj);
+	es = proj->ref->es;
+	return rb_float_new(es/(1 + sqrt(1 - es)));
+}
+
+static VALUE
+rb_proj_fr_meter (VALUE self)
+{
+  Proj *proj;
+  Data_Get_Struct(self, Proj, proj);
+	return rb_float_new(proj->ref->fr_meter);
+}
+
+static VALUE
+rb_proj_is_latlong (VALUE self)
+{
+  Proj *proj;
+  Data_Get_Struct(self, Proj, proj);
+  if ( pj_is_latlong(proj->ref) ) {
+  	return Qtrue;
+  }
+  else {
+  	return Qfalse;
+  }
+}
+
+static VALUE
+rb_proj_is_geocent (VALUE self)
+{
+  Proj *proj;
+  Data_Get_Struct(self, Proj, proj);
+  if ( pj_is_geocent(proj->ref) ) {
+  	return Qtrue;
+  }
+  else {
+  	return Qfalse;
+  }
+}
+
+static VALUE
+rb_proj_to_latlong (VALUE self)
+{
+  volatile VALUE obj;
+  Proj *src, *dst;
+  obj = rb_proj_s_allocate(rb_cProj);
+  Data_Get_Struct(obj, Proj, dst);
+  Data_Get_Struct(self, Proj, src);
+  dst->ref = pj_latlong_from_proj(src->ref);
+  return obj;
+}
+
+static VALUE
+rb_proj_fwd (VALUE self, VALUE vlon, VALUE vlat)
+{
+  Proj *proj;
+  LP data;
+  Data_Get_Struct(self, Proj, proj);
+  data.u = NUM2DBL(vlon) * DEG_TO_RAD;
+  data.v = NUM2DBL(vlat) * DEG_TO_RAD;
+  data = pj_fwd(data, proj->ref);
+  if ( data.u == HUGE_VAL )
+    rb_raise(rb_eRuntimeError, "%s", pj_strerrno(pj_errno));
+  return rb_assoc_new(rb_float_new(data.u), rb_float_new(data.v));
+}
+
+static VALUE
+rb_proj_inv (VALUE self, VALUE vx, VALUE vy)
+{
+  Proj *proj;
+  XY data;
+  Data_Get_Struct(self, Proj, proj);
+  data.u = NUM2DBL(vx);
+  data.v = NUM2DBL(vy);
+  data = pj_inv(data, proj->ref);
+  if ( data.u == HUGE_VAL )
+    rb_raise(rb_eRuntimeError, "%s", pj_strerrno(pj_errno));
+  return rb_assoc_new(rb_float_new(data.u*RAD_TO_DEG), 
+		                  rb_float_new(data.v*RAD_TO_DEG));
+}
+
+#ifdef HAVE_CARRAY_H
+
+#include "carray.h"
+
+static VALUE
+rb_proj_fwd_ca (VALUE self, volatile VALUE vlon, volatile VALUE vlat, 
+                            volatile VALUE vx, volatile VALUE vy)
+{
+  Proj *proj;
+  LP data;
+  CArray *clon, *clat, *cx, *cy;
+  double  *p1, *p2, *p3, *p4;
+  ca_size_t     s1,  s2,  s3,  s4;
+  int8_t  *m, *mp;
+  ca_size_t     count, err_count, i;
+
+  Data_Get_Struct(self, Proj, proj);
+
+  clon = ca_wrap_readonly(vlon, CA_DOUBLE);
+  clat = ca_wrap_readonly(vlat, CA_DOUBLE);
+  cx   = ca_wrap_writable(vx,   CA_DOUBLE);
+  cy   = ca_wrap_writable(vy,   CA_DOUBLE);
+
+  ca_attach_n(4, clon, clat, cx, cy);
+
+  count = ca_set_iterator(4, 
+                          clon, &p1, &s1,
+                          clat, &p2, &s2,
+                          cx,   &p3, &s3,
+                          cy,   &p4, &s4);
+
+  m = ca_allocate_mask_iterator(2, clon, clat);
+
+  mp = m;
+  err_count = 0;
+  for (i=0; i<count; i++) {
+    if ( *mp ) {
+      err_count += 1;
+      *p3 = 0.0/0.0;
+      *p4 = 0.0/0.0;
+    }
+    else {
+      data.u = (*p1) * DEG_TO_RAD;
+      data.v = (*p2) * DEG_TO_RAD;
+      data = pj_fwd(data, proj->ref);
+      if ( data.u == HUGE_VAL ) {
+        err_count += 1;
+        *p3 = 0.0/0.0;
+        *p4 = 0.0/0.0;
+      }
+      else {
+        *p3 = data.u;
+        *p4 = data.v;
+      }
+    }
+    p1+=s1; p2+=s2; p3+=s3; p4+=s4; mp++;
+  }
+
+  free(m);
+
+  ca_sync_n(2, cx, cy);
+  ca_detach_n(4, clon, clat, cx, cy);
+
+  return SIZE2NUM(err_count);
+}
+
+static VALUE
+rb_proj_inv_ca (VALUE self, volatile VALUE vx, volatile VALUE vy, 
+	                    volatile VALUE vlon, volatile VALUE vlat)
+{
+  Proj *proj;
+  LP data;
+  CArray *cx, *cy, *clon, *clat;
+  double  *p1, *p2, *p3, *p4;
+  ca_size_t     s1,  s2,  s3,  s4;
+  int8_t  *m, *mp;
+  ca_size_t     count, err_count, i;
+
+  Data_Get_Struct(self, Proj, proj);
+
+  cx   = ca_wrap_readonly(vx,   CA_DOUBLE);
+  cy   = ca_wrap_readonly(vy,   CA_DOUBLE);
+  clon = ca_wrap_writable(vlon, CA_DOUBLE);
+  clat = ca_wrap_writable(vlat, CA_DOUBLE);
+
+  ca_attach_n(4, cx, cy, clon, clat);
+
+  count = ca_set_iterator(4, 
+                          cx,   &p1, &s1,
+                          cy,   &p2, &s2,
+                          clon, &p3, &s3,
+                          clat, &p4, &s4);
+
+  m = ca_allocate_mask_iterator(2, clon, clat);
+
+  mp = m;
+  err_count = 0;
+  for (i=0; i<count; i++) {
+    if ( *mp ) {
+      err_count += 1;
+      *p3 = 0.0/0.0;
+      *p4 = 0.0/0.0;
+    }
+    else {
+      data.u = (*p1);
+      data.v = (*p2);
+      data = pj_inv(data, proj->ref);
+      if ( data.u == HUGE_VAL ) {
+	      err_count += 1;
+        *p3 = 0.0/0.0;
+        *p4 = 0.0/0.0;
+      }
+      else {
+        *p3 = data.u * RAD_TO_DEG;
+	      *p4 = data.v * RAD_TO_DEG;
+      }
+    }
+    p1+=s1; p2+=s2; p3+=s3; p4+=s4;
+    mp++;
+  }
+
+  free(m);
+
+  ca_sync_n(2, clon, clat);
+  ca_detach_n(4, cx, cy, clon, clat);
+
+  return SIZE2NUM(err_count);
+}
+
+#endif
+
+
+void
+Init_proj ()
+{
+  rb_cProj = rb_define_class_under(rb_mPROJ4, "Proj", rb_cObject);
+
+  rb_define_alloc_func(rb_cProj, rb_proj_s_allocate);
+  rb_define_method(rb_cProj, "initialize", rb_proj_initialize, 1);
+  rb_define_method(rb_cProj, "definition", rb_proj_definition, 0);
+  rb_define_method(rb_cProj, "descr", rb_proj_descr, 0);
+  rb_define_method(rb_cProj, "catalog_name", rb_proj_catalog_name, 0);
+  rb_define_method(rb_cProj, "def_size", rb_proj_def_size, 0);
+  rb_define_method(rb_cProj, "def_shape", rb_proj_def_shape, 0);
+  rb_define_method(rb_cProj, "a", rb_proj_a, 0);
+  rb_define_method(rb_cProj, "f", rb_proj_f, 0);
+  rb_define_method(rb_cProj, "fr_meter", rb_proj_fr_meter, 0);
+  rb_define_method(rb_cProj, "latlong?", rb_proj_is_latlong, 0);
+  rb_define_method(rb_cProj, "geocent?", rb_proj_is_geocent, 0);
+  rb_define_method(rb_cProj, "to_latlong", rb_proj_to_latlong, 0);
+  rb_define_private_method(rb_cProj, "_forward", rb_proj_fwd, 2);
+  rb_define_private_method(rb_cProj, "_inverse", rb_proj_inv, 2);
+#ifdef HAVE_CARRAY_H
+  rb_define_private_method(rb_cProj, "_forward_ca", rb_proj_fwd_ca, 4);
+  rb_define_private_method(rb_cProj, "_inverse_ca", rb_proj_inv_ca, 4);
+#endif
+}
+

data/rb_proj4r.c

@@ -0,0 +1,232 @@
+#include "ruby.h"
+#include "rb_proj4r.h"
+
+VALUE rb_mPROJ4;
+
+static VALUE
+rb_proj_s_dmstor (VALUE mod, VALUE str)
+{
+  char *cdms;
+  double r;
+
+  Check_Type(str, T_STRING);
+
+  cdms = StringValuePtr(str); 
+
+  r = dmstor(cdms, NULL);
+
+  return rb_float_new(r);
+}
+
+static VALUE
+rb_proj_s_dmstod (VALUE mod, VALUE str)
+{
+  char *cdms;
+  double r;
+
+  Check_Type(str, T_STRING);
+
+  cdms = StringValuePtr(str); 
+
+  r = dmstor(cdms, NULL);
+
+  return rb_float_new(r * RAD_TO_DEG);
+}
+
+static VALUE
+rb_proj_s_rtodms (int argc, VALUE *argv, VALUE mod)
+{
+  VALUE vr, vpos, vneg;
+  char cdms[50];
+  int pos, neg;
+  double r;
+
+  rb_scan_args(argc, argv, "12", &vr, &vpos, &vneg);
+
+  r = NUM2DBL(vr);
+  pos = ( NIL_P(vpos) ) ? 0 : StringValuePtr(vpos)[0];
+  neg = ( NIL_P(vneg) ) ? 0 : StringValuePtr(vneg)[0];
+
+  rtodms(cdms, r, pos, neg);
+
+  return rb_str_new2(cdms);
+}
+
+static VALUE
+rb_proj_s_dtodms (int argc, VALUE *argv, VALUE mod)
+{
+  VALUE vr, vpos, vneg;
+  char cdms[50];
+  int pos, neg;
+  double r;
+
+  rb_scan_args(argc, argv, "12", &vr, &vpos, &vneg);
+
+  r = NUM2DBL(vr) * DEG_TO_RAD;
+  pos = ( NIL_P(vpos) ) ? 0 : StringValuePtr(vpos)[0];
+  neg = ( NIL_P(vneg) ) ? 0 : StringValuePtr(vneg)[0];
+
+  rtodms(cdms, r, pos, neg);
+
+  return rb_str_new2(cdms);
+}
+
+static VALUE
+rb_proj_s_transform (int argc, VALUE *argv, VALUE klass)
+{
+  VALUE vsrc, vdst, vx, vy, vz;
+  Proj *proj, *proj_dest;
+  double x, y, z;
+  int status;
+
+  rb_scan_args(argc, argv, "41", &vsrc, &vdst, &vx, &vy, &vz);
+
+  Data_Get_Struct(vsrc, Proj, proj);
+  Data_Get_Struct(vdst, Proj, proj_dest);
+
+  if ( pj_is_latlong(proj->ref) ) {
+    x = NUM2DBL(vx) * DEG_TO_RAD;
+    y = NUM2DBL(vy) * DEG_TO_RAD;
+    z = NIL_P(vz) ? 0.0 : NUM2DBL(vz);    
+  }
+  else {
+    x = NUM2DBL(vx);
+    y = NUM2DBL(vy);
+    z = NIL_P(vz) ? 0.0 : NUM2DBL(vz);
+  }
+
+  status = pj_transform(proj->ref, proj_dest->ref, 1, 0, &x, &y, &z);
+
+  if ( status < 0 )
+    rb_raise(rb_eRuntimeError, "%s", pj_strerrno(pj_errno));
+  
+  if ( pj_is_latlong(proj_dest->ref) ) {
+    if ( NIL_P(vz) ) {
+      return rb_ary_new3(3, 
+  	  	     rb_float_new(x * RAD_TO_DEG),
+  		       rb_float_new(y * RAD_TO_DEG),
+  		       rb_float_new(z));  
+    }
+    else {
+      return rb_ary_new3(2, 
+  	  	     rb_float_new(x * RAD_TO_DEG),
+  		       rb_float_new(y * RAD_TO_DEG));
+    }
+  }
+  else {
+    if ( NIL_P(vz) ) {
+      return rb_ary_new3(3, 
+	    	     rb_float_new(x),
+		         rb_float_new(y),
+		         rb_float_new(z));
+    }
+    else {
+      return rb_ary_new3(2, 
+	    	     rb_float_new(x),
+		         rb_float_new(y));      
+    }
+  }
+}
+
+#ifdef HAVE_CARRAY_H
+
+#include "carray.h"
+
+static VALUE
+rb_proj_s_transform_ca (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE vsrc, vdst, vx, vy, vz;
+  Proj   *psrc, *pdst;
+  int isll_src, isll_dst;
+  CArray *cx, *cy, *cz;
+  double *p1, *p2, *p3;
+  ca_size_t     s1,  s2,  s3;
+  int8_t  *m, *mp;
+  ca_size_t     count, err_count, status, i;
+
+  rb_scan_args(argc, argv, "5", &vsrc, &vdst, &vx, &vy, &vz);
+
+  Data_Get_Struct(vsrc, Proj, psrc);
+  Data_Get_Struct(vdst, Proj, pdst);
+
+  isll_src = pj_is_latlong(psrc->ref);
+  isll_dst = pj_is_latlong(pdst->ref);
+
+  cx   = ca_wrap_writable(vx, CA_DOUBLE);
+  cy   = ca_wrap_writable(vy, CA_DOUBLE);
+  cz   = ca_wrap_writable(vz, CA_DOUBLE);
+
+  count = ca_get_loop_count(3, cx, cy, cz);
+  if ( count == -1 )
+    rb_raise(rb_eRuntimeError, "invalid data_num");
+
+  ca_attach_n(3, cx, cy, cz);
+
+  ca_set_iterator(3, 
+		  cx, &p1, &s1,
+		  cy, &p2, &s2,
+		  cz, &p3, &s3);
+
+  m = ca_allocate_mask_iterator(3, cx, cy, cz);
+
+  mp = m;
+  err_count = 0;
+  for (i=0; i<count; i++) {
+    if ( *mp ) {
+      err_count += 1; 
+    }
+    else {
+      if ( isll_src ) {
+        (*p1) *= DEG_TO_RAD;
+        (*p2) *= DEG_TO_RAD;
+      }
+      status = pj_transform(psrc->ref, pdst->ref, 1, 0, p1, p2, p3);
+      if ( isll_dst ) {
+        (*p1) *= RAD_TO_DEG;
+        (*p2) *= RAD_TO_DEG;
+      }
+      if ( status < 0 ) {
+	      err_count += 1;
+      }
+    }
+    p1+=s1; p2+=s2; p3+=s3; 
+    mp++;
+  }
+
+  free(m);
+
+  ca_sync_n(3, cx, cy, cz);
+  ca_detach_n(3, cx, cy, cz);
+
+  return SIZE2NUM(err_count);
+}
+
+
+#endif
+
+void Init_proj ();
+void Init_geod ();
+
+void
+Init_proj4r ()
+{
+  rb_mPROJ4 = rb_define_module("PROJ4");
+
+  rb_define_const(rb_mPROJ4, "RAD_TO_DEG",   rb_float_new(RAD_TO_DEG));
+  rb_define_const(rb_mPROJ4, "DEG_TO_RAD",   rb_float_new(DEG_TO_RAD));
+
+  set_rtodms(6, 1);
+  rb_define_singleton_method(rb_mPROJ4, "dmstor", rb_proj_s_dmstor, 1);
+  rb_define_singleton_method(rb_mPROJ4, "rtodms", rb_proj_s_rtodms, -1);
+  rb_define_singleton_method(rb_mPROJ4, "dmstod", rb_proj_s_dmstod, 1);
+  rb_define_singleton_method(rb_mPROJ4, "dtodms", rb_proj_s_dtodms, -1);
+
+  rb_define_singleton_method(rb_mPROJ4, "_transform", rb_proj_s_transform, -1);
+#ifdef HAVE_CARRAY_H
+  rb_define_singleton_method(rb_mPROJ4, "_transform_ca", rb_proj_s_transform_ca, -1);
+#endif
+
+  Init_proj();
+  Init_geod();
+}
+

data/rb_proj4r.h

@@ -0,0 +1,46 @@
+#ifndef RB_PROJ_H
+#define RB_PROJ_H
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "projects.h"
+#define projCtx_t int
+#include "proj_api.h"
+#include "geodesic.h"
+
+typedef struct {
+  PJ *ref;
+} Proj;
+
+typedef struct {
+  struct geod_geodesic *ref;
+} Geod;
+
+/*
+void
+proj4_geod_init (struct geodesic *geod, char *param);
+
+void
+proj4_geod_inverse (struct geodesic *geod, 
+                    double l1, double p1, double l2, double p2, 
+                    double *az12, double *az21, double *dist);
+
+double
+proj4_geod_distance (struct geodesic *geod, 
+                     double l1, double p1, double l2, double p2); 
+
+void
+proj4_geod_forward (struct geodesic *geod, 
+                    double l1, double p1, double a, double d, 
+                    double *l2, double *p2, double *az21);
+*/
+
+extern VALUE rb_mPROJ4;
+extern VALUE rb_cProj;
+extern VALUE rb_cGeod;
+extern VALUE rb_cProj4;
+extern VALUE rb_mGeod;
+
+#endif

data/test/TEST.txt

@@ -0,0 +1,5 @@
+#	x	y
+110503	5.059	2.667
+110506	5.132	2.750
+110509	5.174	2.806
+110512	5.277	2.950

data/test/attributes.rb

@@ -0,0 +1,13 @@
+require "proj4r"
+
+pj = PROJ4::Proj.new("+proj=merc +lat_0=0 +ellps=WGS84 +units=km")
+
+p pj.descr
+p pj.definition
+p pj.def_size
+p pj.def_shape
+p pj.latlong?
+p pj.geocent?
+p pj.catalog_name
+
+p pj.to_latlong.definition

data/test/tenkizu.rb

@@ -0,0 +1,29 @@
+require "proj4r"
+
+include PROJ4
+
+scy = 1316.360971/2.097
+scx = scy*1.076
+
+ps = Proj.new("+ellps=WGS84 +units=km +proj=stere +lat_ts=60 +lat_0=90 +lon_0=140")
+ll  = Proj.new("+proj=lonlat")
+
+xoff = 5.708
+yoff = 9399.152289/scy
+
+#p PROJ4.transform(ll, ps, 140*DEG_TO_RAD, 30*DEG_TO_RAD, 0)
+#p PROJ4.transform(ll, ps, 140*DEG_TO_RAD, 40*DEG_TO_RAD, 0)
+#p PROJ4.transform(ps, ll, 0.0, -5555.5289096419965, 0).map{|s| s*RAD_TO_DEG}
+#p PROJ4.transform(ps, ll, 0.0, -6871.88988083827, 0).map{|s| s*RAD_TO_DEG}
+
+while line = gets
+  case line
+  when /^#/
+  else
+    index, x, y = line.chomp.split(/\s+/)
+    x = x.to_f
+    y = y.to_f
+    lon, lat, hgt = *PROJ4.transform(ps, ll, (x-xoff)*scx, (y-yoff)*scy, 0).map{|s| s*RAD_TO_DEG}
+    printf("%s,%g,%g\n", index, lon, lat)
+  end
+end

data/test/test.rb

@@ -0,0 +1,25 @@
+require "proj4r"
+
+#
+#  PROJ4::Geod.new(a = 6378137, f = 1.0/298.257223563)
+#
+#  PROJ4::Geod.inverse(lat1, lon1, lat2, lon2)
+#
+#   -> distance, azi1, azi2
+#
+
+geod = PROJ4::Geod.new("+ellps=WGS84 +units=km")
+p geod.inverse(30,100,-30,-100)
+# => [18101709.587288667, 94.90534751023246, 94.90534751023246]
+
+geod2 = PROJ4::Geod.new()
+p geod2.inverse(30,100,-30,-100)
+# => [18101709.587288667, 94.90534751023246, 94.90534751023246]
+ 
+p geod.inverse(30,100,-30,-120)
+# => [18101709.587288667, 94.90534751023246, 94.90534751023246]
+
+
+p geod.inverse(42.25, -71.11666666666666, 45.516, -123.68)
+p geod.inverse(CA_DOUBLE(42.25), CA_DOUBLE(-71.11666666666666), 
+               CA_DOUBLE(45.516), CA_DOUBLE(-123.68))