timezone_finder 0.0.1 → 1.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7655adbedfe635064333831aa217409072acbf95
-  data.tar.gz: f009e325c8ec9f02d7edadec013f3e5e5f14a152
+  metadata.gz: 13d427ec4275e9a9cf091179165cdaee2c427f08
+  data.tar.gz: bd258529875fec7b818f7839c2a116ff6a29e434
 SHA512:
-  metadata.gz: 0e0b6c8bf962b11f2ebbbd11fbc9b0aa6d48ed2a521630c3aae43f89cfe77cb48be89e78b5f6881fba74eeb6bc9b8608175012ff9c76ca20a45a976551c4e37c
-  data.tar.gz: fdbfd1f79f3a124fd6382f9b56d12f992db6d5cf464306b9db3b50f06ce7bbc199a5f8b0d8c6592d5a46b4e6eecca3315e016ee861db639ed097ee155c0eed6e
+  metadata.gz: a7e3da84f42cc2b1a55c06cfd0ceb35119be8dce2c549a1872fd7f32f3373685582891d34800d03456111e3b89c3c55bda86902a8ff62aa3699077e3e72c525b
+  data.tar.gz: 48374abaab46b420242964dd2373899b4d602f10605964f7497b7580f24200af8d62e99b6f551ea32b79c446dfc2b6cf266d41cfbdad58328f0722c4e9b2097c

data/ChangeLog

@@ -0,0 +1,14 @@
+== 2016-06-03 version 1.5.5
+
+* using the newest version (2016d, May 2016) of the tz_world data from http://efele.net/maps/tz/world/
+* holes in the polygons which are stored in the tz_world data are now correctly stored and handled
+* rewrote the file_converter for storing the holes at the end of the
+timezone_data.bin
+* added specific test cases for hole handling
+* made some optimizations in the algorithms
+
+
+== 2016-05-26 version 0.0.1
+
+* First release
+

data/README.md

@@ -3,7 +3,7 @@
 [![Build Status](https://travis-ci.org/gunyarakun/timezone_finder.svg?branch=master)](https://travis-ci.org/gunyarakun/timezone_finder)
 [![Gem Version](https://badge.fury.io/rb/timezone_finder.svg)](https://badge.fury.io/rb/timezone_finder)
 
-This is a fast and lightweight ruby project to lookup the corresponding
+This is a fast and lightweight ruby project for looking up the corresponding
 timezone for a given lat/lng on earth entirely offline.
 
 This project is derived from
@@ -36,6 +36,9 @@ tf = TimezoneFinder.create
 
 #### fast algorithm:
 
+This approach is fast, but might not be what you are looking for:
+For example when there is only one possible timezone in proximity, this timezone would be returned (without checking if the point is included first).
+
 ```ruby
 # point = (longitude, latitude)
 point = (13.358, 52.5061)
@@ -101,21 +104,17 @@ this converts the .json into the needed .bin (overwriting the old version!) and
 
 ## Known Issues
 
-The original author MrMinimal64 ran tests for approx. 5M points and this are the mistakes he found:
-
-All points in **Lesotho** are counted to the 'Africa/Johannesburg' timezone instead of 'Africa/Maseru'.
-I am pretty sure this is because it is completely surrounded by South Africa and in the data the area of Lesotho is not excluded from this timezone.
-
-Same for the small **usbekish enclaves** in **Kirgisitan** and some points in the **Arizona Dessert** (some weird rules apply here).
-
-Those are mistakes in the data not my algorithms and in order to fix this he would need check for and then separately handle these special cases.
-This would not only slow down the algorithms, but also make them ugly.
+The original author MrMinimal64 ran tests for approx. 5M points and these are no mistakes he found.
 
 ## Contact
 
 If you notice that the tz data is outdated, encounter any bugs, have
 suggestions, criticism, etc. feel free to **open an Issue**, **add a Pull Requests** on Git.
 
+## Credits
+
+Thanks to [MrMinimal64](https://github.com/MrMinimal64) for developing the original version and giving me some advices.
+
 ## License
 
 ``timezone_finder`` is distributed under the terms of the MIT license

data/lib/timezone_finder/file_converter.rb

@@ -17,11 +17,19 @@ module TimezoneFinder
     NR_SHORTCUTS_PER_LAT = 2
 
     def initialize
+      @nr_of_lines = -1
+
       @all_tz_names = []
       @ids = []
       @boundaries = []
       @all_coords = []
       @all_lengths = []
+      @amount_of_holes = 0
+      @first_hole_id_in_line = []
+      @related_line = []
+
+      @all_holes = []
+      @all_hole_lengths = []
     end
 
     # HELPERS:
@@ -94,10 +102,9 @@ module TimezoneFinder
     def parse_polygons_from_json(path = 'tz_world.json')
       f = open(path, 'r')
       puts 'Parsing data from .json'
-      n = 0
+      # file_line is the current line in the .json file being parsed. This is not the id of the Polygon!
+      file_line = 0
       f.each_line do |row|
-        puts "line #{n}" if n % 1000 == 0
-        n += 1
         # puts(row)
         tz_name_match = /"TZID":\s\"(?<name>.*)"\s\}/.match(row)
         # tz_name = /(TZID)/.match(row)
@@ -105,49 +112,124 @@ module TimezoneFinder
         if tz_name_match
           tz_name = tz_name_match['name'].gsub('\\', '')
           @all_tz_names << tz_name
+          @nr_of_lines += 1
           # puts tz_name
 
+          actual_depth = 0
+          counted_coordinate_pairs = 0
+          encountered_nr_of_coordinates = []
+          row.each_char do |char|
+            if char == '['
+              actual_depth += 1
+            elsif char == ']'
+              actual_depth -= 1
+              if actual_depth == 2
+                counted_coordinate_pairs += 1
+              elsif actual_depth == 1
+                encountered_nr_of_coordinates << counted_coordinate_pairs
+                counted_coordinate_pairs = 0
+              end
+            end
+          end
+
+          if actual_depth != 0
+            fail ArgumentError, "uneven number of brackets detected. Something is wrong in line #{file_line}"
+          end
+
           coordinates = row.scan(/[-]?\d+\.?\d+/)
+
+          sum = encountered_nr_of_coordinates.inject(0) { |a, e| a + e }
+          if coordinates.length != sum * 2
+            fail ArgumentError, "There number of coordinates is counten wrong: #{coordinates.length} #{sum * 2}"
+          end
+          # TODO: detect and store all the holes in the bin
           # puts coordinates
 
           # nr_floats = coordinates.length
           x_coords = []
           y_coords = []
-          i = 0
-          coordinates.each do |coord|
-            if i.even?
-              x_coords << coord.to_f
+          xmax = -180.0
+          xmin = 180.0
+          ymax = -90.0
+          ymin = 90.0
+
+          pointer = 0
+          # the coordiate pairs within the first brackets [ [x,y], ..., [xn, yn] ] are the polygon coordinates
+          # The last coordinate pair should be left out (is equal to the first one)
+          (0...(2 * (encountered_nr_of_coordinates[0] - 1))).each do |n|
+            if n.even?
+              x = coordinates[pointer].to_f
+              x_coords << x
+              xmax = x if x > xmax
+              xmin = x if x < xmin
             else
-              y_coords << coord.to_f
+              y = coordinates[pointer].to_f
+              y_coords << y
+              ymax = y if y > ymax
+              ymin = y if y < ymin
             end
-            i += 1
-          end
 
-          fail "#{i} Floats in line #{n} found. Should be even (pairs or (x,y) )" if i.odd?
+            pointer += 1
+          end
 
           @all_coords << [x_coords, y_coords]
           @all_lengths << x_coords.length
-          # puts x_coords
-          # puts y_coords
-          xmax = -180.0
-          xmin = 180.0
-          ymax = -90.0
-          ymin = 90.0
+          # puts(x_coords)
+          # puts(y_coords)
 
-          x_coords.each do |x|
-            xmax = x if x > xmax
-            xmin = x if x < xmin
-          end
+          @boundaries << [xmax, xmin, ymax, ymin]
 
-          y_coords.each do |y|
-            ymax = y if y > ymax
-            ymin = y if y < ymin
+          amount_holes_this_line = encountered_nr_of_coordinates.length - 1
+          if amount_holes_this_line > 0
+            # store how many holes there are in this line
+            # store what the number of the first hole for this line is (for calculating the address to jump)
+            @first_hole_id_in_line << @amount_of_holes
+            # keep track of how many holes there are
+            @amount_of_holes += amount_holes_this_line
+            puts(tz_name)
+
+            (0...amount_holes_this_line).each do |_i|
+              @related_line << @nr_of_lines
+              puts(@nr_of_lines)
+
+              # puts(amount_holes_this_line)
+            end
           end
 
-          @boundaries << [xmax, xmin, ymax, ymin]
+          # for every encountered hole
+          (1...(amount_holes_this_line + 1)).each do |i|
+            x_coords = []
+            y_coords = []
+
+            # since the last coordinate was being left out,
+            # we have to move the pointer 2 floats further to be in the hole data again
+            pointer += 2
+
+            # The last coordinate pair should be left out (is equal to the first one)
+            (0...(2 * (encountered_nr_of_coordinates[i] - 1))).each do |n|
+              if n.even?
+                x_coords << coordinates[pointer].to_f
+              else
+                y_coords << coordinates[pointer].to_f
+              end
+
+              pointer += 1
+            end
+
+            @all_holes << [x_coords, y_coords]
+            @all_hole_lengths << x_coords.length
+          end
         end
+
+        file_line += 1
       end
 
+      # so far the nr_of_lines was used to point to the current polygon but there is actually 1 more polygons in total
+      @nr_of_lines += 1
+
+      puts("amount_of_holes: #{@amount_of_holes}")
+      puts("amount of timezones: #{@nr_of_lines}")
+
       puts("Done\n\n")
     end
 
@@ -158,7 +240,6 @@ module TimezoneFinder
 
     def compile_into_binary(path = 'tz_binary.bin')
       nr_of_floats = 0
-      nr_of_lines = 0
       zone_ids = []
       shortcuts = {}
 
@@ -436,7 +517,7 @@ module TimezoneFinder
       end
 
       def construct_shortcuts(shortcuts)
-        puts('building shortucts...')
+        puts('building shortcuts...')
         puts('currently in line:')
         line = 0
         @boundaries.each do |xmax, xmin, ymax, ymin|
@@ -536,12 +617,16 @@ EOT
         end
       end
 
-      puts('reading the converted .csv file')
+      # test_length = 0
       @ids.each do |id|
-        nr_of_lines += 1
+        # test_length += 1
         zone_ids << id
       end
 
+      # if test_length != @nr_of_lines
+      #   raise ArgumentError, "#{test_length} #{@nr_of_lines} #{@ids.length}"
+      # end
+
       @all_lengths.each do |length|
         nr_of_floats += 2 * length
       end
@@ -553,18 +638,63 @@ EOT
       puts("calculating the shortcuts took: #{end_time - start_time}")
 
       # address where the actual polygon data starts. look in the description below to get more info
-      polygon_address = (24 * nr_of_lines + 6)
+      polygon_address = (24 * @nr_of_lines + 12)
 
       # for every original float now 4 bytes are needed (int32)
       shortcut_start_address = polygon_address + 4 * nr_of_floats
-      puts("The number of polygons is: #{nr_of_lines}")
+
+      # write number of entries in shortcut field (x,y)
+      nr_of_entries_in_shortcut = []
+      shortcut_entries = []
+      amount_filled_shortcuts = 0
+
+      # count how many shortcut addresses will be written:
+      (0...(360 * NR_SHORTCUTS_PER_LNG)).each do |x|
+        (0...(180 * NR_SHORTCUTS_PER_LAT)).each do |y|
+          begin
+            this_lines_shortcuts = shortcuts.fetch([x, y])
+            shortcut_entries << this_lines_shortcuts
+            amount_filled_shortcuts += 1
+            nr_of_entries_in_shortcut << this_lines_shortcuts.length
+            # puts "(#{x}, #{y}, #{this_lines_shortcuts})"
+          rescue KeyError
+            nr_of_entries_in_shortcut << 0
+          end
+        end
+      end
+
+      amount_of_shortcuts = nr_of_entries_in_shortcut.length
+      if amount_of_shortcuts != 64_800 * NR_SHORTCUTS_PER_LNG * NR_SHORTCUTS_PER_LAT
+        puts(amount_of_shortcuts)
+        fail ArgumentError, 'this number of shortcut zones is wrong'
+      end
+
+      puts("number of filled shortcut zones are: #{amount_filled_shortcuts} (=#{(amount_filled_shortcuts.fdiv(amount_of_shortcuts) * 100).round(2)}% of all shortcuts)")
+
+      # for every shortcut S> and L> is written (nr of entries and address)
+      shortcut_space = 360 * NR_SHORTCUTS_PER_LNG * 180 * NR_SHORTCUTS_PER_LAT * 6
+      nr_of_entries_in_shortcut.each do |nr|
+        # every line in every shortcut takes up 2bytes
+        shortcut_space += 2 * nr
+      end
+
+      hole_start_address = shortcut_start_address + shortcut_space
+
+      puts("The number of polygons is: #{@nr_of_lines}")
       puts("The number of floats in all the polygons is (2 per point): #{nr_of_floats}")
       puts("now writing file \"#{path}\"")
       output_file = open(path, 'wb')
       # write nr_of_lines
-      output_file.write([nr_of_lines].pack('S>'))
+      output_file.write([@nr_of_lines].pack('S>'))
       # write start address of shortcut_data:
       output_file.write([shortcut_start_address].pack('L>'))
+
+      # S> amount of holes
+      output_file.write([@amount_of_holes].pack('S>'))
+
+      # L> Address of Hole area (end of shortcut area +1) @ 8
+      output_file.write([hole_start_address].pack('L>'))
+
       # write zone_ids
       zone_ids.each do |zone_id|
         output_file.write([zone_id].pack('S>'))
@@ -603,33 +733,8 @@ EOT
       end
 
       puts("position after writing all polygon data (=start of shortcut section): #{output_file.tell}")
-      # write number of entries in shortcut field (x,y)
-      nr_of_entries_in_shortcut = []
-      shortcut_entries = []
-      total_entries_in_shortcuts = 0
-
-      # count how many shortcut addresses will be written:
-      (0...(360 * NR_SHORTCUTS_PER_LNG)).each do |x|
-        (0...(180 * NR_SHORTCUTS_PER_LAT)).each do |y|
-          begin
-            this_lines_shortcuts = shortcuts.fetch([x, y])
-            shortcut_entries << this_lines_shortcuts
-            total_entries_in_shortcuts += 1
-            nr_of_entries_in_shortcut << this_lines_shortcuts.length
-            # puts("(#{x}, #{y}, #{this_lines_shortcuts})")
-          rescue KeyError
-            nr_of_entries_in_shortcut << 0
-          end
-        end
-      end
-
-      puts("The number of filled shortcut zones are: #{total_entries_in_shortcuts}")
-
-      if nr_of_entries_in_shortcut.length != 64_800 * NR_SHORTCUTS_PER_LNG * NR_SHORTCUTS_PER_LAT
-        puts(nr_of_entries_in_shortcut.length)
-        fail 'this number of shortcut zones is wrong'
-      end
 
+      # [SHORTCUT AREA]
       # write all nr of entries
       nr_of_entries_in_shortcut.each do |nr|
         fail "There are too many polygons in this shortcuts: #{nr}" if nr > 300
@@ -644,7 +749,7 @@ EOT
           output_file.write([0].pack('L>'))
         else
           output_file.write([shortcut_address].pack('L>'))
-          # each polygon takes up 2 bytes of space
+          # each line_nr takes up 2 bytes of space
           shortcut_address += 2 * nr
         end
       end
@@ -652,17 +757,59 @@ EOT
       # write Line_Nrs for every shortcut
       shortcut_entries.each do |entries|
         entries.each do |entry|
-          fail entry if entry > nr_of_lines
+          fail entry if entry > @nr_of_lines
           output_file.write([entry].pack('S>'))
         end
       end
 
+      # [HOLE AREA, Y = number of holes (very few: around 22)]
+
+      # '!H' for every hole store the related line
+      i = 0
+      @related_line.each do |line|
+        fail ArgumentError, line if line > @nr_of_lines
+        output_file.write([line].pack('S>'))
+        i += 1
+      end
+
+      if i > @amount_of_holes
+        fail ArgumentError, 'There are more related lines than holes.'
+      end
+
+      # 'S>'  Y times [H unsigned short: nr of values (coordinate PAIRS! x,y in int32 int32) in this hole]
+      @all_hole_lengths.each do |length|
+        output_file.write([length].pack('S>'))
+      end
+
+      # '!I' Y times [ I unsigned int: absolute address of the byte where the data of that hole starts]
+      hole_address = output_file.tell + @amount_of_holes * 4
+      @all_hole_lengths.each do |length|
+        output_file.write([hole_address].pack('L>'))
+        # each pair of points takes up 8 bytes of space
+        hole_address += 8 * length
+      end
+
+      # Y times [ 2x i signed ints for every hole: x coords, y coords ]
+      # write hole polygon_data
+      @all_holes.each do |x_coords, y_coords|
+        x_coords.each do |x|
+          output_file.write([Helpers.coord2int(x)].pack('l>'))
+        end
+        y_coords.each do |y|
+          output_file.write([Helpers.coord2int(y)].pack('l>'))
+        end
+      end
+
       last_address = output_file.tell
-      shortcut_space = last_address - shortcut_start_address
+      hole_space = last_address - hole_start_address
+      if shortcut_space != last_address - shortcut_start_address - hole_space
+        fail ArgumentError, 'shortcut space is computed wrong'
+      end
       polygon_space = nr_of_floats * 4
 
-      puts("the shortcuts make up #{((shortcut_space / last_address) * 100).round(2) }% of the file")
-      puts("the polygon data makes up #{((polygon_space / last_address) * 100)}.round(2)% of the file")
+      puts("the polygon data makes up #{(polygon_space.fdiv(last_address) * 100).round(2)}% of the file")
+      puts("the shortcuts make up #{(shortcut_space.fdiv(last_address) * 100).round(2) }% of the file")
+      puts("the holes make up #{(hole_space.fdiv(last_address) * 100).round(2) }% of the file")
 
       puts('Success!')
     end
@@ -674,37 +821,58 @@ and it takes lot less space, without loosing too much accuracy (min accuracy is
 
 no of rows (= no of polygons = no of boundaries)
 approx. 28k -> use 2byte unsigned short (has range until 65k)
-'!H' = n
+'S>' = n
+
+L> Address of Shortcut area (end of polygons+1) @ 2
+
+S> amount of holes @6
 
-I Address of Shortcut area (end of polygons+1) @ 2
+L> Address of Hole area (end of shortcut area +1) @ 8
 
-'!H'  n times [H unsigned short: zone number=ID in this line, @ 6 + 2* lineNr]
+'S>'  n times [H unsigned short: zone number=ID in this line, @ 12 + 2* lineNr]
 
-'!H'  n times [H unsigned short: nr of values (coordinate PAIRS! x,y in long long) in this line, @ 6 + 2n + 2* lineNr]
+'S>'  n times [H unsigned short: nr of values (coordinate PAIRS! x,y in long long) in this line, @ 12 + 2n + 2* lineNr]
 
-'!I'n times [ I unsigned int: absolute address of the byte where the polygon-data of that line starts,
-@ 6 + 4 * n +  4*lineNr]
+'L>'n times [ I unsigned int: absolute address of the byte where the polygon-data of that line starts,
+@ 12 + 4 * n +  4*lineNr]
 
 
 
-n times 4 int32 (take up 4*4 per line): xmax, xmin, ymax, ymin  @ 6 + 8n + 16* lineNr
-'!iiii'
+n times 4 int32 (take up 4*4 per line): xmax, xmin, ymax, ymin  @ 12 + 8n + 16* lineNr
+'l>l>l>l>'
 
 
-[starting @ 6+ 24*n = polygon data start address]
+[starting @ 12+ 24*n = polygon data start address]
 (for every line: x coords, y coords:)   stored  @ Address section (see above)
-'!i' * amount of points
+'l>' * amount of points
+
+360 * NR_SHORTCUTS_PER_LNG * 180 * NR_SHORTCUTS_PER_LAT:
+[atm: 360* 1 * 180 * 2 = 129,600]
+129,600 times S>   number of entries in shortcut field (x,y)  @ Pointer see above
 
+
+[SHORTCUT AREA]
 360 * NR_SHORTCUTS_PER_LNG * 180 * NR_SHORTCUTS_PER_LAT:
 [atm: 360* 1 * 180 * 2 = 129,600]
-129,600 times !H   number of entries in shortcut field (x,y)  @ Pointer see above
+129,600 times S>   number of entries in shortcut field (x,y)  @ Pointer see above
 
 
 Address of first Polygon_nr  in shortcut field (x,y) [0 if there is no entry] @  Pointer see above + 129,600
-129,600 times !I
+129,600 times L>
 
 [X = number of filled shortcuts]
-X times !H * amount Polygon_Nr    @ address stored in previous section
+X times S> * amount Polygon_Nr    @ address stored in previous section
+
+
+[HOLE AREA, Y = number of holes (very few: around 22)]
+
+'S>' for every hole store the related line
+
+'S>'  Y times [S unsigned short: nr of values (coordinate PAIRS! x,y in int32 int32) in this hole]
+
+'L>' Y times [ L unsigned int: absolute address of the byte where the data of that hole starts]
+
+Y times [ 2x i signed ints for every hole: x coords, y coords ]
 
 EOT
   end

data/lib/timezone_finder/gem_version.rb

@@ -1,5 +1,5 @@
 module TimezoneFinder
-  VERSION = '0.0.1' unless defined? TimezoneFinder::Version
+  VERSION = '1.5.5' unless defined? TimezoneFinder::Version
   # https://github.com/MrMinimal64/timezonefinder
-  BASED_SHA1_OF_PYTHON = '55861df0d1ae6c4727e7f48068f7cc51ea3891b3'
+  BASED_SHA1_OF_PYTHON = 'f291dad017a839f25c472f4976d2a187de104ca8'
 end

data/lib/timezone_finder/helpers.rb

@@ -6,24 +6,23 @@ module TimezoneFinder
   class Helpers
     # tests if a point pX(x,y) is Left|On|Right of an infinite line from p1 to p2
     #     Return: 2 for pX left of the line from! p1 to! p2
-    #            1 for pX on the line
+    #             1 for pX on the line [is not needed]
     #             0 for pX  right of the line
     #             this approach is only valid because we already know that y lies within ]y1;y2]
     def self.position_to_line(x, y, x1, x2, y1, y2)
-      if x1 > x2
-        # p1 is further right than p2
-        if x > x1
-          # pX is further right than p1,
+      if x1 < x2
+        # p2 is further right than p1
+        if x > x2
+          # pX is further right than p2,
           if y1 > y2
-            # so it has to be left of the line p1-p2
             return 2
           else
             return 0
           end
         end
 
-        if x < x2
-          # pX is further left than p2,
+        if x < x1
+          # pX is further left than p1
           if y1 > y2
             # so it has to be right of the line p1-p2
             return 0
@@ -32,44 +31,22 @@ module TimezoneFinder
           end
         end
 
-        # x1 greater than x2
-        x1gtx2 = True
-
-      elsif x1 == x2
-        # this is a vertical line, the position of pX is also determined by y1 and y2
-
-        if y1 > y2
-
-          return 2 if x > x1
-          if x == x1
-            return 1
-          else
-            return 0
-          end
-
-        else
-          return 0 if x > x1
-          if x == x1
-            return 1
-          else
-            return 2
-          end
-        end
+        x1gtx2 = false
 
       else
-        # p2 is further right than p1
-
-        if x > x2
-          # pX is further right than p2,
+        # p1 is further right than p2
+        if x > x1
+          # pX is further right than p1,
           if y1 > y2
+            # so it has to be left of the line p1-p2
             return 2
           else
             return 0
           end
         end
 
-        if x < x1
-          # pX is further left than p1
+        if x < x2
+          # pX is further left than p2,
           if y1 > y2
             # so it has to be right of the line p1-p2
             return 0
@@ -78,16 +55,23 @@ module TimezoneFinder
           end
         end
 
-        x1gtx2 = False
+        # TODO: is not return also accepted
+        if x1 == x2 && x == x1
+          # could also be equal
+          return 1
+        end
+
+        # x1 greater than x2
+        x1gtx2 = true
       end
 
       # x is between [x1;x2]
       # compute the x-intersection of the point with the line p1-p2
-      # delta_y =  cannot be 0 here because of the condition 'y lies within ]y1;y2]'
+      # delta_y cannot be 0 here because of the condition 'y lies within ]y1;y2]'
       # NOTE: bracket placement is important here (we are dealing with 64-bit ints!). first divide then multiply!
-      x_difference = ((y - y1) * ((x2 - x1).fdiv(y2 - y1))) + x1 - x
+      delta_x = ((y - y1) * ((x2 - x1).fdiv(y2 - y1))) + x1 - x
 
-      if x_difference > 0
+      if delta_x > 0
         if x1gtx2
           if y1 > y2
             return 0
@@ -103,7 +87,7 @@ module TimezoneFinder
           end
         end
 
-      elsif x_difference == 0
+      elsif delta_x == 0
         return 1
 
       else
@@ -182,6 +166,21 @@ module TimezoneFinder
       wn != 0
     end
 
+    def self.all_the_same(pointer, length, id_list)
+      # List mustn't be empty or Null
+      # There is at least one
+
+      element = id_list[pointer]
+      pointer += 1
+
+      while pointer < length
+        return -1 if element != id_list[pointer]
+        pointer += 1
+      end
+
+      element
+    end
+
     def self.cartesian2rad(x, y, z)
       [Math.atan2(y, x), Math.asin(z)]
     end

data/lib/timezone_finder/timezone_finder.rb

@@ -1,7 +1,7 @@
 # rubocop:disable Metrics/ClassLength,Metrics/MethodLength,Metrics/LineLength
 # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/ParameterLists
 # rubocop:disable Style/PredicateName,Style/Next,Style/AndOr
-# rubocop:disable Lint/Void
+# rubocop:disable Lint/Void,Lint/HandleExceptions
 require_relative 'helpers'
 require_relative 'timezone_names'
 
@@ -23,13 +23,45 @@ module TimezoneFinder
       # the address where the shortcut section starts (after all the polygons) this is 34 433 054
       @shortcuts_start = @binary_file.read(4).unpack('L>')[0]
 
-      @nr_val_start_address = 2 * @nr_of_entries + 6
-      @adr_start_address = 4 * @nr_of_entries + 6
-      @bound_start_address = 8 * @nr_of_entries + 6
-      # @poly_start_address = 40 * @nr_of_entries + 6
-      @poly_start_address = 24 * @nr_of_entries + 6
+      @amount_of_holes = @binary_file.read(2).unpack('S>')[0]
+
+      @hole_area_start = @binary_file.read(4).unpack('L>')[0]
+
+      @nr_val_start_address = 2 * @nr_of_entries + 12
+      @adr_start_address = 4 * @nr_of_entries + 12
+      @bound_start_address = 8 * @nr_of_entries + 12
+      # @poly_start_address = 40 * @nr_of_entries + 12
       @first_shortcut_address = @shortcuts_start + 259_200
 
+      @nr_val_hole_address = @hole_area_start + @amount_of_holes * 2
+      @adr_hole_address = @hole_area_start + @amount_of_holes * 4
+      # @hole_data_start = @hole_area_start + @amount_of_holes * 8
+
+      # for store for which polygons (how many) holes exits and the id of the first of those holes
+      @hole_registry = {}
+      last_encountered_line_nr = 0
+      first_hole_id = 0
+      amount_of_holes = 0
+      @binary_file.seek(@hole_area_start)
+      (0...@amount_of_holes).each do |i|
+        related_line = @binary_file.read(2).unpack('S>')[0]
+        # puts(related_line)
+        if related_line == last_encountered_line_nr
+          amount_of_holes += 1
+        else
+          if i != 0
+            @hole_registry.update(last_encountered_line_nr => [amount_of_holes, first_hole_id])
+          end
+
+          last_encountered_line_nr = related_line
+          first_hole_id = i
+          amount_of_holes = 1
+        end
+      end
+
+      # write the entry for the last hole(s) in the registry
+      @hole_registry.update(last_encountered_line_nr => [amount_of_holes, first_hole_id])
+
       ObjectSpace.define_finalizer(self, self.class.__del__)
     end
 
@@ -41,7 +73,7 @@ module TimezoneFinder
 
     def id_of(line = 0)
       # ids start at address 6. per line one unsigned 2byte int is used
-      @binary_file.seek((6 + 2 * line))
+      @binary_file.seek((12 + 2 * line))
       @binary_file.read(2).unpack('S>')[0]
     end
 
@@ -50,7 +82,7 @@ module TimezoneFinder
 
       i = 0
       iterable.each do |line_nr|
-        @binary_file.seek((6 + 2 * line_nr))
+        @binary_file.seek((12 + 2 * line_nr))
         id_array[i] = @binary_file.read(2).unpack('S>')[0]
         i += 1
       end
@@ -102,7 +134,24 @@ module TimezoneFinder
        Helpers.fromfile(@binary_file, false, 4, nr_of_values)]
     end
 
-    # @profile
+    def _holes_of_line(line = 0)
+      amount_of_holes, hole_id = @hole_registry.fetch(line)
+
+      (0...amount_of_holes).each do |_i|
+        @binary_file.seek(@nr_val_hole_address + 2 * hole_id)
+        nr_of_values = @binary_file.read(2).unpack('S>')[0]
+
+        @binary_file.seek(@adr_hole_address + 4 * hole_id)
+        @binary_file.seek(@binary_file.read(4).unpack('L>')[0])
+
+        yield [Helpers.fromfile(@binary_file, false, 4, nr_of_values),
+               Helpers.fromfile(@binary_file, false, 4, nr_of_values)]
+
+        hole_id += 1
+      end
+    rescue KeyError
+    end
+
     # This function searches for the closest polygon in the surrounding shortcuts.
     # Make sure that the point does not lie within a polygon (for that case the algorithm is simply wrong!)
     # Note that the algorithm won't find the closest polygon when it's on the 'other end of earth'
@@ -219,18 +268,16 @@ module TimezoneFinder
       return TIMEZONE_NAMES[id_of(possible_polygons[0])] if nr_possible_polygons == 1
 
       # initialize the list of ids
+      # TODO: sort from least to most occurrences
       ids = possible_polygons.map { |p| id_of(p) }
 
-      # if all the polygons belong to the same zone return it
-      first_entry = ids[0]
-      if ids.count(first_entry) == nr_possible_polygons
-        return TIMEZONE_NAMES[first_entry]
-      end
-
       # otherwise check if the point is included for all the possible polygons
       (0...nr_possible_polygons).each do |i|
         polygon_nr = possible_polygons[i]
 
+        same_element = Helpers.all_the_same(i, nr_possible_polygons, ids)
+        return TIMEZONE_NAMES[same_element] if same_element != -1
+
         # get the boundaries of the polygon = (lng_max, lng_min, lat_max, lat_min)
         # self.binary_file.seek((@bound_start_address + 32 * polygon_nr), )
         @binary_file.seek((@bound_start_address + 16 * polygon_nr))
@@ -238,8 +285,19 @@ module TimezoneFinder
         # only run the algorithm if it the point is withing the boundaries
         unless x > boundaries[0] or x < boundaries[1] or y > boundaries[2] or y < boundaries[3]
 
-          if Helpers.inside_polygon(x, y, coords_of(polygon_nr))
-            return TIMEZONE_NAMES[ids[i]]
+          outside_all_holes = true
+          # when the point is within a hole of the polygon this timezone doesn't need to be checked
+          _holes_of_line(polygon_nr) do |hole_coordinates|
+            if Helpers.inside_polygon(x, y, hole_coordinates)
+              outside_all_holes = false
+              break
+            end
+          end
+
+          if outside_all_holes
+            if Helpers.inside_polygon(x, y, coords_of(polygon_nr))
+              return TIMEZONE_NAMES[ids[i]]
+            end
           end
         end
       end
@@ -267,9 +325,20 @@ module TimezoneFinder
         @binary_file.seek((@bound_start_address + 16 * polygon_nr))
         boundaries = Helpers.fromfile(@binary_file, false, 4, 4)
         unless x > boundaries[0] or x < boundaries[1] or y > boundaries[2] or y < boundaries[3]
-          if Helpers.inside_polygon(x, y, coords_of(polygon_nr))
-            fail id_of(polygon_nr) if id_of(polygon_nr) >= 424
-            return TIMEZONE_NAMES[id_of(polygon_nr)]
+
+          outside_all_holes = true
+          # when the point is within a hole of the polygon this timezone doesn't need to be checked
+          _holes_of_line(polygon_nr) do |hole_coordinates|
+            if Helpers.inside_polygon(x, y, hole_coordinates)
+              outside_all_holes = false
+              break
+            end
+          end
+
+          if outside_all_holes
+            if Helpers.inside_polygon(x, y, coords_of(polygon_nr))
+              return TIMEZONE_NAMES[id_of(polygon_nr)]
+            end
           end
         end
       end

data/lib/timezone_finder/timezone_names.rb

@@ -276,6 +276,7 @@ module TimezoneFinder
     'Asia/Tehran',
     'Asia/Thimphu',
     'Asia/Tokyo',
+    'Asia/Tomsk',
     'Asia/Ulaanbaatar',
     'Asia/Urumqi',
     'Asia/Ust-Nera',
@@ -328,6 +329,7 @@ module TimezoneFinder
     'Europe/Jersey',
     'Europe/Kaliningrad',
     'Europe/Kiev',
+    'Europe/Kirov',
     'Europe/Lisbon',
     'Europe/Ljubljana',
     'Europe/London',

data/timezone_finder.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = 'Look up timezone from lat / long offline.'
   spec.description = %(
-    Python library to look up timezone from lat / long offline.
+    A pure Ruby library to look up timezone from latitude / longitude offline.
     Ported version of 'timezonefinder' on PyPI.
   ).strip.gsub(/\s+/, ' ')
   spec.homepage     = 'https://github.com/gunyarakun/timezone_finder'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timezone_finder
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.5.5
 platform: ruby
 authors:
 - Tasuku SUENAGA a.k.a. gunyarakun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-26 00:00:00.000000000 Z
+date: 2016-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,8 +80,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.40'
-description: Python library to look up timezone from lat / long offline. Ported version
-  of 'timezonefinder' on PyPI.
+description: A pure Ruby library to look up timezone from latitude / longitude offline.
+  Ported version of 'timezonefinder' on PyPI.
 email:
 - tasuku-s-github@titech.ac
 executables: []
@@ -93,6 +93,7 @@ files:
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".travis.yml"
+- ChangeLog
 - Gemfile
 - LICENSE.txt
 - README.md