proj4r 1.0.0

data/rb_geod.c

@@ -0,0 +1,392 @@
+#include "ruby.h"
+#include "rb_proj4r.h"
+
+#define MAX_PARGS 50
+
+VALUE rb_cGeod;
+
+static void 
+free_geod (Geod *geod)
+{
+  if ( geod->ref ) {
+    free(geod->ref);
+  }
+  free(geod);
+}
+
+static VALUE
+rb_geod_s_allocate (VALUE klass)
+{
+  Geod *geod;
+  return Data_Make_Struct(klass, Geod, 0, free_geod, geod);
+}
+
+
+/*
+ *  call-seq:
+ *     Geod.new(a = 6378137, f = 1.0/298.257223563)  ->  nil
+ * 
+ *  Sets parameters for geodesic computations.
+ *  See manual of 'geod' for the details of paramters.
+ *
+ *     Geod.init("+ellps=WGS84 +units=km")
+ *
+ */
+
+
+static VALUE
+rb_geod_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE ra, rf;
+  Geod *geod;
+  rb_scan_args(argc, argv, "02", &ra, &rf);
+  if ( NIL_P(ra) && NIL_P(rf) ) {
+    ra = rb_float_new(6378137);           /* WGS84 : default */
+    rf = rb_float_new(1.0/298.257223563); 
+  }
+  Data_Get_Struct(self, Geod, geod);
+  geod->ref = ALLOC(struct geod_geodesic);
+  geod_init(geod->ref, NUM2DBL(ra), NUM2DBL(rf));
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     Geod.invgeod(lon1,lat1,lon2,lat2)  ->  array
+ * 
+ *  Calculates the forward and back azimuths and distance
+ *  between an initial and terminus point latitudes and longitudes.
+ *  The latitude should be a floating point value in degrees, which
+ *  positive value means northern direction. The longitude should be a
+ *  floating point value in degrees, which positive value means western
+ *  direction. The returned array contains the forward and back azimuths 
+ *  in degrees and distance in the metric specified by +Geod.init+.
+ *
+ *     Geod.init("+ellps=WGS84 +units=km")
+ *     Geod.invgeod(100,30,-100,-30)
+ *     #=> [94.9053479513086, -85.0946520486914, 18101.7096098234]
+ *
+ */
+
+static VALUE
+rb_geod_inverse (VALUE self, VALUE vl1, VALUE vp1, VALUE vl2, VALUE vp2)
+{
+  Geod *geod;
+  double ps12, paz12, paz21;
+  Data_Get_Struct(self, Geod, geod);
+  geod_inverse(geod->ref, 
+                     NUM2DBL(vl1), 
+                     NUM2DBL(vp1), 
+                     NUM2DBL(vl2),
+                     NUM2DBL(vp2), 
+                     &ps12, &paz12, &paz21);
+  return rb_ary_new3(3,
+		     rb_float_new(ps12),
+		     rb_float_new(paz12),
+		     rb_float_new(paz21));
+}
+
+/*
+ *  call-seq:
+ *     Geod.distance(lon1,lat1,lon2,lat2)  ->  array
+ *
+ *  Shortcut of +Geod.invgeod(lon1,lat1,lon2,lat2)[2]+
+ * 
+ */
+
+static VALUE
+rb_geod_distance (VALUE self, VALUE vl1, VALUE vp1, VALUE vl2, VALUE vp2)
+{
+  Geod *geod;
+  double ps12;
+  Data_Get_Struct(self, Geod, geod);
+  geod_inverse(geod->ref,
+                NUM2DBL(vl1), NUM2DBL(vp1), NUM2DBL(vl2), NUM2DBL(vp2),
+                &ps12, 0, 0);
+  return rb_float_new(ps12);
+}
+
+/*
+ *  call-seq:
+ *     Geod.geod(lat1, lon1, az12, dist)  ->  array
+ * 
+ *  Calculates the latitude, longitude and back azimuth of a terminus point
+ *  given a initial point latitude, longitude, azimuth and  distance.
+ *  The latitude should be a floating point value in degrees, which
+ *  positive value means northern direction. The longitude should be a
+ *  floating point value in degrees, which positive value means western
+ *  direction. The returned array contains the latitude, longitude and
+ *  back azimuth at the terminus point in degrees.
+ *
+ *     Geod.init("+ellps=WGS84 +units=km")
+ *     Geod.geod(100,30,94.9053479513086,18101.7096098234)
+ *     #=> [-99.9999997537569, -30.0000001660067, -85.0946531598225]
+ *
+ */
+
+static VALUE
+rb_geod_forward (VALUE self, VALUE vlat1, VALUE vlon1, VALUE vaz, VALUE vdist)
+{
+  Geod *geod;
+  double l2, p2, az21;
+  Data_Get_Struct(self, Geod, geod);
+  geod_direct(geod->ref,
+                     NUM2DBL(vlat1), NUM2DBL(vlon1), NUM2DBL(vaz), NUM2DBL(vdist), 
+                     &l2, &p2, &az21);
+  return rb_ary_new3(3,
+		     rb_float_new(l2),
+		     rb_float_new(p2),
+		     rb_float_new(az21));
+}
+
+#ifdef HAVE_CARRAY_H
+
+#include "carray.h"
+
+
+/*
+ *  call-seq:
+ *     Geod#direct_ca(lat1, lon1, az12, dist, lat2, lon2, az21)  ->  nil
+ *     Geod#forward_ca(lat1, lon1, az12, dist, lat2, lon2, az21)  ->  nil
+ * 
+ *  Calculates the latitude, longitude and back azimuth of a terminus point
+ *  given a initial point latitude, longitude, azimuth and  distance.
+ *  The latitude should be a floating point value in degrees, which
+ *  positive value means northern direction. The longitude should be a
+ *  floating point value in degrees, which positive value means western
+ *  direction. The returned array contains the latitude, longitude and
+ *  back azimuth at the terminus point in degrees.
+ *
+ *    input:
+ *
+ *      lat1, lon1, az12, dist
+ *         read only CArray.double or its convertible
+ *
+ *    output:
+ *
+ *      lat2, lon2, az21
+ *         writable CArray.double or its convertible
+ *
+ */
+
+static VALUE
+rb_geod_direct_ca (VALUE self, 
+                    volatile VALUE vlat1, volatile VALUE vlon1, 
+                    volatile VALUE vaz12, volatile VALUE vdist, 
+                    volatile VALUE vlat2, volatile VALUE vlon2, 
+                    volatile VALUE vaz21)
+{
+  Geod *geod;
+  CArray *lat1, *lon1, *az12, *dist, *lat2, *lon2, *az21;
+  double *p1, *p2, *p3, *p4, *p5, *p6, *p7;
+  ca_size_t  s1,  s2,  s3,  s4,  s5,  s6,  s7;
+  int8_t  *m, *mp;
+  ca_size_t  count;
+  ca_size_t i;
+
+  Data_Get_Struct(self, Geod, geod);
+
+  lat1 = ca_wrap_readonly(vlat1, CA_DOUBLE);
+  lon1 = ca_wrap_readonly(vlon1, CA_DOUBLE); 
+  az12 = ca_wrap_readonly(vaz12, CA_DOUBLE);
+  dist = ca_wrap_readonly(vdist, CA_DOUBLE);
+  lat2 = ca_wrap_writable(vlat2, CA_DOUBLE);
+  lon2 = ca_wrap_writable(vlon2, CA_DOUBLE);
+  az21 = ca_wrap_writable(vaz21, CA_DOUBLE);
+
+  ca_attach_n(7, lat1, lon1, dist, az12, lat2, lon2, az21);
+
+  count = ca_set_iterator(7, 
+                          lat1, &p1, &s1,
+                          lon1, &p2, &s2,
+                          az12, &p3, &s3,
+                          dist, &p4, &s4,
+                          lat2, &p5, &s5,
+                          lon2, &p6, &s6,
+                          az21, &p7, &s7);
+
+  m = ca_allocate_mask_iterator(4, lat1, lon1, az12, dist);
+
+  mp = m;
+  for (i=0; i<count; i++) {
+    if ( *mp ) {
+      *p5 = 0.0/0.0;
+      *p6 = 0.0/0.0;
+      *p7 = 0.0/0.0;
+    }
+    else {
+      geod_direct(geod->ref, *p1, *p2, *p3, *p4, p5, p6, p7);
+    }
+    p1+=s1; p2+=s2; p3+=s3; p4+=s4; p5+=s5; p6+=s6; p7+=s7;
+    mp++;
+  }
+
+  free(m);
+
+  ca_sync_n(3, lat2, lon2, az21);
+  ca_detach_n(7, lat1, lon1, dist, az12, lat2, lon2, az21);
+  
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     Geod.invgeod_d(lat1,lon1,lat2,lon2,dist,az12,az21)  ->  nil
+ * 
+ *  Calculates the forward and back azimuths and distance
+ *  between an initial and terminus point latitudes and longitudes.
+ *  The latitude should be a floating point value in degrees, which
+ *  positive value means northern direction. The longitude should be a
+ *  floating point value in degrees, which positive value means western
+ *  direction. The returned array contains the forward and back azimuths 
+ *  in degrees and distance in the metric specified by +Geod.init+.
+ *
+ *    input:
+ *
+ *      lat1, lon1, lat2, lon2
+ *         read only CArray.double or its convertible
+ *
+ *    output:
+ *
+ *      dist, az12, az21 
+ *         writable CArray.double or its convertible
+ *
+ */
+
+static VALUE
+rb_geod_inverse_ca (VALUE self, 
+                    volatile VALUE vlat1, volatile VALUE vlon1, 
+                    volatile VALUE vlat2, volatile VALUE vlon2,
+                    volatile VALUE vdist, volatile VALUE vaz12, 
+                    volatile VALUE vaz21)
+{
+  Geod *geod;
+  CArray *lat1, *lon1, *lat2, *lon2, *dist, *az12, *az21;
+  double *p1, *p2, *p3, *p4, *p5, *p6, *p7;
+  ca_size_t     s1,  s2,  s3,  s4,  s5,  s6,  s7;
+  int8_t  *m, *mp;
+  ca_size_t    count;
+  ca_size_t i;
+
+  Data_Get_Struct(self, Geod, geod);
+
+  lat1 = ca_wrap_readonly(vlat1, CA_DOUBLE);
+  lon1 = ca_wrap_readonly(vlon1, CA_DOUBLE); 
+  lat2 = ca_wrap_readonly(vlat2, CA_DOUBLE);
+  lon2 = ca_wrap_readonly(vlon2, CA_DOUBLE);
+  dist = ca_wrap_writable(vdist, CA_DOUBLE);
+  az12 = ca_wrap_writable(vaz12, CA_DOUBLE);
+  az21 = ca_wrap_writable(vaz21, CA_DOUBLE);
+
+  ca_attach_n(7, lat1, lon1, lat2, lon2, dist, az12, az21);
+
+  count = ca_set_iterator(7, 
+                          lat1, &p1, &s1,
+                          lon1, &p2, &s2,
+                          lat2, &p3, &s3,
+                          lon2, &p4, &s4,
+                          dist, &p5, &s5,
+                          az12, &p6, &s6,
+                          az21, &p7, &s7);
+
+  m = ca_allocate_mask_iterator(4, lat1, lon1, lat2, lon2);
+
+  mp = m;
+  for (i=0; i<count; i++) {
+    if ( *mp ) {
+      *p5 = 0.0/0.0;
+      *p6 = 0.0/0.0;
+      *p7 = 0.0/0.0;
+    }
+    else {
+      geod_inverse(geod->ref, *p1, *p2, *p3, *p4, p5, p6, p7);
+    }
+    p1+=s1; p2+=s2; p3+=s3; p4+=s4; p5+=s5; p6+=s6; p7+=s7;
+    mp++;
+  }
+
+  free(m);
+
+  ca_sync_n(3, dist, az12, az21);
+  ca_detach_n(7, lat1, lon1, lat2, lon2, dist, az12, az21);
+  
+  return Qnil;
+}
+
+static VALUE
+rb_geod_distance_ca (VALUE self, 
+                     volatile VALUE vlat1, volatile VALUE vlon1, 
+                     volatile VALUE vlat2, volatile VALUE vlon2,
+                     volatile VALUE vdist)
+{
+  Geod *geod;
+  CArray *lat1, *lon1, *lat2, *lon2, *dist;
+  double *p1, *p2, *p3, *p4, *p5;
+  double  d0; 
+  ca_size_t  s1,  s2,  s3,  s4,  s5;
+  int8_t  *m, *mp;
+  ca_size_t    count;
+  ca_size_t i;
+
+  Data_Get_Struct(self, Geod, geod);
+
+  lat1 = ca_wrap_readonly(vlat1, CA_DOUBLE);
+  lon1 = ca_wrap_readonly(vlon1, CA_DOUBLE); 
+  lat2 = ca_wrap_readonly(vlat2, CA_DOUBLE);
+  lon2 = ca_wrap_readonly(vlon2, CA_DOUBLE);
+  dist = ca_wrap_writable(vdist, CA_DOUBLE);
+
+  ca_attach_n(5, lat1, lon1, lat2, lon2, dist);
+
+  count = ca_set_iterator(5, 
+                          lat1, &p1, &s1,
+                          lon1, &p2, &s2,
+                          lat2, &p3, &s3,
+                          lon2, &p4, &s4,
+                          dist, &p5, &s5);
+
+  m = ca_allocate_mask_iterator(4, lat1, lon1, lat2, lon2);
+
+  mp = m;
+  for (i=0; i<count; i++) {
+    if ( *mp ) {
+      *p5 = 0.0/0.0;
+    }
+    else {
+      geod_inverse(geod->ref, *p1, *p2, *p3, *p4, &d0, 0, 0);
+      *p5 = d0;
+    }
+    p1+=s1; p2+=s2; p3+=s3; p4+=s4; p5+=s5;
+    mp++;
+  }
+
+  free(m);
+
+  ca_sync(dist);
+  ca_detach_n(5, lat1, lon1, lat2, lon2, dist);
+  
+  return Qnil;
+}
+
+
+#endif
+
+void
+Init_geod ()
+{
+  rb_cGeod = rb_define_class_under(rb_mPROJ4, "Geod", rb_cObject);
+  rb_define_alloc_func(rb_cGeod, rb_geod_s_allocate);
+  rb_define_method(rb_cGeod, "_initialize", rb_geod_initialize, -1);
+  rb_define_private_method(rb_cGeod, "_inverse", rb_geod_inverse, 4);
+  rb_define_private_method(rb_cGeod, "_distance", rb_geod_distance, 4);
+  rb_define_private_method(rb_cGeod, "_forward", rb_geod_forward, 4);
+
+#ifdef HAVE_CARRAY_H
+  rb_define_private_method(rb_cGeod, "_direct_ca", rb_geod_direct_ca, 7);
+  rb_define_private_method(rb_cGeod, "_forward_ca", rb_geod_direct_ca, 7);
+  rb_define_private_method(rb_cGeod, "_inverse_ca", rb_geod_inverse_ca, 7);
+  rb_define_private_method(rb_cGeod, "_distance_ca", rb_geod_distance_ca, 5);
+#endif
+
+}
+