nofxx-georuby 1.3.7

data/lib/geo_ruby/base/geometry_collection.rb

@@ -0,0 +1,136 @@
+require 'geo_ruby/base/geometry'
+
+module GeoRuby
+  module Base
+    #Represents a collection of arbitrary geometries
+    class GeometryCollection < Geometry
+      attr_reader :geometries
+
+      def initialize(srid = @@default_srid,with_z=false,with_m=false)
+        super(srid,with_z,with_m)
+        @geometries = []
+      end
+
+      #Delegate the unknown methods to the geometries array
+      def method_missing(method_name,*args,&b)
+        @geometries.send(method_name,*args,&b)
+      end
+
+      #Bounding box in 2D/3D. Returns an array of 2 points
+      def bounding_box
+        max_x, min_x, max_y, min_y = -Float::MAX, Float::MAX, -Float::MAX, Float::MAX, -Float::MAX, Float::MAX
+        if with_z
+          max_z, min_z = -Float::MAX, Float::MAX
+          each do |geometry|
+            bbox = geometry.bounding_box
+            sw = bbox[0]
+            ne = bbox[1]
+
+            max_y = ne.y if ne.y > max_y
+            min_y = sw.y if sw.y < min_y
+            max_x = ne.x if ne.x > max_x
+            min_x = sw.x if sw.x < min_x
+            max_z = ne.z if ne.z > max_z
+            min_z = sw.z if sw.z < min_z
+          end
+          [Point.from_x_y_z(min_x,min_y,min_z),Point.from_x_y_z(max_x,max_y,max_z)]
+        else
+          each do |geometry|
+            bbox = geometry.bounding_box
+            sw = bbox[0]
+            ne = bbox[1]
+
+            max_y = ne.y if ne.y > max_y
+            min_y = sw.y if sw.y < min_y
+            max_x = ne.x if ne.x > max_x
+            min_x = sw.x if sw.x < min_x
+          end
+          [Point.from_x_y(min_x,min_y),Point.from_x_y(max_x,max_y)]
+        end
+      end
+
+      def m_range
+        if with_m
+          max_m, min_m = -Float::MAX, Float::MAX
+          each do |lr|
+            lrmr = lr.m_range
+            max_m = lrmr[1] if lrmr[1] > max_m
+            min_m = lrmr[0] if lrmr[0] < min_m
+          end
+          [min_m,max_m]
+        else
+          [0,0]
+        end
+      end
+
+      #tests the equality of geometry collections
+      def ==(other_collection)
+        if(other_collection.class != self.class)
+          false
+        elsif length != other_collection.length
+          false
+        else
+          index=0
+          while index<length
+            return false if self[index] != other_collection[index]
+            index+=1
+          end
+          true
+        end
+      end
+
+      #Binary representation of the collection
+      def binary_representation(allow_z=true,allow_m=true) #:nodoc:
+        rep = [length].pack("V")
+        #output the list of geometries without outputting the SRID first and with the same setting regarding Z and M
+        each {|geometry| rep << geometry.as_ewkb(false,allow_z,allow_m) }
+        rep
+      end
+
+      #WKB geometry type of the collection
+      def binary_geometry_type #:nodoc:
+        7
+      end
+
+      #Text representation of a geometry collection
+      def text_representation(allow_z=true,allow_m=true) #:nodoc:
+        @geometries.collect{|geometry| geometry.as_ewkt(false,allow_z,allow_m)}.join(",")
+      end
+
+      #WKT geometry type
+      def text_geometry_type #:nodoc:
+        "GEOMETRYCOLLECTION"
+      end
+
+      #georss simple representation : outputs only the first geometry of the collection
+      def georss_simple_representation(options)#:nodoc:
+        self[0].georss_simple_representation(options)
+      end
+      #georss w3c representation : outputs the first point of the outer ring
+      def georss_w3cgeo_representation(options)#:nodoc:
+        self[0].georss_w3cgeo_representation(options)
+      end
+      #georss gml representation : outputs only the first geometry of the collection
+      def georss_gml_representation(options)#:nodoc:
+        self[0].georss_gml_representation(options)
+      end
+
+      #outputs the geometry in kml format
+      def kml_representation(options = {}) #:nodoc:
+        result = "<MultiGeometry#{options[:id_attr]}>\n"
+        options[:id_attr] = "" #the subgeometries do not have an ID
+        each do |geometry|
+          result += geometry.kml_representation(options)
+        end
+        result += "</MultiGeometry>\n"
+      end
+
+      #creates a new GeometryCollection from an array of geometries
+      def self.from_geometries(geometries,srid=@@default_srid,with_z=false,with_m=false)
+        geometry_collection = new(srid,with_z,with_m)
+        geometry_collection.concat(geometries)
+        geometry_collection
+      end
+    end
+  end
+end

data/lib/geo_ruby/base/geometry_factory.rb

@@ -0,0 +1,81 @@
+require 'geo_ruby/base/point'
+require 'geo_ruby/base/line_string'
+require 'geo_ruby/base/linear_ring'
+require 'geo_ruby/base/polygon'
+require 'geo_ruby/base/multi_point'
+require 'geo_ruby/base/multi_line_string'
+require 'geo_ruby/base/multi_polygon'
+require 'geo_ruby/base/geometry_collection'
+
+
+module GeoRuby
+  module Base
+    #Creates a new geometry according to constructions received from a parser, for example EWKBParser.
+    class GeometryFactory
+      #the built geometry
+      attr_reader :geometry
+
+      def initialize
+        @geometry = nil
+        @geometry_stack = []
+      end
+      #resets the factory
+      def reset
+        @geometry = nil
+        @geometry_stack = []
+      end
+      #add a 2D point to the current geometry
+      def add_point_x_y(x,y)
+        @geometry_stack.last.set_x_y(x,y)
+      end
+      #add 2D points to the current geometry
+      def add_points_x_y(xy)
+        xy.each_slice(2) {|slice| add_point_x_y(*slice)}
+      end
+      #add a 3D point to the current geometry
+      def add_point_x_y_z(x,y,z)
+        @geometry_stack.last.set_x_y_z(x,y,z)
+      end
+      #add 3D points to the current geometry
+      def add_points_x_y_z(xyz)
+        xyz.each_slice(3) {|slice| add_point_x_y_z(*slice)}
+      end
+      #add a 2D point with M to the current geometry
+      def add_point_x_y_m(x,y,m)
+        @geometry_stack.last.set_x_y(x,y)
+        @geometry_stack.last.m=m
+      end
+      #add 2D points with M to the current geometry
+      def add_points_x_y_m(xym)
+        xym.each_slice(3) {|slice| add_point_x_y_m(*slice)}
+      end
+      #add a 3D point with M to the current geometry
+      def add_point_x_y_z_m(x,y,z,m)
+        @geometry_stack.last.set_x_y_z(x,y,z)
+        @geometry_stack.last.m=m
+      end
+       #add 3D points with M to the current geometry
+      def add_points_x_y_z_m(xyzm)
+        xyzm.each_slice(4) {|slice| add_point_x_y_z_m(*slice)}
+      end
+      #begin a geometry of type +geometry_type+
+      def begin_geometry(geometry_type,srid=@@default_srid)
+        geometry= geometry_type::new(srid)
+        @geometry= geometry if @geometry.nil?
+        @geometry_stack << geometry
+      end
+      #terminates the current geometry
+      def end_geometry(with_z=false,with_m=false)
+        @geometry=@geometry_stack.pop
+        @geometry.with_z=with_z
+        @geometry.with_m=with_m
+        #add the newly defined geometry to its parent if there is one
+        @geometry_stack.last << geometry if !@geometry_stack.empty?
+      end
+      #abort a geometry
+      def abort_geometry
+        reset
+      end
+    end
+  end
+end

data/lib/geo_ruby/base/georss_parser.rb

@@ -0,0 +1,135 @@
+require 'geo_ruby/base/point'
+require 'geo_ruby/base/line_string'
+require 'geo_ruby/base/linear_ring'
+require 'geo_ruby/base/polygon'
+require 'geo_ruby/base/multi_point'
+require 'geo_ruby/base/multi_line_string'
+require 'geo_ruby/base/multi_polygon'
+require 'geo_ruby/base/geometry_collection'
+require 'geo_ruby/base/envelope'
+
+module GeoRuby
+  module Base
+
+    #Raised when an error in the GeoRSS string is detected
+    class GeorssFormatError < StandardError
+    end
+
+    #Contains tags possibly found on GeoRss Simple geometries
+    class GeorssTags < Struct.new(:featuretypetag,:relationshiptag,:elev,:floor,:radius)
+    end
+
+    #Parses GeoRSS strings
+    #You can also use directly the static method Geometry.from_georss
+    class GeorssParser
+      attr_reader :georss_tags, :geometry
+
+      #Parses the georss geometry  passed as argument and notifies the factory of events
+      #The parser assumes
+      def parse(georss,with_tags = false)
+        @geometry = nil
+        @georss_tags = GeorssTags.new
+        parse_geometry(georss,with_tags)
+      end
+
+      private
+      def parse_geometry(georss,with_tags)
+        georss.strip!
+        #check for W3CGeo first
+        if georss =~ /<[^:>]*:lat\s*>([^<]*)</
+          #if valid, it is W3CGeo
+          lat = $1.to_f
+          if georss =~ /<[^:>]*:long\s*>([^<]*)</
+            lon = $1.to_f
+            @geometry = Point.from_x_y(lon,lat)
+          else
+            raise GeorssFormatError.new("Bad W3CGeo GeoRSS format")
+          end
+        elsif georss =~ /^<\s*[^:>]*:where\s*>/
+          #GML format found
+          gml = $'.strip
+          if gml =~ /^<\s*[^:>]*:Point\s*>/
+            #gml point
+            if gml =~ /<\s*[^:>]*:pos\s*>([^<]*)/
+              point = $1.split(" ")
+              #lat comes first
+              @geometry = Point.from_x_y(point[1].to_f,point[0].to_f)
+            else
+              raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Point")
+            end
+          elsif gml =~ /^<\s*[^:>]*:LineString\s*>/
+            if gml =~ /<\s*[^:>]*:posList\s*>([^<]*)/
+              xy = $1.split(" ")
+              @geometry = LineString.new
+              0.upto(xy.size/2 - 1) { |index| @geometry << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+            else
+              raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed LineString")
+            end
+          elsif gml =~ /^<\s*[^:>]*:Polygon\s*>/
+            if gml =~ /<\s*[^:>]*:posList\s*>([^<]*)/
+              xy = $1.split(" ")
+              @geometry = Polygon.new
+              linear_ring = LinearRing.new
+              @geometry << linear_ring
+              xy = $1.split(" ")
+              0.upto(xy.size/2 - 1) { |index| linear_ring << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+            else
+              raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Polygon")
+            end
+          elsif gml =~ /^<\s*[^:>]*:Envelope\s*>/
+            if gml =~ /<\s*[^:>]*:lowerCorner\s*>([^<]*)</
+              lc = $1.split(" ").collect { |x| x.to_f}.reverse
+              if gml =~ /<\s*[^:>]*:upperCorner\s*>([^<]*)</
+                uc = $1.split(" ").collect { |x| x.to_f}.reverse
+                @geometry = Envelope.from_coordinates([lc,uc])
+              else
+                raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Envelope")
+              end
+            else
+              raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Envelope")
+            end
+          else
+            raise GeorssFormatError.new("Bad GML GeoRSS format: Unknown geometry type")
+          end
+        else
+          #must be simple format
+          if georss =~ /^<\s*[^>:]*:point([^>]*)>(.*)</m
+            tags = $1
+            point = $2.gsub(","," ").split(" ")
+            @geometry = Point.from_x_y(point[1].to_f,point[0].to_f)
+          elsif georss =~ /^<\s*[^>:]*:line([^>]*)>(.*)</m
+            tags = $1
+            @geometry = LineString.new
+            xy = $2.gsub(","," ").split(" ")
+            0.upto(xy.size/2 - 1) { |index| @geometry << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+          elsif georss =~ /^<\s*[^>:]*:polygon([^>]*)>(.*)</m
+            tags = $1
+            @geometry = Polygon.new
+            linear_ring = LinearRing.new
+            @geometry << linear_ring
+            xy = $2.gsub(","," ").split(" ")
+            0.upto(xy.size/2 - 1) { |index| linear_ring << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+          elsif georss =~ /^<\s*[^>:]*:box([^>]*)>(.*)</m
+            tags = $1
+            corners = []
+            xy = $2.gsub(","," ").split(" ")
+            0.upto(xy.size/2 - 1) {|index| corners << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+            @geometry = Envelope.from_points(corners)
+          else
+            raise GeorssFormatError.new("Bad Simple GeoRSS format: Unknown geometry type")
+          end
+
+          #geometry found: parse tags
+          return unless with_tags
+
+          @georss_tags.featuretypetag = $1 if tags =~ /featuretypetag=['"]([^"']*)['"]/
+          @georss_tags.relationshiptag = $1 if tags =~ /relationshiptag=['"]([^'"]*)['"]/
+          @georss_tags.elev = $1.to_f if tags =~ /elev=['"]([^'"]*)['"]/
+          @georss_tags.floor = $1.to_i if tags =~ /floor=['"]([^'"]*)['"]/
+          @georss_tags.radius = $1.to_f if tags =~ /radius=['"]([^'"]*)['"]/
+
+        end
+      end
+    end
+  end
+end

data/lib/geo_ruby/base/helper.rb

@@ -0,0 +1,18 @@
+module GeoRuby
+  module Base
+    #indicates the presence of Z coordinates in EWKB strings
+    Z_MASK=0x80000000
+    #indicates the presence of M coordinates in EWKB strings.
+    M_MASK=0x40000000
+    #indicate the presence of a SRID in EWKB strings.
+    SRID_MASK=0x20000000
+    #GeoRSS namespace
+    GEORSS_NS = "http://www.georss.org/georss"
+    #GML Namespace
+    GML_NS = "http://www.opengis.net/gml"
+    #W3CGeo Namespace
+    W3CGEO_NS = "http://www.w3.org/2003/01/geo/wgs84_pos#"
+    #KML Namespace
+    KML_NS = "http://earth.google.com/kml/2.1"
+  end
+end

data/lib/geo_ruby/base/line_string.rb

@@ -0,0 +1,184 @@
+require "geo_ruby/base/geometry"
+
+module GeoRuby
+  module Base
+    #Represents a line string as an array of points (see Point).
+    class LineString < Geometry
+      #the list of points forming the line string
+      attr_reader :points
+
+      def initialize(srid= @@default_srid,with_z=false,with_m=false)
+        super(srid,with_z,with_m)
+        @points=[]
+      end
+
+      #Delegate the unknown methods to the points array
+      def method_missing(method_name,*args,&b)
+        @points.send(method_name,*args,&b)
+      end
+
+      #tests if the line string is closed
+      def is_closed
+        #a bit naive...
+        @points.first == @points.last
+      end
+      alias :closed? :is_closed
+
+      #Bounding box in 2D/3D. Returns an array of 2 points
+      def bounding_box
+        max_x, min_x, max_y, min_y = -Float::MAX, Float::MAX, -Float::MAX, Float::MAX
+        if(with_z)
+          max_z, min_z = -Float::MAX,Float::MAX
+          each do |point|
+            max_y = point.y if point.y > max_y
+            min_y = point.y if point.y < min_y
+            max_x = point.x if point.x > max_x
+            min_x = point.x if point.x < min_x
+            max_z = point.z if point.z > max_z
+            min_z = point.z if point.z < min_z
+          end
+          [Point.from_x_y_z(min_x,min_y,min_z),Point.from_x_y_z(max_x,max_y,max_z)]
+        else
+          each do |point|
+            max_y = point.y if point.y > max_y
+            min_y = point.y if point.y < min_y
+            max_x = point.x if point.x > max_x
+            min_x = point.x if point.x < min_x
+          end
+          [Point.from_x_y(min_x,min_y),Point.from_x_y(max_x,max_y)]
+        end
+      end
+
+      def m_range
+        if with_m
+          max_m, min_m = -Float::MAX, Float::MAX
+          each do |point|
+            max_m = point.m if point.m > max_m
+            min_m = point.m if point.m < min_m
+          end
+          [min_m,max_m]
+        else
+          [0,0]
+        end
+      end
+
+     #call to native Geo intersect, return true or false
+      def intersects?(other_line_string)
+
+      end
+
+      def spherical_distance
+        total = 0
+        @points.each_with_index do |p,i|
+          total += p.spherical_distance(@points[i+1]) if @points[i+1]
+        end
+        total
+      end
+
+      def euclidian_distance
+        total = 0
+        @points.each_with_index do |p,i|
+          total += p.euclidian_distance(@points[i+1]) if @points[i+1]
+        end
+        total
+      end
+
+      #Tests the equality of line strings
+      def ==(other_line_string)
+        if(other_line_string.class != self.class or
+             other_line_string.length != self.length)
+          false
+        else
+          index=0
+          while index<length
+            return false if self[index] != other_line_string[index]
+            index+=1
+          end
+          true
+        end
+      end
+
+      #Binary representation of a line string
+      def binary_representation(allow_z=true,allow_m=true) #:nodoc:
+        rep = [length].pack("V")
+        each {|point| rep << point.binary_representation(allow_z,allow_m) }
+        rep
+      end
+
+      #WKB geometry type
+      def binary_geometry_type #:nodoc:
+        2
+      end
+
+      #Text representation of a line string
+      def text_representation(allow_z=true,allow_m=true) #:nodoc:
+        @points.collect{|point| point.text_representation(allow_z,allow_m) }.join(",")
+      end
+      #WKT geometry type
+      def text_geometry_type #:nodoc:
+        "LINESTRING"
+      end
+
+      #georss simple representation
+      def georss_simple_representation(options) #:nodoc:
+        georss_ns = options[:georss_ns] || "georss"
+        geom_attr = options[:geom_attr]
+        "<#{georss_ns}:line#{geom_attr}>" + georss_poslist + "</#{georss_ns}:line>\n"
+      end
+      #georss w3c representation : outputs the first point of the line
+      def georss_w3cgeo_representation(options) #:nodoc:
+        w3cgeo_ns = options[:w3cgeo_ns] || "geo"
+        "<#{w3cgeo_ns}:lat>#{self[0].y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{self[0].x}</#{w3cgeo_ns}:long>\n"
+      end
+      #georss gml representation
+      def georss_gml_representation(options) #:nodoc:
+        georss_ns = options[:georss_ns] || "georss"
+        gml_ns = options[:gml_ns] || "gml"
+
+        result = "<#{georss_ns}:where>\n<#{gml_ns}:LineString>\n<#{gml_ns}:posList>\n"
+        result += georss_poslist
+        result += "\n</#{gml_ns}:posList>\n</#{gml_ns}:LineString>\n</#{georss_ns}:where>\n"
+      end
+
+      def georss_poslist #:nodoc:
+        map {|point| "#{point.y} #{point.x}"}.join(" ")
+      end
+
+      #outputs the geometry in kml format : options are <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
+      #<tt>:altitude_mode</tt>. If the altitude_mode option is not present, the Z (if present) will not be output (since
+      #it won't be used by GE anyway: clampToGround is the default)
+      def kml_representation(options = {}) #:nodoc:
+        result = "<LineString#{options[:id_attr]}>\n"
+        result += options[:geom_data] if options[:geom_data]
+        result += "<coordinates>"
+        result += kml_poslist(options)
+        result += "</coordinates>\n"
+        result += "</LineString>\n"
+      end
+
+      def kml_poslist(options) #:nodoc:
+        pos_list = if options[:allow_z]
+           map {|point| "#{point.x},#{point.y},#{options[:fixed_z] || point.z || 0}" }
+        else
+          map {|point| "#{point.x},#{point.y}" }
+        end
+        pos_list.reverse! if(options[:reverse])
+        pos_list.join(" ")
+      end
+
+      #Creates a new line string. Accept an array of points as argument
+      def self.from_points(points,srid=@@default_srid,with_z=false,with_m=false)
+        line_string = new(srid,with_z,with_m)
+        line_string.concat(points)
+        line_string
+      end
+
+      #Creates a new line string. Accept a sequence of points as argument : ((x,y)...(x,y))
+      def self.from_coordinates(points,srid=@@default_srid,with_z=false,with_m=false)
+        line_string = new(srid,with_z,with_m)
+        line_string.concat( points.map {|p| Point.from_coordinates(p,srid,with_z,with_m) } )
+        line_string
+      end
+    end
+  end
+end