terragona 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88715c69977bde03e32967c508e4f4a519fecd03
-  data.tar.gz: e3fc05839b11f705c3e38ddac17bff854fadb179
+  metadata.gz: bacfcba592bdf78f9891f8065d8f9e8172fe049c
+  data.tar.gz: 9c8baebb11ad0b66b27635bab3c1c2bd918e4902
 SHA512:
-  metadata.gz: bc40ce6a147fdfa8e55eb838b6f1f911a68b821b2e59dfda30618c2b2738c9fbbd8048afacc0eacac8c01ad7851e427d678c30cc3108bf7c686e8792d02c5399
-  data.tar.gz: 069423d4fee2ca209821cae9d2e1d43626e2e90b0dbe66a9edb0c8ee7fb1d1550dc297c338296a2d788fbaa737ce926ef409f7d20ea05ba6359c2429db37a891
+  metadata.gz: 21c854dbc451bf049243d910ee0276c4214583a1f97695f81bd7ec522058c53fe0577a284c3fe3f0c7740442f795702181d77acd5f7d9690d3adb90f02a54c3d
+  data.tar.gz: b693d2a52d5481d861fe279b158b41b9d31da88cde5a4155053146d743697c96bcc1f2b1cda3c6c1f949c8d67668cea3685bc3be0ad7d76d7627dbcfbe348fc6

data/README.md

@@ -1,8 +1,8 @@
 terragona
 =========
 
-Create polygons for [GeoNames](http://www.geonames.org) places.
-This means: Create concave polygons using geonames places and store them in a postgres/postgis database.
+Create polygons from [GeoNames](http://www.geonames.org) places or other sources.
+This means: Create concave polygons using, i.e., geonames places and store them in a postgres/postgis database.
 See [ST_Concave_Hull](http://postgis.net/docs/ST_ConcaveHull.html).
 
 ![alt tag](https://cloud.githubusercontent.com/assets/6061036/5606205/2216ff3c-9402-11e4-9123-fff91369208e.png)
@@ -19,17 +19,25 @@ Install
 
 or add `gem 'terragona'` to your Gemfile
 
+News
+----
+
+* Classes API and Dump are now nested inside a `Geonames` class.
+
 Usage
 -----
 
 First, create a db in postgres and install the postgis extension.
 
-You can use the GeoNames API, with the Terragona::API class, or download
-a dump, (Terragona::Dump class) and specify the dump file path in opts. The API is faster 
-but less accurate (max 1000 points per request). The dump is more accurate but much slower (please, 
-use country dumps, not the world dump: it's to big -~9 million points- and could take lots of time.). For example:
-with the API, the Italy polygon is drawn using 1000 points. With the dump, the input is ~95.000 points. 
-You can use the `max_points` option to limit this number.
+Right now, as sources you can use:
+* GeoNames API, with the `Terragona::Geonames::API` class,
+* A Geonames dump, (`Terragona::Geonames::Dump` class) and specify the dump file path in opts. 
+* A CSV (`Terragona::CSVParser` class) (with headers: `name,x,y`)
+
+The API is faster but less accurate than the dump (max 1000 points per request). 
+The dump is more accurate but much slower (please, use country dumps, not the world dump: it's to big 
+-~9 million points- and could take lots of time.). For example: with the API, the Italy polygon is drawn 
+using 1000 points. With the dump, the input is ~95.000 points. You can use the `max_points` option to limit this number.
 
 The slow part of the process is when points are filtered: the ones that are isolated are discarded. 
 This has to be refactored.
@@ -46,13 +54,12 @@ opts = {...}
 countries=[{:name=>'Argentina',:fcode=>'PCLI',:country=>'AR'},
            {:name=>'Uruguay',:fcode=>'PCLI',:country=>'UY'}]
 
-terragona = Terragona::API.new(opts)
+terragona = Terragona::Geonames::API.new(opts)
 terragona.create_polygons_family(countries, 'countries', 'countries_subdivisions')
 
 ```
 
 With Dump, and using returned children places
-
 ```ruby
 require 'terragona'
 
@@ -67,16 +74,36 @@ opts={
 
 italy=[{:name=>'Italy',:fcode=>'PCLI'}]
 
-terragona=Terragona::Dump.new(opts)
-result=terragona.create_polygons_family(italy,'italy','italian_regions')
+terragona = Terragona::Geonames::Dump.new(opts)
+result = terragona.create_polygons_family(italy,'italy','italian_regions')
 
-italian_rest=[]
+italian_rest = []
 result.each {|r|
 	italian_rest.concat(r[:children_places])
 }
 terragona.create_polygons_family(italian_rest,'province','comuni')
 ```
 
+With the CSVParser class
+
+```ruby
+require 'terragona'
+
+opts={
+	:target_percent=> 0.85,
+	:max_distance_ratio=>1.6,
+	:db_username=>'mydbuser',
+	:db_password=>'mydbpsswd',
+	:db_name=>'mydb',
+	:csv_filename=>'/path/to/csv/IT.csv'}
+
+italy=[] #Don't need input but the csv.
+
+terragona = Terragona::CSVParser.new(opts)
+terragona.create_polygons_family(italy,'italy','italian_regions')
+
+```
+
 Methods
 -------
 
@@ -86,6 +113,9 @@ create_polygons(<array of places>, options)
 create_polygons_family(<array of places>, <first order geometries table name>, <second order geometries table name>, options)
 ```
 
+Important: **With the CSVParser class the initial array of places is not used**. 
+Terragona tries to create the parent polygon using all points.
+
 Each place in the array of places is a hash with this keys:
 
 ```
@@ -110,10 +140,11 @@ Options
 ```
 dump                    Only for Dump. Path to dump file.
 max_points              Only for Dump. Max number of points to consider from
-                        dump file.            
-default_country         Default country.
+                        dump file.
+csv_filename            Only for CSV.
+default_country         Default country. Only for Geonames.
 geonames_username       Only for API. Geonames API username.
-use_cache               Boolean. Default: false.    
+use_cache               Boolean. Default: false.
 cache_expiration_time   Default: 7200.
 projection              Default: EPSG 4326 (WGS84).
 target_percent          Require to draw the concave polygons. 

data/lib/terragona/base.rb

@@ -1,3 +1,4 @@
+require_relative './generic'
 require_relative './geonames'
 require_relative './concave_hull'
 require_relative './version'
@@ -12,23 +13,20 @@ module Terragona
     def create_polygons(names,options={})
       opts=@options.merge(options)
 
-      concave_hull = ConcaveHull.new(opts) if not opts[:dont_create_polygons]
+      concave_hull = ConcaveHull.new(opts)
 
-      names.map{|n|
-        name = @geonames.search(n)
-
-        if name[:points].count < @minimal_polygon_points
-          puts "No points for #{n[:name]}"
-          next
-        end
+      if (!names or names.empty?) and @input.class == Generic::CSVParser
+        n = {:name => 'CSV'}
+        name = @input.search(n)
+        process_points(n,name,concave_hull,opts)
+        return [name]
+      end
 
-        unless opts[:dont_create_polygons]
-          if concave_hull.perform(name[:points],name[:place_name],name[:place_id])
-            puts "Polygon created for #{n[:name]}"
-          end
-        end
+      names.map{|n|
+        name = @input.search(n)
+        next unless process_points(n,name,concave_hull,opts)
         name
-      }
+      }.compact
     end
 
     def create_polygons_family(names,parents_table,children_table,opts={})
@@ -39,20 +37,49 @@ module Terragona
       }
       create_polygons(children,opts.merge({:table => children_table}))
     end
+
+    private
+    def process_points(n, name, concave_hull, opts)
+      if name[:points].count < @minimal_polygon_points
+        puts "No points for #{n[:name]}"
+        return
+      end
+
+      unless opts[:dont_create_polygons]
+        if concave_hull.perform(name[:points],name[:place_name],name[:place_id])
+          puts "Polygon created for #{n[:name]}"
+        end
+      end
+
+      # Thought the polygon might have not been created, we return true
+      # (so we retrieve it's children). The only case where we don't want the children is if
+      # there are no enough points.
+
+      true
+
+    end
   end
-  
-  class API < Base
-    def initialize (options={})
-      super
-      @geonames = GeoNames::API.new(options) 
+
+  class Geonames
+    class API < Base
+      def initialize (options={})
+        super
+        @input = GeoNames::API.new(options)
+      end
+    end
+
+    class Dump < Base
+      def initialize (options={})
+        super
+        @input = GeoNames::Dump.new(options)
+      end
     end
   end
-  
-  class Dump < Base
+
+  class CSVParser < Base
     def initialize (options={})
       super
-      @geonames = GeoNames::Dump.new(options) 
+      @input = Generic::CSVParser.new(options)
     end
   end
-  
 end

data/lib/terragona/concave_hull.rb

@@ -59,10 +59,6 @@ module Terragona
         puts "Error with #{tags}, Id: #{id}, #{count} points."
       end
     end
-    
-    def drop_points_table(table)
-      @db << "DROP TABLE IF EXISTS #{table};"
-    end
 
     def filter_points_by_distance(points)     
       random_points = points.count > 200 ? (0..200).map {|e|
@@ -92,7 +88,7 @@ module Terragona
     end
 
     def clean_str(str)
-      str.gsub("'",' ')
+      str.to_s.gsub("'",' ')
     end
   end
 end

data/lib/terragona/generic.rb

@@ -0,0 +1,41 @@
+require 'csv'
+
+module Terragona
+  module Generic
+    class CSVParser
+      def initialize(args = {})
+        filename = args[:csv_filename]
+
+        abort "Missing CSV filename. Aborting." unless filename
+
+        @csv = CSV.table(filename)
+        @id_counter = 0
+      end
+      def search(options = {})
+        @id_counter +=1
+
+        name = options[:name]
+
+        points = []
+
+        if name == 'CSV'
+          children = []
+
+          @csv.each {|p|
+            points.push({:x => p[:x], :y => p[:y]})
+            children.push({:name => p[:name]})
+          }
+
+          children.uniq!
+
+          children_places = (children.count > 1 )? children : []
+        else
+          @csv.select{|row| row[:name] == name}.each {|p| points.push({:x => p[:x], :y => p[:y]})}
+          children_places = []
+        end
+
+        {:children_places=>children_places, :points => points, :place_name=> name, :place_id=>@id_counter}
+      end
+    end
+  end
+end

data/lib/terragona/version.rb

@@ -1,3 +1,3 @@
 module Terragona
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: terragona
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Bruno Salerno
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-16 00:00:00.000000000 Z
+date: 2015-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -151,6 +151,7 @@ files:
 - lib/terragona.rb
 - lib/terragona/base.rb
 - lib/terragona/concave_hull.rb
+- lib/terragona/generic.rb
 - lib/terragona/geonames.rb
 - lib/terragona/version.rb
 - terragona.gemspec