georuby-ext 0.0.1 → 0.0.2

data/lib/georuby-ext/rspec_helper.rb

@@ -21,39 +21,78 @@ def geometry(text, srid = 4326)
 end
 
 def point(x=0.0, y=0.0, srid = 4326)
-  GeoRuby::SimpleFeatures::Point.from_x_y(x,y,srid)
+  if String === x
+    geometry("POINT(#{x})")
+  else
+    GeoRuby::SimpleFeatures::Point.from_x_y x, y, srid
+  end
 end
 
 def points(text)
-  text.split(",").collect { |definition| geometry "POINT(#{definition})" }
+  text.split(",").collect { |definition| point definition }
 end
 
 def line_string(*points)
   if points.one? and String === points.first
     geometry("LINESTRING(#{points})")
   else
-    GeoRuby::SimpleFeatures::LineString.from_points(points)
+    GeoRuby::SimpleFeatures::LineString.from_points(points, points.first.srid)
+  end
+end
+
+def multi_line_string(*lines)
+  if lines.one? and String === lines.first
+    geometry("MULTILINESTRING(#{lines})")
+  else
+    GeoRuby::SimpleFeatures::MultiLineString.from_line_strings lines, lines.first.srid
   end
 end
 
 def linear_ring(*points)
-  GeoRuby::SimpleFeatures::LinearRing.from_points(points)
+  GeoRuby::SimpleFeatures::LinearRing.from_points(points, points.first.srid)
+end
+
+def envelope(lower_corner, upper_corner)
+  lower_corner = point(lower_corner) if String === lower_corner
+  upper_corner = point(upper_corner) if String === upper_corner
+
+  GeoRuby::SimpleFeatures::Envelope.from_points([lower_corner, upper_corner], lower_corner.srid)
 end
 
 def polygon(*points)
-  GeoRuby::SimpleFeatures::Polygon.from_points([points])
+  if points.one? and String === points.first
+    geometry("POLYGON(#{points})")
+  else
+    GeoRuby::SimpleFeatures::Polygon.from_points([points], points.first.srid)
+  end
 end
 
 def multi_polygon(*polygons)
-  GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([polygons])
+  GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([polygons], polygons.first.srid)
+end
+
+def rgeo_factory
+  @rgeo_factory ||= RGeo::Geos.factory(:srid => 4326, :wkt_parser => {:support_ewkt => true})
 end
 
 def rgeo_point(x = 0, y = 0, srid = 4326)
-  RGeo::Geos.factory(:srid => srid).point(x, y)
+  rgeo_factory.point(x, y)
+end
+
+def rgeo_multi_polygon(polygons, srid = 4326)
+  rgeo_factory.multi_polygon(polygons)
+end
+
+def rgeo_multi_line_string(multi_line_string, srid = 4326)
+  if lines.one? and String === lines.first
+    geometry("MULTILINESTRING(#{lines})")
+  else
+    Rgeo::Geos::MultiLineString.from_line_strings lines, lines.first.srid
+  end
 end
 
 def rgeometry(text, srid = 4326)
-  RGeo::Geos.factory(:srid => srid).parse_wkt text
+  rgeo_factory.parse_wkt text
 end
 
 def rgeo_line_string(text, srid = 4326)

data/spec/lib/geokit_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe GeoKit::LatLng do
+  
+  subject { GeoKit::LatLng.new }
+
+  describe "#valid?" do
+    
+    it "should be invalid when lat is nil" do
+      subject.lat, subject.lng = nil, 45
+      subject.should_not be_valid
+    end
+
+    it "should be invalid when lng is nil" do
+      subject.lat, subject.lng = 45, nil
+      subject.should_not be_valid
+    end
+
+    it "should be valid when lat is between -90 and 90, lng between -180 and 180" do
+      subject.lat, subject.lng = 45, 90
+      subject.should be_valid
+    end
+
+  end
+
+  describe "#wgs84_to_google" do
+    
+    it "should return google coordinates" do
+      subject.lat, subject.lng = 45, 90
+      #subject.wgs84_to_google.eql?(Geokit::LatLng.new(5621521.48619207, 10018754.1713946)).should be_true 
+    end
+    
+  end
+
+  describe "#google_to_wgs84" do
+    
+    it "should wgs84 coordinates" do
+      subject.lat, subject.lng = 45, 90
+      #subject.google_to_wgs84.eql?(Geokit::LatLng.new(0.000404241877844722, 0.000808483755707569)).should be_true 
+    end
+    
+  end
+
+end

data/spec/lib/georuby/envelope_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe GeoRuby::SimpleFeatures::Envelope do  
+
+  subject { envelope point(0,0), point(1,1) }
+
+  describe "#to_google" do
+    
+    it "should return an Envelope with Google srid" do
+      subject.to_google.srid.should == 900913
+    end
+
+  end
+
+  describe "to_polygon" do
+    let(:geo_polygon){ polygon(point(0,0), point(0,1), point(1,1), point(1,0), point(0,0))}
+    let(:geo_envelope) { envelope( point(0,0), point(1,1) ) }
+
+    it "should return a polygon GeoRuby::SimpleFeatures::Polygon" do
+      (geo_envelope.to_polygon == geo_polygon).should be_true 
+    end                      
+  end
+
+  describe ".bounds" do
+
+    it "should return a global bounds of children" do      
+      geometries = [polygon("(0 0,1 1,1 0, 0 0)"), polygon("(1 1,2 2,2 0, 1 1)")] 
+      GeoRuby::SimpleFeatures::Envelope.bounds(geometries).should == envelope("0 0","2 2")
+    end                
+  end
+
+  describe ".overlaps?" do
+
+    it "should return true if bound is included in envelope" do      
+      bound = envelope("0 0","1 1")      
+      envelope("0 0","2 2").overlaps?(bound).should == true
+    end                
+
+    it "should return true if bound intersects envelope" do      
+      bound = envelope("0 0","1 1")      
+      envelope("0.5 0.5","2 2").overlaps?(bound).should == true
+    end                
+  end
+
+
+end

data/spec/lib/georuby/geometry_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+describe GeoRuby::SimpleFeatures::Geometry do
+
+  subject { point }
+
+  describe "#to_ewkt" do
+
+    it "should return as_ewkt result" do
+      subject.to_ewkt.should == subject.as_ewkt
+    end
+    
+  end
+
+  it "should be wgs84 when srid == 4326" do
+    subject.srid = 4326
+    subject.should be_wgs84
+  end
+
+  it "should not be wgs84 when srid isn't 4326" do
+    subject.srid = 900913
+    subject.should_not be_wgs84
+  end
+
+  describe "#inspect" do
+
+    it "should include geometry class name" do
+      subject.inspect.should include(subject.class.name)
+    end
+    
+    it "should include geometry ekwt" do
+      subject.inspect.should include(subject.to_ewkt)
+    end
+
+  end
+
+  describe ".srid!" do
+    
+    it "should return the uniq srid of given geometries" do
+      GeoRuby::SimpleFeatures::Geometry.srid!([point.to_google]).should == 900913
+    end
+
+    it "should raise an error when srid is not uniq" do
+      lambda do
+        GeoRuby::SimpleFeatures::Geometry.srid!([point, point.to_google])
+      end.should raise_error
+    end
+
+  end
+
+  describe "#to_wgs84" do
+
+    let(:projected_geometry) { mock }
+
+    it "should return a geometry with 4326 srid" do
+      subject.to_wgs84.srid.should == 4326
+    end
+
+    it "should project the geometry in wgs84" do
+      subject.should_receive(:project_to).with(4326).and_return(projected_geometry)
+      subject.to_wgs84.should == projected_geometry
+    end
+
+  end
+
+  describe "#to_google" do
+
+    let(:projected_geometry) { mock }
+
+    it "should return a geometry with 900913 srid" do
+      subject.to_google.srid.should == 900913
+    end
+
+    it "should project the geometry in google" do
+      subject.should_receive(:project_to).with(900913).and_return(projected_geometry)
+      subject.to_google.should == projected_geometry
+    end
+
+  end
+
+end

data/spec/{georuby → lib/georuby}/line_string_spec.rb

@@ -5,9 +5,6 @@ describe GeoRuby::SimpleFeatures::LineString do
   subject { line_string "0 0,1 1,0 0" }
 
   describe "#to_rgeo" do
-    it "should create a RGeo Geos geometry" do
-      subject.to_rgeo.should be_kind_of(RGeo::Geos::GeometryImpl)
-    end
 
     context "returned RGeo LineString" do
       it "should have the same srid" do
@@ -41,7 +38,6 @@ describe GeoRuby::SimpleFeatures::LineString do
       
       it "should have the same srid" do
         subject.to_ring.should have_same(:srid).than(subject)
-        # subject.to_ring.srid.should == subject.srid
       end
 
       context "when line is closed" do
@@ -72,7 +68,7 @@ describe GeoRuby::SimpleFeatures::LineString do
       subject.change(:points => other_points).points.should == other_points
     end
 
-    it "should change the points if specified" do
+    it "should change the srid if specified" do
       subject.change(:srid => 1).srid.should == 1
     end
 
@@ -94,27 +90,46 @@ describe GeoRuby::SimpleFeatures::LineString do
 
   end
 
-  describe "#to_wgs84" do
+  describe "#project_to" do
+
+    let(:target_srid) { 900913 }
+    subject { line_string("0 0,1 1,0 0") }
 
     it "should project all points into wgs84" do
-      subject.to_wgs84.points.each_with_index do |wgs84_point, index|
-        wgs84_point.should == subject[index].to_wgs84
+      subject.project_to(target_srid).points.each_with_index do |point, index|
+        point.should == subject[index].project_to(target_srid)
       end
     end
 
-    it "should have the srid 4326" do
-      subject.to_wgs84.srid.should == 4326
+    it "should have the target srid" do
+      subject.project_to(target_srid).srid.should == target_srid
     end
 
     it "should not change other attributes" do
-      subject.reverse.should have_same(:with_z, :with_m).than(subject)
+      subject.project_to(target_srid).should have_same(:with_z, :with_m).than(subject)
+    end
+
+  end
+
+  describe "#close!" do
+    
+    it "should add first point if needed" do
+      line_string("0 0,1 1").close!.should == line_string("0 0,1 1,0 0")
+    end
+
+    it "should not change a closed line" do
+      line_string("0 0,1 1,0 0").close!.should == line_string("0 0,1 1,0 0")
     end
 
   end
 
-  it "should be closed when is_closed is true" do
-    subject.stub :is_closed => true
-    subject.should be_closed
+  describe "#side_count" do
+    
+    it "should return point count minus one" do
+      line_string("0 0,1 1,2 2").side_count.should == 2
+    end
+
   end
 
 end
+

data/spec/lib/georuby/linear_ring_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe GeoRuby::SimpleFeatures::LinearRing do
+  let(:result) { rgeo_factory.linear_ring([rgeo_point(0, 0), rgeo_point(2, 1), rgeo_point(3, 2), rgeo_point(0, 0)])} 
+  
+  describe "to_rgeo" do
+    it "should create a RGeo::Feature::LinearRing" do
+      line = linear_ring(point(0,0), point(2,1), point(3,2), point(0,0))
+      line.to_rgeo.should == result
+    end 
+
+    it "should create a RGeo::Feature::LinearRing if the georuby linear ring is not closed" do
+      line = linear_ring(point(0,0), point(2,1), point(3,2))
+      line.to_rgeo.should == result
+    end
+
+  end
+
+  describe ".from_points" do
+    
+    it "should be closed even if last point is missing" do
+      GeoRuby::SimpleFeatures::LinearRing.from_points(points("0 0,1 1,0 0")).should be_closed
+    end
+
+    it "should accept already closed line" do
+      GeoRuby::SimpleFeatures::LinearRing.from_points(points("0 0,1 1,0 0")).should == line_string("0 0,1 1,0 0")
+    end
+
+  end
+
+  describe ".from_coordinates" do
+    
+    it "should be closed even if last point is missing" do
+      GeoRuby::SimpleFeatures::LinearRing.from_coordinates([[0,0],[1,1],[0,0]]).should be_closed
+    end
+
+    it "should accept already closed line" do
+      GeoRuby::SimpleFeatures::LinearRing.from_coordinates([[0,0],[1,1],[0,0]]).should == line_string("0 0,1 1,0 0")
+    end
+
+  end
+
+  it "should close linear rings parsed from ekt" do
+    polygon("(0 0,1 1)").rings.first.should be_closed
+  end
+
+  it "should close linear rings parsed from ekb" do
+    ewkb_polygon = GeoRuby::SimpleFeatures::Geometry.from_ewkb(polygon("(0 0,1 1,0 0)").as_ewkb)
+    ewkb_polygon.rings.first.should be_closed
+  end
+
+end

data/spec/lib/georuby/locators_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe GeoRuby::SimpleFeatures::MultiLineString do
+
+  describe "locate_point" do
+
+    context "examples" do
+
+      # it "should find 2,1 at 0.5 between 0,0 and 4,0" do
+      #   multi_line_string("(0 0,4 0)").locate_point(point(2,1)).should == 0.5
+      # end
+
+      # it "should find 2,1 at 1.5 for (0,4)...(0,1) and (0,0)...(4,0)" do
+      #   multi_line_string("(0 4,0 1),(0 0,4 0)").locate_point(point(2,1)).should == 1.5
+      # end
+    
+    end
+
+  end
+
+  describe "interpolate_point" do
+    
+    context "examples" do
+
+      it "should find 0.5 at (2,0) between 0,0 and 4,0" do
+        multi_line_string("(0 0,4 0)").interpolate_point(0.5).should == point(2,0)
+      end
+
+      it "should find 1.5 at (2,0) for (0,4)...(0,1) and (0,0)...(4,0)" do
+        multi_line_string("(0 4,0 1),(0 0,4 0)").interpolate_point(1.5).should == point(2,0)
+      end
+      
+    end
+
+  end
+
+end
+
+describe GeoRuby::SimpleFeatures::LineString do
+
+  describe "locate_point" do
+    
+    # context "examples" do
+
+    #   it "should find 2,1 at 0.5 between 0,0 and 4,0" do
+    #     line_string("0 0,4 0").locate_point(point(2,1)).should == 0.5
+    #   end
+
+    #   it "should find 2,1 at 0.5 between 0,0 and 4,0 (with several segments)" do
+    #     line_string("0 0,2 0,4 0").locate_point(point(2,1)).should == 0.5
+    #   end
+      
+    # end
+
+    it "should find Tour Eiffel at 0.434073695339917 on Avenue Gustave Eiffel" do
+      tour_eiffel = point 2.2946, 48.8580
+      avenue_gustave_eiffel = line_string "2.29406861440145 48.8570391455916,2.29498049424636 48.8576531708278,2.29540512788116 48.8579392878211,2.29634853859254 48.8585744605187"
+      expected_location = 0.434073695339917
+
+      avenue_gustave_eiffel.locate_point(tour_eiffel).should be_within(0.001).of(expected_location)
+    end
+
+  end
+
+end
+
+describe GeoRuby::SimpleFeatures::LineString::PointLocator do
+
+  alias_method :p, :point
+
+  def locator(target, departure, arrival)
+    GeoRuby::SimpleFeatures::LineString::PointLocator.new target, departure, arrival
+  end
+
+  describe "distance_from_segment" do
+
+    it "should be zero if target is the segment departure" do
+      departure = point(0, 0)
+      locator(departure, departure, p(1,1)).distance_from_segment.should be_zero
+    end
+
+    it "should be zero if target is the segment arrival" do
+      arrival = point(0, 0)
+      locator(arrival, p(1,1), arrival).distance_from_segment.should be_zero
+    end
+
+  end
+  
+  context "examples" do
+
+    it "should find right angle between 3 points" do
+      origin = tour_eiffel = point(2.2946, 48.8580)
+      locator(origin.endpoint(45, 100), origin, origin.endpoint(90, 100)).angle.rad2deg.should be_within(0.001).of(45)
+    end
+
+    # it "should locate 0,y at 0 between 0,0 and 4,0" do
+    #   -10.upto(10) do |y|
+    #     locator(p(0,y), p(0,0), p(4,0)).locate_point.should be_zero
+    #   end
+    # end
+
+    # it "should locate 2,y at 0.5 between 0,0 and 4,0" do
+    #   -10.upto(10) do |y|
+    #     locator(p(2,y), p(0,0), p(4,0)).locate_point.should == 0.5
+    #   end
+    # end
+
+    # it "should locate 4,y at 1 between 0,0 and 4,0" do
+    #   -10.upto(10) do |y|
+    #     locator(p(4,y), p(0,0), p(4,0)).locate_point.should == 1
+    #   end
+    # end
+
+    # it "should find 2,y at a distance of y from 0,0 and 4,0" do
+    #   -10.upto(10) do |y|
+    #     locator(p(2,y), p(0,0), p(4,0)).distance_from_segment.should be_within(0.001).of(y.abs)
+    #   end
+    # end
+
+  end
+
+
+end