georuby-ext 0.0.1 → 0.0.2

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

@@ -0,0 +1,17 @@
+class GeoRuby::SimpleFeatures::Srid
+  attr_accessor :srid 
+
+  def initialize(srid)   
+    @srid ||= srid
+  end 
+
+  @@instances = {}
+  def self.new(srid)
+    @@instances[srid] ||= super(srid)
+  end
+ 
+  def rgeo_factory
+    @rgeo_factory ||= RGeo::Geos.factory(:srid => srid, :wkt_parser => {:support_ewkt => true})
+  end
+
+end

data/lib/georuby-ext/proj4.rb

@@ -1,11 +1,24 @@
 class Proj4::Projection
 
+  @@wgs84 = nil
   def self.wgs84
-    Proj4::Projection.new '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
+    @@wgs84 ||= Proj4::Projection.new '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
   end
 
+  @@goggle = nil
   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'
+    @@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
+
+  def self.for_srid(srid)
+    case srid
+    when 4326
+      wgs84
+    when 900913
+      google
+    else
+      raise "Unsupported srid: #{srid}"
+    end
   end
 
 end

data/lib/georuby-ext/rgeo/cartesian/feature_methods.rb

@@ -0,0 +1,58 @@
+module RGeo
+  module Cartesian
+    module GeometryMethods
+      
+      def to_georuby
+        if self.class == PointImpl
+          GeoRuby::SimpleFeatures::Point.from_x_y x, y, srid
+        elsif self.class == LineStringImpl
+          GeoRuby::SimpleFeatures::LineString.from_points points.collect(&:to_georuby), srid     
+        elsif self.class == LinearRingImpl
+          GeoRuby::SimpleFeatures::LinearRing.from_points points.collect(&:to_georuby), srid
+        elsif self.class == PolygonImpl
+          GeoRuby::SimpleFeatures::Polygon.from_linear_rings linear_rings.collect(&:to_georuby), srid
+        else
+          GeoRuby::SimpleFeatures::Geometry.from_geometry collect(&:to_georuby), srid
+        end      
+        
+      end    
+      
+    end 
+    
+    module GeometryCollectionMethods
+      def to_georuby
+        if self.class == MultiPolygonImpl
+          GeoRuby::SimpleFeatures::MultiPolygon.from_polygons collect(&:to_georuby), srid
+        else
+          GeoRuby::SimpleFeatures::GeometryCollection.from_geometries collect(&:to_georuby), srid
+        end
+      end
+    end 
+
+    module LineStringMethods      
+      def to_linear_ring
+        linear_ring_points = points.first == points.last ? points : points.push(points.first)
+        factory.linear_ring linear_ring_points
+      end
+    end
+
+    module LinearRingMethods      
+      def to_linear_ring
+        linear_ring_points = points.first == points.last ? points : points.push(points.first)
+        factory.linear_ring linear_ring_points
+      end
+    end
+
+    module PolygonMethods      
+      def rings
+        [exterior_ring] + interior_rings
+      end
+      
+      def linear_rings
+        rings.collect(&:to_linear_ring)
+      end
+    end
+
+
+  end
+end

data/lib/georuby-ext/rgeo/feature/geometry.rb

@@ -0,0 +1,11 @@
+module RGeo
+  module Feature
+    module Geometry      
+      
+      def to_georuby
+        raise Error::UnsupportedOperation, "Method Geometry#to_georuby not defined."
+      end      
+      
+    end
+  end
+end

data/lib/georuby-ext/rgeo/feature/geometry_collection.rb

@@ -0,0 +1,11 @@
+module RGeo
+  module Feature
+    module GeometryCollection      
+      
+      def to_georuby
+        raise Error::UnsupportedOperation, "Method GeometryCollection#to_georuby not defined."
+      end      
+      
+    end
+  end
+end

data/lib/georuby-ext/rgeo/feature/rgeo.rb

@@ -0,0 +1,157 @@
+# module RGeo
+
+#   module Feature
+
+#     module Point      
+#       def to_georuby
+#         GeoRuby::SimpleFeatures::Point.from_x_y x, y, srid
+#       end      
+#     end
+
+#     module LineString
+#       def to_georuby
+#         GeoRuby::SimpleFeatures::LineString.from_points points.collect(&:to_georuby), srid
+#       end  
+      
+#       def to_linear_ring
+#         linear_ring_points = points.first == points.last ? points : points.push(points.first)
+#         factory.linear_ring linear_ring_points
+#       end
+#     end
+
+#     module LinearRing
+#       def to_georuby
+#         GeoRuby::SimpleFeatures::LinearRing.from_points points.collect(&:to_georuby), srid
+#       end
+      
+#       def to_linear_ring
+#         linear_ring_points = points.first == points.last ? points : points.push(points.first)
+#         factory.linear_ring linear_ring_points
+#       end
+#     end
+
+#     module Polygon
+#       def rings
+#         [exterior_ring] + interior_rings
+#       end
+      
+#       def linear_rings
+#         rings.collect(&:to_linear_ring)
+#       end
+      
+#       def to_georuby
+#         GeoRuby::SimpleFeatures::Polygon.from_linear_rings linear_rings.collect(&:to_georuby), srid
+#       end
+#     end
+
+#     module MultiPolygon
+#       def to_georuby
+#         GeoRuby::SimpleFeatures::MultiPolygon.from_polygons collect(&:to_georuby), srid
+#       end
+#     end
+
+#     module GeometryCollection
+#       def to_georuby
+#         GeoRuby::SimpleFeatures::GeometryCollection.from_geometries collect(&:to_georuby), srid
+#       end
+#     end
+
+#   end
+# end
+
+# ###############################
+# #           FFI               #
+# ###############################
+# class RGeo::Geos::FFIPointImpl
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::Point.from_x_y x, y, srid
+#   end
+# end
+
+# class RGeo::Geos::FFILineStringImpl
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::LineString.from_points points.collect(&:to_georuby), srid
+#   end  
+
+#   def to_linear_ring
+#     linear_ring_points = points.first == points.last ? points : points.push(points.first)
+#     factory.linear_ring linear_ring_points
+#   end
+# end
+
+# class RGeo::Geos::FFILinearRingImpl
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::LinearRing.from_points points.collect(&:to_georuby), srid
+#   end
+
+#   def to_linear_ring
+#     linear_ring_points = points.first == points.last ? points : points.push(points.first)
+#     factory.linear_ring linear_ring_points
+#   end
+# end
+
+# class RGeo::Geos::FFIPolygonImpl
+#   def rings
+#     [exterior_ring] + interior_rings
+#   end
+
+#   def linear_rings
+#     rings.collect(&:to_linear_ring)
+#   end
+
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::Polygon.from_linear_rings linear_rings.collect(&:to_georuby), srid
+#   end
+# end
+
+# class RGeo::Geos::FFIMultiPolygonImpl
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::MultiPolygon.from_polygons collect(&:to_georuby), srid
+#   end
+# end
+
+# class RGeo::Geos::FFIGeometryCollectionImpl
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::GeometryCollection.from_geometries collect(&:to_georuby), srid
+#   end
+# end
+
+
+# ###############################
+# #           CAPI              #
+# ###############################
+# class RGeo::Geos::CAPIPointImpl
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::Point.from_x_y x, y, srid
+#   end
+# end
+
+# class RGeo::Geos::CAPILineStringImpl
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::LineString.from_points points.collect(&:to_georuby), srid
+#   end
+# end
+
+# class RGeo::Geos::CAPILinearRingImpl
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::LinearRing.from_points points.collect(&:to_georuby), srid
+#   end
+# end
+
+# class RGeo::Geos::CAPIPolygonImpl
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::Polygon.from_linear_rings [exterior_ring.to_georuby] + interior_rings.map(&:to_georuby), srid
+#   end
+# end
+
+# class RGeo::Geos::CAPIMultiPolygonImpl
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::MultiPolygon.from_polygons collect(&:to_georuby), srid
+#   end
+# end
+
+# class RGeo::Geos::CAPIGeometryCollectionImpl
+#   def to_georuby
+#     GeoRuby::SimpleFeatures::GeometryCollection.from_geometries collect(&:to_georuby), srid
+#   end
+# end

data/lib/georuby-ext/rgeo/geos/ffi_feature_methods.rb

@@ -0,0 +1,265 @@
+module RGeo
+  module Geos
+    module FFIGeometryMethods
+      
+      def to_georuby
+        if self.class == FFIPointImpl
+          GeoRuby::SimpleFeatures::Point.from_x_y x, y, srid
+        elsif self.class == FFILineStringImpl
+          GeoRuby::SimpleFeatures::LineString.from_points points.collect(&:to_georuby), srid     
+        elsif self.class == FFILinearRingImpl
+          GeoRuby::SimpleFeatures::LinearRing.from_points points.collect(&:to_georuby), srid
+        elsif self.class == FFIPolygonImpl
+          GeoRuby::SimpleFeatures::Polygon.from_linear_rings linear_rings.collect(&:to_georuby), srid
+        else
+          GeoRuby::SimpleFeatures::Geometry.from_geometry collect(&:to_georuby), srid
+        end      
+        
+      end
+
+      def to_geometry
+        self
+      end
+      
+    end 
+    
+    module FFIGeometryCollectionMethods
+      alias_method :geometries, :each
+
+      def to_georuby
+        if self.class == FFIMultiPolygonImpl
+          GeoRuby::SimpleFeatures::MultiPolygon.from_polygons collect(&:to_georuby), srid
+        else
+          GeoRuby::SimpleFeatures::GeometryCollection.from_geometries collect(&:to_georuby), srid
+        end
+      end
+
+      def to_geometry
+        self
+      end
+    end 
+
+    module FFILineStringMethods      
+
+      def to_linear_ring
+        linear_ring_points = points.first == points.last ? points : points.push(points.first)
+        factory.linear_ring linear_ring_points
+      end
+
+      def locate_point(target)
+        distance_on_line(target) / length
+      end
+
+      def distance_on_line(target)
+        nearest_locator = nearest_locator(target)
+        nearest_locator.distance_on_segment + nearest_locator.segment.line_distance_at_departure
+      end
+
+      def distance_from_line(target)
+        nearest_locator(target).distance_from_segment
+      end
+
+      def nearest_locator(target)
+        locators(target).min_by(&:distance_from_segment)
+      end
+
+      def locators(point)
+        segments.collect { |segment| segment.locator(point) }
+      end
+
+      def segments_without_cache
+        previous_point = nil
+        distance_from_departure = 0
+
+        
+        points.inject([]) do |segments, point|
+          Segment.new(previous_point, point).tap do |segment|
+            segment.line = self
+            segment.line_distance_at_departure = distance_from_departure
+
+            distance_from_departure += segment.distance
+            
+            segments << segment
+          end if previous_point
+          
+          previous_point = point
+          segments
+        end
+      end
+
+      def segments_with_cache
+        @segments ||= segments_without_cache
+      end
+      alias_method :segments, :segments_with_cache
+
+      def interpolate_point(location)
+        return points.last if location >= 1
+        return points.first if location <= 0
+
+        distance_on_line = location * spherical_distance
+
+        segment = segments.find do |segment|
+          segment.line_distance_at_arrival > distance_on_line
+        end
+
+        location_on_segment =
+          (distance_on_line - segment.line_distance_at_departure) / segment.distance
+
+        segment.interpolate_point location_on_segment
+      end
+
+      class Segment
+
+        attr_reader :departure, :arrival
+        
+        def initialize(departure, arrival)
+          @departure, @arrival = departure, arrival
+        end
+
+        attr_accessor :line, :line_distance_at_departure
+
+        def line_distance_at_arrival
+          line_distance_at_departure + distance
+        end
+
+        def locator(target)
+          PointLocator.new target, self
+        end
+
+        def location_in_line
+          if line and line_distance_at_departure
+            line_distance_at_departure / line.length
+          end
+        end
+
+        def square_of_distance
+          distance**2
+        end
+
+        def distance
+          @distance ||= departure.distance(arrival)
+        end
+
+        def to_s
+          "#{departure.x},#{departure.y}..#{arrival.x},#{arrival.y}"
+        end
+
+        def interpolate_point(location)
+          dx, dy = (arrival.x - departure.x) * location, (arrival.y - departure.y) * location
+          RGeo::Geos::FFIPoint.from_x_y departure.x + dx, departure.y + dy, line.srid
+        end
+
+      end
+
+      class PointLocator
+        extend ActiveSupport::Memoizable
+        include Math
+
+        attr_reader :target, :segment, :factory
+        delegate :departure, :arrival, :to => :segment
+        
+        def initialize(target, segment_or_departure, arrival = nil)
+          @segment = 
+            if arrival
+              Segment.new(segment_or_departure, arrival)
+            else
+              segment_or_departure
+            end
+          @target = target
+          @factory = departure.factory
+          raise "Target is not defined" unless target
+        end
+
+        def distance_on_segment          
+          Math.sqrt( target_distance_from_departure**2 - target_distance_from_segment**2 )
+        end
+
+        def distance_from_segment
+          return 0 if [segment.departure, segment.arrival].include?(target)          
+          target_distance_from_segment
+        end
+
+        def target_distance_from_departure
+          departure.distance target
+        end
+
+        def target_distance_from_segment
+          target.distance(factory.line_string([segment.departure, segment.arrival]))
+        end
+
+      end
+
+    end
+
+    module FFIMultiLineStringMethods    
+
+      def locate_point(target)
+        nearest_locator = nearest_locator(target)
+        nearest_locator.location + nearest_locator.index
+      end
+
+      def interpolate_point(location)
+        line_index, line_location = location.to_i, location % 1
+        if line = geometries[line_index]
+          line.interpolate_point(line_location)
+        end
+      end
+
+      def nearest_locator(target)
+        locators(target).min_by(&:distance_from_line)
+      end
+
+      def locators(point)
+        [].tap do |locators|
+          geometries.each_with_index do |line, index| 
+            locators << PointLocator.new(point, line, index) 
+          end
+        end
+      end
+
+      class PointLocator
+
+        attr_reader :target, :line, :index
+
+        def initialize(target, line, index)
+          @target = target
+          @line = line
+          @index = index
+        end
+
+        def location
+          line.locate_point(target)
+        end
+
+        def distance_on_line
+          line.distance_on_line(target)
+        end
+
+        def distance_from_line
+          line.distance_from_line(target)
+        end
+
+      end
+
+    end
+
+    module FFILinearRingMethods      
+      def to_linear_ring
+        linear_ring_points = points.first == points.last ? points : points.push(points.first)
+        factory.linear_ring linear_ring_points
+      end
+    end
+
+    module FFIPolygonMethods      
+      def rings
+        [exterior_ring] + interior_rings
+      end
+      
+      def linear_rings
+        rings.collect(&:to_linear_ring)
+      end
+    end
+
+
+  end
+end