rgeo 0.2.3 → 0.2.4

data/History.rdoc

@@ -1,3 +1,10 @@
+=== 0.2.4 / 2010-12-31
+
+* Several bugs were preventing the low-level Proj4 transform functions from working at all. Fixed. (Reported by mRg.)
+* The GEOS factories over-optimized projection casts, sometimes resulting in proj4 transformations not getting applied. Fixed. (Reported by mRg.)
+* Proj4 objects now have a flag to indicate whether geographic coordinate systems should be in radians. The (undocumented) radians option is no longer supported in transform_coords.
+* Disabled the spatialreference.org tests for the time being because the site seems to be offline.
+
 === 0.2.3 / 2010-12-19
 
 * The "simpler mercator" geographic type incorrectly reported EPSG 3857 instead of EPSG 3785 for the projection. Dyslexia fixed.

data/Version

@@ -1 +1 @@
-0.2.3
+0.2.4

data/ext/proj4_c_impl/main.c

@@ -67,6 +67,7 @@ RGEO_BEGIN_C
 typedef struct {
   projPJ pj;
   VALUE original_str;
+  char uses_radians;
 } RGeo_Proj4Data;
 
 
@@ -99,6 +100,7 @@ static VALUE alloc_proj4(VALUE klass)
   if (data) {
     data->pj = NULL;
     data->original_str = Qnil;
+    data->uses_radians = 0;
     result = Data_Wrap_Struct(klass, mark_proj4_func, destroy_proj4_func, data);
   }
   return result;
@@ -108,16 +110,19 @@ static VALUE alloc_proj4(VALUE klass)
 static VALUE method_proj4_initialize_copy(VALUE self, VALUE orig)
 {
   // Clear out any existing value
-  projPJ pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  RGeo_Proj4Data* self_data = RGEO_PROJ4_DATA_PTR(self);
+  projPJ pj = self_data->pj;
   if (pj) {
     pj_free(pj);
-    RGEO_PROJ4_DATA_PTR(self)->pj = NULL;
-    RGEO_PROJ4_DATA_PTR(self)->original_str = Qnil;
+    self_data->pj = NULL;
+    self_data->original_str = Qnil;
   }
   
   // Copy value from orig
-  RGEO_PROJ4_DATA_PTR(self)->pj = RGEO_PROJ4_DATA_PTR(orig)->pj;
-  RGEO_PROJ4_DATA_PTR(self)->original_str = RGEO_PROJ4_DATA_PTR(orig)->original_str;
+  RGeo_Proj4Data* orig_data = RGEO_PROJ4_DATA_PTR(orig);
+  self_data->pj = orig_data->pj;
+  self_data->original_str = orig_data->original_str;
+  self_data->uses_radians = orig_data->uses_radians;
   
   return self;
 }
@@ -126,11 +131,13 @@ static VALUE method_proj4_initialize_copy(VALUE self, VALUE orig)
 static VALUE method_proj4_get_geographic(VALUE self)
 {
   VALUE result = Qnil;
-  RGeo_Proj4Data* data = ALLOC(RGeo_Proj4Data);
-  if (data) {
-    data->pj = pj_latlong_from_proj(RGEO_PROJ4_DATA_PTR(self)->pj);
-    data->original_str = Qnil;
-    result = Data_Wrap_Struct(CLASS_OF(self), mark_proj4_func, destroy_proj4_func, data);
+  RGeo_Proj4Data* new_data = ALLOC(RGeo_Proj4Data);
+  if (new_data) {
+    RGeo_Proj4Data* self_data = RGEO_PROJ4_DATA_PTR(self);
+    new_data->pj = pj_latlong_from_proj(self_data->pj);
+    new_data->original_str = Qnil;
+    new_data->uses_radians = self_data->uses_radians;
+    result = Data_Wrap_Struct(CLASS_OF(self), mark_proj4_func, destroy_proj4_func, new_data);
   }
   return result;
 }
@@ -142,6 +149,12 @@ static VALUE method_proj4_original_str(VALUE self)
 }
 
 
+static VALUE method_proj4_uses_radians(VALUE self)
+{
+  return RGEO_PROJ4_DATA_PTR(self)->uses_radians ? Qtrue : Qfalse;
+}
+
+
 static VALUE method_proj4_canonical_str(VALUE self)
 {
   VALUE result = Qnil;
@@ -211,7 +224,7 @@ static VALUE cmethod_proj4_transform(VALUE method, VALUE from, VALUE to, VALUE x
 }
 
 
-static VALUE cmethod_proj4_create(VALUE klass, VALUE str)
+static VALUE cmethod_proj4_create(VALUE klass, VALUE str, VALUE uses_radians)
 {
   VALUE result = Qnil;
   Check_Type(str, T_STRING);
@@ -219,6 +232,7 @@ static VALUE cmethod_proj4_create(VALUE klass, VALUE str)
   if (data) {
     data->pj = pj_init_plus(RSTRING_PTR(str));
     data->original_str = str;
+    data->uses_radians = RTEST(uses_radians) ? 1 : 0;
     result = Data_Wrap_Struct(klass, mark_proj4_func, destroy_proj4_func, data);
   }
   return result;
@@ -230,13 +244,14 @@ static void rgeo_init_proj4()
   VALUE rgeo_module = rb_define_module("RGeo");
   VALUE coordsys_module = rb_define_module_under(rgeo_module, "CoordSys");
   VALUE proj4_class = rb_define_class_under(coordsys_module, "Proj4", rb_cObject);
-  rb_define_module_function(proj4_class, "_create", cmethod_proj4_create, 1);
+  rb_define_module_function(proj4_class, "_create", cmethod_proj4_create, 2);
   rb_define_method(proj4_class, "initialize_copy", method_proj4_initialize_copy, 1);
   rb_define_method(proj4_class, "_original_str", method_proj4_original_str, 0);
   rb_define_method(proj4_class, "_canonical_str", method_proj4_canonical_str, 0);
   rb_define_method(proj4_class, "_valid?", method_proj4_is_valid, 0);
   rb_define_method(proj4_class, "_geographic?", method_proj4_is_geographic, 0);
   rb_define_method(proj4_class, "_geocentric?", method_proj4_is_geocentric, 0);
+  rb_define_method(proj4_class, "_radians?", method_proj4_uses_radians, 0);
   rb_define_method(proj4_class, "_get_geographic", method_proj4_get_geographic, 0);
   rb_define_module_function(proj4_class, "_transform_coords", cmethod_proj4_transform, 5);
 }

data/lib/rgeo/coord_sys/proj4.rb

@@ -78,7 +78,7 @@ module RGeo
       # system.
       
       def eql?(rhs_)
-        rhs_.class == self.class && rhs_.canonical_hash == canonical_hash
+        rhs_.class == self.class && rhs_.canonical_hash == canonical_hash && rhs_._radians? == _radians?
       end
       alias_method :==, :eql?
       
@@ -137,6 +137,14 @@ module RGeo
       end
       
       
+      # Returns true if this Proj4 object uses radians rather than degrees
+      # if it is a geographic coordinate system.
+      
+      def radians?
+        _radians?
+      end
+      
+      
       # Get the geographic (unprojected lat-long) coordinate system
       # corresponding to this coordinate system; i.e. the one that uses
       # the same ellipsoid and datum.
@@ -161,8 +169,21 @@ module RGeo
         # Create a new Proj4 object, given a definition, which may be
         # either a string or a hash. Returns nil if the given definition
         # is invalid or Proj4 is not supported.
+        # 
+        # Recognized options include:
+        # 
+        # <tt>:radians</tt>::
+        #   If set to true, then this proj4 will represent geographic
+        #   (latitude/longitude) coordinates in radians rather than
+        #   degrees. If this is a geographic coordinate system, then its
+        #   units will be in radians. If this is a projected coordinate
+        #   system, then its units will be unchanged, but any geographic
+        #   coordinate system obtained using get_geographic will use
+        #   radians as its units. If this is a geocentric or other type of
+        #   coordinate system, this has no effect. Default is false.
+        #   (That is all coordinates are in degrees by default.)
         
-        def create(defn_)
+        def create(defn_, opts_={})
           result_ = nil
           if supported?
             if defn_.kind_of?(::Hash)
@@ -171,7 +192,7 @@ module RGeo
             unless defn_ =~ /^\s*\+/
               defn_ = defn_.sub(/^(\s*)/, '\1+').gsub(/(\s+)([^+\s])/, '\1+\2')
             end
-            result_ = _create(defn_)
+            result_ = _create(defn_, opts_[:radians])
             result_ = nil unless result_._valid?
           end
           result_
@@ -182,8 +203,8 @@ module RGeo
         # either a string or a hash. Raises Error::UnsupportedOperation
         # if the given definition is invalid or Proj4 is not supported.
         
-        def new(defn_)
-          result_ = create(defn_)
+        def new(defn_, opts_={})
+          result_ = create(defn_, opts_)
           unless result_
             raise Error::UnsupportedOperation, "Proj4 not supported in this installation"
           end
@@ -196,14 +217,13 @@ module RGeo
         # coordinate system to another. Returns an array with either two
         # or three elements.
         
-        def transform_coords(from_proj_, to_proj_, x_, y_, z_=nil, opts_={})
-          degrees_ = !opts_[:radians]
-          if degrees_ && from_proj_._geographic?
+        def transform_coords(from_proj_, to_proj_, x_, y_, z_=nil)
+          if !from_proj_._radians? && from_proj_._geographic?
             x_ *= ImplHelper::Math::RADIANS_PER_DEGREE
             y_ *= ImplHelper::Math::RADIANS_PER_DEGREE
           end
           result_ = _transform_coords(from_proj_, to_proj_, x_, y_, z_)
-          if result_ && degrees_ && to_proj_._geographic?
+          if result_ && !to_proj_._radians? && to_proj_._geographic?
             result_[0] *= ImplHelper::Math::DEGREES_PER_RADIAN
             result_[1] *= ImplHelper::Math::DEGREES_PER_RADIAN
           end
@@ -222,11 +242,11 @@ module RGeo
           when Feature::Point
             _transform_point(from_proj_, from_geometry_, to_proj_, to_factory_)
           when Feature::Line
-            to_factory_.line(from_geometry_.points.map{ |p_| transform(from_proj_, p_, to_proj_, to_factory_) })
+            to_factory_.line(from_geometry_.points.map{ |p_| _transform_point(from_proj_, p_, to_proj_, to_factory_) })
           when Feature::LinearRing
             _transform_linear_ring(from_proj_, from_geometry_, to_proj_, to_factory_)
           when Feature::LineString
-            to_factory_.line_string(from_geometry_.points.map{ |p_| transform(from_proj_, p_, to_proj_, to_factory_) })
+            to_factory_.line_string(from_geometry_.points.map{ |p_| _transform_point(from_proj_, p_, to_proj_, to_factory_) })
           when Feature::Polygon
             _transform_polygon(from_proj_, from_geometry_, to_proj_, to_factory_)
           when Feature::MultiPoint
@@ -247,17 +267,30 @@ module RGeo
           from_has_m_ = from_factory_.property(:has_m_coordinate)
           to_has_z_ = to_factory_.property(:has_z_coordinate)
           to_has_m_ = to_factory_.property(:has_m_coordinate)
-          coords_ = _transform_coords(from_proj_, to_proj_, from_point_.x, from_point_.y,
-                                      from_has_z_ ? from_point_.z : nil)
-          extras_ = []
-          extras_ << coords_[2].to_f if to_has_z_
-          extras_ << from_has_m_ ? from_point_.m : 0.0 if to_has_m_?
-          to_factory_.point(coords_[0], coords_[1], extras_)
+          x_ = from_point_.x
+          y_ = from_point_.y
+          if !from_proj_._radians? && from_proj_._geographic?
+            x_ *= ImplHelper::Math::RADIANS_PER_DEGREE
+            y_ *= ImplHelper::Math::RADIANS_PER_DEGREE
+          end
+          coords_ = _transform_coords(from_proj_, to_proj_, x_, y_, from_has_z_ ? from_point_.z : nil)
+          if coords_
+            if !to_proj_._radians? && to_proj_._geographic?
+              coords_[0] *= ImplHelper::Math::DEGREES_PER_RADIAN
+              coords_[1] *= ImplHelper::Math::DEGREES_PER_RADIAN
+            end
+            extras_ = []
+            extras_ << coords_[2].to_f if to_has_z_
+            extras_ << from_has_m_ ? from_point_.m : 0.0 if to_has_m_
+            to_factory_.point(coords_[0], coords_[1], *extras_)
+          else
+            nil
+          end
         end
         
         
         def _transform_linear_ring(from_proj_, from_ring_, to_proj_, to_factory_)  # :nodoc:
-          to_factory_.linear_ring(from_ring_.points[0..-2].map{ |p_| transform(from_proj_, p_, to_proj_, to_factory_) })
+          to_factory_.linear_ring(from_ring_.points[0..-2].map{ |p_| _transform_point(from_proj_, p_, to_proj_, to_factory_) })
         end
         
         

data/lib/rgeo/geos/factory.rb

@@ -106,7 +106,7 @@ module RGeo
       # Factory equivalence test.
       
       def eql?(rhs_)
-        rhs_.is_a?(Factory) && rhs_.srid == _srid && rhs_._buffer_resolution == _buffer_resolution && rhs_._flags == _flags
+        rhs_.is_a?(Factory) && rhs_.srid == _srid && rhs_._buffer_resolution == _buffer_resolution && rhs_._flags == _flags && rhs_.proj4 == @proj4
       end
       alias_method :==, :eql?
       
@@ -257,14 +257,16 @@ module RGeo
         return nil unless Geos.supported?
         keep_subtype_ = flags_[:keep_subtype]
         force_new_ = flags_[:force_new]
+        project_ = flags_[:project]
         type_ = original_.geometry_type
         ntype_ = type_ if keep_subtype_ && type_.include?(ntype_)
         case original_
         when GeometryImpl
           # Optimization if we're just changing factories, but the
-          # factories are zm-compatible.
+          # factories are zm-compatible and proj4-compatible.
           if original_.factory != self && ntype_ == type_ &&
-              original_.factory._flags & 0x6 == _flags & 0x6
+              original_.factory._flags & 0x6 == _flags & 0x6 &&
+              (!project_ || original_.factory.proj4 == @proj4)
           then
             result_ = original_.dup
             result_._set_factory(self)
@@ -273,6 +275,7 @@ module RGeo
           # LineString conversion optimization.
           if (original_.factory != self || ntype_ != type_) &&
               original_.factory._flags & 0x6 == _flags & 0x6 &&
+              (!project_ || original_.factory.proj4 == @proj4) &&
               type_.subtype_of?(Feature::LineString) && ntype_.subtype_of?(Feature::LineString)
           then
             return IMPL_CLASSES[ntype_]._copy_from(self, original_)

data/lib/rgeo/geos/zm_factory.rb

@@ -236,13 +236,16 @@ module RGeo
         return nil unless Geos.supported?
         keep_subtype_ = flags_[:keep_subtype]
         force_new_ = flags_[:force_new]
+        project_ = flags_[:project]
         type_ = original_.geometry_type
         ntype_ = type_ if keep_subtype_ && type_.include?(ntype_)
         case original_
         when ZMGeometryImpl
           # Optimization if we're just changing factories, but to
           # another ZM factory.
-          if original_.factory != self && ntype_ == type_
+          if original_.factory != self && ntype_ == type_ &&
+              (!project_ || original_.factory.proj4 == @proj4)
+          then
             zresult_ = original_.z_geometry.dup
             zresult_._set_factory(@zfactory)
             mresult_ = original_.m_geometry.dup
@@ -251,6 +254,7 @@ module RGeo
           end
           # LineString conversion optimization.
           if (original_.factory != self || ntype_ != type_) &&
+              (!project_ || original_.factory.proj4 == @proj4) &&
               type_.subtype_of?(Feature::LineString) && ntype_.subtype_of?(Feature::LineString)
           then
             klass_ = Factory::IMPL_CLASSES[ntype_]

data/test/coord_sys/tc_proj4.rb

@@ -92,15 +92,15 @@ module RGeo
         
         
         def test_simple_mercator_transform
-          geography_ = RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
+          geography_ = RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :radians => true)
           projection_ = RGeo::CoordSys::Proj4.create('+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs')
-          _assert_xy_close(_project_merc(0, 0), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 0, 0, nil, :radians => true))
-          _assert_xy_close(_project_merc(0.01, 0.01), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 0.01, 0.01, nil, :radians => true))
-          _assert_xy_close(_project_merc(1, 1), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 1, 1, nil, :radians => true))
-          _assert_xy_close(_project_merc(-1, -1), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, -1, -1, nil, :radians => true))
-          _assert_xy_close(_unproject_merc(0, 0), RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, 0, 0, nil, :radians => true))
-          _assert_xy_close(_unproject_merc(10000, 10000), RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, 10000, 10000, nil, :radians => true))
-          _assert_xy_close(_unproject_merc(-20000000, -20000000), RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, -20000000, -20000000, nil, :radians => true))
+          _assert_xy_close(_project_merc(0, 0), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 0, 0, nil))
+          _assert_xy_close(_project_merc(0.01, 0.01), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 0.01, 0.01, nil))
+          _assert_xy_close(_project_merc(1, 1), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 1, 1, nil))
+          _assert_xy_close(_project_merc(-1, -1), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, -1, -1, nil))
+          _assert_xy_close(_unproject_merc(0, 0), RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, 0, 0, nil))
+          _assert_xy_close(_unproject_merc(10000, 10000), RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, 10000, 10000, nil))
+          _assert_xy_close(_unproject_merc(-20000000, -20000000), RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, -20000000, -20000000, nil))
         end
         
         
@@ -111,6 +111,26 @@ module RGeo
         end
         
         
+        def test_point_projection_cast
+          geography_ = RGeo::Geos.factory(:proj4 => '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :srid =>4326)
+          projection_ = RGeo::Geos.factory(:proj4 => '+proj=tmerc +lat_0=49 +lon_0=-2 +k=0.9996012717 +x_0=400000 +y_0=-100000 +ellps=airy +datum=OSGB36 +units=m +no_defs', :srid => 27700)
+          proj_point_ = projection_.parse_wkt('POINT(473600.5000000000000000 186659.7999999999883585)')
+          geo_point_ = RGeo::Feature.cast(proj_point_, :project => true, :factory => geography_)
+          _assert_close_enough(-0.9393598527244420, geo_point_.x)
+          _assert_close_enough(51.5740106527552697, geo_point_.y)
+        end
+        
+        
+        def test_point_transform_lowlevel
+          geography_ = RGeo::Geos.factory(:proj4 => '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :srid =>4326)
+          projection_ = RGeo::Geos.factory(:proj4 => '+proj=tmerc +lat_0=49 +lon_0=-2 +k=0.9996012717 +x_0=400000 +y_0=-100000 +ellps=airy +datum=OSGB36 +units=m +no_defs', :srid => 27700)
+          proj_point_ = projection_.parse_wkt('POINT(473600.5000000000000000 186659.7999999999883585)')
+          geo_point_ = RGeo::CoordSys::Proj4.transform(projection_.proj4, proj_point_, geography_.proj4, geography_)
+          _assert_close_enough(-0.9393598527244420, geo_point_.x)
+          _assert_close_enough(51.5740106527552697, geo_point_.y)
+        end
+        
+        
       end
       
     end

data/test/coord_sys/tc_sr_org.rb

@@ -63,7 +63,7 @@ module RGeo
         end
         
         
-      end
+      end if false
       
     end
   end

data/test/coord_sys/tc_url_reader.rb

@@ -75,7 +75,7 @@ module RGeo
         end
         
         
-      end
+      end if false
       
     end
   end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 3
-  version: 0.2.3
+  - 4
+  version: 0.2.4
 platform: ruby
 authors: 
 - Daniel Azuma
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-19 00:00:00 -08:00
+date: 2010-12-31 00:00:00 -08:00
 default_executable: 
 dependencies: []