google_static_maps_helper 1.3.2 → 1.3.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1dc3b1f8fedc9305d84b0cc3332f378bd40cdebf101d0e41dc43612c088fbbd0
+  data.tar.gz: eb7c8f2723e3ec54a27f39362320212047d5cbc83b793ea8b64956be068432c9
+SHA512:
+  metadata.gz: 0417026d675d2e70d4f1a4288432d3614bb0c49c46fa9ae963cf162aa59054bb1323264b42bffd747810cfcf6721c533f9615ac2439e8f84ea52e1f9bbb334b0
+  data.tar.gz: 900a3386da65ee3e2f9c273d2398b000937bb968b7d61ed8364025aefbf204f13e136b3aae0f937a425e306cfee994743140f9433c760cd4c09d63bceaf06d11

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    google_static_maps_helper (1.3.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (13.0.1)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.6)
+  google_static_maps_helper!
+  rake (>= 10.0)
+  rspec
+
+BUNDLED WITH
+   2.1.4

data/README.rdoc

@@ -4,10 +4,6 @@ This gem provides a simple interface to the Google Static Maps V2 API (http://co
 
 
 = Installation
-If you haven't already, add gemcutter as a gem source
-  [sudo] gem sources --add http://gemcutter.org
-
-Then install this gem
   [sudo] gem install google_static_maps_helper
 
 
@@ -18,15 +14,14 @@ Then install this gem
     marker :lng => 3, :lat => 4
   end
 
-This will return the URL for a map with these markers. Please note that if you do use this approach you have to set key, size and sensor setting.
+This will return the URL for a map with these markers. Please note that if you do use this approach you have to set size and sensor setting.
 You do this by:
-  GoogleStaticMapsHelper.key = 'your google key'
   GoogleStaticMapsHelper.size = '300x600'
   GoogleStaticMapsHelper.sensor = false
 
-If you are on Rails you can put it in your environment configuration file and while you are there you can add the following line inside the configuration block:
+If you are on Rails (2.3.x) you can put it in your environment configuration file and while you are there you can add the following line inside the configuration block:
   Rails::Initializer.run do |config|
-    config.gem 'google_static_maps_helper', :source => 'http://gemcutter.org'
+    config.gem 'google_static_maps_helper'
     ...
   end
 
@@ -56,24 +51,24 @@ You uild a marker by simply sending in an object which responds to lng and lat,
   marker = GoogleStaticMapsHelper::Marker.new(location)
   marker = GoogleStaticMapsHelper::Marker.new(:lng => 1, :lat => 2)
 
-Google's static maps supports some options on markers. You can change the color, the label and the size.
+Google's static maps supports some options on markers. You can change the color, the label and the size or you can send in your own icon.
 (http://code.google.com/apis/maps/documentation/staticmaps/#MarkerStyles). You send in options as a second
 parameter to the new method if you gave a location object, or include it in the hash where lng and lat is.
   marker = GoogleStaticMapsHelper::Marker.new(location, :color => 'blue')
   marker = GoogleStaticMapsHelper::Marker.new(:lng => 1, :lat => 2, :color => 'blue')
+  marker = GoogleStaticMapsHelper::Marker.new(:lng => 1, :lat => 2, :icon => 'http://www.domain.com/icon.png')
 
 
 == Map
-A Map holds many markers, paths, pluss some additional options like the size of the static map, Google key, what zoom level and center point it should be fixed to
+A Map holds many markers, paths, pluss some additional options like the size of the static map, what zoom level and center point it should be fixed to
 etc. If no zoom or center point is give it will calculate the map view based on the markers or paths. You can leave markers and paths out, but then you have to supply
 zoom and center. More info can be found here: http://code.google.com/apis/maps/documentation/staticmaps/#URL_Parameters.
 
 === How to build a map?
-When building a map object you have to supply key, sensor and size. Other options are optional.
-  map = GoogleStaticMapsHelper::Map.new(:key => YOUR_GOOGLE_KEY, :sensor => false, :size => '200x300')
+When building a map object you have to supply sensor and size. Other options are optional.
+  map = GoogleStaticMapsHelper::Map.new(:sensor => false, :size => '200x300')
 
 Or, if you have set default options on GoogleStaticMapsHelper, you can skip the required keys when creating a map
-  GoogleStaticMapsHelper.key = 'your google key'
   GoogleStaticMapsHelper.size = '300x600'
   GoogleStaticMapsHelper.sensor = false
   map = GoogleStaticMapsHelper::Map.new
@@ -84,12 +79,11 @@ With the map object made, we are ready to add some markers to it:
   map << marker
   map << another_marker << yet_another_marker << and_one_more_marker
 
-We can now ask the map for it's URL to where we'll get the requested map from. This URL can be used as src attribute on an image tag.
+We can now ask the map for it's URL to where we'll get the map from. This URL can be used as source attribute on an image tag.
   map.url
 
 Another thing you might want to do is to override the center point and zoom level. This is done during map construction
-  map = GoogleStaticMapsHelper::Map.new(:key => YOUR_GOOGLE_KEY,
-                                        :sensor => false,
+  map = GoogleStaticMapsHelper::Map.new(:sensor => false,
                                         :size => '200x300',
                                         :center => '1,2',
                                         :zoom => 4)
@@ -97,7 +91,10 @@ Another thing you might want to do is to override the center point and zoom leve
 
 
 == Paths and Polygons
-It is also possible to create Paths and Polygons and to use them together with markers. To create a Path you need two Points and a Path object:
+It is also possible to create Paths and Polygons and to use them together with markers.
+Paths and Polygons will by default encode it's points with Google's encoding algorithm.
+
+To create a Path you need two Points and a Path object:
   path = GoogleStaticMapsHelper::Path.new
   start_point = {:lat => 1, :lng => 2} # You can also use any object which responds to lat and lng here
   end_point = {:lat => 1, :lng => 2}
@@ -119,10 +116,10 @@ If you feel like it, you can add points at construction time:
 
 
 == Locations
-The location class is what we wrap all our lat- and lng values in. Either it is a Marker, or points for a Path. It has a few helper methods which 
-you can use to calculate distance between locations (<tt>distance_to(another_location)</tt>) and use to generate new locations based on 
-distance and heading (<tt>endpoint(distance, heading)</tt>). It also have a helper method called <tt>endpoints_for_circle_with_radius</tt>
-which returns locations that make up a circle around the receiving location. Some examples:
+The location class is what we wrap all our lat- and lng values in. Either it is a Marker, or points for a Path; it will store it's lng and lat value
+in a Location object. Location objects have a few helper methods which you can use to calculate distance between 
+locations (<tt>distance_to(another_location)</tt>) and use to generate new locations based on distance and heading from current location (<tt>endpoint(distance, heading)</tt>).
+It also have a helper method called <tt>endpoints_for_circle_with_radius</tt> which returns locations that makes up a circle around the receiving location. Some examples:
 
   # Create a marker object, which it's lng and lat are stored under the hood as a location object.
   # Methods which the marker itself cannot answer, like lat and lng and distance_to is delegated to the location object
@@ -136,9 +133,6 @@ which returns locations that make up a circle around the receiving location. Som
   map << path
 
 
-== TODO
-* Ruby 1.9 support
-
 == Copyright
 
 Copyright (c) 2009 Thorbjørn Hermansen. See LICENSE for details.

data/Rakefile

@@ -1,48 +1 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "google_static_maps_helper"
-    gem.summary = %Q{This gem provides a simple interface to the Google Static Maps V2 API}
-    gem.description = %Q{This gem provides a simple interface to the Google Static Maps V2 API.}
-    gem.email = "thhermansen@gmail.com"
-    gem.homepage = "http://github.com/thhermansen/google_static_maps_helper"
-    gem.authors = ["Thorbjørn Hermansen"]
-    gem.add_development_dependency "rspec"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
-
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-task :spec => :check_dependencies
-
-task :default => :spec
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION')
-    version = File.read('VERSION')
-  else
-    version = ""
-  end
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "google_static_maps_helper #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+require "bundler/gem_tasks"

data/changelog.txt

@@ -1,4 +1,21 @@
-= v.1.3.2 (in git)
+= v.1.3.7
+* Use HTTPS in google url (by morgoth)
+
+= v.1.3.6
+* Removed deprecation warnings `URI.escape is obsolete` in Ruby 2.7 (by morgoth)
+
+= v.1.3.5
+* Added support for icon on markers.
+* DEPRECATED Google API key as its no longer required when requesting a static map (will be removed from this gem in upcoming versions).
+
+= v.1.3.4
+* Paths are now as default encoding it's points with Google's encoding algorithm. Thanks to Joel Rosenberg for providing an easy class to use.
+This will cut the length of the generated URL quite a bit; down to between 1/3 and 1/2 of the old size.
+
+= v.1.3.3
+* We are now supporting ruby 1.9.1.
+
+= v.1.3.2
 * Location will now round and reduce numbers so it doesn't get above a precision of 6.
 * Added two helper methods to Location: distance_to(another_location) and endpoint(distance, heading).
 * a_location.endpoints_for_circle_with_radius(radius) returns an array of end points making a circle around location.

data/google_static_maps_helper.gemspec

@@ -1,67 +1,31 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
+require_relative "lib/google_static_maps_helper/version"
 
-Gem::Specification.new do |s|
-  s.name = %q{google_static_maps_helper}
-  s.version = "1.3.1"
+Gem::Specification.new do |spec|
+  spec.name          = "google_static_maps_helper"
+  spec.version       = GoogleStaticMapsHelper::VERSION
+  spec.authors       = ["Thorbjørn Hermansen"]
+  spec.email         = ["thhermansen@gmail.com"]
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Thorbj\303\270rn Hermansen"]
-  s.date = %q{2009-10-31}
-  s.description = %q{This gem provides a simple interface to the Google Static Maps V2 API.}
-  s.email = %q{thhermansen@gmail.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "changelog.txt",
-     "google_static_maps_helper.gemspec",
-     "lib/google_static_maps_helper.rb",
-     "lib/google_static_maps_helper/location.rb",
-     "lib/google_static_maps_helper/map.rb",
-     "lib/google_static_maps_helper/marker.rb",
-     "lib/google_static_maps_helper/path.rb",
-     "spec/google_static_maps_helper_spec.rb",
-     "spec/location_spec.rb",
-     "spec/map_spec.rb",
-     "spec/marker_spec.rb",
-     "spec/path_spec.rb",
-     "spec/spec_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/thhermansen/google_static_maps_helper}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{This gem provides a simple interface to the Google Static Maps V2 API}
-  s.test_files = [
-    "spec/spec_helper.rb",
-     "spec/marker_spec.rb",
-     "spec/google_static_maps_helper_spec.rb",
-     "spec/location_spec.rb",
-     "spec/map_spec.rb",
-     "spec/path_spec.rb"
-  ]
+  spec.summary       = %Q{This gem provides a simple interface to the Google Static Maps V2 API}
+  spec.description   = %Q{This gem provides a simple interface to the Google Static Maps V2 API.}
+  spec.homepage      = "http://github.com/thhermansen/google_static_maps_helper"
+  spec.license       = "MIT"
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "http://github.com/thhermansen/google_static_maps_helper"
+  spec.metadata["changelog_uri"] = "https://github.com/thhermansen/google_static_maps_helper/blob/master/changelog.txt"
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, [">= 0"])
-    else
-      s.add_dependency(%q<rspec>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rspec>, [">= 0"])
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
 
+  spec.add_development_dependency "bundler", ">= 1.6"
+  spec.add_development_dependency "rake", ">= 10.0"
+  spec.add_development_dependency "rspec"
+end

data/lib/google_static_maps_helper.rb

@@ -1,10 +1,12 @@
+# -*- encoding: utf-8 -*-
 require 'uri'
 require File.dirname(__FILE__) + '/google_static_maps_helper/map'
 require File.dirname(__FILE__) + '/google_static_maps_helper/location'
 require File.dirname(__FILE__) + '/google_static_maps_helper/marker'
 require File.dirname(__FILE__) + '/google_static_maps_helper/path'
+require File.dirname(__FILE__) + '/google_static_maps_helper/gmap_polyline_encoder'
 
-# 
+#
 # The Google Static Map Helper provides a simple interface to the
 # Google Static Maps V2 API (http://code.google.com/apis/maps/documentation/staticmaps/).
 #
@@ -12,14 +14,14 @@ require File.dirname(__FILE__) + '/google_static_maps_helper/path'
 # <tt>Map</tt>::      A map is what keeps all of the state of which you'll build a URL for.
 # <tt>Marker</tt>::   One or more markers can be added to the map. A marker can be customized with size, label and color.
 # <tt>Path</tt>::     A path will create lines or polygons in your map.
-# 
+#
 # == About
 #
 # Author:: Thorbjørn Hermansen (thhermansen@gmail.com)
 #
 module GoogleStaticMapsHelper
   # The basic url to the API which we'll build the URL from
-  API_URL = 'http://maps.google.com/maps/api/staticmap'
+  API_URL = 'https://maps.google.com/maps/api/staticmap'
 
   class OptionMissing < ArgumentError; end # Raised when required options is not sent in during construction
   class OptionNotExist < ArgumentError; end # Raised when incoming options include keys which is invalid
@@ -29,7 +31,7 @@ module GoogleStaticMapsHelper
 
   class << self
     attr_accessor :key, :size, :sensor
-    
+
     #
     # Provides a simple DSL stripping away the need of manually instantiating classes
     #
@@ -39,7 +41,7 @@ module GoogleStaticMapsHelper
     #   GoogleStaticMapsHelper.key = 'your google key'
     #   GoogleStaticMapsHelper.size = '300x600'
     #   GoogleStaticMapsHelper.sensor = false
-    #   
+    #
     #   # Then, you'll be able to do:
     #   url = GoogleStaticMapsHelper.url_for do
     #     marker :lng => 1, :lat => 2
@@ -62,5 +64,11 @@ module GoogleStaticMapsHelper
       block.arity < 1 ? map.instance_eval(&block) : block.call(map)
       map.url
     end
+
+
+    def key=(key)# :nodoc:
+      warn "[DEPRECATION] 'key' is deprecated. Key is no longer used when require a static map. Key will be removed from this gem soon!"
+      @key = key
+    end
   end
 end

data/lib/google_static_maps_helper/gmap_polyline_encoder.rb

@@ -0,0 +1,390 @@
+#--
+#
+# Utility for creating Google Maps Encoded GPolylines
+#
+# License: You may distribute this code under the same terms as Ruby itself
+#
+# Author: Joel Rosenberg
+#
+# ( Drawing from the official example pages as well as Mark McClure's work )
+#
+# == Example
+#
+#   data = [
+#     [ 37.4419, -122.1419],
+#     [ 37.4519, -122.1519],
+#     [ 37.4619, -122.1819],
+#   ]
+#
+#   encoder = GMapPolylineEncoder.new()
+#   result = encoder.encode( data )
+#
+#   javascript << "  var myLine = new GPolyline.fromEncoded({\n"
+#   javascript << "     color: \"#FF0000\",\n"
+#   javascript << "     weight: 10,\n"
+#   javascript << "     opacity: 0.5,\n"
+#   javascript << "     zoomFactor: #{result[:zoomFactor]},\n"
+#   javascript << "     numLevels: #{result[:numLevels]},\n"
+#   javascript << "     points: \"#{result[:points]}\",\n"
+#   javascript << "     levels: \"#{result[:levels]}\"\n"
+#   javascript << "  });"
+#
+# == Methods
+#
+#   Constructor args (all optional): 
+#     :numLevels (default 18)
+#     :zoomFactor (default 2)
+#     :reduce: Reduce points (default true)
+#     :escape: Escape backslashes (default true)
+#
+#   encode( points ) method
+#     points (required): array of longitude, latitude pairs
+#
+#     returns hash with keys :points, :levels, :zoomFactor, :numLevels
+#
+# == Background
+#
+# Description: http://www.google.com/apis/maps/documentation/#Encoded_Polylines
+# API: http://www.google.com/apis/maps/documentation/reference.html#GPolyline
+# Hints: http://www.google.com/apis/maps/documentation/polylinealgorithm.html
+#
+# Example Javascript for instantiating an encoded polyline:
+# var encodedPolyline = new GPolyline.fromEncoded({
+#     color: "#FF0000",
+#     weight: 10,
+#     points: "yzocFzynhVq}@n}@o}@nzD",
+#     levels: "BBB",
+#     zoomFactor: 32,
+#     numLevels: 4
+# });
+#
+# == Changes
+#
+# 06.29.2007 - Release 0.1
+#            Profiling showed that distance() accounted for 50% of the time when
+#            processing McClure's British coast data. By moving the distance
+#            calculation into encode(), we can cache a few of the calculations
+#            (magnitude) and eliminate the overhead of the function call. This
+#            reduced the time to encode by ~ 30%
+#
+# 06.21.2007 Implementing the Doublas-Peucker algorithm for removing superflous
+#            points as per Mark McClure's design:
+#                http://facstaff.unca.edu/mcmcclur/GoogleMaps/EncodePolyline/
+#
+# 10.14.2006 Cleaned up (and finally grasped) zoom levels
+#
+# 09.2006    First port of the official example's javascript. Ignoring zoom
+#            levels for now, showing points at all zoom levels
+#
+#++
+module GoogleStaticMapsHelper
+  class GMapPolylineEncoder
+    attr_accessor :reduce, :escape #zoomFactor and numLevels need side effects
+    attr_reader :zoomFactor, :numLevels
+    
+    # The minimum distance from the line that a point must exceed to avoid
+    # elimination under the DP Algorithm.
+    @@dp_threshold = 0.00001
+    
+    def initialize(options = {})
+      # There are no required parameters
+
+      # Nice defaults
+      @numLevels  = options.has_key?(:numLevels)  ? options[:numLevels]  : 18
+      @zoomFactor = options.has_key?(:zoomFactor) ? options[:zoomFactor] : 2
+      
+      # Calculate the distance thresholds for each zoom level
+      calculate_zoom_breaks()
+      
+      # By default we'll simplify the polyline unless told otherwise
+      @reduce = ! options.has_key?(:reduce) ? true : options[:reduce]
+      
+      # Escape by default; most people are using this in a web context
+      @escape = ! options.has_key?(:escape) ? true : options[:escape]
+      
+    end
+    
+    def numLevels=( new_num_levels )
+      @numLevels = new_num_levels
+      # We need to recalculate our zoom breaks
+      calculate_zoom_breaks()
+    end
+    
+    def zoomFactor=( new_zoom_factor )
+      @zoomFactor = new_zoom_factor
+      # We need to recalculate our zoom breaks
+      calculate_zoom_breaks()
+    end
+    
+    def encode( points )
+    
+      #
+      # This is an implementation of the Douglas-Peucker algorithm for simplifying
+      # a line. You can thing of it as an elimination of points that do not
+      # deviate enough from a vector. That threshold for point elimination is in
+      # @@dp_threshold. See
+      #
+      #   http://everything2.com/index.pl?node_id=859282
+      #
+      # for an explanation of the algorithm
+      #
+      
+      max_dist = 0  # Greatest distance we measured during the run
+      stack = []
+      distances = Array.new(points.size)
+    
+      if(points.length > 2)
+        stack << [0, points.size-1]
+        
+        while(stack.length > 0) 
+          current_line = stack.pop()
+          p1_idx = current_line[0]
+          pn_idx = current_line[1]
+          pb_dist = 0
+          pb_idx = nil
+          
+          x1 = points[p1_idx][0]
+          y1 = points[p1_idx][1]
+          x2 = points[pn_idx][0]
+          y2 = points[pn_idx][1]
+          
+          # Caching the line's magnitude for performance
+          magnitude = Math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
+          magnitude_squared = magnitude ** 2
+          
+          # Find the farthest point and its distance from the line between our pair
+          for i in (p1_idx+1)..(pn_idx-1)
+          
+            # Refactoring distance computation inline for performance
+            #current_distance = compute_distance(points[i], points[p1_idx], points[pn_idx])
+            
+            # 
+            # This uses Euclidian geometry. It shouldn't be that big of a deal since
+            # we're using it as a rough comparison for line elimination and zoom
+            # calculation.
+            #
+            # TODO: Implement Haversine functions which would probably bring this to
+            #       a snail's pace (ehhhh)
+            #
+      
+            px = points[i][0]
+            py = points[i][1]
+           
+            current_distance = nil
+            
+            if( magnitude == 0 )
+              # The line is really just a point
+              current_distance = Math.sqrt((x2-px)**2 + (y2-py)**2)
+            else
+           
+              u = (((px - x1) * (x2 - x1)) + ((py - y1) * (y2 - y1))) / magnitude_squared
+              
+              if( u <= 0 || u > 1 )
+                  # The point is closest to an endpoint. Find out which one
+                  ix = Math.sqrt((x1 - px)**2 + (y1 - py)**2)
+                  iy = Math.sqrt((x2 - px)**2 + (y2 - py)**2)
+                  if( ix > iy )
+                    current_distance = iy
+                  else
+                    current_distance = ix
+                  end
+              else
+                  # The perpendicular point intersects the line
+                  ix = x1 + u * (x2 - x1)
+                  iy = y1 + u * (y2 - y1)
+                  current_distance = Math.sqrt((ix - px)**2 + (iy - py)**2)
+              end
+            end
+            
+            # See if this distance is the greatest for this segment so far
+            if(current_distance > pb_dist)
+              pb_dist = current_distance
+              pb_idx = i
+            end
+          end
+          
+          # See if this is the greatest distance for all points
+          if(pb_dist > max_dist)
+            max_dist = pb_dist
+          end
+          
+          if(pb_dist > @@dp_threshold)
+            # Our point, Pb, that had the greatest distance from the line, is also
+            # greater than our threshold. Process again using Pb as a new 
+            # start/end point. Record this distance - we'll use it later when
+            # creating zoom values
+            distances[pb_idx] = pb_dist
+            stack << [p1_idx, pb_idx]
+            stack << [pb_idx, pn_idx]
+          end
+          
+        end
+      end
+      
+      # Force line endpoints to be included (sloppy, but faster than checking for
+      # endpoints in encode_points())
+      distances[0] = max_dist
+      distances[distances.length-1] = max_dist
+    
+      # Create Base64 encoded strings for our points and zoom levels
+      points_enc = encode_points( points, distances)
+      levels_enc = encode_levels( points, distances, max_dist)
+      
+      # Make points_enc an escaped string if desired.
+      # We should escape the levels too, in case google pulls a switcheroo
+      @escape && points_enc && points_enc.gsub!( /\\/, '\\\\\\\\' )
+     
+      
+      # Returning a hash. Yes, I am a Perl programmer
+      return {
+        :points     => points_enc,
+        :levels     => levels_enc,
+        :zoomFactor => @zoomFactor,
+        :numLevels  => @numLevels,
+      }
+      
+    end
+    
+    private
+    
+    def calculate_zoom_breaks()
+      # Calculate the distance thresholds for each zoom level
+      @zoom_level_breaks = Array.new(@numLevels);
+      
+      for i in 0..(@numLevels-1)
+        @zoom_level_breaks[i] = @@dp_threshold * (@zoomFactor ** ( @numLevels-i-1));
+      end
+      
+      return
+    end
+    
+    def encode_points( points, distances )
+      encoded = ""
+      
+      plat = 0
+      plon = 0
+
+      #points.each do |point| # Gah, need the distances.
+      for i in 0..(points.size() - 1)
+        if(! @reduce || distances[i] != nil )
+          point = points[i]
+          late5 = (point[0] * 1e5).floor();
+          lone5 = (point[1] * 1e5).floor();
+
+          dlat = late5 - plat
+          dlon = lone5 - plon
+
+          plat = late5;
+          plon = lone5;
+
+          # I used to need this for some reason
+          #encoded << encodeSignedNumber(Fixnum.induced_from(dlat)).to_s
+          #encoded << encodeSignedNumber(Fixnum.induced_from(dlon)).to_s
+          encoded << encodeSignedNumber(dlat).to_s
+          encoded << encodeSignedNumber(dlon).to_s
+        end
+      end
+
+      return encoded
+
+    end
+    
+    def encode_levels( points, distances, max_dist )
+      
+      encoded = "";
+      
+      # Force startpoint
+      encoded << encodeNumber(@numLevels - 1)
+      
+      if( points.size() > 2 )
+        for i in 1..(points.size() - 2)
+          distance = distances[i]
+          if( ! @reduce || distance != nil)
+            computed_level = 0
+          
+            while (distance < @zoom_level_breaks[computed_level]) do
+              computed_level += 1
+            end
+            
+            encoded << encodeNumber( @numLevels - computed_level - 1 )
+          end
+        end
+      end
+      
+      # Force endpoint
+      encoded << encodeNumber(@numLevels - 1)
+      
+      return encoded;
+      
+    end
+   
+    def compute_distance( point, lineStart, lineEnd )
+    
+      #
+      # Note: This has been refactored to encode() inline for performance and 
+      #       computation caching
+      #
+      
+      px = point[0]
+      py = point[1]
+      x1 = lineStart[0]
+      y1 = lineStart[1]
+      x2 = lineEnd[0]
+      y2 = lineEnd[1]
+     
+      distance = nil
+     
+      magnitude = Math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
+      
+      if( magnitude == 0 )
+        return Math.sqrt((x2-px)**2 + (y2-py)**2)
+      end
+     
+      u = (((px - x1) * (x2 - x1)) + ((py - y1) * (y2 - y1))) / (magnitude**2)
+      
+      if( u <= 0 || u > 1 )
+          # The point is closest to an endpoint. Find out which
+          ix = Math.sqrt((x1 - px)**2 + (y1 - py)**2)
+          iy = Math.sqrt((x2 - px)**2 + (y2 - py)**2)
+          if( ix > iy )
+            distance = iy
+          else
+            distance = ix
+          end
+      else
+          # The perpendicular point intersects the line
+          ix = x1 + u * (x2 - x1)
+          iy = y1 + u * (y2 - y1)
+          distance = Math.sqrt((ix - px)**2 + (iy - py)**2)
+      end
+      
+      return distance
+    end
+    
+    def encodeSignedNumber(num)
+      # Based on the official google example
+      
+      sgn_num = num << 1
+
+      if( num < 0 )
+          sgn_num = ~(sgn_num)
+      end
+
+      return encodeNumber(sgn_num)
+    end
+
+    def encodeNumber(num)
+      # Based on the official google example
+      
+      encoded = "";
+
+      while (num >= 0x20) do
+          encoded << ((0x20 | (num & 0x1f)) + 63).chr;
+          num = num >> 5;
+      end
+
+      encoded << (num + 63).chr;
+      return encoded;
+    end
+  end
+end