geoweb 0.0.5

data/lib/geoweb.rb

@@ -0,0 +1,26 @@
+#require 'matrix'
+#require 'mathn'
+#require 'bigdecimal'
+#TODO - Procurar Proj4js e Procurar Proj4R(uby)
+
+module GeoWeb
+  DEG_TO_RAD = Math::PI / 180.0
+
+  autoload :Point,            'geoweb/point'
+  autoload :Location,         'geoweb/location'
+  autoload :LatLon,           'geoweb/lat_lon'
+  autoload :Coordinate,       'geoweb/coordinate'
+  autoload :Transformation,   'geoweb/transformation'
+  autoload :Projection,       'geoweb/projection'
+  autoload :Map,              'geoweb/map'
+
+  class << self
+    def deg_to_rad(location)
+      location * [DEG_TO_RAD, DEG_TO_RAD, 1]
+    end
+
+    def rad_to_deg(location)
+      location / [DEG_TO_RAD, DEG_TO_RAD, 1]
+    end
+  end
+end

data/lib/geoweb/coordinate.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+module GeoWeb
+  class Coordinate < Point
+    MAX_ZOOM = 25
+
+    alias row y
+    alias row= y=
+
+    alias column x
+    alias column= x=
+
+    def zoom_to(destination)
+      self.class.new(self.x * 2 ** (destination - self.z),
+                     self.y * 2 ** (destination - self.z),
+                     destination)
+    end
+
+    def zoom_by(distance)
+      self.class.new(self.x * 2 ** distance,
+                     self.y * 2 ** distance,
+                     self.z + distance)
+    end
+
+#    def to_s
+#      "(#{sprintf('%f', @x)}, #{sprintf('%f', @y)}, #{@z})"
+#    end
+
+  end
+end

data/lib/geoweb/lat_lon.rb

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+module GeoWeb
+  class LatLon
+    attr_accessor :lat, :lon
+    alias y lat
+    alias y= lat=
+    alias x lon
+    alias x= lon=
+
+    #If the object respond only to lat and lon, the second parameter can be z
+    #Location.new(lat, lon)
+    #Location.new(obj) - obj.lat and obj.lon
+    #Location.new(obj) - obj.y and obj.x
+    #Location.new(hash) - hash[:lat] and hash[:lon]
+    #Location.new(array) - hash[:lat] and hash[:lon]
+    def initialize(lat_or_object, lon=nil)
+
+      lat = lat_or_object
+      if lon.nil?
+        object = lat_or_object
+        lat, lon = if latlongeable?(object)
+          [object.lat, object.lon]
+        elsif object.respond_to?(:y) and object.respond_to?(:x)
+          [object.y, object.x]
+        elsif object.respond_to?(:to_a)
+          object.to_a.values_at 0, 1
+        elsif object.respond_to?(:to_hash)
+          object.to_hash.values_at :lat, :lon
+        end
+      end
+
+      @lat, @lon = lat, lon
+    end
+
+    def +(other)
+      other = self.class.new(other) unless latlongeable?(other)
+      self.class.new(@lat + other.lat, @lon + other.lon)
+    end
+
+    def -(other)
+      other = self.class.new(other) unless latlongeable?(other)
+      self.class.new(@lat - other.lat, @lon - other.lon)
+    end
+
+    def ==(other)
+      other = self.class.new(other) unless latlongeable?(other)
+      @lat == other.lat and @lon == other.lon
+    end
+
+    # LatLon multiplication. Accepts other LatLon, a Numeric
+    def *(other)
+      if other.kind_of? Numeric
+        self.class.new(@lat.to_f * other.to_f, @lon.to_f * other.to_f)
+      else
+        other = self.class.new(other) unless latlongeable?(other)
+        self.class.new(@lat.to_f * other.lat.to_f, @lon.to_f * other.lon.to_f)
+      end
+    end
+
+    # LatLon division. Accepts other LatLon, a Numeric or an Array
+    def /(other)
+      if other.kind_of? Numeric
+        self.class.new(@lat.to_f./(other.to_f), @lon.to_f./(other.to_f))
+      else
+        other = self.class.new(other) unless latlongeable?(other)
+        self.class.new(@lat.to_f./(other.lat.to_f), @lon.to_f./(other.lon.to_f))
+      end
+    end
+
+    def round!
+      @lat = @lat.round
+      @lon = @lon.round
+      self
+    end
+
+    def round
+      self.clone.round!
+    end
+
+    def abs!
+      @lat = @lat.abs
+      @lon = @lon.abs
+      self
+    end
+
+    def abs
+      self.clone.abs!
+    end
+
+    def to_rad
+      self.class.to_rad(self)
+    end
+
+    def to_deg
+      self.class.to_deg(self)
+    end
+
+    def self.to_rad(latlon)
+      latlon * [GeoWeb::DEG_TO_RAD, GeoWeb::DEG_TO_RAD]
+    end
+
+    def self.to_deg(latlon)
+      latlon / [GeoWeb::DEG_TO_RAD, GeoWeb::DEG_TO_RAD]
+    end
+
+    def to_a
+      [@lat, @lon]
+    end
+
+    def to_hash
+      {:lat => @lat, :lon => @lon}
+    end
+
+    def to_s
+      "(#{sprintf('%f', lat)}, #{sprintf('%f', lon)})"
+    end
+
+    private
+    def latlongeable?(other)
+      other.respond_to?(:lat) and other.respond_to?(:lon)
+    end
+
+  end
+end

data/lib/geoweb/location.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+module GeoWeb
+  class Location < Point
+    alias lat y
+    alias lat= y=
+    alias lon x
+    alias lon= x=
+
+    #If the object respond only to lat and lon, the second parameter can be z
+    #Location.new(lat, lon)
+    #Location.new(obj) - obj.lat and obj.lon
+    #Location.new(obj) - obj.y and obj.x
+    #TODO - Location.new(hash) - hash[:lat] and hash[:lon]
+    def initialize(lon_or_object, lat=nil)
+      lon = lon_or_object
+      if lon.respond_to? :lat and lon.respond_to? :lon
+        lon, lat = lon_or_object.lon, lon_or_object.lat
+        z = lon_or_object.respond_to?(:z) && lon_or_object.z || lat
+      end
+
+      super(lon, lat)
+    end
+
+    def to_rad
+      Location.to_rad(self)
+    end
+
+    def to_deg
+      Location.to_deg(self)
+    end
+
+    def self.to_rad(location)
+      location * [GeoWeb::DEG_TO_RAD, GeoWeb::DEG_TO_RAD, 1]
+    end
+
+    def self.to_deg(location)
+      location / [GeoWeb::DEG_TO_RAD, GeoWeb::DEG_TO_RAD, 1]
+    end
+
+    def self.from_lat_lon(lat, lon)
+      self.new(lon, lat)
+    end
+
+    def to_s
+      "(#{sprintf('%f', lat)}, #{sprintf('%f', lon)})"
+    end
+
+  end
+end

data/lib/geoweb/map.rb

@@ -0,0 +1,98 @@
+module GeoWeb
+
+  class Map
+    attr_accessor :projection, :zoom #, :transformation
+    attr_accessor :boundaries
+    attr_accessor :tile_width, :tile_height
+
+    # Calculates the map-size (width or height) given a tile size and specific zoom
+    def self.map_extent(zoom, tile_size=256)
+      2 ** (zoom + Math::log(tile_size)/Math::log(2))
+    end
+
+    def initialize(options={})
+      @tile_width = options[:tile_width] || 256
+      @tile_height = options[:tile_height] || 256
+      @zoom = options[:zoom] || 1
+      @boundaries = options[:boundaries] || {}
+
+      @origin_tile = options[:origin_tile] || Coordinate.new(0, 0, @zoom)
+      @origin_pixel = options[:origin_pixel] || Point.new(0, 0, @zoom)
+#      @dimensions = Point.new(map_extent(@zoom, @tile_width), map_extent(@zoom, @tile_height))
+
+#      @transformation = options[:transformation] || default_transformation
+      @projection = options[:projection] || default_mercator_projection(options[:transformation])
+    end
+
+    #SAME AS DIMENSIONS, retirar isso
+    def width; @width ||= GeoWeb::Map.map_extent(zoom, tile_width); end
+    def height; @height ||= GeoWeb::Map.map_extent(zoom, tile_height); end
+
+    def relative_point(point)
+      (point - @origin_pixel)
+    end
+    
+    def absolute_point(offset)
+      (@origin_pixel + offset)
+    end
+
+    # Return an x, y point on the map image for a given geographical location.
+    def location_point(location)
+      coord = projection.location_coordinate(location).zoom_to(zoom)
+      point = (coord - @origin_tile) * [@tile_width, @tile_height]
+      return absolute_point(point)
+    end
+
+    # Faster, but is accurate only to zoom levels lesser than 17
+    def coordinates_to_point(location)
+      lat, lon = location.lat, location.lon
+
+      #Parece que ele faz isso pra representar como uma fração (sem sinal) de 2Pi
+      #http://en.wikipedia.org/wiki/Longitude#Noting_and_calculating_longitude
+      long_deg = (-180.0 - lon).abs
+      long_ppd = width.to_f / 360.0
+      long_ppdrad = width.to_f / (2.0 * Math::PI)
+      px_x = long_deg * long_ppd
+
+      e = Math::sin( lat * (1.0/180.0 * Math::PI) )
+      e = 0.9999 if e > 0.9999
+      e = -0.9999 if e < -0.9999
+      px_y = (height / 2.0) + 0.5 * Math::log((1+e)/(1-e)) * (-long_ppdrad)
+
+      return absolute_point(Point.new(px_x, px_y, zoom))
+    end
+
+    # Return a geographical location on the map image for a given x, y point.
+    def point_location(point)
+        # origin tile at maximum zoom
+        hizoom_origin_tile = @origin_tile.zoom_to(Coordinate::MAX_ZOOM)
+
+        # distance in tile widths from reference tile to point
+        tiles_distance = relative_point(point) / [@tile_width, @tile_height]
+
+        # distance in rows & columns at maximum zoom
+        distance = Coordinate.new(tiles_distance.x, tiles_distance.y, zoom).zoom_to(Coordinate::MAX_ZOOM)
+        distance.z = 0
+
+        # absolute tile at maximum zoom
+        tile = (hizoom_origin_tile + distance).round!
+        tile = tile.zoom_to(zoom)
+
+        location = projection.coordinate_location(tile)
+        return location
+    end
+
+    private
+    def default_mercator_projection(transformation)
+      transformation ||= default_transformation
+      GeoWeb::Projection::Mercator.new(26, transformation)
+    end
+
+    def default_transformation
+      # see: http://modestmaps.mapstraction.com/trac/wiki/TileCoordinateComparisons#TileGeolocations
+      GeoWeb::Transformation.new(1.068070779e7, 0.0, 3.355443185e7, 0.0, -1.068070890e7, 3.355443057e7)
+    end
+
+  end
+
+end

data/lib/geoweb/point.rb

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+module GeoWeb
+  class Point
+    attr_accessor :x, :y, :z
+
+    # ClassMethods
+    class << self
+      def from_hash(coord)
+        self.new(coord[:x], coord[:y], coord[:z])
+      end
+
+      def from_array(coord)
+        self.new(coord[0], coord[1], coord[2])
+      end
+    end
+
+    #If the object respond only to x and y, the second parameter can be z
+    #Point.new(x, y)
+    #Point.new(obj) - obj.x and obj.y and obj.z
+    #Point.new(obj, z) - obj.x and obj.y
+    #TODO - Point.new(hash) - hash[:x] and hash[:y] and hash[:z]
+    #TODO - Point.new(hash, z) - hash[:x] and hash[:y]
+    def initialize(x_or_object, y=nil, z=nil)
+      x = x_or_object
+      if x_or_object.respond_to? :x and x_or_object.respond_to? :y
+        x, y = x_or_object.x, x_or_object.y
+        z = x_or_object.respond_to?(:z) && x_or_object.z || y
+      end
+      @x, @y, @z = x, y, z
+    end
+
+    def round!
+      @x = @x.round
+      @y = @y.round
+      @z = @z && @z.round
+      self
+    end
+
+    def round
+      self.clone.round!
+    end
+
+    # Spatial sum (sums x, y and z)
+    def +(other)
+      self.class.new(self.x + other.x, self.y + other.y, self.z.to_i + other.z.to_i)
+    end
+
+    # Planar sum (sums x and y)
+    def |(other)
+#      new_z = self.z unless self.z != other.z
+      self.class.new(self.x + other.x, self.y + other.y, self.z)
+    end
+
+    def -(other)
+      self.class.new(self.x - other.x, self.y - other.y, self.z.to_i - other.z.to_i)
+    end
+
+    def ==(other)
+      self.class.x == other.x and self.y == other.y and self.z.to_i == other.z.to_i
+    end
+
+    # Point multiplication. Accepts other point, a Numeric or an Array
+    def *(other)
+      if other.respond_to? :x and other.respond_to? :y and other.respond_to? :z
+        self.class.new(self.x.to_f * other.x.to_f, self.y.to_f * other.y.to_f, self.z.to_f * other.z.to_f)
+      elsif other.respond_to? :to_a
+        self * self.class.from_array(other.to_a)
+      else
+        self.class.new(self.x.to_f * other.to_f, self.y.to_f * other.to_f, self.z.to_f * other.to_f)
+      end
+    end
+
+    # Point division. Accepts other point, a Numeric or an Array
+    def /(other)
+#      self.class.new(self.x / num, self.y / num, self.z)
+      if other.respond_to? :x and other.respond_to? :y and other.respond_to? :z
+        self.class.new(self.x.to_f / other.x.to_f, self.y.to_f / other.y.to_f, self.z.to_f / other.z.to_f)
+      elsif other.respond_to? :to_a
+        self / self.class.from_array(other.to_a)
+      else
+        self.class.new(self.x.to_f / other.to_f, self.y.to_f / other.to_f, self.z.to_f / other.to_f)
+      end
+    end
+
+    def to_s
+      "(#{sprintf('%f', @x)}, #{sprintf('%f', @y)}, #{@z})"
+    end
+
+    def to_a
+      [@x, @y, @z]
+    end
+
+    def to_hash
+      {:x => @x, :y => @y, :z => @z}
+    end
+
+  end
+end

data/lib/geoweb/projection.rb

@@ -0,0 +1,7 @@
+module GeoWeb
+  module Projection
+    autoload :Base,       'geoweb/projection/base'
+    autoload :Linear,     'geoweb/projection/linear'
+    autoload :Mercator,   'geoweb/projection/mercator'
+  end
+end

data/lib/geoweb/projection/base.rb

@@ -0,0 +1,42 @@
+module GeoWeb
+  module Projection
+
+    class Base
+      attr_accessor :zoom, :transformation
+
+      def initialize(zoom, t=Transformation.new(1, 0, 0, 0, 1, 0))
+        @zoom = zoom
+        @transformation = t
+      end
+
+      def raw_project(point); nil; end
+      def raw_unproject(point); nil; end
+
+      def project(point)
+        point = self.raw_project(point)
+        point = transformation.transform(point) unless transformation.nil?
+        point
+      end
+
+      def unproject(point)
+        point = transformation.untransform(point) unless transformation.nil?
+        point = self.raw_unproject(point)
+        point
+      end
+
+      def location_coordinate(latlon)
+        point = self.project(latlon.to_rad)
+        Coordinate.new(point.x, point.y, self.zoom)
+      end
+
+      def coordinate_location(coordinate)
+        coordinate = coordinate.zoom_to(self.zoom)
+        point = Point.new(coordinate.x, coordinate.y)
+        point = self.unproject(point)
+        LatLon.new(point).to_deg
+      end
+
+    end
+
+  end  
+end

data/lib/geoweb/projection/linear.rb

@@ -0,0 +1,15 @@
+module GeoWeb
+  module Projection
+
+    class Linear < Base
+      def raw_project(point)
+        point.clone
+      end
+
+      def raw_unproject(point)
+        point.clone
+      end
+    end
+
+  end
+end

data/lib/geoweb/projection/mercator.rb

@@ -0,0 +1,21 @@
+module GeoWeb
+  module Projection
+
+    #Mercator OR CylindricMercator?
+    class Mercator < Base
+
+      # OK
+      def raw_project(point)
+        Point.new(point.x,
+                  Math::log(Math::tan(0.25 * Math::PI + 0.5 * point.y)))
+      end
+
+      # OK
+      def raw_unproject(point)
+        Point.new(point.x,
+                  2 * Math::atan(Math::E ** point.y) - 0.5 * Math::PI)
+      end
+    end
+
+  end
+end

data/lib/geoweb/transformation.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+module GeoWeb
+  class Transformation
+    attr_reader :ax, :bx, :cx, :ay, :by, :cy
+
+    def initialize(ax, bx, cx, ay, by, cy)
+      @ax, @bx, @cx, @ay, @by, @cy = ax, bx, cx, ay, by, cy
+    end
+
+    # Transforms a point
+    def transform(point)
+      return Point.new(self.ax * point.x + self.bx * point.y + self.cx,
+                   self.ay * point.x + self.by * point.y + self.cy)
+    end
+
+    # Inverse of transform
+		def untransform(point)
+		  Point.new((point.x*by - point.y*bx - cx*by + cy*bx) / (ax*by - ay*bx),
+		            (point.x*ay - point.y*ax - cx*ay + cy*ax) / (bx*ay - by*ax))
+		end
+
+    def to_s
+      "T([#{ax},#{bx},#{cx}][#{ay},#{by},#{cy}])"
+    end
+
+    # Generates a transform based on three pairs of points, a1 -> a2, b1 -> b2, c1 -> c2.
+    def self.deriveTransformation(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y, c1x, c1y, c2x, c2y)
+      ax, bx, cx = linearSolution(a1x, a1y, a2x, b1x, b1y, b2x, c1x, c1y, c2x)
+      ay, by, cy = linearSolution(a1x, a1y, a2y, b1x, b1y, b2y, c1x, c1y, c2y)
+
+      self.new(ax, bx, cx, ay, by, cy)
+    end
+
+    # Solves a system of linear equations.
+    #
+    #  t1 = (a * r1) + (b + s1) + c
+    #  t2 = (a * r2) + (b + s2) + c
+    #  t3 = (a * r3) + (b + s3) + c
+    #
+    # r1 - t3 are the known values.
+    # a, b, c are the unknowns to be solved.
+    # returns the a, b, c coefficients.
+    def self.linearSolution(r1, s1, t1, r2, s2, t2, r3, s3, t3)
+      # make them all floats
+      r1, s1, t1, r2, s2, t2, r3, s3, t3 = [r1, s1, t1, r2, s2, t2, r3, s3, t3].map{|n| n.to_f}
+
+      a = (((t2 - t3) * (s1 - s2)) - ((t1 - t2) * (s2 - s3))) \
+        / (((r2 - r3) * (s1 - s2)) - ((r1 - r2) * (s2 - s3)))
+
+      b = (((t2 - t3) * (r1 - r2)) - ((t1 - t2) * (r2 - r3))) \
+        / (((s2 - s3) * (r1 - r2)) - ((s1 - s2) * (r2 - r3)))
+
+      c = t1 - (r1 * a) - (s1 * b)
+      
+      return a, b, c
+    end
+
+  end
+end

data/spec/core/lat_lon_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe LatLon do
+  
+  describe :initialize do
+  
+    before(:all) do
+      @lat = -17.4727215168151
+      @lon = -40.6738941939658
+    end
+  
+    it "should accept latitude and longitude" do
+      @latlon = LatLon.new(@lat, @lon)
+      @latlon.lat.should == @lat
+      @latlon.lon.should == @lon
+    end
+
+    it "should accept an object with :lat and :lon methods" do
+      lat_lon_object = double("array input")
+      lat_lon_object.stub(:respond_to?).with(any_args()).and_return(false)
+
+      lat_lon_object.should_receive(:respond_to?).with(:lat).and_return(true)
+      lat_lon_object.should_receive(:respond_to?).with(:lon).and_return(true)
+
+      lat_lon_object.should_receive(:lat).and_return(@lat)
+      lat_lon_object.should_receive(:lon).and_return(@lon)
+
+      @latlon = LatLon.new(lat_lon_object)
+      @latlon.lat.should == @lat
+      @latlon.lon.should == @lon
+    end
+    
+    it "should accept an object with :x and :y methods" do
+      xy_object = double("xy object input")
+      xy_object.stub(:respond_to?).with(any_args()).and_return(false)
+
+      xy_object.should_receive(:respond_to?).with(:y).and_return(true)
+      xy_object.should_receive(:respond_to?).with(:x).and_return(true)
+
+      xy_object.should_receive(:y).and_return(@lat)
+      xy_object.should_receive(:x).and_return(@lon)
+
+      @latlon = LatLon.new(xy_object)
+      @latlon.lat.should == @lat
+      @latlon.lon.should == @lon
+      
+    end
+
+    it "should accept an Array with two values" do
+      array_or_object = double("array input")
+      array_or_object.stub(:respond_to?).with(any_args()).and_return(false)
+
+      array_or_object.should_receive(:respond_to?).with(:to_a).and_return(true)
+      array_or_object.should_receive(:to_a).and_return([@lat, @lon])
+
+      @latlon = LatLon.new(array_or_object)
+      @latlon.lat.should == @lat
+      @latlon.lon.should == @lon
+    end
+    
+    it "should accept a Hash with :lat and :lon keys" do
+      hash_or_object = double("hash input")
+      hash_or_object.stub(:respond_to?).with(any_args()).and_return(false)
+
+      hash_or_object.should_receive(:respond_to?).with(:to_hash).and_return(true)
+      hash_or_object.should_receive(:to_hash).and_return({:lat => @lat, :lon => @lon})
+
+      @latlon = LatLon.new(hash_or_object)
+      @latlon.lat.should == @lat
+      @latlon.lon.should == @lon
+    end
+
+  end  
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+#require 'rubygems'
+#require 'spec'
+#gem 'activerecord', '=2.3.5'
+#gem 'activerecord', '=3.0.0.beta3'
+#require 'active_record'
+
+$:.unshift((File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'geoweb'
+
+include GeoWeb
+

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: geoweb
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
+platform: ruby
+authors: 
+- Reinaldo de Souza Junior
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-16 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: 
+email: juniorz@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/geoweb.rb
+- lib/geoweb/projection.rb
+- lib/geoweb/lat_lon.rb
+- lib/geoweb/coordinate.rb
+- lib/geoweb/projection/linear.rb
+- lib/geoweb/projection/base.rb
+- lib/geoweb/projection/mercator.rb
+- lib/geoweb/location.rb
+- lib/geoweb/map.rb
+- lib/geoweb/point.rb
+- lib/geoweb/transformation.rb
+- spec/spec_helper.rb
+- spec/core/lat_lon_spec.rb
+- README
+has_rdoc: true
+homepage: http://reinaldojunior.net
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: GeoWeb is a Ruby Geographic Web Library
+test_files: []
+