georuby-ext 0.0.1 → 0.0.2

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

@@ -3,7 +3,21 @@ class GeoRuby::SimpleFeatures::MultiPolygon
     self.class.from_polygons(self.polygons.collect(&:to_wgs84), 4326)
   end
 
+  def to_google
+    self.class.from_polygons(self.polygons.collect(&:to_google), 900913)
+  end
+
   def polygons
-    self.geometries.flatten
+    self.geometries
+  end
+
+  def difference(georuby_multi_polygon)
+    multi_polygon_difference = georuby_multi_polygon.present? ? self.to_rgeo.difference(georuby_multi_polygon.to_rgeo) : self.to_rgeo
+    multi_polygon_difference.to_georuby
   end
+
+  def to_rgeo
+    rgeo_factory.multi_polygon(polygons.collect(&:to_rgeo))
+  end
+
 end

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

@@ -1,20 +1,115 @@
 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
+  # Earth radius in kms
+  #
+  # GeoRuby Point#spherical_distance uses 6370997.0 m
+  # Geokit::LatLng uses 6376.77271 km
+  # ...
+  @@earth_radius = 6370997.0
+  def self.earth_radius
+    @@earth_radius 
+  end
+  def earth_radius
+    self.class.earth_radius
+  end
+
+  # Length of a latitude degree in meters
+  @@latitude_degree_distance = @@earth_radius * 2 * Math::PI / 360
+  def self.latitude_degree_distance
+    @@latitude_degree_distance 
+  end
+  def latitude_degree_distance
+    self.class.latitude_degree_distance
+  end
+
+  def change(options)
+    # TODO support z
+    self.class.from_x_y(options[:x] || x, 
+                        options[:y] || y, 
+                        options[:srid] || srid)
+    # or instead of || requires parenthesis
+  end
+
+  def ==(other)
+    other and 
+      other.respond_to?(:lat) and other.respond_to?(:lng) and
+      (other.respond_to?(:srid) and srid == other.srid) ? (lat == other.lat and lng == other.lng) : (spherical_distance(other) < 10e-3)
+  end
+
+  def spherical_distance_with_srid_support(other)
+    to_wgs84.spherical_distance_without_srid_support(other.to_wgs84)
+  end
+  alias_method_chain :spherical_distance, :srid_support
+
+  def endpoint(heading, distance, options={})
+    Endpointer.new(self, heading, distance, options).arrival
+  end
+
+  class Endpointer
+
+    attr_accessor :origin, :heading, :distance, :unit
+
+    def initialize(origin, heading, distance, options = {})
+      @origin, @heading, @distance = origin, heading.deg2rad, distance
+    end
+
+    def radius
+      GeoRuby::SimpleFeatures::Point.earth_radius
+    end
+
+    def distance_per_radius
+      @distance_per_radius ||= distance / radius
+    end
+
+    def cos_distance_per_radius
+      @cos_distance_per_radius ||= Math.cos(distance_per_radius)
+    end
+
+    def sin_distance_per_radius
+      @sin_distance_per_radius ||= Math.sin(distance_per_radius)
+    end
+
+    def latitude
+      @latitude ||= origin.lat.deg2rad
+    end
+
+    def cos_latitude
+      @cos_latitude ||= Math.cos(latitude)
+    end
+
+    def sin_latitude
+      @sin_latitude ||= Math.sin(latitude)
+    end
+
+    def longitude
+      @longitude ||= origin.lng.deg2rad
+    end
+
+    def arrival_latitude
+      Math.asin(sin_latitude * cos_distance_per_radius +
+                cos_latitude * sin_distance_per_radius * Math.cos(heading))
+    end
+
+    def arrival_longitude
+      longitude + Math.atan2(Math.sin(heading) * sin_distance_per_radius * cos_latitude,
+                             cos_distance_per_radius - sin_latitude * Math.sin(arrival_latitude))
+    end
+
+    def arrival
+      origin.change :x => arrival_longitude.rad2deg, :y => arrival_latitude.rad2deg    end
+
   end
 
   def eql?(other)
-     [x,y,srid] == [other.x, other.y, other.srid]
+     [x,y,z,srid] == [other.x, other.y, other.z, other.srid]
+  end
+
+  def close_to?(other)
+    spherical_distance(other) < 10e-3
   end
 
   def hash
-    [x,y,srid].hash
+    [x,y,z,srid].hash
   end
 
   def to_s
@@ -28,40 +123,62 @@ class GeoRuby::SimpleFeatures::Point
     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
+      from_x_y points.sum(&:x) / 2, points.sum(&:y) / 2, srid!(points)
     else
-      points = [points.last, *points]
-      GeoRuby::SimpleFeatures::Polygon.from_points([points]).centroid.tap do |centroid|
-        centroid.srid = points.first.srid if centroid
-      end
+      points = [points.last, *points] # polygon must be closed for rgeo
+      GeoRuby::SimpleFeatures::Polygon.from_points([points], srid!(points)).centroid
     end
   end
 
+  def self.from_lat_lng(object, srid = 4326)
+    ActiveSupport::Deprecation.warn "Don't use Geokit::LatLng to represent no wgs84 point" unless srid == 4326
+    
+    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 to_lat_lng
     Geokit::LatLng.new y, x
   end
 
-  def to_s
-    to_lat_lng.to_s
+  def projection
+    Proj4::Projection.for_srid srid
   end
+  
+  def project_to(target_srid)
+    return self if srid == target_srid
 
-  def to_wgs84
-    self.class.from_lat_lng to_lat_lng.google_to_wgs84, 4326
+    self.class.from_pro4j projection.transform(Proj4::Projection.for_srid(target_srid), to_proj4.x, to_proj4.y), target_srid
   end
 
-  def to_google
-    self.class.from_lat_lng to_lat_lng.wgs84_to_google, 900913
+  def to_proj4(ratio = nil)
+    # Proj4 use radian instead of degres
+    ratio ||= (wgs84? ? Proj4::DEG_TO_RAD : 1.0)
+    Proj4::Point.new x * ratio, y * ratio
   end
 
-  def to_rgeo
-    factory = RGeo::Geos::Factory.create
-    factory.point(self.x, self.y)
-  end  
+  def self.from_pro4j(point, srid, ratio = nil)
+    ratio ||= (srid == 4326 ? Proj4::RAD_TO_DEG : 1.0)
+    from_x_y point.x * ratio, point.y * ratio, srid
+  end
 
+  def to_rgeo
+    rgeo_factory.point x, y
+  end
+  
   def to_openlayers
     OpenLayers::LonLat.new x, y
   end
 
+  # Fixes original bounding_box which creates points without srid
+  def bounding_box
+    Array.new(with_z ? 3 : 2) { dup }
+  end
+
   def self.bounds(points)
     return nil if points.blank?
 
@@ -70,4 +187,11 @@ class GeoRuby::SimpleFeatures::Point
     end
   end
 
+  def metric_delta(other)
+    longitude_degree_distance =
+      (latitude_degree_distance * Math.cos(lat.deg2rad)).abs
+    [ latitude_degree_distance * (other.lat - lat),
+      longitude_degree_distance * (other.lng - lng) ]
+  end
+
 end

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

@@ -1,48 +1,45 @@
 class GeoRuby::SimpleFeatures::Polygon
 
   def self.circle(center, radius, sides_number = 24)
-    coordinates = (0...sides_number).collect do |side|
+    points = sides_number.times.map 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.map! do |angle|
+      center.endpoint angle, radius
     end
-    # Close the circle
-    coordinates << coordinates.first
-    from_coordinates [coordinates]
+
+    from_points [points], center.srid
   end
 
   def side_count
-    # Reduce by one because polygon is closed
-    (rings.collect(&:size).sum) - 1
+    rings.sum(&:side_count)
   end
 
   def points
     rings.collect(&:points).flatten
   end
 
+  def perimeter
+    rings.sum(&:spherical_distance)
+  end
+  
   def centroid
-    if rgeo_polygon = to_rgeo
-      rgeo_polygon.centroid.to_georuby
-    end
+    to_rgeo.centroid.to_georuby
   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
+    return nil if georuby_polygons.empty?             
+
+    rgeo_polygons = georuby_polygons.collect(&:to_rgeo)      
+    rgeo_polygon_union = rgeo_polygons.first    
      
-    georuby_polygons.each do |polygon|
-       polygon_union = polygon_union.union(polygon.to_rgeo)
+    rgeo_polygons[1..(rgeo_polygons.size - 1)].each do |rgeo_polygon|
+       rgeo_polygon_union = rgeo_polygon_union.union(rgeo_polygon)
     end
     
-    polygon_union.to_georuby
-   end
+    rgeo_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
@@ -55,14 +52,28 @@ class GeoRuby::SimpleFeatures::Polygon
     polygon_intersection.to_georuby
   end
 
-  def to_wgs84
-    self.class.from_points([self.points.collect(&:to_wgs84)], 4326)
+  def difference(georuby_polygon)
+    polygon_difference = self.to_rgeo.difference(georuby_polygon.to_rgeo)
+    polygon_difference.to_georuby
   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)
+    outer_ring = rings.first.to_rgeo
+    rings.size > 1 ? inner_rings = rings[1..(rings.size - 1)].collect(&:to_rgeo) : inner_rings = nil
+    rgeo_factory.polygon(outer_ring, inner_rings)
   end  
 
+  def change(options)
+    self.class.from_linear_rings(options[:rings] || rings, 
+                                 options[:srid] || srid,
+                                 options[:with_z] || with_z, 
+                                 options[:with_m] || with_m)
+    # or instead of || requires parenthesis
+  end
+
+  def project_to(target_srid)
+    return self if srid == target_srid
+    change :rings => rings.map { |ring| ring.project_to(target_srid) }, :srid => target_srid
+  end
+
 end

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

@@ -0,0 +1,133 @@
+module GeoRuby
+  class Rtree
+    attr_accessor :root
+
+    def initialize(root)
+      @root = root
+    end
+
+    def self.bulk_loading(elements, options = {})
+      options = { :node_size => 2 }.merge(options)
+      STRBuilder.new(elements, options[:node_size]).to_rtree
+    end
+
+    delegate :containing, :to => :root
+
+    class STRBuilder
+      attr_accessor :elements, :node_size
+      
+      def initialize(elements, node_size = 2)
+        @elements = elements
+        @node_size = node_size
+      end
+
+      def to_rtree
+        Rtree.new root_node
+      end
+
+      def leaf_nodes
+        slices.collect(&:nodes).flatten
+      end
+
+      def root_node
+        nodes = leaf_nodes
+
+        while nodes.many?
+          nodes = [].tap do |parent_nodes|
+            nodes.each_slice(node_size) do |children|
+              parent_nodes << Node.new(children)
+            end
+          end
+        end
+
+        nodes.first
+      end
+
+      def slices
+        [].tap do |slices|
+          sort_x.each_slice(slice_size) do |slice_elements|
+            slices << Slice.new(slice_elements, node_size)
+          end
+        end
+      end
+
+      def sort_x
+        elements.sort_by do |element|
+          element.bounds.center.x
+        end
+      end
+
+      def leaf_nodes_count
+        (elements.count / node_size.to_f).ceil
+      end
+
+      def slice_size
+        Math.sqrt(leaf_nodes_count).ceil
+      end
+      
+      class Slice
+
+        attr_accessor :elements, :node_size
+
+        def initialize(elements, node_size = 2)
+          @elements, @node_size = elements, node_size
+        end
+
+        delegate :size, :to => :elements
+
+        def sort_y
+          elements.sort_by do |element|
+            element.bounds.center.y
+          end
+        end
+
+        def nodes
+          [].tap do |nodes|
+            sort_y.each_slice(node_size) do |node_elements|
+              nodes << Node.new(node_elements)
+            end
+          end
+        end
+
+        def ==(other)
+          other.respond_to?(:elements) and elements == other.elements
+        end
+
+      end
+
+    end
+    
+    class Node
+      attr_accessor :children
+
+      def initialize(*children)
+        @children = children.flatten
+      end
+
+      def bounds
+        @bounds ||= GeoRuby::SimpleFeatures::Envelope.bounds(children)
+      end
+      alias_method :envelope, :bounds
+
+      delegate :size, :to => :children
+
+      def ==(other)
+        other.respond_to?(:children) and children == other.children
+      end
+
+      def containing(bounds)
+        children.select do |child|
+          child.bounds.overlaps?(bounds) 
+        end.collect do |child|
+          if child.respond_to?(:containing)
+            child.containing(bounds)
+          else
+            child
+          end
+        end.flatten
+      end
+
+    end
+
+  end
+end