spherical_mercator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 16bd516923907417c8a6900535ae5492b8e2f028
+  data.tar.gz: 0d75745f7a75eec2b9b563af0461133d6d731831
+SHA512:
+  metadata.gz: c1f7eebc8eea7dfadef4006a775e45dfa40aef3c4e763dcf0a70ddd7bef8f7cfcc38778c33239413fe2f4305a51cee228e36caeabb5b858a3ca41c3e2164b277
+  data.tar.gz: 525366eebcf95f726443b684462c9e702b493e8ac6a26b14cb46e61f2b633383f6b43d08c7a05f36fa9e5d694c78eb8ede60887a516fc9f4dd1279c59af4e815

data/.gitignore

@@ -0,0 +1,53 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+.idea/
+Gemfile.lock
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.rubocop.yml

@@ -0,0 +1,10 @@
+AllCops:
+  Exclude:
+    - 'spec/**/*'
+  DisplayCopNames: true
+Documentation:
+  Enabled: false
+LineLength:
+  Max: 120
+Metrics/ClassLength:
+  Max: 110

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+before_install: gem install bundler
+bundler_args: --without yard guard benchmarks
+script: "rake spec"
+rvm:
+  - 2.0.0
+  - 2.2.4
+  - 2.3.3
+  - 2.4.0
+  - jruby-9.0.5.0
+  - jruby-9.1.5.0
+  - jruby-9.1.6.0
+  - ruby-head
+env: JRUBY_OPTS="$JRUBY_OPTS --debug"
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'coveralls', require: false
+  gem 'rspec', '~> 3.6'
+  gem 'simplecov'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Nikita Bulai
+
+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 sell
+copies of the Software, and to 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.md

@@ -0,0 +1,110 @@
+# Ruby port of Mapbox Spherical Mercator
+[![Gem Version](https://badge.fury.io/rb/spherical_mercator.svg)](http://badge.fury.io/rb/spherical_mercator)
+[![Build Status](https://travis-ci.org/nbulaj/spherical_mercator.svg?branch=master)](https://travis-ci.org/nbulaj/spherical_mercator)
+[![Dependency Status](https://gemnasium.com/nbulaj/spherical_mercator.svg)](https://gemnasium.com/nbulaj/spherical_mercator)
+[![Coverage Status](https://coveralls.io/repos/github/nbulaj/spherical_mercator/badge.svg)](https://coveralls.io/github/nbulaj/spherical_mercator)
+[![License](http://img.shields.io/badge/license-MIT-brightgreen.svg)](#license)
+
+Spherical Mercator gem is a port of [Mapbox sphericalmercator JS lib](https://github.com/mapbox/sphericalmercator) that provides projection math
+for converting between mercator meters, screen pixels (of 256x256 or configurable-size tiles), and latitude/longitude.
+
+## Requirements
+
+* Ruby >= 2.0
+
+## Installation
+
+Simple:
+
+`gem install spherical_mercator`
+
+For Gemfile:
+
+`gem 'spherical_mercator'`
+
+## API
+
+_NOTE_: API description copied from the original repo.
+
+Some datatypes are assumed to be arrays: `ll` is `[lon, lat]`, `xy` and `px` are
+`[x, y]`.
+
+```ruby
+# By default, precomputes up to z30
+mercator = SphericalMercator.new(size: 256)
+```
+
+### `px(lon_lat, zoom)`
+
+Convert lon, lat to screen pixel x, y from 0, 0 origin, at a certain zoom level.
+The inverse of `ll`
+
+### `ll(px, zoom)`
+
+Convert screen pixel value to lon, lat, at a certain zoom level. The inverse
+of `px`
+
+### `bbox(x, y, zoom, tms_style, srs)`
+
+Convert tile xyz value to bbox of the form `[w, s, e, n]`
+
+* `x` {Number} x (longitude) number.
+* `y` {Number} y (latitude) number.
+* `zoom` {Number} zoom.
+* `tms_style` {Boolean} whether to compute using tms-style. (optional, default `false`)
+* `srs` {String} projection for resulting bbox ('WGS84'|'900913'). (optional, default 'WGS84')
+
+Returns bbox array of values in form `[w, s, e, n]`.
+
+### `xyz(bbox, zoom, tms_style, srs)`
+
+Convert bbox to xyz bounds
+
+* `bbox` {Number} bbox in the form `[w, s, e, n]`.
+* `zoom` {Number} zoom.
+* `tms_style` {Boolean} whether to compute using tms-style. (optional, default `false`)
+* `srs` {String} projection of input bbox ('WGS84'|'900913'). (optional, default 'WGS84')
+
+Returns {Object} XYZ bounds containing minX, maxX, minY, maxY properties.
+
+### `convert(bbox, to)`
+
+Convert bbox from 900913 to WGS84 or vice versa
+
+* `bbox` {Number} bbox in the form `[w, s, e, n]`.
+* `to` {String} projection of resulting bbox ('WGS84'|'900913'). (optional, default 'WGS84')
+
+Returns bbox array of values in form `[w, s, e, n]`.
+
+### `forward(lon_lat)`
+
+Convert lon, lat values to mercator x, y
+
+### `inverse(xy)`
+
+Convert mercator x, y values to lon, lat
+
+## Contributing
+
+You are very welcome to help improve spherical_mercator if you have suggestions for features that other people can use.
+
+To contribute:
+
+1. Fork the project.
+2. Create your feature branch (`git checkout -b my-new-feature`).
+3. Implement your feature or bug fix.
+4. Add documentation for your feature or bug fix.
+5. Run <tt>rake doc:yard</tt>. If your changes are not 100% documented, go back to step 4.
+6. Add tests for your feature or bug fix.
+7. Run `rake` to make sure all tests pass.
+8. Commit your changes (`git commit -am 'Add new feature'`).
+9. Push to the branch (`git push origin my-new-feature`).
+10. Create new pull request.
+
+Thanks.
+
+## License
+
+Spherical Mercator gem is released under the [MIT License](http://www.opensource.org/licenses/MIT).
+
+Copyright (c) 2017 Nikita Bulai (bulajnikita@gmail.com) and [original lib authors](https://github.com/mapbox/sphericalmercator/graphs/contributors).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/spherical_mercator.rb

@@ -0,0 +1,180 @@
+require 'spherical_mercator/version'
+
+class SphericalMercator
+  attr_reader :options
+  # Closures including constants and other precalculated values.
+
+  EPSLN = 1.0e-10
+  D2R = Math::PI / 180
+  R2D = 180.0 / Math::PI
+  # 900913 properties.
+  A = 6_378_137.0
+  MAX_EXTENT = 20_037_508.342_789_244
+
+  attr_accessor :size, :cache
+
+  attr_accessor :ac, :bc, :cc, :zc
+
+  # SphericalMercator constructor: precaches calculations
+  # for fast tile lookups.
+  def initialize(opts = {})
+    @cache = {}
+    @options = opts || {}
+
+    self.size = (options[:size] || 256).to_f
+
+    if cache[size].nil?
+      size = self.size
+      c = cache[self.size] = {}
+      c['Bc'] = []
+      c['Cc'] = []
+      c['zc'] = []
+      c['Ac'] = []
+
+      30.times do
+        c['Ac'].push(size.to_i)
+        c['Bc'].push(size / 360)
+        c['Cc'].push(size / (2 * Math::PI))
+        c['zc'].push((size / 2).to_i)
+
+        size *= 2
+      end
+    end
+
+    @ac = cache[self.size]['Ac']
+    @bc = cache[self.size]['Bc']
+    @cc = cache[self.size]['Cc']
+    @zc = cache[self.size]['zc']
+  end
+
+  # Convert lon lat to screen pixel value
+  #
+  # - `ll` {Array} `[lon, lat]` array of geographic coordinates.
+  # - `zoom` {Number} zoom level.
+  def px(lon_lat, zoom)
+    d = @zc[zoom]
+    # JS: Math.min(Math.max(Math.sin(D2R * ll[1]), -0.9999), 0.9999);
+    f = [[Math.sin(D2R * lon_lat[1]), -0.9999].max, 0.9999].min
+    x = (d + lon_lat[0] * @bc[zoom]).round
+    y = (d + 0.5 * Math.log((1 + f) / (1 - f)) * (-@cc[zoom])).round
+    (x > @ac[zoom]) && (x = @ac[zoom])
+    (y > @ac[zoom]) && (y = @ac[zoom])
+
+    # (x < 0) && (x = 0);
+    # (y < 0) && (y = 0);
+    [x, y]
+  end
+
+  # Convert screen pixel value to lon lat
+  #
+  # - `px` {Array} `[x, y]` array of geographic coordinates.
+  # - `zoom` {Number} zoom level.
+  def ll(px, zoom)
+    g = (px[1] - @zc[zoom]) / (-@cc[zoom])
+    lon = (px[0] - @zc[zoom]) / @bc[zoom]
+    lat = R2D * (2 * Math.atan(Math.exp(g)) - 0.5 * Math::PI)
+    [lon, lat]
+  end
+
+  # Convert tile xyz value to bbox of the form `[w, s, e, n]`
+  #
+  # - `x` {Number} x (longitude) number.
+  # - `y` {Number} y (latitude) number.
+  # - `zoom` {Number} zoom.
+  # - `tms_style` {Boolean} whether to compute using tms-style.
+  # - `srs` {String} projection for resulting bbox (WGS84|900913).
+  # - `return` {Array} bbox array of values in form `[w, s, e, n]`.
+  def bbox(x, y, zoom, tms_style = false, srs = 'WGS84')
+    # Convert xyz into bbox with srs WGS84
+    y = ((2**zoom) - 1) - y if tms_style
+
+    lower_left = [x * @size, (y + 1) * @size] # lower left
+    upper_right = [(x + 1) * @size, y * @size] # upper right
+
+    bbox = ll(lower_left, zoom).concat(ll(upper_right, zoom))
+
+    # If web mercator requested reproject to 900913.
+    if srs == '900913'
+      convert(bbox, '900913')
+    else
+      bbox
+    end
+  end
+
+  # Convert bbox to xyx bounds
+  #
+  # - `bbox` {Number} bbox in the form `[w, s, e, n]`.
+  # - `zoom` {Number} zoom.
+  # - `tms_style` {Boolean} whether to compute using tms-style.
+  # - `srs` {String} projection of input bbox (WGS84|900913).
+  # - `@return` {Object} XYZ bounds containing minX, maxX, minY, maxY properties
+  def xyz(bbox, zoom, tms_style = false, srs = 'WGS84')
+    # If web mercator provided reproject to WGS84.
+    bbox = convert(bbox, 'WGS84') if srs == '900913'
+
+    lower_left = [bbox[0], bbox[1]] # lower left
+    upper_right = [bbox[2], bbox[3]] # upper right
+    px_ll = px(lower_left, zoom)
+    px_ur = px(upper_right, zoom)
+
+    # Y = 0 for XYZ is the top hence minY uses px_ur[1].
+    x = [(px_ll[0] / @size).floor, ((px_ur[0] - 1) / @size).floor]
+    y = [(px_ur[1] / @size).floor, ((px_ll[1] - 1) / @size).floor]
+
+    bounds = {
+      minX: x.min < 0 ? 0 : x.min, # JS: Math.min.apply(Math, x)
+      minY: y.min < 0 ? 0 : y.min,
+      maxX: x.max,
+      maxY: y.max
+    }
+
+    if tms_style
+      tms = {
+        minY: ((2**zoom) - 1) - bounds[:maxY],
+        maxY: ((2**zoom) - 1) - bounds[:minY]
+      }
+
+      bounds[:minY] = tms[:minY]
+      bounds[:maxY] = tms[:maxY]
+    end
+
+    bounds
+  end
+
+  # Convert projection of given bbox.
+  #
+  # - `bbox` {Number} bbox in the form `[w, s, e, n]`.
+  # - `to` {String} projection of output bbox (WGS84|900913). Input bbox
+  #   assumed to be the "other" projection.
+  # - `@return` {Object} bbox with reprojected coordinates.
+  def convert(bbox, to = 'WGS84')
+    if to == '900913'
+      forward(bbox.slice(0, 2)).concat(forward(bbox.slice(2, 4)))
+    else
+      inverse(bbox.slice(0, 2)).concat(inverse(bbox.slice(2, 4)))
+    end
+  end
+
+  # Convert lon/lat values to 900913 x/y.
+  def forward(lon_lat)
+    xy = [
+      A * lon_lat[0] * D2R,
+      A * Math.log(Math.tan((Math::PI * 0.25) + (0.5 * lon_lat[1] * D2R)))
+    ]
+
+    # if xy value is beyond maxextent (e.g. poles), return maxextent.
+    (xy[0] > MAX_EXTENT) && (xy[0] = MAX_EXTENT)
+    (xy[0] < -MAX_EXTENT) && (xy[0] = -MAX_EXTENT)
+    (xy[1] > MAX_EXTENT) && (xy[1] = MAX_EXTENT)
+    (xy[1] < -MAX_EXTENT) && (xy[1] = -MAX_EXTENT)
+    xy
+  end
+
+  # Convert 900913 x/y values to lon/lat.
+  def inverse(xy)
+    [
+      (xy[0] * R2D / A),
+      ((Math::PI * 0.5) - 2.0 * Math.atan(Math.exp(-xy[1] / A))) * R2D
+    ]
+  end
+end

data/lib/spherical_mercator/version.rb

@@ -0,0 +1,19 @@
+class SphericalMercator
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  ##
+  # AlphaCard semantic versioning
+  module VERSION
+    # Major version number
+    MAJOR = 0
+    # Minor version number
+    MINOR = 1
+    # Smallest version number
+    TINY  = 0
+
+    # Full version number
+    STRING = [MAJOR, MINOR, TINY].compact.join('.')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+if ENV['CI'] || ENV['TRAVIS'] || ENV['COVERALLS'] || ENV['JENKINS_URL']
+  require 'coveralls'
+  Coveralls.wear!
+else
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'spherical_mercator'
+
+RSpec.configure do |config|
+  config.order = 'random'
+end

data/spec/spherical_mercator/spherical_mercator_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+MAX_EXTENT_MERC = [
+  -20037508.342789244, -20037508.342789244, 20037508.342789244, 20037508.342789244
+].freeze
+
+MAX_EXTENT_WGS84 = [
+  -180, -85.0511287798066, 180, 85.0511287798066
+].freeze
+
+def rand_float
+  rand(0.0...1.0)
+end
+
+describe SphericalMercator do
+  let!(:sm) {SphericalMercator.new}
+
+  context '#bbox' do
+    it '[0,0,0] converted to proper bbox' do
+      expect(sm.bbox(0, 0, 1, true, 'WGS84')).to eq([-180, -85.05112877980659, 0, 0])
+    end
+
+    it '[0,0,1] converted to proper bbox' do
+      expect(sm.bbox(0, 0, 0, true, 'WGS84')).to eq([-180, -85.05112877980659, 180, 85.0511287798066])
+    end
+  end
+
+  context '#xyz' do
+    it 'World extents converted to proper tile ranges' do
+      expect(sm.xyz([-180, -85.05112877980659, 0, 0], 1, true, 'WGS84')).to eq({minX: 0, minY: 0, maxX: 0, maxY: 0})
+    end
+
+    it 'SW converted to proper tile ranges' do
+      expect(sm.xyz([-180, -85.05112877980659, 180, 85.0511287798066], 0, true, 'WGS84')).to eq({minX: 0, minY: 0, maxX: 0, maxY: 0})
+    end
+
+    it 'broken' do
+      extent = [-0.087891, 40.95703, 0.087891, 41.044916]
+      xyz = sm.xyz(extent, 3, true, 'WGS84')
+
+      expect(xyz[:minX] <= xyz[:maxX]).to be_truthy
+      expect(xyz[:minY] <= xyz[:maxY]).to be_truthy
+    end
+
+    it 'negative' do
+      extent = [-112.5, 85.0511, -112.5, 85.0511]
+      xyz = sm.xyz(extent, 0)
+
+      expect(xyz[:minY]).to be_zero
+    end
+
+    it 'fuzz' do
+      1000.times do
+        x = [-180 + (360 * rand_float), -180 + (360 * rand_float)]
+        y = [-85 + (170 * rand_float), -85 + (170 * rand_float)]
+        z = (22 * rand_float).floor
+
+        extent = [
+          x.min,
+          y.min,
+          x.max,
+          y.max
+        ]
+
+        xyz = sm.xyz(extent, z, true, 'WGS84')
+
+        if xyz[:minX] > xyz[:maxX]
+          expect(xyz[:minX] <= xyz[:maxX]).to be_truthy
+        end
+
+        if xyz[:minY] > xyz[:maxY]
+          expect(xyz[:minY] <= xyz[:maxY]).to be_truthy
+        end
+      end
+    end
+  end
+
+  context '#convert' do
+    it 'MAX_EXTENT_WGS84' do
+      expect(sm.convert(MAX_EXTENT_WGS84, '900913')).to eq(MAX_EXTENT_MERC)
+    end
+
+    it 'MAX_EXTENT_MERC' do
+      expect(sm.convert(MAX_EXTENT_MERC, 'WGS84')).to eq(MAX_EXTENT_WGS84)
+    end
+  end
+
+  context '#extents' do
+    it 'Maximum extents enforced on conversion to tile ranges' do
+      expect(sm.xyz([-240, -90, 240, 90], 4, true, 'WGS84')).to eq({minX: 0, minY: 0, maxX: 15, maxY: 15})
+    end
+
+    it '' do
+      expect(sm.convert([-240, -90, 240, 90], '900913')).to eq(MAX_EXTENT_MERC)
+    end
+  end
+end

data/spherical_mercator.gemspec

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'spherical_mercator/version'
+
+Gem::Specification.new do |gem|
+  gem.name = 'spherical_mercator'
+  gem.version = SphericalMercator.gem_version
+  gem.date = '2017-10-03'
+  gem.summary = 'Spherical Mercator math in Ruby'
+  gem.description = 'Spherical Mercator provides projection math for converting between mercator' \
+                    'meters, screen pixels (of 256x256 or configurable-size tiles), and latitude/longitude'
+  gem.authors = ['Nikita Bulai']
+  gem.email = 'bulajnikita@gmail.com'
+  gem.require_paths = ['lib']
+  gem.files = `git ls-files`.split($RS)
+  gem.homepage = 'http://github.com/nbulaj/spherical_mercator'
+  gem.license = 'MIT'
+  gem.required_ruby_version = '>= 2.0'
+
+  gem.add_development_dependency 'rspec', '~> 3.5'
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: spherical_mercator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nikita Bulai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: Spherical Mercator provides projection math for converting between mercatormeters,
+  screen pixels (of 256x256 or configurable-size tiles), and latitude/longitude
+email: bulajnikita@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/spherical_mercator.rb
+- lib/spherical_mercator/version.rb
+- spec/spec_helper.rb
+- spec/spherical_mercator/spherical_mercator_spec.rb
+- spherical_mercator.gemspec
+homepage: http://github.com/nbulaj/spherical_mercator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Spherical Mercator math in Ruby
+test_files: []