georuby_remake 1.0.0

data/lib/geo_ruby/simple_features/geometry.rb

@@ -0,0 +1,230 @@
+module GeoRuby#:nodoc:
+  module SimpleFeatures
+    #arbitrary default SRID
+    DEFAULT_SRID = 4326 unless defined? DEFAULT_SRID
+
+    #Root of all geometric data classes.
+    #Objects of class Geometry should not be instantiated.
+    class Geometry
+      #SRID of the geometry
+      attr_reader :srid #writer defined below
+      #Flag indicating if the z ordinate of the geometry is meaningful
+      attr_accessor :with_z
+      alias :with_z? :with_z
+      #Flag indicating if the m ordinate of the geometry is meaningful
+      attr_accessor :with_m
+      alias :with_m? :with_m
+
+      def initialize(srid=DEFAULT_SRID,with_z=false,with_m=false)
+        @srid=srid
+        @with_z=with_z
+        @with_m=with_m
+      end
+
+      def srid=(new_srid)
+        @srid = new_srid
+        unless self.is_a?(Point)
+          self.each do |geom|
+            geom.srid=new_srid
+          end
+        end
+      end
+
+      #to be implemented in subclasses
+      def bounding_box
+      end
+
+      #to be implemented in subclasses
+      def m_range
+      end
+
+      #Returns an Envelope object for the geometry
+      def envelope
+        Envelope.from_points(bounding_box,srid,with_z)
+      end
+
+      #Outputs the geometry as an EWKB string.
+      #The +allow_srid+, +allow_z+ and +allow_m+ arguments allow the output to include srid, z and m respectively if they are present in the geometry. If these arguments are set to false, srid, z and m are not included, even if they are present in the geometry. By default, the output string contains all the information in the object.
+      def as_ewkb(allow_srid=true,allow_z=true,allow_m=true)
+        ewkb="";
+
+        ewkb << 1.chr #little_endian by default
+
+        type= binary_geometry_type
+        if @with_z and allow_z
+          type = type | Z_MASK
+        end
+        if @with_m and allow_m
+          type = type | M_MASK
+        end
+        if allow_srid
+          type = type | SRID_MASK
+          ewkb << [type,@srid].pack("VV")
+        else
+          ewkb << [type].pack("V")
+        end
+
+        ewkb << binary_representation(allow_z,allow_m)
+      end
+
+      #Outputs the geometry as a strict WKB string.
+      def as_wkb
+        as_ewkb(false,false,false)
+      end
+
+      #Outputs the geometry as a HexEWKB string. It is almost the same as a WKB string, except that each byte of a WKB string is replaced by its hexadecimal 2-character representation in a HexEWKB string.
+      def as_hex_ewkb(allow_srid=true,allow_z=true,allow_m=true)
+        as_ewkb(allow_srid, allow_z, allow_m).unpack('H*').join('').upcase
+      end
+
+      #Outputs the geometry as a strict HexWKB string
+      def as_hex_wkb
+        as_hex_ewkb(false,false,false)
+      end
+
+      #Outputs the geometry as an EWKT string.
+      def as_ewkt(allow_srid=true,allow_z=true,allow_m=true)
+        if allow_srid
+          ewkt="SRID=#{@srid};"
+        else
+          ewkt=""
+        end
+        ewkt << text_geometry_type
+        ewkt << "M" if @with_m and allow_m and (!@with_z or !allow_z) #to distinguish the M from the Z when there is actually no Z...
+        ewkt << "(" << text_representation(allow_z,allow_m) << ")"
+      end
+
+      #Outputs the geometry as strict WKT string.
+      def as_wkt
+        as_ewkt(false,false,false)
+      end
+
+      #Outputs the geometry in georss format.
+      #Assumes the geometries are in latlon format, with x as lon and y as lat.
+      #Pass the <tt>:dialect</tt> option to switch format. Possible values are: <tt>:simple</tt> (default), <tt>:w3cgeo</tt> and <tt>:gml</tt>.
+      def as_georss(options = {})
+        dialect= options[:dialect] || :simple
+        case(dialect)
+        when :simple
+          geom_attr = ""
+          geom_attr += " featuretypetag=\"#{options[:featuretypetag]}\"" if options[:featuretypetag]
+          geom_attr += " relationshiptag=\"#{options[:relationshiptag]}\"" if options[:relationshiptag]
+          geom_attr += " floor=\"#{options[:floor]}\"" if options[:floor]
+          geom_attr += " radius=\"#{options[:radius]}\"" if options[:radius]
+          geom_attr += " elev=\"#{options[:elev]}\"" if options[:elev]
+          georss_simple_representation(options.merge(:geom_attr => geom_attr))
+        when :w3cgeo
+          georss_w3cgeo_representation(options)
+        when :gml
+          georss_gml_representation(options)
+        end
+      end
+
+      #Iutputs 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 as_kml(options = {})
+        id_attr = ""
+        id_attr = " id=\"#{options[:id]}\"" if options[:id]
+
+        geom_data = ""
+        geom_data += "<extrude>#{options[:extrude]}</extrude>\n" if options[:extrude]
+        geom_data += "<tesselate>#{options[:tesselate]}</tesselate>\n" if options[:tesselate]
+        geom_data += "<altitudeMode>#{options[:altitude_mode]}</altitudeMode>\n" if options[:altitude_mode]
+
+        allow_z = (with_z || !options[:altitude].nil? )&& (!options[:altitude_mode].nil?) && options[:atitude_mode] != "clampToGround"
+        fixed_z = options[:altitude]
+
+        kml_representation(options.merge(:id_attr => id_attr, :geom_data => geom_data, :allow_z => allow_z, :fixed_z => fixed_z))
+      end
+
+      #Creates a geometry based on a EWKB string. The actual class returned depends of the content of the string passed as argument. Since WKB strings are a subset of EWKB, they are also valid.
+      def self.from_ewkb(ewkb)
+        factory = GeometryFactory::new
+        ewkb_parser= EWKBParser::new(factory)
+        ewkb_parser.parse(ewkb)
+        factory.geometry
+      end
+
+      #Creates a geometry based on a HexEWKB string
+      def self.from_hex_ewkb(hexewkb)
+        factory = GeometryFactory::new
+        hexewkb_parser= HexEWKBParser::new(factory)
+        hexewkb_parser.parse(hexewkb)
+        factory.geometry
+      end
+
+      #Creates a geometry based on a EWKT string. Since WKT strings are a subset of EWKT, they are also valid.
+      def self.from_ewkt(ewkt)
+        factory = GeometryFactory::new
+        ewkt_parser= EWKTParser::new(factory)
+        ewkt_parser.parse(ewkt)
+        factory.geometry
+      end
+
+      #sends back a geometry based on the GeoRSS string passed as argument
+      def self.from_georss(georss)
+        georss_parser= GeorssParser::new
+        georss_parser.parse(georss)
+        georss_parser.geometry
+      end
+
+      #sends back an array: The first element is the goemetry based on the GeoRSS string passed as argument. The second one is the GeoRSSTags (found only with the Simple format)
+      def self.from_georss_with_tags(georss)
+        georss_parser= GeorssParser::new
+        georss_parser.parse(georss,true)
+        [georss_parser.geometry, georss_parser.georss_tags]
+      end
+
+      #Sends back a geometry from a KML encoded geometry string.
+      #Limitations : Only supports points, linestrings and polygons (no collection for now).
+      #Addapted from Pramukta's code
+      def self.from_kml(kml)
+        return GeoRuby::SimpleFeatures::Geometry.from_ewkt(kml_to_wkt(kml))
+      end
+
+      require 'rexml/document'
+      def self.kml_to_wkt(kml)
+        doc = REXML::Document.new(kml)
+        wkt = ""
+        if ["Point", "LineString", "Polygon" ].include?(doc.root.name)
+          case doc.root.name
+          when "Point" then
+            coords = doc.elements["/Point/coordinates"].text.gsub(/\n/," ")
+            wkt = doc.root.name.upcase + "(" + split_coords(coords).join(' ') + ")"
+          when "LineString" then
+            coords = doc.elements["/LineString/coordinates"].text.gsub(/\n/," ")
+            coords = split_coords(coords)
+            wkt = doc.root.name.upcase + "(" + coords.join(",") + ")"
+          when "Polygon" then
+            # polygons have one outer ring and zero or more inner rings
+            bounds = []
+            bounds << doc.elements["/Polygon/outerBoundaryIs/LinearRing/coordinates"].text
+            inner_coords_elements = doc.elements.each("/Polygon/innerBoundaryIs/LinearRing/coordinates") do |inner_coords|
+              inner_coords = inner_coords.text
+              bounds << inner_coords
+            end
+
+            wkt = doc.root.name.upcase + "(" + bounds.map do |bound|
+              bound.gsub!(/\n/, " ")
+              bound = split_coords(bound)
+              if bound.first != bound.last
+                bound.push bound.first
+              end
+              "(" + bound.join(",") + ")"
+            end.join(",") + ")"
+          end
+        end
+        return wkt
+      end
+
+      private
+
+      def self.split_coords(coords)
+        coords.split(" ").collect { |coord|
+          coord.gsub(","," ")
+        }
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/geometry_collection.rb

@@ -0,0 +1,136 @@
+#require 'geo_ruby/simple_features/geometry'
+
+module GeoRuby
+  module SimpleFeatures
+    #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/simple_features/geometry_factory.rb

@@ -0,0 +1,81 @@
+require 'geo_ruby/simple_features/point'
+require 'geo_ruby/simple_features/line_string'
+require 'geo_ruby/simple_features/linear_ring'
+require 'geo_ruby/simple_features/polygon'
+require 'geo_ruby/simple_features/multi_point'
+require 'geo_ruby/simple_features/multi_line_string'
+require 'geo_ruby/simple_features/multi_polygon'
+require 'geo_ruby/simple_features/geometry_collection'
+
+
+module GeoRuby
+  module SimpleFeatures
+    #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/simple_features/georss_parser.rb

@@ -0,0 +1,135 @@
+#require 'geo_ruby/simple_features/point'
+#require 'geo_ruby/simple_features/line_string'
+#require 'geo_ruby/simple_features/linear_ring'
+#require 'geo_ruby/simple_features/polygon'
+#require 'geo_ruby/simple_features/multi_point'
+#require 'geo_ruby/simple_features/multi_line_string'
+#require 'geo_ruby/simple_features/multi_polygon'
+#require 'geo_ruby/simple_features/geometry_collection'
+#require 'geo_ruby/simple_features/envelope'
+
+module GeoRuby
+  module SimpleFeatures
+
+    #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