nofxx-georuby 1.7.3 → 1.9.0

data/README.rdoc

@@ -0,0 +1,184 @@
+= GeoRuby
+
+
+This is a fork of GeoRuby with some updates and extra funcionality.
+
+It is intended as a holder for geometric data. The data model roughly
+follows the OGC "Simple Features for SQL" specification, so it should
+play nice with data returned from PostGIS or any Spatial Extensions (MongoDB, MySQL...).
+Although without any kind of advanced functionalities (such as geometric operators or reprojections).
+It also supports various output and input formats (GeoRSS, KML, Shapefile).
+
+OGC:"http://www.opengis.org/docs/99-049.pdf"
+
+
+== 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
+
+They can be in 2D, 3DZ, 3DM, and 4D.
+
+On top of this an Envelope class is available, to contain the bounding box of a geometry.
+
+== Installation
+
+To install the latest version, just type:
+
+      gem install nofxx-georuby
+
+
+== Use
+
+
+=== Simple Examples
+
+Creating a 3D Point:
+
+    Point.from_x_y_z(10.0, 20.0, 5.0)
+
+
+Creating a LineString:
+
+     LineString.from_coordinates([[1,1],[2,2]],4326))
+
+
+=== Input and output
+
+These geometries can be input and output in WKB/EWKB/WKT/EWKT format as well as
+the related HexWKB and HexEWKB formats. HexEWKB and WKB are the default form under
+which geometric data is returned respectively from PostGIS and MySql.
+
+GeoRSS Simple, GeoRSS W3CGeo, GeoRSS GML can also be input and output.
+Note that they will not output valid RSS, but just the part strictly concerning
+the geometry as outlined in http://www.georss.org/1/ . Since the model does
+not allow multiple geometries, for geometry collections, only the first geometry
+will be output. Similarly, for polygons, the GeoRSS output will only contain the outer ring.
+As for W3CGeo output, only points can be output, so the first point of the geometry is chosen.
+By default the Simple format is output. Envelope can also be output in these formats:
+The box geometric type is chosen (except for W3CGeo, where the center of the envelope is chose).
+These formats can also be input and a GeoRuby geometry will be created.
+Note that it will not read a valid RSS file, only a geometry string.
+
+On top of that, there is now support for KML output and input.
+As for GeoRSS, a valid KML file will not be output, but only the geometric data.
+Options <tt>:id</tt>, <tt>:extrude</tt>, <tt>:tesselate</tt> and <tt>:altitude_mode</tt> can be given.
+Note that if the <tt>:altitude_mode</tt> option is not passed or set to <tt>clampToGround</tt>,
+the altitude data will not be output even if present. Envelopes output a LatLonAltBox instead of a geometry.
+For the output, the following geometric types are supported : Point, LineString, Polygon.
+
+
+=== SHP reading et writing
+
+Georuby has support for reading ESRI shapefiles (http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf).
+A tool called <tt>shp2sql.rb</tt> is also provided: it shows how to use the SHP reading functionality together
+with the spatial adapter plugin for Rails to import spatial features into MySQL and PostGIS.
+
+Here is an example of Shapefile reading, that goes through all the geometries
+in a file and disaply the values of the attributes :
+
+      require 'geo_ruby/shp'
+
+      ShpFile.open(shpfile) do |shp|
+        shp.each do |shape|
+          geom = shape.geometry #a GeoRuby SimpleFeature
+          att_data = shape.data #a Hash
+          shp.fields.each do |field|
+            puts att_data[field.name]
+          end
+        end
+      end
+
+Support for ESRI shapefile creation and modification has been added as well.
+New shapefiles can be created given a geometry type and specifications for the DBF fields.
+Data can be added and removed from an existing shapefile.
+An update operation is also provided for convenience: it just performs a 'delete' and an 'add',
+which means the index of the modified record will change. Note that once a shapefile has been created,
+GeoRuby does not allow the modification of the schema (it will probably be done in a subsequent version).
+
+Here is an example of how to create a new Shapefile with 2 fields :
+
+      shpfile = ShpFile.create('hello.shp',ShpType::POINT,[Dbf::Field.new("Hoyoyo","C",10),Dbf::Field.new("Boyoul","N",10,0)])
+
+The file is then open for reading and writing.
+
+Here is an example of how to write to a shapefile (created or not with GeoRuby) :
+
+      shpfile = ShpFile.open('places.shp')
+      shpfile.transaction do |tr|
+        tr.add(ShpRecord.new(Point.from_x_y(123.4,123.4),'Hoyoyo' => "AEZ",'Bouyoul' => 45))
+        tr.update(4,ShpRecord.new(Point.from_x_y(-16.67,16.41),'Hoyoyo' => "EatMe",'Bouyoul' => 42))
+        tr.delete(1)
+      end
+      shpfile.close
+
+Note the transaction is just there so the operations on the files can be buffered.
+Nothing happens on the original files until the block has finished executing.
+Calling <tt>tr.rollback</tt> at anytime during the execution will prevent the modifications.
+
+Also currently, error reporting is minimal and it has not been tested that
+thoroughly so caveat emptor and backup before performing any destructive operation.
+
+
+=== GPX Reading
+
+You can read and convert GPX Files to LineString/Polygon:
+
+     gpxfile = GpxFile.open(tour.gpx')
+     gpxfile.as_line_string
+     => GeoRuby::SimpleFeatures::LineString..
+
+=== GeoJSON Support
+Basic GeoJSON support has been implemented per v1.0 of the {spec}[http://geojson.org/geojson-spec.html].
+
+USAGE:
+
+ input - GeoRuby::SimpleFeatures::Geometry.from_geojson(geojson_string)
+ output - call #as_geojson or #to_json on any SimpleFeature Geometry instance
+
+TODO:
+ * Refactor to support extremely large GeoJSON input streams / files. Currently
+   the entire GeoJSON representation must be loaded into memory as a String
+ * Improve srid/crs support on input and add support on output
+ * Implement bounding-box spport per spec on input/output?
+ * Improved / more tests
+
+GeoJSON support implemented by {Marcus Mateus}[http://github.com/marcusmateus] and released courtesy {SimpliTex}[http://simplitex.com].
+
+=== Acknowledgement
+
+The SHP reading part uses the DBF library (http://rubyforge.org/projects/dbf/) by Keith Morrison (http://infused.org).
+Thanks also to Pramukta Kumar and Pete Schwamb for their contributions.
+
+=== License
+
+GeoRuby is released under the MIT license.
+
+
+== Support (Original GeoRuby gem)
+
+Any questions, enhancement proposals, bug notifications or corrections
+can be sent to mailto:guilhem.vellut@gmail.com.
+
+
+=== Changes since the last version
+
+- Writing of ESRI shapefiles
+- Reading of ESRI shapefiles
+- Addition of a small tool to import spatial features in MySQL and PostGIS from a SHP file
+
+
+=== Coming in the next versions
+
+- Schema modification of existing shapefiles
+- More error reporting when writing shapefiles
+- More tests on writing shapefiles ; tests on real-world shapefiles
+- Better shp2sql import tool
+- Documentation

data/Rakefile

@@ -7,11 +7,12 @@ begin
     gem.name = "nofxx-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.email = "georuby@simplitex.com"
     gem.homepage = "http://github.com/nofxx/georuby"
-    gem.authors = ["Guilhem Vellut", "Marcos Piccinini"]
-    gem.add_development_dependency "rspec", ">= 1.2.9"
-    gem.add_development_dependency "dbf", ">= 1.1.2"
+    gem.authors = ["Guilhem Vellut", "Marcos Piccinini", "Marcus Mateus", "Doug Cole"]
+    gem.add_runtime_dependency "json_pure", ">=1.4.6"
+    gem.add_development_dependency "rspec", ">= 2.0.0"
+    gem.add_development_dependency "dbf", ">= 1.2.9"
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"

data/VERSION

@@ -1 +1 @@
-1.7.3
+1.9.0

data/lib/geo_ruby.rb

@@ -16,6 +16,7 @@ require 'geo_ruby/simple_features/geometry_collection'
 require 'geo_ruby/simple_features/envelope'
 require 'geo_ruby/simple_features/geometry_factory'
 require 'geo_ruby/simple_features/georss_parser'
+require 'geo_ruby/simple_features/geojson_parser'
 
 # Include if you need
 # require 'geo_ruby/shp4r/shp'

data/lib/geo_ruby/simple_features/envelope.rb

@@ -50,7 +50,7 @@ module GeoRuby
 
       #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)
+        Point.from_x_y((lower_corner.x + upper_corner.x)/2,(lower_corner.y + upper_corner.y)/2, srid)
       end
 
       #Zoom level

data/lib/geo_ruby/simple_features/ewkb_parser.rb

@@ -27,15 +27,6 @@ module GeoRuby
 
       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
@@ -70,8 +61,21 @@ module GeoRuby
           @srid= @srid || DEFAULT_SRID
         end
 
-        if @parse_options.has_key? @geometry_type
-          @parse_options[@geometry_type].call
+        case @geometry_type
+        when 1
+          parse_point
+        when 2
+          parse_line_string
+        when 3
+          parse_polygon
+        when 4
+          parse_multi_point
+        when 5
+          parse_multi_line_string
+        when 6
+          parse_multi_polygon
+        when 7
+          parse_geometry_collection
         else
           raise EWKBFormatError::new("Unknown geometry type")
         end
@@ -156,12 +160,7 @@ module GeoRuby
       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
+        [hexewkb].pack("H*")
       end
     end
 

data/lib/geo_ruby/simple_features/geojson_parser.rb

@@ -0,0 +1,132 @@
+# GeoJSON parser based on the v1.0 spec at http://geojson.org/geojson-spec.html
+require 'json/pure'
+
+module GeoRuby
+  module SimpleFeatures
+    #Raised when an error in the GeoJSON string is detected
+    class GeojsonFormatError < StandardError
+    end
+
+    # Class added to support geojson 'Feature' objects
+    class GeojsonFeature
+      attr_accessor :geometry, :properties, :id
+      
+      def initialize(geometry, properties = {}, id = nil)
+        @geometry = geometry
+        @properties = properties
+        @id = id
+      end
+
+      def ==(other)
+        if (self.class != other.class)
+          false
+        else
+          (self.id == other.id) && (self.geometry == other.geometry) && (self.properties == other.properties) 
+        end
+      end
+
+      def to_json(options={})
+        output = {}
+        output[:type] = 'Feature'
+        output[:geometry] = geometry
+        output[:properties] = properties
+        output[:id] = id unless id.nil?
+        output.to_json(options)
+      end
+      alias :as_geojson :to_json
+    end
+
+    # Class added to support geojson 'Feature Collection' objects
+    class GeojsonFeatureCollection
+      attr_accessor :features
+
+      def initialize(features)
+        @features = features
+      end
+
+      def ==(other)
+        if (self.class != other.class) || (features.size != other.features.size)
+          return false
+        else
+          features.each_index do |index|
+            return false if self.features[index] != other.features[index]
+          end
+        end
+        true
+      end
+
+      def to_json(options = {})
+        {:type => 'FeatureCollection',
+         :features => features}.to_json(options)
+      end
+      alias :as_geojson :to_json
+    end
+
+
+    class GeojsonParser
+      attr_reader :geometry
+      
+      def parse(geojson, srid=DEFAULT_SRID)
+        @geometry = nil
+        geohash = JSON.parse(geojson)
+        parse_geohash(geohash, srid)
+      end
+
+      private
+
+      def parse_geohash(geohash, srid)
+        srid = srid_from_crs(geohash['crs']) || srid
+        case geohash['type']
+        when 'Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon', 'GeometryCollection'
+          @geometry = parse_geometry(geohash, srid)
+        when 'Feature'
+          @geometry = parse_geojson_feature(geohash, srid)
+        when 'FeatureCollection'
+          @geometry = parse_geojson_feature_collection(geohash, srid)
+        else
+          GeojsonFormatError.new('Unknown GeoJSON type')
+        end
+      end
+      
+      def parse_geometry(geohash, srid)
+        srid = srid_from_crs(geohash['crs']) || srid
+        if geohash['type'] == 'GeometryCollection'
+          parse_geometry_collection(geohash, srid)
+        else
+          klass = GeoRuby::SimpleFeatures.const_get(geohash['type'])
+          klass.from_coordinates(geohash['coordinates'], srid, false, false)
+        end
+      end
+
+      def parse_geometry_collection(geohash, srid)
+        srid = srid_from_crs(geohash['crs']) || srid
+        geometries = geohash['geometries'].map{|g| parse_geometry(g,srid)}
+        GeometryCollection.from_geometries(geometries,srid)
+      end
+
+      def parse_geojson_feature(geohash, srid)
+        srid = srid_from_crs(geohash['crs']) || srid
+        geometry = parse_geometry(geohash['geometry'],srid)
+        GeojsonFeature.new(geometry, geohash['properties'], geohash['id'])
+      end
+
+      def parse_geojson_feature_collection(geohash, srid)
+        srid = srid_from_crs(geohash['crs']) || srid
+        features = []
+        geohash['features'].each do |feature|
+          features << parse_geojson_feature(feature, srid)
+        end
+        GeojsonFeatureCollection.new(features)
+      end
+
+      def srid_from_crs(crs)
+        # We somehow need to map crs to srid, currently only support for EPSG 
+        if crs && crs['type'] == 'OGC'
+          urn = crs['properties']['urn'].split(':')
+          return urn.last if urn[4] == 'EPSG'
+        end
+        return nil
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/geometry.rb

@@ -215,6 +215,14 @@ module GeoRuby#:nodoc:
         end
         return wkt
       end
+      
+      # Some GeoJSON files do not include srid info, so
+      # we provide an optional parameter
+      def self.from_geojson(geojson, srid=DEFAULT_SRID)
+        geojson_parser= GeojsonParser::new
+        geojson_parser.parse(geojson, srid)
+        geojson_parser.geometry
+      end
 
       private
 

data/lib/geo_ruby/simple_features/geometry_collection.rb

@@ -102,6 +102,14 @@ module GeoRuby
         "GEOMETRYCOLLECTION"
       end
 
+      # simple geojson representation
+      # TODO add CRS / SRID support?
+      def to_json(options = {})
+        {:type => 'GeometryCollection',
+         :geometries => self.geometries}.to_json(options)
+      end
+      alias :as_geojson :to_json
+
       #georss simple representation : outputs only the first geometry of the collection
       def georss_simple_representation(options)#:nodoc:
         self[0].georss_simple_representation(options)

data/lib/geo_ruby/simple_features/line_string.rb

@@ -188,6 +188,18 @@ module GeoRuby
         end
       end
 
+      def to_coordinates
+        points.map{|p| p.to_coordinates }
+      end
+      
+      # simple geojson representation
+      # TODO add CRS / SRID support?
+      def to_json(options = {})
+        {:type => 'LineString',
+         :coordinates => self.to_coordinates}.to_json(options)
+      end
+      alias :as_geojson :to_json
+
       #Creates a new line string. Accept an array of points as argument
       def self.from_points(points,srid=DEFAULT_SRID,with_z=false,with_m=false)
         line_string = new(srid,with_z,with_m)