georuby-ext 0.0.1

data/lib/georuby-ext/georuby/point.rb

@@ -0,0 +1,73 @@
+class GeoRuby::SimpleFeatures::Point
+
+  def self.from_lat_lng(object, srid = GeoRuby::SimpleFeatures::DEFAULT_SRID)
+    if object.respond_to?(:to_lat_lng)
+      lat_lng = object.to_lat_lng
+    else
+      lat_lng = Geokit::LatLng.normalize object
+    end 
+    from_x_y lat_lng.lng, lat_lng.lat, srid
+  end
+
+  def eql?(other)
+     [x,y,srid] == [other.x, other.y, other.srid]
+  end
+
+  def hash
+    [x,y,srid].hash
+  end
+
+  def to_s
+    "#{y},#{x}"
+  end
+
+  def self.centroid(points)
+    case points.size
+    when 0
+      nil
+    when 1
+      points.first
+    when 2
+      return GeoRuby::SimpleFeatures::Point.from_x_y points.map(&:x).sum / 2, points.map(&:y).sum / 2, points.first.srid
+    else
+      points = [points.last, *points]
+      GeoRuby::SimpleFeatures::Polygon.from_points([points]).centroid.tap do |centroid|
+        centroid.srid = points.first.srid if centroid
+      end
+    end
+  end
+
+  def to_lat_lng
+    Geokit::LatLng.new y, x
+  end
+
+  def to_s
+    to_lat_lng.to_s
+  end
+
+  def to_wgs84
+    self.class.from_lat_lng to_lat_lng.google_to_wgs84, 4326
+  end
+
+  def to_google
+    self.class.from_lat_lng to_lat_lng.wgs84_to_google, 900913
+  end
+
+  def to_rgeo
+    factory = RGeo::Geos::Factory.create
+    factory.point(self.x, self.y)
+  end  
+
+  def to_openlayers
+    OpenLayers::LonLat.new x, y
+  end
+
+  def self.bounds(points)
+    return nil if points.blank?
+
+    points.inject(points.first.envelope) do |envelope, point|
+      envelope.extend!(point.envelope)
+    end
+  end
+
+end

data/lib/georuby-ext/georuby/polygon.rb

@@ -0,0 +1,68 @@
+class GeoRuby::SimpleFeatures::Polygon
+
+  def self.circle(center, radius, sides_number = 24)
+    coordinates = (0...sides_number).collect do |side|
+      2 * 180 / sides_number * side
+    end.collect do |angle|
+      point = GeoRuby::SimpleFeatures::Point.from_lat_lng(center.to_lat_lng.endpoint(angle, radius, {:units => :kms}))
+      [point.x, point.y]
+    end
+    # Close the circle
+    coordinates << coordinates.first
+    from_coordinates [coordinates]
+  end
+
+  def side_count
+    # Reduce by one because polygon is closed
+    (rings.collect(&:size).sum) - 1
+  end
+
+  def points
+    rings.collect(&:points).flatten
+  end
+
+  def centroid
+    if rgeo_polygon = to_rgeo
+      rgeo_polygon.centroid.to_georuby
+    end
+  end
+
+  def self.union(georuby_polygons)
+    factory = RGeo::Geos::Factory.create
+    if !georuby_polygons.empty?
+      polygon_union = georuby_polygons.first.to_rgeo
+      georuby_polygons.shift
+    end
+     
+    georuby_polygons.each do |polygon|
+       polygon_union = polygon_union.union(polygon.to_rgeo)
+    end
+    
+    polygon_union.to_georuby
+   end
+
+  def self.intersection(georuby_polygons)
+    factory = RGeo::Geos::Factory.create
+    if !georuby_polygons.empty?
+      polygon_intersection = georuby_polygons.first.to_rgeo
+      georuby_polygons.shift
+    end
+    
+    georuby_polygons.each do |polygon|
+      polygon_intersection = polygon_intersection.intersection(polygon.to_rgeo)
+    end
+
+    polygon_intersection.to_georuby
+  end
+
+  def to_wgs84
+    self.class.from_points([self.points.collect(&:to_wgs84)], 4326)
+  end
+
+  def to_rgeo
+    # take only the first ring for the outer ring of RGeo::Feature::Polygon
+    factory = RGeo::Geos::Factory.create #(:srid => srid)
+    polygon = factory.polygon(self.rings.collect(&:to_rgeo).first)
+  end  
+
+end

data/lib/georuby-ext/proj4.rb

@@ -0,0 +1,11 @@
+class Proj4::Projection
+
+  def self.wgs84
+    Proj4::Projection.new '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
+  end
+
+  def self.google
+    Proj4::Projection.new '+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 +no_defs'
+  end
+
+end

data/lib/georuby-ext/rgeo.rb

@@ -0,0 +1,23 @@
+class RGeo::Geos::PointImpl
+  def to_georuby
+    GeoRuby::SimpleFeatures::Point.from_x_y x, y, srid
+  end
+end
+
+class RGeo::Geos::LineStringImpl
+  def to_georuby
+    GeoRuby::SimpleFeatures::LineString.from_points points.collect(&:to_georuby), srid
+  end
+end
+
+class RGeo::Geos::PolygonImpl
+  def to_georuby
+    GeoRuby::SimpleFeatures::Polygon.from_linear_rings [exterior_ring.to_georuby], srid
+  end
+end
+
+class RGeo::Geos::MultiPolygonImpl
+  def to_georuby
+    GeoRuby::SimpleFeatures::MultiPolygon.from_polygons collect(&:to_georuby), srid
+  end
+end

data/lib/georuby-ext/rspec_helper.rb

@@ -0,0 +1,61 @@
+RSpec::Matchers.define :be_same_polygon do |reference|
+  match do |actual|
+    reference = 
+      case reference
+      when Array
+        GeoRuby::SimpleFeatures::Polygon.from_coordinates [reference]
+      when String
+        geometry reference
+      else
+        reference
+      end
+
+    [actual.points, reference.points].transpose.all? do |actual_point, reference_point|
+      actual_point.euclidian_distance(reference_point) < 0.01
+    end
+  end
+end
+
+def geometry(text, srid = 4326)
+  GeoRuby::SimpleFeatures::Geometry.from_ewkt "SRID=#{srid};#{text}"
+end
+
+def point(x=0.0, y=0.0, srid = 4326)
+  GeoRuby::SimpleFeatures::Point.from_x_y(x,y,srid)
+end
+
+def points(text)
+  text.split(",").collect { |definition| geometry "POINT(#{definition})" }
+end
+
+def line_string(*points)
+  if points.one? and String === points.first
+    geometry("LINESTRING(#{points})")
+  else
+    GeoRuby::SimpleFeatures::LineString.from_points(points)
+  end
+end
+
+def linear_ring(*points)
+  GeoRuby::SimpleFeatures::LinearRing.from_points(points)
+end
+
+def polygon(*points)
+  GeoRuby::SimpleFeatures::Polygon.from_points([points])
+end
+
+def multi_polygon(*polygons)
+  GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([polygons])
+end
+
+def rgeo_point(x = 0, y = 0, srid = 4326)
+  RGeo::Geos.factory(:srid => srid).point(x, y)
+end
+
+def rgeometry(text, srid = 4326)
+  RGeo::Geos.factory(:srid => srid).parse_wkt text
+end
+
+def rgeo_line_string(text, srid = 4326)
+  rgeometry "LINESTRING(#{text})"
+end

data/spec/georuby/line_string_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+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
+        subject.to_rgeo.srid.should == subject.srid
+      end
+      it "should have the points" do
+        line_string("0 0,1 1,0 0").to_rgeo.should == rgeo_line_string("0 0,1 1,0 0")
+      end
+    end 
+  end
+
+  describe "#==" do
+    
+    it "should be true when points are same" do
+      line_string("0 0,1 1").should == line_string("0 0,1 1")
+    end
+
+    it "should be true when the other is LineRing with the same points" do
+      line_string("0 0,1 1,0 0").should == line_string("0 0,1 1,0 0").to_ring
+    end
+
+  end
+
+  describe "#to_ring" do
+
+    it "should be a GeoRuby::SimpleFeatures::LinearRing" do
+      subject.to_ring.should be_instance_of(GeoRuby::SimpleFeatures::LinearRing)
+    end
+    
+    context "returned LinearRing" 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
+        subject { line_string("0 0,1 1,0 0") }
+
+        it "should have the same points" do
+          subject.to_ring.points.should == subject.points
+        end
+      end
+
+      context "when line isn't closed" do
+        subject { line_string("0 0,1 1") }
+
+        it "should have the line points and the first one" do
+          subject.to_ring.points.should == (subject.points << subject.first)
+        end
+      end
+                              
+    end
+
+  end
+
+  describe "#change" do
+
+    let(:other_points) { subject.points + points("3 3") }
+    
+    it "should change the points if specified" do
+      subject.change(:points => other_points).points.should == other_points
+    end
+
+    it "should change the points if specified" do
+      subject.change(:srid => 1).srid.should == 1
+    end
+
+    it "should not change unspecified attributes" do
+      subject.change(:points => other_points).should have_same(:srid, :with_z, :with_m).than(subject)
+    end
+
+  end
+
+  describe "#reverse" do
+    
+    it "should return a LineString with reversed points" do
+      subject.reverse.points.should == subject.points.reverse
+    end
+
+    it "should not change other attributes" do
+      subject.reverse.should have_same(:srid, :with_z, :with_m).than(subject)
+    end
+
+  end
+
+  describe "#to_wgs84" do
+
+    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
+      end
+    end
+
+    it "should have the srid 4326" do
+      subject.to_wgs84.srid.should == 4326
+    end
+
+    it "should not change other attributes" do
+      subject.reverse.should have_same(:with_z, :with_m).than(subject)
+    end
+
+  end
+
+  it "should be closed when is_closed is true" do
+    subject.stub :is_closed => true
+    subject.should be_closed
+  end
+
+end

data/spec/georuby/linear_ring_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe GeoRuby::SimpleFeatures::LinearRing do
+  let(:result) {factory = RGeo::Geos::Factory.create
+    factory.linear_ring([factory.point(0, 0), factory.point(2, 1), factory.point(3, 2), factory.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 "#to_wgs84" do
+    let(:line) {linear_ring(point(0,0), point(1,1), point(0,0))}
+    let(:line_wgs84) {    GeoRuby::SimpleFeatures::LinearRing.from_points([point(0,0,4326), point(0.000008983152841195214, 0.000008983152840993819,4326), point(0,0,4326)], 4326)}
+    
+    it "should return true when we compare line coordinates" do
+      line.to_wgs84.should == line_wgs84
+    end
+
+    it "should return same srid" do
+      line.to_wgs84.srid.should == line_wgs84.srid
+    end
+  end
+  
+end

data/spec/georuby/locators_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe GeoRuby::SimpleFeatures::MultiLineString do
+
+  def point(x, y)
+    GeoRuby::SimpleFeatures::Point.from_x_y x,y
+  end
+  def line(*xy)
+    GeoRuby::SimpleFeatures::LineString.from_coordinates [*xy]
+  end
+  def lines(*lines)
+    GeoRuby::SimpleFeatures::MultiLineString.from_line_strings lines
+  end
+
+  it "should create a valid ewkb" do
+    GeoRuby::SimpleFeatures::Geometry.from_ewkb(lines(line([0,0],[4,0]),line([0,2],[4,2])).as_ewkb)
+  end
+
+  describe "locate_point" do
+    
+    context "examples" do
+
+      it "should find 2,1 at 0.5 between 0,0 and 4,0" do
+        lines(line([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
+        lines(line([0,4],[0,1]), line([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
+        lines(line([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
+        lines(line([0,4],[0,1]), line([0,0],[4,0])).interpolate_point(1.5).should == point(2,0)
+      end
+      
+    end
+
+  end
+
+end
+
+describe GeoRuby::SimpleFeatures::LineString do
+
+  def point(x, y)
+    GeoRuby::SimpleFeatures::Point.from_x_y x,y
+  end
+  def line(*xy)
+    GeoRuby::SimpleFeatures::LineString.from_coordinates [*xy]
+  end
+
+  describe "locate_point" do
+    
+    context "examples" do
+
+      it "should find 2,1 at 0.5 between 0,0 and 4,0" do
+        line([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([0,0],[2,0],[4,0]).locate_point(point(2,1)).should == 0.5
+      end
+      
+    end
+
+  end
+
+
+end
+
+describe GeoRuby::SimpleFeatures::LineString::PointLocator do
+
+  def point(x, y)
+    GeoRuby::SimpleFeatures::Point.from_x_y x,y
+  end
+  alias_method :p, :point
+
+  def locator(target, departure, arrival)
+    GeoRuby::SimpleFeatures::LineString::PointLocator.new target, departure, arrival
+  end
+  
+  context "examples" do
+
+    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