GeoRuby 0.0.1

data/lib/geo_ruby/simple_features/multi_polygon.rb

@@ -0,0 +1,38 @@
+require 'geo_ruby/simple_features/geometry_collection'
+
+
+module GeoRuby
+  module SimpleFeatures
+    #Represents a group of polygons (see Polygon).
+   class MultiPolygon < GeometryCollection
+      def initialize(srid = DEFAULT_SRID)
+        super(srid)
+      end
+      def binary_geometry_type
+        6
+      end
+      #Text representation of a MultiPolygon
+      def text_representation(dimension=2)
+        @geometries.collect{|polygon| "(" + polygon.text_representation(dimension) + ")"}.join(",")
+      end
+      #WKT geometry type
+      def text_geometry_type
+        "MULTIPOLYGON"
+      end
+      
+      #Creates a multi polygon from an array of polygons
+      def self.from_polygons(polygons,srid=DEFAULT_SRID)
+        multi_polygon = MultiPolygon::new(srid)
+        multi_polygon.concat(polygons)
+        multi_polygon
+      end
+      #Creates a multi polygon from sequences of points : ((((x,y)...(x,y)),((x,y)...(x,y)),((x,y)...(x,y))) 
+      def self.from_raw_point_sequences(point_sequences, srid= DEFAULT_SRID)
+        multi_polygon = MultiPolygon::new(srid)
+        multi_polygon.concat( point_sequences.collect {|point_sequence| Polygon.from_raw_point_sequences(point_sequence,srid) } )
+        multi_polygon
+      end
+      
+    end
+  end
+end

data/lib/geo_ruby/simple_features/point.rb

@@ -0,0 +1,85 @@
+require "geo_ruby/simple_features/geometry"
+
+module GeoRuby
+  module SimpleFeatures
+    #Represents a point. It is in 3D if the Z coordinate is not +nil+.
+    class Point < Geometry
+      #Coordinates of the point
+      attr_accessor :x,:y,:z
+      
+      def initialize(srid=DEFAULT_SRID)
+        super(srid)
+        @x=0.0
+        @y=0.0
+        @z=nil
+      end
+      #sets all coordinates in one call
+      def set_x_y_z(x,y,z)
+        @x=x
+        @y=y
+        @z=z
+      end
+      #sets all coordinates of a 2D point in one call
+      def set_x_y(x,y)
+        @x=x
+        @y=y
+      end
+      #tests the equality of points
+      def ==(other_point)
+        if other_point.class != self.class
+          false
+        else
+          @x == other_point.x and @y == other_point.y and @z == other_point.z
+        end
+      end
+      #binary representation of a point. It lacks some headers to be a valid EWKB representation.
+      def binary_representation(dimension=2)
+        if dimension == 2
+          [@x,@y].pack("EE")
+        else
+          [@x,@y,@z || 0].pack("EEE")
+        end
+      end
+      #WKB geometry type of a point
+      def binary_geometry_type
+        1
+      end
+      
+      #text representation of a point
+      def text_representation(dimension=2)
+        if dimension == 2
+          "#{@x} #{@y}"
+        else
+          "#{@x} #{@y} #{@z || 0}"
+        end
+      end
+      #WKT geometry type of a point
+      def text_geometry_type
+        "POINT"
+      end
+      
+      #creates a point from an array of coordinates
+      def self.from_coordinates(coords,srid=DEFAULT_SRID)
+        point= Point::new(srid)
+        if coords.length == 2
+          point.set_x_y(*coords)
+        else
+          point.set_x_y_z(*coords)
+        end
+        point
+      end
+      #creates a point from the X and Y coordinates
+      def self.from_x_y(x,y,srid=DEFAULT_SRID)
+        point= Point::new(srid)
+        point.set_x_y(x,y)
+        point
+      end
+      #creates a point from the X, Y and Z coordinates
+      def self.from_x_y_z(x,y,z,srid=DEFAULT_SRID)
+        point= Point::new(srid)
+        point.set_x_y_z(x,y,z)
+        point
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/polygon.rb

@@ -0,0 +1,103 @@
+require 'geo_ruby/simple_features/geometry'
+
+module GeoRuby
+  module SimpleFeatures
+    #Represents a polygon as an array of linear rings (see LinearRing). No check is performed regarding the validity of the geometries forming the polygon.
+    class Polygon < Geometry
+      #the list of rings forming the polygon
+      attr_reader :rings
+      
+      def initialize(srid = DEFAULT_SRID)
+        super(srid)
+        @rings = []
+      end
+      #add one to the polygon
+      def <<(ring)
+        @rings << ring
+      end
+      #add one or more rings to the polygon
+      def concat(rings)
+        @rings.concat rings
+      end
+      #number of linear rings in the polygon
+      def length
+        @rings.length
+      end
+      #access the nth linear ring
+      def [](n)
+        @rings[n]
+      end
+      #modifies the value of the nth linear ring
+      def []=(n,ring)
+        @rings[n]=ring
+      end
+      #iterates over the linear rings
+      def each(&proc)
+        @rings.each(&proc)
+      end
+      #iterates over the linear rings, passing their indices to the bloc
+      def each_index(&proc)
+        @rings.each_index(&proc)
+      end
+      #insert linear rings at the nth position
+      def insert(n,*ring)
+        @rings.insert(n,*ring)
+      end
+      #index of the linear_ring
+      def index(ring)
+        @rings.index(ring)
+      end
+      #remove linear rings. Arguments can be of the same type as Array#slice
+      def remove(*slice)
+        @rings.slice(*slice)
+      end
+      #tests for other equality. The SRID is not taken into account.
+      def ==(other_polygon)
+        if other_polygon.class != self.class or
+            length != other_polygon.length
+          false
+        else
+          index=0
+          while index<length
+            return false if self[index] != other_polygon[index]
+            index+=1
+          end
+          true
+        end
+      end
+      #binary representation of a polygon, without the headers neccessary for a valid WKB string
+      def binary_representation(dimension=2)
+        rep = [length].pack("V")
+        each {|linear_ring| rep << linear_ring.binary_representation(dimension) }
+        rep
+      end
+      #WKB geometry type
+      def binary_geometry_type
+        3
+      end
+      #Text representation of a polygon 
+      def text_representation(dimension=2)
+        @rings.collect{|line_string| "(" + line_string.text_representation(dimension) + ")" }.join(",")
+      end
+      #WKT geometry type
+      def text_geometry_type
+        "POLYGON"
+      end
+      #creates a new polygon. Accepts an array of linear strings as argument
+      def self.from_linear_rings(linear_rings,srid = DEFAULT_SRID)
+        polygon = Polygon::new(srid)
+        polygon.concat(linear_rings)
+        polygon
+      end
+      
+      #creates a new polygon. Accepts a sequence of points as argument : ((x,y)....(x,y)),((x,y).....(x,y))
+      def self.from_raw_point_sequences(point_sequences,srid=DEFAULT_SRID)
+        polygon = Polygon::new(srid)
+        polygon.concat( point_sequences.collect {|point_sequence| LinearRing.from_raw_point_sequence(point_sequence,srid) } )
+        polygon
+      end
+
+
+    end
+  end
+end

data/lib/geo_ruby.rb

@@ -0,0 +1,12 @@
+require 'geo_ruby/simple_features/geometry'
+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/ewkb_parser'
+require 'geo_ruby/simple_features/geometry_factory'
+

data/rakefile.rb

@@ -0,0 +1,50 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+task :default => :test
+
+desc "Run the tests"
+Rake::TestTask::new do |t|
+    t.test_files = FileList['test/test*.rb']
+    t.verbose = true
+end
+
+desc "Generate the documentation"
+Rake::RDocTask::new do |rdoc|
+  rdoc.rdoc_dir = 'doc/'
+  rdoc.title    = "GeoRuby Documentation"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification::new do |s|
+  s.platform = Gem::Platform::RUBY
+
+  s.name = 'GeoRuby'
+  s.version = "0.0.1"
+  s.summary = "Ruby data holder for OGC Simple Features"
+  s.description = <<EOF
+GeoRuby 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 www.opengis.org/docs/99-049.pdf), although without any kind of advanced functionalities (such as geometric operators or reprojections)
+EOF
+  s.author = 'Guilhem Vellut'
+  s.email = 'guilhem.vellut+georuby@gmail.com'
+  s.homepage = "http://thepochisuperstarmegashow.com"
+  
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  s.files = FileList["lib/**/*.rb", "test/**/*.rb", "README","MIT-LICENSE","rakefile.rb"]
+  s.test_files = FileList['test/test*.rb']
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README"]
+  s.rdoc_options.concat ['--main',  'README']
+end
+
+desc "Package the library as a gem"
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/test/test_ewkb_parser.rb

@@ -0,0 +1,91 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'geo_ruby'
+require 'test/unit'
+
+include GeoRuby::SimpleFeatures
+
+class TestEWKBParser < Test::Unit::TestCase
+  
+  def setup
+    @factory = GeometryFactory::new
+    @hex_ewkb_parser = HexEWKBParser::new(@factory)
+  end
+  
+  def test_point2d
+    @hex_ewkb_parser.parse("01010000207B000000CDCCCCCCCCCC28406666666666A64640")
+    point = @factory.geometry
+    assert(point.instance_of?(Point))
+    assert_equal(Point.from_x_y(12.4,45.3,123),point)
+  end
+  
+  def test_point3d
+    @hex_ewkb_parser.parse("01010000A07B000000CDCCCCCCCCCC28406666666666A646400000000000000CC0")
+    point = @factory.geometry
+    assert(point.instance_of?(Point))
+    assert_equal(Point.from_x_y_z(12.4,45.3,-3.5,123),point)
+  end
+  
+  def test_line_string
+    @hex_ewkb_parser.parse("01020000200001000002000000CDCCCCCCCCCC28406666666666A646C03333333333B34640CDCCCCCCCCCC4440")
+    line_string = @factory.geometry
+    assert(line_string.instance_of?(LineString))
+    assert_equal(LineString.from_raw_point_sequence([[12.4,-45.3],[45.4,41.6]],256),line_string)
+  end
+
+  def test_polygon
+    @hex_ewkb_parser.parse("0103000020000100000200000005000000000000000000000000000000000000000000000000001040000000000000000000000000000010400000000000001040000000000000000000000000000010400000000000000000000000000000000005000000000000000000F03F000000000000F03F0000000000000840000000000000F03F00000000000008400000000000000840000000000000F03F0000000000000840000000000000F03F000000000000F03F")
+    polygon = @factory.geometry
+    assert(polygon.instance_of?(Polygon))
+    assert_equal(Polygon.from_raw_point_sequences([[[0,0],[4,0],[4,4],[0,4],[0,0]],[[1,1],[3,1],[3,3],[1,3],[1,1]]],256),polygon)
+  end
+
+  def test_geometry_collection
+    @hex_ewkb_parser.parse("010700002000010000020000000101000000AE47E17A14AE12403333333333B34640010200000002000000CDCCCCCCCCCC16406666666666E628403333333333E350400000000000004B40")
+    geometry_collection = @factory.geometry
+    assert(geometry_collection.instance_of?(GeometryCollection))
+    assert_equal(GeometryCollection.from_geometries([Point.from_x_y(4.67,45.4,256),LineString.from_raw_point_sequence([[5.7,12.45],[67.55,54]],256)],256),geometry_collection)
+    assert_equal(256,geometry_collection[0].srid)
+  end
+  
+  def test_multi_point
+    @hex_ewkb_parser.parse("0104000020BC010000030000000101000000CDCCCCCCCCCC28403333333333D35EC0010100000066666666664650C09A99999999D95E4001010000001F97DD388EE35E400000000000C05E40")
+    multi_point = @factory.geometry
+    assert(multi_point.instance_of?(MultiPoint))
+    assert_equal(MultiPoint.from_raw_point_sequence([[12.4,-123.3],[-65.1,123.4],[123.55555555,123]],444),multi_point)
+    assert_equal(444,multi_point.srid)
+    assert_equal(444,multi_point[0].srid)
+  end
+  
+  def test_multi_line_string
+    @hex_ewkb_parser.parse("01050000200001000002000000010200000002000000000000000000F83F9A99999999994640E4BD6A65C20F4BC0FA7E6ABC749388BF010200000003000000000000000000F83F9A99999999994640E4BD6A65C20F4BC0FA7E6ABC749388BF39B4C876BE8F46403333333333D35E40")
+    multi_line_string = @factory.geometry
+    assert(multi_line_string.instance_of?(MultiLineString))
+    assert_equal(MultiLineString.from_line_strings([LineString.from_raw_point_sequence([[1.5,45.2],[-54.12312,-0.012]],256),LineString.from_raw_point_sequence([[1.5,45.2],[-54.12312,-0.012],[45.123,123.3]],256)],256),multi_line_string)
+    assert_equal(256,multi_line_string.srid)
+    assert_equal(256,multi_line_string[0].srid)
+  end
+  
+  def test_multi_polygon
+    @hex_ewkb_parser.parse("0106000020000100000200000001030000000200000004000000CDCCCCCCCCCC28406666666666A646C03333333333B34640CDCCCCCCCCCC44406DE7FBA9F1D211403D2CD49AE61DF13FCDCCCCCCCCCC28406666666666A646C004000000333333333333034033333333333315409A999999999915408A8EE4F21FD2F63FEC51B81E85EB2C40F6285C8FC2F5F03F3333333333330340333333333333154001030000000200000005000000000000000000000000000000000000000000000000001040000000000000000000000000000010400000000000001040000000000000000000000000000010400000000000000000000000000000000005000000000000000000F03F000000000000F03F0000000000000840000000000000F03F00000000000008400000000000000840000000000000F03F0000000000000840000000000000F03F000000000000F03F")
+    multi_polygon = @factory.geometry
+    assert(multi_polygon.instance_of?(MultiPolygon))
+    assert_equal(MultiPolygon.from_polygons([Polygon.from_raw_point_sequences([[[12.4,-45.3],[45.4,41.6],[4.456,1.0698],[12.4,-45.3]],[[2.4,5.3],[5.4,1.4263],[14.46,1.06],[2.4,5.3]]],256),Polygon.from_raw_point_sequences([[[0,0],[4,0],[4,4],[0,4],[0,0]],[[1,1],[3,1],[3,3],[1,3],[1,1]]],256)],256),multi_polygon)
+    assert_equal(256,multi_polygon.srid)
+    assert_equal(256,multi_polygon[0].srid)
+  end
+  def test_failure_trailing_data
+    #added A345 at the end
+    assert_raise(StandardError){@hex_ewkb_parser.parse("01010000207B000000CDCCCCCCCCCC28406666666666A64640A345")}
+  end
+  def test_failure_unknown_geometry_type
+    assert_raise(StandardError){@hex_ewkb_parser.parse("01090000207B000000CDCCCCCCCCCC28406666666666A64640")}
+  end
+  def test_failure_m
+    assert_raise(StandardError){@hex_ewkb_parser.parse("01010000607B000000CDCCCCCCCCCC28406666666666A64640")}
+  end
+  def test_failure_truncated_data
+    assert_raise(StandardError){@hex_ewkb_parser.parse("01010000207B000000CDCCCCCCCCCC2840666666")}
+  end
+  
+end