proj4rb 0.2.0-i486-linux

data/src/projrb.c

@@ -0,0 +1,532 @@
+#include "ruby.h"
+#include "projects.h"
+#include "proj_api.h"
+ 
+static VALUE mProjrb;
+
+static VALUE cDef;
+static VALUE cDatum;
+static VALUE cEllipsoid;
+static VALUE cPrimeMeridian;
+static VALUE cProjectionType;
+static VALUE cUnit;
+
+static VALUE cError;
+static VALUE cProjection;
+
+static ID idRaise;
+static ID idGetX;
+static ID idSetX;
+static ID idGetY;
+static ID idSetY;
+static ID idGetZ;
+static ID idSetZ;
+static ID idParseInitParameters;
+
+typedef struct {projPJ pj;} _wrap_pj;
+
+static void proj_free(void* p){
+  _wrap_pj * wpj = (_wrap_pj*) p;
+  if(wpj->pj != 0)
+    pj_free(wpj->pj);
+  free(p);
+}
+
+static VALUE proj_alloc(VALUE klass){
+  _wrap_pj* wpj;
+  VALUE obj;
+  wpj = (_wrap_pj*) malloc(sizeof(_wrap_pj));
+  wpj->pj = 0; //at init the projection has not been defined
+  obj = Data_Wrap_Struct(klass, 0, proj_free, wpj);
+  return obj;
+}
+
+/**Creates a new projection object. See the intro for details.
+
+   call-seq: new(String) -> Proj4::Projection
+             new(Array) -> Proj4::Projection
+             new(Hash) -> Proj4::Projection
+
+ */
+static VALUE proj_initialize(VALUE self, VALUE params){
+  _wrap_pj* wpj;
+  VALUE proj_params = rb_funcall(cProjection, idParseInitParameters, 1, params);
+  int size = RARRAY(proj_params)->len; 
+  char** c_params = (char **) malloc(size*sizeof(char *));
+  VALUE *ptr = RARRAY(proj_params)->ptr; 
+  int i;
+  for (i=0; i < size; i++, ptr++)
+    c_params[i]= STR2CSTR(*ptr); 
+  Data_Get_Struct(self,_wrap_pj,wpj);
+  wpj->pj = pj_init(size,c_params);
+  free(c_params);
+  if(wpj->pj == 0) {
+    if (pj_errno > 0) {
+        rb_raise(rb_eSystemCallError, "Unknown system call error");
+    } else {
+        rb_funcall(cError, idRaise, 1, INT2FIX(pj_errno) );
+    }
+  }
+  return self;
+}
+
+/**Has this projection an inverse?
+
+   call-seq: hasInverse? -> true or false
+
+ */
+static VALUE proj_has_inverse(VALUE self){
+  _wrap_pj* wpj;
+  Data_Get_Struct(self,_wrap_pj,wpj);
+  return wpj->pj->inv ? Qtrue : Qfalse;
+}
+
+/**Is this projection a latlong projection?
+
+   call-seq: isLatLong? -> true or false
+
+ */
+static VALUE proj_is_latlong(VALUE self){
+  _wrap_pj* wpj;
+  Data_Get_Struct(self,_wrap_pj,wpj);
+  return pj_is_latlong(wpj->pj) ? Qtrue : Qfalse;
+}
+
+/**Is this projection a geocentric projection?
+
+   call-seq: isGeocentric? -> true or false
+
+ */
+static VALUE proj_is_geocent(VALUE self){
+  _wrap_pj* wpj;
+  Data_Get_Struct(self,_wrap_pj,wpj);
+  return pj_is_geocent(wpj->pj) ? Qtrue : Qfalse;
+}
+
+/**Get the expanded definition of this projection as a string.
+
+   call-seq: getDef -> String
+
+ */
+static VALUE proj_get_def(VALUE self){
+  _wrap_pj* wpj;
+  Data_Get_Struct(self,_wrap_pj,wpj);
+  return rb_str_new2(pj_get_def(wpj->pj, 0));
+}
+
+/**Transforms a point in WGS84 LonLat in radians to projected coordinates.
+   This version of the method changes the point in-place.
+
+   call-seq: forward!(point) -> point
+
+ */
+static VALUE proj_forward(VALUE self,VALUE point){
+  _wrap_pj* wpj;
+  projUV* pResult = (projUV*) malloc(sizeof(projUV));
+  Data_Get_Struct(self,_wrap_pj,wpj);
+
+  pResult->u = NUM2DBL( rb_funcall(point, idGetX, 0) );
+  pResult->v = NUM2DBL( rb_funcall(point, idGetY, 0) );
+  *pResult = pj_fwd(*pResult,wpj->pj);
+
+  if (pj_errno == 0) {
+    rb_funcall(point, idSetX, 1, rb_float_new(pResult->u) );
+    rb_funcall(point, idSetY, 1, rb_float_new(pResult->v) );
+    return point;
+  } else if (pj_errno > 0) {
+    rb_raise(rb_eSystemCallError, "Unknown system call error");
+  } else {
+    rb_funcall(cError, idRaise, 1, INT2FIX(pj_errno) );
+  }
+}
+
+/**Transforms a point in the coordinate system defined at initialization of the Projection object to WGS84 LonLat in radians.
+   This version of the method changes the point in-place.
+
+   call-seq: inverse!(point) -> point
+
+ */
+static VALUE proj_inverse(VALUE self,VALUE point){
+  _wrap_pj* wpj;
+  projUV* pResult = (projUV*) malloc(sizeof(projUV));
+  Data_Get_Struct(self,_wrap_pj,wpj);
+
+  pResult->u = NUM2DBL( rb_funcall(point, idGetX, 0) );
+  pResult->v = NUM2DBL( rb_funcall(point, idGetY, 0) );
+  *pResult = pj_inv(*pResult,wpj->pj);
+
+  if (pj_errno == 0) {
+    rb_funcall(point, idSetX, 1, rb_float_new(pResult->u) );
+    rb_funcall(point, idSetY, 1, rb_float_new(pResult->v) );
+    return point;
+  } else if (pj_errno > 0) {
+    rb_raise(rb_eSystemCallError, "Unknown system call error");
+  } else {
+    rb_funcall(cError, idRaise, 1, INT2FIX(pj_errno) );
+  }
+}
+
+/**Transforms a point from one projection to another. The second parameter is
+   either a Proj4::Point object or you can use any object which
+   responds to the x, y, z read and write accessor methods. (In fact you
+   don't even need the z accessor methods, 0 is assumed if they don't exist).
+   This is the destructive variant of the method, i.e. it will overwrite your
+   existing point coordinates but otherwise leave the point object alone.
+
+   call-seq: transform!(destinationProjection, point) -> point
+
+ */
+static VALUE proj_transform(VALUE self, VALUE dst, VALUE point){
+  _wrap_pj* wpjsrc;
+  _wrap_pj* wpjdst;
+  double array_x[1];
+  double array_y[1];
+  double array_z[1];
+  int result;
+
+  Data_Get_Struct(self,_wrap_pj,wpjsrc);
+  Data_Get_Struct(dst,_wrap_pj,wpjdst);
+
+  array_x[0] = NUM2DBL( rb_funcall(point, idGetX, 0) );
+  array_y[0] = NUM2DBL( rb_funcall(point, idGetY, 0) );
+
+  /* if point objects has a method 'z' we get the z coordinate, otherwise we just assume 0 */
+  if ( rb_respond_to(point, idGetZ) ) {
+    array_z[0] = NUM2DBL( rb_funcall(point, idGetZ, 0) );
+  } else {
+    array_z[0] = 0.0;
+  }
+
+  result = pj_transform(wpjsrc->pj, wpjdst->pj, 1, 1, array_x, array_y, array_z);
+  if (! result) {
+    rb_funcall(point, idSetX, 1, rb_float_new(array_x[0]) );
+    rb_funcall(point, idSetY, 1, rb_float_new(array_y[0]) );
+    /* if point objects has a method 'z=' we set the z coordinate, otherwise we ignore it  */
+    if ( rb_respond_to(point, idSetZ) ) {
+        rb_funcall(point, idSetZ, 1, rb_float_new(array_z[0]) );
+    }
+    return point;
+  } else {
+    if (result > 0) {
+        rb_raise(rb_eSystemCallError, "Unknown system call error");
+    } else {
+        rb_funcall(cError, idRaise, 1, INT2FIX(result) );
+    }
+  }
+}
+
+static VALUE projerr_strerrno(VALUE self, VALUE errno){
+    char *errmsg = pj_strerrno(NUM2INT(errno));
+    if (errmsg) {
+        return rb_str_new2(errmsg);
+    } else {
+        return rb_str_new2("unknown error");
+    }
+}
+
+#if PJ_VERSION >= 449
+/**Return list of all datums we know about.
+
+   call-seq: list -> Array of Proj4::Datum
+
+ */
+static VALUE datum_list(VALUE self){
+  struct PJ_DATUMS *datum;
+  VALUE list = rb_ary_new();
+  for (datum = pj_get_datums_ref(); datum->id; datum++){
+    rb_ary_push(list, Data_Wrap_Struct(cDatum, 0, 0, datum));
+  }
+  return list;
+}
+/**Get ID of the datum.
+
+   call-seq: id -> String
+
+ */
+static VALUE datum_get_id(VALUE self){
+  struct PJ_DATUMS *datum;
+  Data_Get_Struct(self,struct PJ_DATUMS,datum);
+  return rb_str_new2(datum->id);
+}
+/**Get ID of the ellipse used by the datum.
+
+   call-seq: ellipse_id -> String
+
+ */
+static VALUE datum_get_ellipse_id(VALUE self){
+  struct PJ_DATUMS *datum;
+  Data_Get_Struct(self,struct PJ_DATUMS,datum);
+  return rb_str_new2(datum->ellipse_id);
+}
+/**Get definition of the datum.
+
+   call-seq: defn -> String
+
+ */
+static VALUE datum_get_defn(VALUE self){
+  struct PJ_DATUMS *datum;
+  Data_Get_Struct(self,struct PJ_DATUMS,datum);
+  return rb_str_new2(datum->defn);
+}
+/**Get comments about the datum.
+
+   call-seq: comments -> String
+
+ */
+static VALUE datum_get_comments(VALUE self){
+  struct PJ_DATUMS *datum;
+  Data_Get_Struct(self,struct PJ_DATUMS,datum);
+  return rb_str_new2(datum->comments);
+}
+
+/**Return list of all reference ellipsoids we know about.
+
+   call-seq: list -> Array of Proj4::Ellipsoid
+
+ */
+static VALUE ellipsoid_list(VALUE self){
+  struct PJ_ELLPS *el;
+  VALUE list = rb_ary_new();
+  for (el = pj_get_ellps_ref(); el->id; el++){
+    rb_ary_push(list, Data_Wrap_Struct(cEllipsoid, 0, 0, el));
+  }
+  return list;
+}
+/**Get ID of the reference ellipsoid.
+
+   call-seq: id -> String
+
+ */
+static VALUE ellipsoid_get_id(VALUE self){
+  struct PJ_ELLPS *el;
+  Data_Get_Struct(self,struct PJ_ELLPS,el);
+  return rb_str_new2(el->id);
+}
+/**Get equatorial radius (semi-major axis, a value) of the reference ellipsoid.
+
+   call-seq: major -> String
+
+ */
+static VALUE ellipsoid_get_major(VALUE self){
+  struct PJ_ELLPS *el;
+  Data_Get_Struct(self,struct PJ_ELLPS,el);
+  return rb_str_new2(el->major);
+}
+/**Get elliptical parameter of the reference ellipsoid. This is either the polar radius (semi-minor axis, b value) or the inverse flattening (1/f, rf).
+
+   call-seq: ell -> String
+
+ */
+static VALUE ellipsoid_get_ell(VALUE self){
+  struct PJ_ELLPS *el;
+  Data_Get_Struct(self,struct PJ_ELLPS,el);
+  return rb_str_new2(el->ell);
+}
+/**Get name of the reference ellipsoid.
+
+   call-seq: name -> String
+
+ */
+static VALUE ellipsoid_get_name(VALUE self){
+  struct PJ_ELLPS *el;
+  Data_Get_Struct(self,struct PJ_ELLPS,el);
+  return rb_str_new2(el->name);
+}
+
+/**Return list of all prime meridians we know about.
+
+   call-seq: list -> Array of Proj4::PrimeMeridian
+
+ */
+static VALUE prime_meridian_list(VALUE self){
+  struct PJ_PRIME_MERIDIANS *prime_meridian;
+  VALUE list = rb_ary_new();
+  for (prime_meridian = pj_get_prime_meridians_ref(); prime_meridian->id; prime_meridian++){
+    rb_ary_push(list, Data_Wrap_Struct(cPrimeMeridian, 0, 0, prime_meridian));
+  }
+  return list;
+}
+/**Get ID of this prime_meridian.
+
+   call-seq: id -> String
+
+ */
+static VALUE prime_meridian_get_id(VALUE self){
+  struct PJ_PRIME_MERIDIANS *prime_meridian;
+  Data_Get_Struct(self,struct PJ_PRIME_MERIDIANS,prime_meridian);
+  return rb_str_new2(prime_meridian->id);
+}
+/**Get definition of this prime_meridian.
+
+   call-seq: defn -> String
+
+ */
+static VALUE prime_meridian_get_defn(VALUE self){
+  struct PJ_PRIME_MERIDIANS *prime_meridian;
+  Data_Get_Struct(self,struct PJ_PRIME_MERIDIANS,prime_meridian);
+  return rb_str_new2(prime_meridian->defn);
+}
+
+/**Return list of all projection types we know about.
+
+   call-seq: list -> Array of Proj4::ProjectionType
+
+ */
+static VALUE projection_type_list(VALUE self){
+  struct PJ_LIST *pt;
+  VALUE list = rb_ary_new();
+  for (pt = pj_get_list_ref(); pt->id; pt++){
+    rb_ary_push(list, Data_Wrap_Struct(cProjectionType, 0, 0, pt));
+  }
+  return list;
+}
+/**Get ID of this projection type.
+
+   call-seq: id -> String
+
+ */
+static VALUE projection_type_get_id(VALUE self){
+  struct PJ_LIST *pt;
+  Data_Get_Struct(self,struct PJ_LIST,pt);
+  return rb_str_new2(pt->id);
+}
+/**Get description of this projection type as a multiline string.
+
+   call-seq: descr -> String
+
+ */
+static VALUE projection_type_get_descr(VALUE self){
+  struct PJ_LIST *pt;
+  Data_Get_Struct(self,struct PJ_LIST,pt);
+  return rb_str_new2(*(pt->descr));
+}
+
+/**Return list of all units we know about.
+
+   call-seq: list -> Array of Proj4::Unit
+
+ */
+static VALUE unit_list(VALUE self){
+  struct PJ_UNITS *unit;
+  VALUE list = rb_ary_new();
+  for (unit = pj_get_units_ref(); unit->id; unit++){
+    rb_ary_push(list, Data_Wrap_Struct(cUnit, 0, 0, unit));
+  }
+  return list;
+}
+/**Get ID of the unit.
+
+   call-seq: id -> String
+
+ */
+static VALUE unit_get_id(VALUE self){
+  struct PJ_UNITS *unit;
+  Data_Get_Struct(self,struct PJ_UNITS,unit);
+  return rb_str_new2(unit->id);
+}
+/**Get conversion factor of this unit to a meter. Note that this is a string, it can either contain a floating point number or it can be in the form numerator/denominator.
+
+   call-seq: to_meter -> String
+
+ */
+static VALUE unit_get_to_meter(VALUE self){
+  struct PJ_UNITS *unit;
+  Data_Get_Struct(self,struct PJ_UNITS,unit);
+  return rb_str_new2(unit->to_meter);
+}
+/**Get name (description) of the unit.
+
+   call-seq: name -> String
+
+ */
+static VALUE unit_get_name(VALUE self){
+  struct PJ_UNITS *unit;
+  Data_Get_Struct(self,struct PJ_UNITS,unit);
+  return rb_str_new2(unit->name);
+}
+
+#endif
+
+void Init_projrb(void) {
+
+  idRaise = rb_intern("raise_error");
+  idGetX = rb_intern("x");
+  idSetX = rb_intern("x=");
+  idGetY = rb_intern("y");
+  idSetY = rb_intern("y=");
+  idGetZ = rb_intern("z");
+  idSetZ = rb_intern("z=");
+  idParseInitParameters = rb_intern("_parse_init_parameters");
+
+  mProjrb = rb_define_module("Proj4");
+
+  /**
+     Radians per degree
+  */
+  rb_define_const(mProjrb,"DEG_TO_RAD", rb_float_new(DEG_TO_RAD));
+  /**
+     Degrees per radian
+  */
+  rb_define_const(mProjrb,"RAD_TO_DEG", rb_float_new(RAD_TO_DEG));
+  /**
+     Version of C libproj
+  */
+  rb_define_const(mProjrb,"LIBVERSION", rb_float_new(PJ_VERSION));
+
+  cError = rb_define_class_under(mProjrb,"Error",rb_path2class("StandardError"));
+  rb_define_singleton_method(cError,"strerrno",projerr_strerrno,1);
+
+  cProjection = rb_define_class_under(mProjrb,"Projection",rb_cObject);
+  rb_define_alloc_func(cProjection,proj_alloc);
+  rb_define_method(cProjection,"initialize",proj_initialize,1);
+  rb_define_method(cProjection,"hasInverse?",proj_has_inverse,0);
+  rb_define_method(cProjection,"isLatLong?",proj_is_latlong,0);
+  rb_define_method(cProjection,"isGeocent?",proj_is_geocent,0);
+  rb_define_alias(cProjection,"isGeocentric?","isGeocent?");
+  rb_define_method(cProjection,"getDef",proj_get_def,0);
+  rb_define_method(cProjection,"forward!",proj_forward,1);
+  rb_define_method(cProjection,"inverse!",proj_inverse,1);
+  rb_define_method(cProjection,"transform!",proj_transform,2);
+
+  #if PJ_VERSION >= 449
+    cDef = rb_define_class_under(mProjrb,"Def",rb_cObject);
+
+    /* The Datum class holds information about datums ('WGS84', 'potsdam', ...) known to Proj.4. */
+    cDatum = rb_define_class_under(mProjrb,"Datum",cDef);
+    rb_define_singleton_method(cDatum,"list",datum_list,0);
+    rb_define_method(cDatum,"id",datum_get_id,0);
+    rb_define_method(cDatum,"ellipse_id",datum_get_ellipse_id,0);
+    rb_define_method(cDatum,"defn",datum_get_defn,0);
+    rb_define_method(cDatum,"comments",datum_get_comments,0);
+
+    /* The Ellipsoid class holds information about ellipsoids ('WGS84', 'bessel', ...) known to Proj.4. */
+    cEllipsoid = rb_define_class_under(mProjrb,"Ellipsoid",cDef);
+    rb_define_singleton_method(cEllipsoid,"list",ellipsoid_list,0);
+    rb_define_method(cEllipsoid,"id",ellipsoid_get_id,0);
+    rb_define_method(cEllipsoid,"major",ellipsoid_get_major,0);
+    rb_define_method(cEllipsoid,"ell",ellipsoid_get_ell,0);
+    rb_define_method(cEllipsoid,"name",ellipsoid_get_name,0);
+
+    /* The PrimeMeridian class holds information about prime meridians ('greenwich', 'lisbon', ...) known to Proj.4. */
+    cPrimeMeridian = rb_define_class_under(mProjrb,"PrimeMeridian",cDef);
+    rb_define_singleton_method(cPrimeMeridian,"list",prime_meridian_list,0);
+    rb_define_method(cPrimeMeridian,"id",prime_meridian_get_id,0);
+    rb_define_method(cPrimeMeridian,"defn",prime_meridian_get_defn,0);
+
+    /* The ProjectionType class holds information about projections types ('merc', 'aea', ...) known to Proj.4. */
+    cProjectionType = rb_define_class_under(mProjrb,"ProjectionType",cDef);
+    rb_define_singleton_method(cProjectionType,"list",projection_type_list,0);
+    rb_define_method(cProjectionType,"id",projection_type_get_id,0);
+    rb_define_method(cProjectionType,"descr",projection_type_get_descr,0);
+
+    /* The Unit class holds information about the units ('m', 'km', 'mi', ...) known to Proj.4. */
+    cUnit = rb_define_class_under(mProjrb,"Unit",cDef);
+    rb_define_singleton_method(cUnit,"list",unit_list,0);
+    rb_define_method(cUnit,"id",unit_get_id,0);
+    rb_define_method(cUnit,"to_meter",unit_get_to_meter,0);
+    rb_define_method(cUnit,"name",unit_get_name,0);
+
+  #endif
+
+}
+

data/test/test_constants.rb

@@ -0,0 +1,20 @@
+$: << 'lib'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'proj4')
+require 'test/unit'
+
+class ConstantsTest < Test::Unit::TestCase
+
+    def test_version
+        assert 440 < Proj4::LIBVERSION
+    end
+
+    def test_deg
+        assert_equal Math::PI/180, Proj4::DEG_TO_RAD
+    end
+
+    def test_rad
+        assert_equal 180/Math::PI, Proj4::RAD_TO_DEG
+    end
+
+end
+

data/test/test_create_projection.rb

@@ -0,0 +1,63 @@
+$: << 'lib'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'proj4')
+require 'test/unit'
+
+class CreateProjectionTest < Test::Unit::TestCase
+
+    def setup
+        @proj_wgs84   = Proj4::Projection.new(["init=epsg:4326"])           # WGS84
+        @proj_gk      = Proj4::Projection.new(["init=epsg:31467"])          # Gauss-Kruger Zone 3
+        @proj_conakry = Proj4::Projection.new(["init=epsg:31528"])          # Conakry 1905 / UTM zone 28N
+        @proj_ortel   = Proj4::Projection.new(["proj=ortel", "lon_0=90w"])  # Ortelius Oval Projection
+    end
+
+    def test_has_inverse
+        assert   @proj_wgs84.hasInverse?
+        assert   @proj_gk.hasInverse?
+        assert   @proj_conakry.hasInverse?
+        assert ! @proj_ortel.hasInverse?
+    end
+
+    def test_is_latlong
+        assert   @proj_wgs84.isLatLong?
+        assert ! @proj_gk.isLatLong?
+        assert ! @proj_conakry.isLatLong?
+        assert ! @proj_ortel.isLatLong?
+    end
+
+    def test_is_geocent
+        assert_equal @proj_gk.isGeocent?, @proj_gk.isGeocentric?    # two names for same method
+        assert ! @proj_wgs84.isGeocent?
+        assert ! @proj_gk.isGeocent?
+        assert ! @proj_conakry.isGeocent?
+        assert ! @proj_ortel.isGeocent?
+    end
+
+    def test_get_def
+        assert_equal '+init=epsg:4326 +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +towgs84=0,0,0', @proj_wgs84.getDef.strip
+        assert_equal '+init=epsg:31467 +proj=tmerc +lat_0=0 +lon_0=9 +k=1.000000 +x_0=3500000 +y_0=0 +ellps=bessel +datum=potsdam +units=m +no_defs +towgs84=606.0,23.0,413.0', @proj_gk.getDef.strip
+        assert_equal '+init=epsg:31528 +proj=utm +zone=28 +a=6378249.2 +b=6356515 +towgs84=-23,259,-9,0,0,0,0 +units=m +no_defs', @proj_conakry.getDef.strip
+        assert_equal '+proj=ortel +lon_0=90w +ellps=WGS84', @proj_ortel.getDef.strip
+    end
+
+    def test_inspect
+        assert_equal '#<Proj4::Projection +init=epsg:4326 +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +towgs84=0,0,0>', @proj_wgs84.to_s
+        assert_equal '#<Proj4::Projection +init=epsg:4326 +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +towgs84=0,0,0>', @proj_wgs84.inspect
+    end
+
+    def test_projection
+        assert_equal 'longlat', @proj_wgs84.projection
+        assert_equal 'tmerc',   @proj_gk.projection
+        assert_equal 'utm',     @proj_conakry.projection
+        assert_equal 'ortel',   @proj_ortel.projection
+    end
+
+    def test_datum
+        assert_equal 'WGS84',   @proj_wgs84.datum
+        assert_equal 'potsdam', @proj_gk.datum
+        assert_nil              @proj_conakry.datum
+        assert_nil              @proj_ortel.datum
+    end
+
+end
+

data/test/test_datums.rb

@@ -0,0 +1,44 @@
+$: << 'lib'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'proj4')
+require 'test/unit'
+
+if Proj4::LIBVERSION >= 449
+    class DatumsTest < Test::Unit::TestCase
+
+        def test_get_all
+            datums = Proj4::Datum.list.sort.collect{ |u| u.id }
+            assert datums.index('WGS84')
+            assert datums.index('potsdam')
+            assert datums.index('ire65')
+        end
+
+        def test_one
+            datum = Proj4::Datum.get('potsdam')
+            assert_kind_of Proj4::Datum, datum
+            assert_equal 'potsdam', datum.id
+            assert_equal 'potsdam', datum.to_s
+            assert_equal 'bessel', datum.ellipse_id
+            assert_equal 'towgs84=606.0,23.0,413.0', datum.defn
+            assert_equal 'Potsdam Rauenberg 1950 DHDN', datum.comments
+            assert_equal '#<Proj4::Datum id="potsdam", ellipse_id="bessel", defn="towgs84=606.0,23.0,413.0", comments="Potsdam Rauenberg 1950 DHDN">', datum.inspect
+        end
+
+        def test_compare
+            u1 = Proj4::Datum.get('potsdam')
+            u2 = Proj4::Datum.get('potsdam')
+            assert u1 == u2
+        end
+
+        def test_failed_get
+            datum = Proj4::Datum.get('foo')
+            assert_nil datum
+        end
+
+        def test_new
+            assert_raise TypeError do
+                Proj4::Datum.new
+            end
+        end
+
+    end
+end

data/test/test_ellipsoids.rb

@@ -0,0 +1,45 @@
+$: << 'lib'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'proj4')
+require 'test/unit'
+
+if Proj4::LIBVERSION >= 449
+    class EllipsoidsTest < Test::Unit::TestCase
+
+        def test_get_all
+            ellipsoids = Proj4::Ellipsoid.list.sort.collect{ |u| u.id }
+            assert ellipsoids.index('WGS84')
+            assert ellipsoids.index('bessel')
+            assert ellipsoids.index('lerch')
+        end
+
+        def test_one
+            ellipsoid = Proj4::Ellipsoid.get('bessel')
+            assert_kind_of Proj4::Ellipsoid, ellipsoid
+            assert_equal 'bessel', ellipsoid.id
+            assert_equal 'a=6377397.155', ellipsoid.major
+            assert_equal 'rf=299.1528128', ellipsoid.ell
+            assert_equal 'Bessel 1841', ellipsoid.name
+            assert_equal 'bessel', ellipsoid.to_s
+            assert_equal '#<Proj4::Ellipsoid id="bessel", major="a=6377397.155", ell="rf=299.1528128", name="Bessel 1841">', ellipsoid.inspect
+        end
+
+        def test_compare
+            e1 = Proj4::Ellipsoid.get('bessel')
+            e2 = Proj4::Ellipsoid.get('bessel')
+            assert e1 == e2
+        end
+
+        def test_failed_get
+            ellipsoid = Proj4::Ellipsoid.get('foo')
+            assert_nil ellipsoid
+        end
+
+        def test_new
+            assert_raise TypeError do
+                Proj4::Ellipsoid.new
+            end
+        end
+
+    end
+end
+