jsl-GeoRuby 1.3.3

data/lib/geo_ruby/simple_features/envelope.rb

@@ -0,0 +1,134 @@
+module GeoRuby
+  module SimpleFeatures
+    
+    #Contains the bounding box of a geometry
+    class Envelope 
+      attr_accessor :lower_corner, :upper_corner
+      attr_accessor :srid, :with_z
+      
+      #Creates a enw Envelope with +lower_corner+ as the first element of the corners array and +upper_corner+ as the second element
+      def initialize(srid = DEFAULT_SRID, with_z = false)
+        @srid = srid
+        @with_z = with_z
+      end
+
+      #Merges the argument with the current evelope
+      def extend!(envelope)
+        lower_corner.x = [lower_corner.x,envelope.lower_corner.x].min
+        lower_corner.y = [lower_corner.y,envelope.lower_corner.y].min
+        upper_corner.x = [upper_corner.x,envelope.upper_corner.x].max
+        upper_corner.y = [upper_corner.y,envelope.upper_corner.y].max
+        self
+      end
+      
+      #Merges the argument with the current evelope and sends back a new
+      #envelope without changing the current one
+      def extend(envelope)
+        e = Envelope.from_points([Point.from_x_y(lower_corner.x,lower_corner.y),
+                          Point.from_x_y(upper_corner.x,upper_corner.y)],srid,with_z)
+        e.extend!(envelope)
+        e
+      end
+      
+      #Sends back the center of the envelope
+      def center
+        Point.from_x_y((lower_corner.x + upper_corner.x)/2,(lower_corner.y + upper_corner.y)/2)
+      end
+
+      #Tests the equality of line strings
+      def ==(other_envelope)
+        if other_envelope.class != self.class
+          false
+        else
+          upper_corner == other_envelope.upper_corner and lower_corner == other_envelope.lower_corner
+        end
+      end
+
+      #georss serialization: Dialect can be passed as option <tt>:dialect</tt> and set to <tt>:simple</tt> (default)
+      #<tt>:w3cgeo</tt> or <tt>:gml</tt>. Options <tt>:featuretypetag
+      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
+      
+       #georss simple representation
+      def georss_simple_representation(options = {}) #:nodoc:
+        georss_ns = options[:georss_ns] || "georss"
+        geom_attr = options[:geom_attr]
+        "<#{georss_ns}:box#{geom_attr}>#{lower_corner.y} #{lower_corner.x} #{upper_corner.y} #{upper_corner.x}</#{georss_ns}:box>\n"
+      end
+
+      #georss w3c representation : outputs the first point of the line
+      def georss_w3cgeo_representation(options = {}) #:nodoc:
+        w3cgeo_ns = options[:w3cgeo_ns] || "geo"
+        point = self.center
+        "<#{w3cgeo_ns}:lat>#{point.y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{point.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}:Envelope>\n"
+        result += "<#{gml_ns}:LowerCorner>" + "#{lower_corner.y} #{lower_corner.x}" + "</#{gml_ns}:LowerCorner>"
+        result += "<#{gml_ns}:UpperCorner>" + "#{upper_corner.y} #{upper_corner.x}" + "</#{gml_ns}:UpperCorner>"
+        result += "</#{gml_ns}:Envelope>\n</#{georss_ns}:where>\n"
+      end
+
+      #Sends back a latlonaltbox
+      def as_kml(options = {})
+        geom_data = ""
+        geom_data = "<altitudeMode>#{options[:altitude_mode]}</altitudeMode>\n" if options[:altitude_mode]
+        
+        allow_z = with_z && (!options[:altitude_mode].nil?) && options[:atitude_mode] != "clampToGround"
+        
+        kml_representation(options.merge(:geom_data => geom_data,:allow_z => allow_z))
+      end
+      
+      def kml_representation(options = {})#:nodoc:
+        result = "<LatLonAltBox>\n"
+        result += options[:geom_data]
+        result += "<north>#{upper_corner.y}</north>\n"
+        result += "<south>#{lower_corner.y}</south>\n"
+        result += "<east>#{upper_corner.x}</east>\n"
+        result += "<west>#{lower_corner.x}</west>\n"
+        
+        if with_z
+          result += "<minAltitude>#{lower_corner.z}</minAltitude>"
+          result += "<maxAltitude>#{upper_corner.z}</maxAltitude>"
+        end
+        
+        result += "</LatLonAltBox>\n"
+      end
+
+      #Creates a new envelope. Accept an array of 2 points as argument
+      def self.from_points(points,srid=DEFAULT_SRID,with_z=false)
+        e = Envelope.new(srid,with_z)
+        e.lower_corner, e.upper_corner = points
+        e
+      end
+
+      #Creates a new envelope. Accept a sequence of point coordinates as argument : ((x,y),(x,y))
+      def self.from_coordinates(points,srid=DEFAULT_SRID,with_z=false)
+        e = Envelope.new(srid,with_z)
+        e.lower_corner, e.upper_corner =  points.collect{|point_coords| Point.from_coordinates(point_coords,srid,with_z)}
+        e
+      end
+      
+    end
+  end
+end

data/lib/geo_ruby/simple_features/ewkb_parser.rb

@@ -0,0 +1,216 @@
+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
+
+    #Raised when an error in the EWKB string is detected
+    class EWKBFormatError < StandardError
+    end
+
+    #Parses EWKB strings and notifies of events (such as the beginning of the definition of geometry, the value of the SRID...) the factory passed as argument to the constructor.
+    #
+    #=Example
+    # factory = GeometryFactory::new
+    # ewkb_parser = EWKBParser::new(factory)
+    # ewkb_parser.parse(<EWKB String>)
+    # geometry = @factory.geometry
+    #
+    #You can also use directly the static method Geometry.from_ewkb
+    class EWKBParser
+  
+      def initialize(factory)
+        @factory = factory
+        @parse_options ={
+          1 => method(:parse_point),
+          2 => method(:parse_line_string),
+          3 => method(:parse_polygon),
+          4 => method(:parse_multi_point),
+          5 => method(:parse_multi_line_string),
+          6 => method(:parse_multi_polygon),
+          7 => method(:parse_geometry_collection)
+        }
+      end
+      
+      #Parses the ewkb string passed as argument and notifies the factory of events
+      def parse(ewkb)
+        @factory.reset
+        @unpack_structure=UnpackStructure::new(ewkb)
+        @with_z = false
+        @with_m = false
+        parse_geometry
+        @unpack_structure.done
+        @srid=nil
+      end
+      
+      private
+      def parse_geometry
+        @unpack_structure.endianness=@unpack_structure.read_byte
+        @geometry_type = @unpack_structure.read_uint
+                
+        if (@geometry_type & Z_MASK) != 0
+          @with_z=true
+          @geometry_type = @geometry_type & ~Z_MASK
+        end
+        if (@geometry_type & M_MASK) != 0
+          @with_m=true
+          @geometry_type = @geometry_type & ~M_MASK
+        end
+        if (@geometry_type & SRID_MASK) != 0
+          @srid = @unpack_structure.read_uint
+          @geometry_type = @geometry_type & ~SRID_MASK
+        else
+          #to manage multi geometries : the srid is not present in sub_geometries, therefore we take the srid of the parent ; if it is the root, we take the default srid
+          @srid= @srid || DEFAULT_SRID
+        end
+        
+        if @parse_options.has_key? @geometry_type
+          @parse_options[@geometry_type].call
+        else
+          raise EWKBFormatError::new("Unknown geometry type")
+        end
+      end
+      
+      def parse_geometry_collection
+        parse_multi_geometries(GeometryCollection)
+      end
+      
+      def parse_multi_polygon
+        parse_multi_geometries(MultiPolygon)
+      end
+      
+      def parse_multi_line_string
+        parse_multi_geometries(MultiLineString)
+      end
+      
+      def parse_multi_point
+        parse_multi_geometries(MultiPoint)
+      end
+      
+      def parse_multi_geometries(geometry_type)
+        @factory.begin_geometry(geometry_type,@srid)
+        num_geometries = @unpack_structure.read_uint
+        1.upto(num_geometries) { parse_geometry }
+        @factory.end_geometry(@with_z,@with_m)
+      end
+      
+      def parse_polygon
+        @factory.begin_geometry(Polygon,@srid)
+        num_linear_rings = @unpack_structure.read_uint
+        1.upto(num_linear_rings) {parse_linear_ring}
+        @factory.end_geometry(@with_z,@with_m)
+      end
+      
+      def parse_linear_ring
+        parse_point_list(LinearRing)
+      end
+      
+      def parse_line_string
+        parse_point_list(LineString)
+      end
+      
+      #used to parse line_strings and linear_rings
+      def parse_point_list(geometry_type)
+        @factory.begin_geometry(geometry_type,@srid)
+        num_points = @unpack_structure.read_uint
+        1.upto(num_points) {parse_point}
+        @factory.end_geometry(@with_z,@with_m)
+      end
+      
+      def parse_point
+        @factory.begin_geometry(Point,@srid)
+        x = @unpack_structure.read_double
+        y = @unpack_structure.read_double
+        if ! (@with_z or @with_m) #most common case probably
+          @factory.add_point_x_y(x,y)
+        elsif @with_m and @with_z
+          z = @unpack_structure.read_double
+          m = @unpack_structure.read_double
+          @factory.add_point_x_y_z_m(x,y,z,m)
+        elsif @with_z
+          z = @unpack_structure.read_double
+          @factory.add_point_x_y_z(x,y,z)
+        else
+          m = @unpack_structure.read_double
+          @factory.add_point_x_y_m(x,y,m)
+        end
+                
+        @factory.end_geometry(@with_z,@with_m)
+      end
+    end
+
+    #Parses HexEWKB strings. In reality, it just transforms the HexEWKB string into the equivalent EWKB string and lets the EWKBParser do the actual parsing.
+    class HexEWKBParser < EWKBParser
+      def initialize(factory)
+        super(factory)
+      end
+      #parses an HexEWKB string
+      def parse(hexewkb)
+        super(decode_hex(hexewkb))
+      end
+      #transforms a HexEWKB string into an EWKB string 
+      def decode_hex(hexewkb)
+        result=""
+        num_bytes = (hexewkb.size + 1) / 2
+        0.upto(num_bytes-1) do |i|
+          result << hexewkb[i*2,2].hex
+        end
+        result
+      end
+    end
+
+    class HexEWKBParser < EWKBParser
+     #transforms a HexEWKB string into an EWKB string
+     # Patched for speedup
+     
+   end
+
+    class UnpackStructure #:nodoc:
+      NDR=1
+      XDR=0
+      def initialize(ewkb)
+        @position=0
+        @ewkb=ewkb
+      end
+      def done
+        raise EWKBFormatError::new("Trailing data") if @position != @ewkb.length
+      end
+      def read_double
+        i=@position
+        @position += 8
+        packed_double = @ewkb[i...@position]
+        raise EWKBFormatError::new("Truncated data") if packed_double.nil? or packed_double.length < 8
+        packed_double.unpack(@double_mark)[0]
+      end
+      def read_uint
+        i=@position
+        @position += 4
+        packed_uint = @ewkb[i...@position]
+        raise EWKBFormatError::new("Truncated data") if packed_uint.nil? or packed_uint.length < 4
+        packed_uint.unpack(@uint_mark)[0]
+      end
+      def read_byte
+        i = @position
+        @position += 1
+        packed_byte = @ewkb[i...@position]
+        raise EWKBFormatError::new("Truncated data") if packed_byte.nil? or packed_byte.length < 1
+        packed_byte.unpack("C")[0]
+      end
+      def endianness=(byte_order)
+        if(byte_order == NDR)
+          @uint_mark="V"
+          @double_mark="E"
+        elsif(byte_order == XDR)
+          @uint_mark="N"
+          @double_mark="G"
+        end
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/ewkt_parser.rb

@@ -0,0 +1,336 @@
+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 'strscan'
+
+module GeoRuby
+  module SimpleFeatures
+
+    #Raised when an error in the EWKT string is detected
+    class EWKTFormatError < StandardError
+    end
+
+    #Parses EWKT strings and notifies of events (such as the beginning of the definition of geometry, the value of the SRID...) the factory passed as argument to the constructor.
+    #
+    #=Example
+    # factory = GeometryFactory::new
+    # ewkt_parser = EWKTParser::new(factory)
+    # ewkt_parser.parse(<EWKT String>)
+    # geometry = @factory.geometry
+    #
+    #You can also use directly the static method Geometry.from_ewkt
+    class EWKTParser
+  
+      def initialize(factory)
+        @factory = factory
+        @parse_options ={
+          "POINT" => method(:parse_point),
+          "LINESTRING" => method(:parse_line_string),
+          "POLYGON" => method(:parse_polygon),
+          "MULTIPOINT" => method(:parse_multi_point),
+          "MULTILINESTRING" => method(:parse_multi_line_string),
+          "MULTIPOLYGON" => method(:parse_multi_polygon),
+          "GEOMETRYCOLLECTION" => method(:parse_geometry_collection)
+        }
+      end
+      
+      #Parses the ewkt string passed as argument and notifies the factory of events
+      def parse(ewkt)
+        @factory.reset
+        @tokenizer_structure = TokenizerStructure.new(ewkt)
+        @with_z=false
+        @with_m=false
+        @is_3dm = false
+        parse_geometry(true)
+        @srid=nil
+      end
+      
+      private
+      def parse_geometry(srid_allowed)
+        
+        token = @tokenizer_structure.get_next_token
+        if token == 'SRID'
+          #SRID present
+          raise  EWKTFormatError.new("SRID not allowed at this position") if(!srid_allowed)
+          if @tokenizer_structure.get_next_token != '='
+            raise EWKTFormatError.new("Invalid SRID expression")
+          else
+            @srid = @tokenizer_structure.get_next_token.to_i
+            raise EWKTFormatError.new("Invalid SRID separator") if @tokenizer_structure.get_next_token != ';'
+            geom_type = @tokenizer_structure.get_next_token
+          end
+          
+        else
+          #to manage multi geometries : the srid is not present in sub_geometries, therefore we take the srid of the parent ; if it is the root, we take the default srid
+          @srid= @srid || DEFAULT_SRID
+          geom_type = token
+        end
+        
+        if geom_type[-1] == ?M
+          @is_3dm=true
+          @with_m=true
+          geom_type.chop! #remove the M
+        end
+        
+        if @parse_options.has_key?(geom_type)
+          @parse_options[geom_type].call
+        else
+          raise EWKTFormatError.new("Urecognized geometry type: #{geom_type}")
+        end
+      end
+      
+      def parse_geometry_collection
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid GeometryCollection')
+        end
+        
+        @factory.begin_geometry(GeometryCollection,@srid)
+        
+        token = ''
+        while token != ')'
+          parse_geometry(false)
+          token = @tokenizer_structure.get_next_token
+          if token.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
+        end
+        
+        @factory.end_geometry(@with_z,@with_m)
+      end
+      
+      def parse_multi_polygon
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid MultiLineString')
+        end
+        
+        @factory.begin_geometry(MultiPolygon,@srid)
+        token = ''
+        while token != ')'
+          parse_polygon
+          token = @tokenizer_structure.get_next_token
+          if token.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
+        end
+        
+        @factory.end_geometry(@with_z,@with_m)
+      end
+                 
+      def parse_multi_line_string
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid MultiLineString')
+        end
+        
+        @factory.begin_geometry(MultiLineString,@srid)
+
+        token = ''
+        while token != ')'
+          parse_line_string
+          token = @tokenizer_structure.get_next_token
+          if token.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
+        end
+        
+        @factory.end_geometry(@with_z,@with_m)
+      end
+
+      def parse_polygon
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid Polygon')
+        end
+        
+        @factory.begin_geometry(Polygon,@srid)
+        
+        token = ''
+        while token != ')'
+          parse_linear_ring
+          token = @tokenizer_structure.get_next_token
+          if token.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
+        end
+
+        @factory.end_geometry(@with_z,@with_m)
+      end
+           
+      #must support the PostGIS form and the one in the specification
+      def parse_multi_point
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid MultiPoint')
+        end
+        
+        token = @tokenizer_structure.check_next_token
+        if token == '('
+          #specification
+          @factory.begin_geometry(MultiPoint,@srid)
+                    
+          token = ''
+          while token != ')'
+            parse_point
+            token = @tokenizer_structure.get_next_token
+            if token.nil?
+              raise EWKTFormatError.new("EWKT string not correctly terminated")
+            end
+          end
+                    
+          @factory.end_geometry(@with_z,@with_m)
+        else
+          #postgis
+          parse_point_list(MultiPoint)
+        end
+      end
+      
+      def parse_linear_ring
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid Linear ring')
+        end
+        
+        parse_point_list(LinearRing)
+      end
+      
+      def parse_line_string
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid Line string')
+        end
+        
+        parse_point_list(LineString)
+      end
+      
+      #used to parse line_strings and linear_rings and the PostGIS form of multi_points
+      def parse_point_list(geometry_type)
+        @factory.begin_geometry(geometry_type,@srid)
+               
+        token = ''
+        while token != ')'
+          @factory.begin_geometry(Point,@srid)
+          token = parse_coords
+          if token.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
+          @factory.end_geometry(@with_z,@with_m)
+        end
+        
+        @factory.end_geometry(@with_z,@with_m)
+      end
+      
+      def parse_point
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid Point')
+        end
+        
+        @factory.begin_geometry(Point,@srid)
+                
+        token = parse_coords
+        
+        if token != ')'
+          raise EWKTFormatError.new("EWKT string not correctly terminated")
+        end
+
+        @factory.end_geometry(@with_z,@with_m)
+      end
+
+      def parse_coords
+        coords = Array.new
+        x = @tokenizer_structure.get_next_token
+        y = @tokenizer_structure.get_next_token
+
+        if x.nil? or y.nil?
+          raise EWKTFormatError.new("Bad Point format")
+        end
+        
+        if @is_3dm
+          m = @tokenizer_structure.get_next_token
+
+          if m.nil? or m == ',' or m == ')'
+            raise EWKTFormatError.new("No M dimension found")
+          else
+            @factory.add_point_x_y_m(x.to_f,y.to_f,m.to_f)
+            @tokenizer_structure.get_next_token
+          end
+        else
+          z = @tokenizer_structure.get_next_token
+          
+          if z.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
+          
+          if z == ',' or z == ')'
+            #2D : no z no m
+            @factory.add_point_x_y(x.to_f,y.to_f)
+            z
+          else
+            m = @tokenizer_structure.get_next_token
+            if m.nil?
+              raise EWKTFormatError.new("EWKT string not correctly terminated")
+            end
+            
+            if m == ',' or m ==')'
+              #3Dz : no m
+              @with_z = true
+              @factory.add_point_x_y_z(x.to_f,y.to_f,z.to_f)
+              m
+            else
+              #4D
+              @with_z = true
+              @with_m = true
+              @factory.add_point_x_y_z_m(x.to_f,y.to_f,z.to_f,m.to_f)
+              @tokenizer_structure.get_next_token
+            end
+          end
+        end
+      end
+    end
+    
+    class TokenizerStructure
+      
+      def initialize(ewkt)
+        @ewkt = ewkt
+        @scanner = StringScanner.new(ewkt)
+        @regex = /\s*([\w.-]+)s*/
+      end
+
+      def get_next_token
+        if @scanner.scan(@regex).nil?
+          if @scanner.eos?
+            nil
+          else
+            ch = @scanner.getch
+            while ch == ' '
+              ch = @scanner.getch
+            end
+            ch
+          end
+        else
+          @scanner[1]
+        end
+      end
+      
+      
+      def check_next_token
+        check = @scanner.check(@regex)
+        if check.nil?
+          if @scanner.eos?
+            nil
+          else
+            pos = @scanner.pos
+            while @ewkt[pos].chr == ' '
+              pos+=1
+            end
+            @ewkt[pos].chr
+          end
+        else
+          check
+        end
+      end
+
+    end
+
+  end
+end