nofxx-georuby 1.3.7

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-08-14
+
+* 1 major enhancement:
+  * Initial release

data/LICENSE

@@ -0,0 +1,21 @@
+GeoRuby License
+
+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
+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.txt

@@ -0,0 +1,59 @@
+= geo_ruby
+
+Experiment with GeoRuby (http://georuby.rubyforge.org) with the fast Geo (http://geo.rubyforge.org).
+
+
+== DESCRIPTION:
+
+the objective is provide all the georuby functionalities, with time consuming calculus in C.
+_this is not usable yet_
+
+See:
+GeoRuby (http://georuby.rubyforge.org)
+Copyright (c) 2006 Guilhem Vellut <guilhem.vellut+georuby@gmail.com>
+
+Geo (http://geo.rubyforge.org)
+Copyright (C) 2007 Martin Kihlgren
+
+
+== REQUIREMENTS:
+
+glib:: http://www.gtk.org/
+
+== FEATURES:
+
+=Available data types
+
+- Point
+- Line string
+- Linear ring
+- Polygon
+- Multi point
+- Multi line string
+- Multi polygon
+- Geometry collection
+
+They can be in 2D, 3DZ, 3DM, and 4D.
+
+
+Geo::Point:: A 2D point providing some common geometry operations.
+Geo::Line:: A 2D line consisting of 2 Geo::Points providing some common geometry operations.
+Geo::Triangle:: A 2D triangle consisting of 3 Geo::Points providing some common geometry operations.
+Geo::PointSet:: A Set-like container of Points.
+Geo::LineSet:: A Set-like container of Lines that provides optimized versions of some common geometry operations on lines.
+Geo::TriangleSet:: A Set-like container of Triangles that provides optimized versions of some common geometry operations on lines.
+
+== Usage:
+
+Just install the gem.
+
+== Examples:
+
+To find if a given line intersects a set of 100 000 other lines:
+
+ :include:examples/intersects.rb
+
+== License:
+
+GeoRuby is released under the MIT license.
+geo is provided under the GPL-2.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "georuby"
+    gem.summary = "Ruby data holder for OGC Simple Features"
+    gem.description = "GeoRuby provides geometric data types from the OGC 'Simple Features' specification."
+    gem.email = "x@nofxx.com"
+    gem.homepage = "http://github.com/nofxx/georuby"
+    gem.authors = ["Guilhem Vellut", "Marcos Augusto"]
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "geo_ruby #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+---
+:major: 1
+:minor: 3
+:patch: 7

data/lib/geo_ruby.rb

@@ -0,0 +1,21 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'geo_ruby/base/helper'
+require 'geo_ruby/base/ewkt_parser'
+require 'geo_ruby/base/ewkb_parser'
+require 'geo_ruby/base/geometry'
+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'
+require 'geo_ruby/base/geometry_factory'
+require 'geo_ruby/base/georss_parser'
+require 'geo_ruby/shp4r/shp'
+
+GeoRuby::SimpleFeatures = GeoRuby::Base

data/lib/geo_ruby/base/envelope.rb

@@ -0,0 +1,167 @@
+module GeoRuby
+  module Base
+
+    #Contains the bounding box of a geometry
+    class Envelope
+      attr_accessor :lower_corner, :upper_corner
+      attr_accessor :srid, :with_z, :zoom
+
+      #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
+#  def bounding_box(markers)
+#    max_lat, max_lon, min_lat, min_lon = -Float::MAX, -Float::MAX, Float::MAX, Float::MAX
+#    markers.each do |marker|
+#      coord = marker.point
+#      max_lat = coord.lat if coord.lat > max_lat
+#      min_lat = coord.lat if coord.lat < min_lat
+#      max_lon = coord.lng if coord.lng > max_lon
+#      min_lon = coord.lng if coord.lng < min_lon
+#    end
+#    min_point = Point.from_x_y(min_lat,min_lon)
+#    max_point = Point.from_x_y(max_lat,max_lon)
+
+#    end
+#    centrelat = (max_lat + min_lat)/2
+#    centrelng = (max_lon + min_lon)/2
+#    # logger.info("distance[#{distance}],zoom[#{zoom}]")
+#    #return GLatLngBounds.new(GLatLng.new(min_point),GLatLng.new(max_point)), [centrelat,centrelng], zoom
+#    return [centrelat,centrelng], zoom
+
+      #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
+
+      #Zoom level
+      def zoom
+        distance = lower_corner.spherical_distance(upper_corner)/10000
+        @zoom = case distance
+        when 150..9000  then 5
+        when 80..149    then 6
+        when 50..79     then 7
+        when 20..49     then 8
+        when 10..19     then 9
+        when 5..9       then 10
+        else 13
+        end
+      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)
+        raise "Not an array" unless points.class == Array
+        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/base/ewkb_parser.rb

@@ -0,0 +1,216 @@
+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
+
+    #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