hexagonly 0.1.0

data/lib/hexagonly/point.rb

@@ -0,0 +1,113 @@
+module Hexagonly
+  class Point
+
+    # Adds Point methods to an object. Any Point bears x and y coordinates,
+    # returned by the #x and #y methods. You can either override these methods
+    # to output your desired coordinates or you can map coordinate readers to 
+    # different method names by using the #x_y_coord_methods, #x_coord_method or 
+    # #y_coord_method methods.
+    #
+    # @example
+    #   class MyPoint
+    #     
+    #     include Hexagonly::Point::Methods
+    #     # The x coordinate will be read from #a and the y coordinate will be read from #b
+    #     x_y_coord_methods :a, :b
+    #     
+    #     attr_accessor :a, :b
+    #     def initialize(a, b); @a, @b = a, b; end
+    #     
+    #   end
+    #   
+    #   p = MyPoint.new(1, 2)
+    #   p.x_coord # => 1
+    #   p.y_coord # => 2
+    module Methods
+
+      include Comparable
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        attr_accessor :x_coord_method_name, :y_coord_method_name
+
+        def x_coord_method(x_method)
+          self.x_coord_method_name = x_method.to_sym
+        end
+
+        def y_coord_method(y_method)
+          self.y_coord_method_name = y_method.to_sym
+        end
+
+        def x_y_coord_methods(x_method, y_method)
+          x_coord_method(x_method)
+          y_coord_method(y_method)
+        end
+      end
+
+      def x_coord
+        send(self.class.x_coord_method_name || 'x')
+      end
+
+      def x_coord=(value)
+        send("#{self.class.x_coord_method_name || 'x'}=", value)
+      end
+
+      def y_coord
+        send(self.class.y_coord_method_name || 'y')
+      end
+
+      def y_coord=(value)
+        send("#{self.class.y_coord_method_name || 'y'}=", value)
+      end
+
+      # Sets the coordinates for the current Point.
+      #
+      # @param x [Float]
+      # @param y [Float]
+      def set_coords(x, y)
+        self.x_coord = x
+        self.y_coord = y
+      end
+
+      def <=>(another_point)
+        if x_coord == another_point.x_coord && y_coord == another_point.y_coord
+          0
+        elsif x_coord > another_point.x_coord
+          1
+        else
+          -1
+        end
+      end
+
+      # Enable implicit splat.
+      # def to_ary
+      #   [x_coord, y_coord]
+      # end
+
+      def to_geojson
+        {
+          :type => "Feature",
+          :geometry => {
+            :type => "Point",
+            :coordinates => [x_coord, y_coord]
+          },
+          :properties => nil
+        }
+      end
+
+    end
+
+  include Methods
+
+  attr_accessor :x, :y
+  
+  # (see #set_coords)
+  def initialize(*coords)
+    set_coords(*coords) if coords.size == 2
+  end
+
+  end
+end

data/lib/hexagonly/polygon.rb

@@ -0,0 +1,94 @@
+module Hexagonly
+  class Polygon
+
+    # Adds Polygon methods to an object. The Polygon corners are read via
+    # the #poly_points method. You can override this method or use the 
+    # #poly_points_method class method to set a method name for reading
+    # polygon corners.
+    #
+    # @example
+    #   class MyPolygon
+    #     
+    #     include Hexagonly::Polygon::Methods
+    #     poly_points_method :corners
+    #     
+    #     attr_reader :corners
+    #     def initialize(corners); @corners = corners; end
+    #     
+    #   end
+    module Methods
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        attr_accessor :poly_points_method_name
+
+        def poly_points_method(points_method)
+          self.poly_points_method_name = points_method.to_sym
+        end
+      end
+
+      attr_accessor :collected_points, :rejected_points
+
+      def poly_points
+        raise NoMethodError if self.class.poly_points_method_name.nil?
+
+        send(self.class.poly_points_method_name)
+      end
+
+      # Crossing count algorithm for determining whether a point lies within a 
+      # polygon. Ported from http://www.visibone.com/inpoly/inpoly.c.txt
+      # (original C code by Bob Stein & Craig Yap).
+      def contains?(point)
+        raise "Not a valid polygon!" if poly_points.nil? || poly_points.size < 3
+
+        is_inside = false
+        old_p = poly_points.last
+        poly_points.each do |new_p|
+          if new_p.x_coord > old_p.x_coord
+            first_p = old_p
+            second_p = new_p
+          else
+            first_p = new_p
+            second_p = old_p
+          end
+          if ((new_p.x_coord < point.x_coord) == (point.x_coord <= old_p.x_coord)) && ((point.y_coord - first_p.y_coord) * (second_p.x_coord - first_p.x_coord) < (second_p.y_coord - first_p.y_coord) * (point.x_coord - first_p.x_coord))
+            is_inside = ! is_inside
+          end
+          old_p = new_p
+        end
+
+        is_inside
+      end
+
+      # Grabs all points within the polygon boundries from an array of Points
+      # and appends them to @collected_points. All rejected Points are stored 
+      # under @rejected_points (if you want to pass the to other objects).
+      #
+      # @param points [Array<Hexagonly::Point>]
+      #
+      # @return [Array<Hexagonly::Point] the grabed points
+      def grab(points)
+        parts = points.partition{ |p| contains?(p) }
+        @collected_points ||= []
+        @collected_points += parts[0]
+        @rejected_points = parts[1]
+
+        parts[0]
+      end
+
+    end
+
+    include Methods
+
+    attr_accessor :poly_points
+
+    # @param [Array<Hexagonly::Point>] poly_points the points that make up the polygon
+    def initialize(poly_points)
+      @poly_points = poly_points
+    end
+
+  end
+end

data/lib/hexagonly/space.rb

@@ -0,0 +1,37 @@
+module Hexagonly
+  class Space
+
+    attr_reader :points, :north, :west, :south, :east, :height, :width, :center
+
+    # @param [Array<Hexagonly::Point>] points an array of points that make up the space
+    def initialize(points)
+      @points = points
+      refresh
+    end
+    
+    private
+
+    def refresh
+      compute_boundries
+      compute_center
+    end
+
+    def compute_boundries
+      @north, @west, @south, @east = nil
+      @points.each do |p|
+        @north = p if @north.nil? || @north.y_coord < p.y_coord
+        @west = p if @west.nil? || @west.x_coord > p.x_coord
+        @south = p if @south.nil? || @south.y_coord > p.y_coord
+        @east = p if @east.nil? || @east.x_coord < p.x_coord
+      end
+    end
+
+    def compute_center
+      compute_boundries if @north.nil? || @west.nil? || @south.nil? || @east.nil?
+      @height = @north.y_coord - @south.y_coord
+      @width = @east.x_coord - @west.x_coord
+      @center = Hexagonly::Point.new(@width / 2 + @west.x_coord, @height / 2 + @south.y_coord)
+    end
+
+  end
+end

data/lib/hexagonly/version.rb

@@ -0,0 +1,3 @@
+module Hexagonly
+  VERSION = "0.1.0"
+end

data/lib/hexagonly.rb

@@ -0,0 +1,11 @@
+require 'hexagonly/version'
+
+require 'hexagonly/point'
+require 'hexagonly/space'
+require 'hexagonly/polygon'
+require 'hexagonly/hexagon'
+require 'hexagonly/geo_json'
+
+module Hexagonly
+
+end

data/localities.rb

@@ -0,0 +1,17 @@
+# bundle exec ruby localities.rb | xclip -selection clipboard
+
+require 'hexagonly'
+require 'csv'
+
+localities_csv = CSV.read(File.expand_path('../spec/fixtures/localities.csv', __FILE__))
+
+points = []
+localities_csv.first(1000).each do |row|
+  points << Hexagonly::Point.new(row[2].to_f, row[1].to_f)
+end
+
+hexagons = Hexagonly::Hexagon.pack(points, 0.4, { grab_points: true, reject_empty: true })
+
+geo = Hexagonly::GeoJson.new(hexagons)
+# geo.add_features(points)
+puts geo.to_json

data/spec/factories.rb

@@ -0,0 +1,12 @@
+require 'csv'
+
+FactoryGirl.define do
+  localities_csv = CSV.read(File.expand_path('../fixtures/localities.csv', __FILE__))
+
+  sequence(:x) { |n| localities_csv.size >= n ? localities_csv[n][2].to_f : nil }
+  sequence(:y) { |n| localities_csv.size >= n ? localities_csv[n][1].to_f : nil }
+
+  factory :point, :class => Hexagonly::Point do
+    initialize_with { new(generate(:x), generate(:y)) }
+  end
+end