GeoRuby 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2006 Guilhem Vellut <guilhem.vellut+georuby@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 

data/README

@@ -0,0 +1,22 @@
+=GeoRuby
+This is GeoRuby 0.0.1. It is intended as a holder for data returned from PostGIS queries. Therefore, the data model roughly follows the OGC "Simple Features for SQL" specification (see http://www.opengis.org/docs/99-049.pdf), although without any kind of advanced functionalities (such as geometric operators or reprojections).
+
+===Available data types
+The following geometric data types are provided :
+- Point
+- Line string
+- Linear ring
+- Polygon
+- Multi point
+- Multi line string
+- Multi polygon
+- Geometry collection
+
+===Input and output
+These geometries can be input and output in WKB/EWKB format (as well as the related HexWKB and HexEWKB formats). Since EWKB and HexEWKB are respectively the canonical binary and ASCII representations of geometries in PostGIS, this functionality can prove useful. Geometries can also be output as WKT/EWKT.
+
+===License
+GeoRuby is released under the MIT license.
+
+===Support
+Any questions, enhancement proposals, bug notifications or corrections can be sent to mailto:guilhem.vellut+georuby@gmail.com.

data/lib/geo_ruby/simple_features/ewkb_parser.rb

@@ -0,0 +1,185 @@
+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
+    #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
+    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)
+        parse_geometry
+        @unpack_structure.done
+      end
+      private
+      def parse_geometry
+        @unpack_structure.endianness=@unpack_structure.read_byte
+        @geometry_type = @unpack_structure.read_uint
+        @dimension=2
+        
+        if (@geometry_type & Z_MASK) != 0
+          @dimension=3
+          @geometry_type = @geometry_type & ~Z_MASK
+        end
+        if (@geometry_type & M_MASK) != 0
+          raise StandardError::new("For next version")
+        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 parent, we take the default srid
+          @srid= @srid || DEFAULT_SRID
+        end
+        if @parse_options.has_key? @geometry_type
+          @parse_options[@geometry_type].call
+        else
+          raise StandardError::new("Unknown geometry type")
+        end
+      end
+      def parse_geometry_collection
+        parse_multi_geometries(GeometryCollection)
+      end
+      ##must be corrected : endianness + geometry_type present
+      def parse_multi_polygon
+        parse_multi_geometries(MultiPolygon)
+      end
+      #must be corrected
+      def parse_multi_line_string
+        parse_multi_geometries(MultiLineString)
+      end
+      #must be corrected
+      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
+      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
+      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
+      end
+      def parse_point
+        @factory.begin_geometry(Point,@srid)
+        x = @unpack_structure.read_double
+        y = @unpack_structure.read_double
+        if @dimension == 3
+          z = @unpack_structure.read_double
+          @factory.add_point_x_y_z(x,y,z)
+        else
+          @factory.add_point_x_y(x,y)
+        end
+        @factory.end_geometry
+      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)
+        temp_hexewkb= hexewkb.clone
+        result=""
+        while c = temp_hexewkb.slice!(0,2) do
+          break if c.length==0
+          result << c.hex
+        end
+        result
+      end
+
+    end
+
+    class UnpackStructure #:nodoc:
+      NDR=1
+      XDR=2
+      def initialize(ewkb)
+        @position=0
+        @ewkb=ewkb
+      end
+      def done
+        raise StandardError::new("Trailing data") if @position != @ewkb.length
+      end
+      def read_double
+        i=@position
+        @position += 8
+        packed_double = @ewkb[i...@position]
+        raise StandardError::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 StandardError::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 StandardError::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/geometry.rb

@@ -0,0 +1,87 @@
+module GeoRuby#:nodoc:
+  module SimpleFeatures
+    #arbitrary default SRID
+    DEFAULT_SRID=128
+    #indicates the presence of Z coordinates in EWKB strings
+    Z_MASK=0x80000000
+    #indicates the presence of M coordinates in EWKB strings. It is not supported at present.
+    M_MASK=0x40000000
+    #indicate the presence of a SRID in EWKB strings.
+    SRID_MASK=0x20000000
+    
+    
+    #Root of all geometric data classes.
+    #Objects of class Geometry should not be instantiated.
+    class Geometry
+      #SRID of the geometry
+      attr_accessor :srid
+      
+      def initialize(srid=DEFAULT_SRID)
+        @srid=srid
+      end
+            
+      #Outputs the geometry as an EWKB string.
+      #
+      #The argument +dimension+ forces the dimension of the output. The argument +with_srid+ indicates if the output must contain the SRID.
+      #
+      #WKB output can be obtained for any geometry by passing a +dimension+ of 2 and +with_srid+ set to false.
+      def as_binary(dimension=2,with_srid=true)
+        ewkb="";
+       
+        ewkb << 1.chr #little_endian by default
+        
+        type= binary_geometry_type
+        if dimension == 3
+          type = type | Z_MASK
+        end
+        if(with_srid)
+          type = type | SRID_MASK
+          ewkb << [type,@srid].pack("VV")
+        else
+          ewkb << [type].pack("V")
+        end
+        ewkb << binary_representation(dimension)
+      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.
+      #
+      #The argument +dimension+ forces the dimension of the output. The argument +with_srid+ indicates if the output must contain the SRID.
+      #
+      #HexWKB output can be obtained for any geometry by passing a +dimension+ of 2 and +with_srid+ set to false.
+      def as_hex_binary(dimension=2,with_srid=true)
+        str = ""
+        as_binary(dimension,with_srid).each_byte {|char| str << sprintf("%02x",char).upcase}
+        str
+      end
+
+      #Outputs the geometry as a EWKT string.
+      #
+      #
+      #The argument +dimension+ forces the dimension of the output. The argument +with_srid+ indicates if the output must contain the SRID.
+      #
+      #WKT output can be obtained for any geometry by passing a +dimension+ of 2 and +with_srid+ set to false.
+      def as_text(dimension=2,with_srid=true)
+        if with_srid
+          ewkt="SRID=#{@srid};"
+        else
+          ewkt=""
+        end
+        ewkt << text_geometry_type << "("
+        ewkt << text_representation(dimension) << ")"        
+      end
+
+      def self.from_ewkb(ewkb)
+        factory = GeometryFactory::new
+        ewkb_parser= EWKBParser::new(factory)
+        ewkb_parser.parse(ewkb)
+        factory.geometry
+      end
+
+      def self.from_hexewkb(hexewkb)
+        factory = GeometryFactory::new
+        hexewkb_parser= HexEWKBParser::new(factory)
+        hexewkb_parser.parse(hexewkb)
+        factory.geometry
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/geometry_collection.rb

@@ -0,0 +1,94 @@
+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)
+        super(srid)
+        @geometries = []
+      end
+      #add a geometry to the collection
+      def <<(geometry)
+        @geometries << geometry
+      end
+      #add geometries to the collection
+      def concat(geometries)
+        @geometries.concat geometries
+      end
+      #number of geometries in the collection
+      def length
+        @geometries.length
+      end
+      #gets the nth geometry
+      def [](n)
+        @geometries[n]
+      end
+      #replaces the nth geometry
+      def []=(n,geometry)
+        @geometries[n]=geometry
+      end
+      #iterates over all the geometries
+      def each(&proc)
+        @geometries.each(&proc)
+      end
+      #iterates over all the geometries, passing the index to the bloc
+      def each_index(&proc)
+        @geometries.each_index(&proc)
+      end
+      #inserts geometries at the nth position
+      def insert(n,*geometry)
+        @geometries.insert(n,*geometry)
+      end
+      #index of the geometry
+      def index(geometry)
+        @geometries.index(geometry)
+      end
+      #remove a slice of the collection
+      def remove(*slice)
+        @geometries.slice(*slice)
+      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(dimension=2)
+        rep = [length].pack("V")
+        each {|geometry| rep << geometry.as_binary(dimension,false) }
+        rep
+      end
+      #WKB geometry type of the collection
+      def binary_geometry_type
+        7
+      end
+      #Text representation of a geometry collection
+      def text_representation(dimension=2)
+        @geometries.collect{|geometry| geometry.as_text(dimension,false)}.join(",")
+      end
+      #WKT geometry type
+      def text_geometry_type
+        "GEOMETRYCOLLECTION"
+      end
+      #creates a new GeometryCollection from an array of geometries
+      def self.from_geometries(geometries,srid=DEFAULT_SRID)
+        geometry_collection = GeometryCollection::new(srid)
+        geometry_collection.concat(geometries)
+        geometry_collection
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/geometry_factory.rb

@@ -0,0 +1,51 @@
+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_stack = []
+      end
+      #resets the factory
+      def reset
+        @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 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
+      #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
+        geometry=@geometry_stack.pop
+        #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/line_string.rb

@@ -0,0 +1,109 @@
+require "geo_ruby/simple_features/geometry"
+
+module GeoRuby
+  module SimpleFeatures
+    #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 )
+        super(srid)
+        @points=[]
+      end
+      #tests if the line string is closed
+      def is_closed
+        #a bit naive...
+        @points.first == @points.last
+      end
+      #add a point to the end of the line string
+      def <<(point)
+        @points << point
+      end
+      #add points to the end of the line string
+      def concat(points)
+        @points.concat points
+      end
+      #number of points of the line string
+      def length
+        @points.length
+      end
+      #accesses the nth point in the line string
+      def [](n)
+        @points[n]
+      end
+      #replaces the nth point in the line string
+      def []=(n,point)
+        @points[n]=point
+      end
+      #iterates over the points in the line string
+      def each(&proc)
+        @points.each(&proc)
+      end
+      #iterates over the points, passing their indices to the bloc
+      def each_index(&proc)
+        @points.each_index(&proc)
+      end
+      #inserts points at the nth position
+      def insert(n,*point)
+        @points.insert(n,*point)
+      end
+      #gets the indices of point
+      def index(point)
+        @points.index(point)
+      end
+      #Removes a slice of points
+      def remove(*slice)
+        @points.slice(*slice)
+      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(dimension=2)
+        rep = [length].pack("V")
+        each {|point| rep << point.binary_representation(dimension) }
+        rep
+      end
+      #WKB geometry type
+      def binary_geometry_type
+        2
+      end
+      #Text representation of a line string
+      def text_representation(dimension=2)
+        @points.collect{|point| point.text_representation(dimension) }.join(",") 
+      end
+      #WKT geometry type
+      def text_geometry_type
+        "LINESTRING"
+      end
+      
+      #Creates a new line string. Accept an array of points as argument
+      def self.from_points(points,srid=DEFAULT_SRID)
+        line_string = LineString::new(srid)
+        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_raw_point_sequence(points,srid=DEFAULT_SRID)
+        line_string = LineString::new(srid)
+        line_string.concat( points.collect{|point_coords| Point.from_coordinates(point_coords,srid)  } )
+        line_string
+      end
+
+     end
+  end
+end

data/lib/geo_ruby/simple_features/linear_ring.rb

@@ -0,0 +1,27 @@
+require 'geo_ruby/simple_features/line_string'
+
+module GeoRuby
+  module SimpleFeatures
+    #Represents a linear ring, which is a closed line string (see LineString). No check is performed to verify if the linear ring is really closed.
+    class LinearRing < LineString
+      def initialize(srid= DEFAULT_SRID)
+        super(srid)
+      end
+
+      #creates a new linear ring from an array of points. The first and last points should be equal, although no check is performed here.
+      def self.from_points(points,srid=DEFAULT_SRID)
+        linear_ring = LinearRing::new(srid)
+        linear_ring.concat(points)
+        linear_ring
+      end
+
+      #creates a new linear ring from a sequence of points : ((x,y)...(x,y)).
+      def self.from_raw_point_sequence(points,srid=DEFAULT_SRID)
+        linear_ring = LinearRing::new(srid)
+        linear_ring.concat( points.collect{|point_coords| Point.from_coordinates(point_coords,srid)  } ) 
+        linear_ring
+      end
+      
+    end
+  end
+end

data/lib/geo_ruby/simple_features/multi_line_string.rb

@@ -0,0 +1,35 @@
+require 'geo_ruby/simple_features/geometry_collection'
+
+module GeoRuby
+  module SimpleFeatures
+    #Represents a group of line strings (see LineString).
+    class MultiLineString < GeometryCollection
+      def initialize(srid = DEFAULT_SRID)
+        super(srid)
+      end
+      def binary_geometry_type
+        5
+      end
+      #Text representation of a multi line string
+      def text_representation(dimension = 2)
+        @geometries.collect{|line_string| "(" + line_string.text_representation + ")" }.join(",")
+      end
+      #WKT geometry type
+      def text_geometry_type
+        "MULTILINESTRING"
+      end
+      #Creates a new multi line string from an array of line strings
+      def self.from_line_strings(line_strings,srid=DEFAULT_SRID)
+        multi_line_string = MultiLineString::new(srid)
+        multi_line_string.concat(line_strings)
+        multi_line_string
+      end
+      #Creates a new multi line string from sequences of points : (((x,y)...(x,y)),((x,y)...(x,y)))
+      def self.from_raw_point_sequences(point_sequences,srid=DEFAULT_SRID)
+        multi_line_string = MultiLineString::new(srid)
+        multi_line_string.concat(point_sequences.collect {|point_sequence| LineString.from_raw_point_sequence(point_sequence,srid) })
+        multi_line_string
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/multi_point.rb

@@ -0,0 +1,40 @@
+require 'geo_ruby/simple_features/geometry_collection'
+
+module GeoRuby
+  module SimpleFeatures
+    #Represents a group of points (see Point).
+    class MultiPoint < GeometryCollection
+      
+      def initialize(srid= DEFAULT_SRID)
+        super(srid)
+      end
+      
+      def binary_geometry_type
+        4
+      end
+      #Text representation of a MultiPoint
+      def text_representation(dimension=2)
+        @geometries.collect{|point| point.text_representation(dimension)}.join(",")
+      end
+      #WKT geoemtry type
+      def text_geometry_type
+        "MULTIPOINT"
+      end
+
+      #Creates a new multi point from an array of points
+      def self.from_points(points,srid= DEFAULT_SRID)
+        multi_point= MultiPoint::new(srid)
+        multi_point.concat(points)
+        multi_point
+      end
+
+      #Creates a new multi point from a list of point coordinates : ((x,y)...(x,y))
+      def self.from_raw_point_sequence(point_sequence,srid= DEFAULT_SRID)
+        multi_point= MultiPoint::new(srid)
+        multi_point.concat(point_sequence.collect {|point| Point.from_coordinates(point,srid)})
+        multi_point
+      end
+      
+    end
+  end
+end