gps_tools 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f34883d049d7636e5425c8e21baa8b2d3db4329cbc5e0e19e5a68fdae380b2ee
+  data.tar.gz: e1bfa8b3b062c361c6137231262003e368d4b33a5855a7faa48217bcc5d6bb86
+SHA512:
+  metadata.gz: db5312a54634fd9acea85c51f20789f463dcf952dc4e22d4cc4a249699866d84107abad20cb359b0d770aed11bf4841105faaf8cf39c757aabbc9293287ba201
+  data.tar.gz: f8d2e305358eeffd2acd3e1530ac2c9a0bde6f0a07d2dac3309bcdc24b1e00bd0c672708352d243c1374a576e7092291b205899cd54aa4f5ea5d59c38df9b4b6

data/lib/gps_tools.rb

@@ -0,0 +1,20 @@
+require 'gps_tools/distance'
+require 'gps_tools/geometry'
+
+class GPSTools
+    ##
+    # Returns the distance in miles (unit = "mile"), kilometers (unit = "km"), or nautical miles (unit = "nm")
+    # between two gps coordinates, coord1 and coord2
+    def self.distance(coord1, coord2, unit = "mile")
+        distance_tool = Distance.new(unit)
+        return distance_tool.get_distance(coord1[0], coord1[1], coord2[0], coord2[1])
+    end
+
+    ##
+    # Returns a boolean that identifies if a given gps coordinate, coord, is within
+    # a given polygon (array of [lat, lng])
+    def self.in_polygon?(polygon, coord)
+        geometry = Geometry.new()
+        return geometry.in_polygon?(polygon, coord)
+    end
+end

data/lib/gps_tools/distance.rb

@@ -0,0 +1,33 @@
+class Distance
+    def initialize(unit = "mile")
+        @unit = unit
+        case @unit
+        when "mile"
+            @earth_radius = 3958.8
+        when "km"
+            @earth_radius = 6378
+        when "nm"
+            @earth_radius = 3440.1 
+        end
+    end
+
+    def get_distance(coord1, coord2)
+        lat1 = coord1[0]
+        long1 = coord1[1]
+        lat2 = coord2[0]
+        long2 = coord2[1]
+
+        lat_diff = lat2 - lat1
+        long_diff = long2 - long1
+
+        a = Math.sin(degrees_to_radians(lat_diff)/2) * Math.sin(degrees_to_radians(lat_diff)/2) + Math.sin(degrees_to_radians(long_diff)/2) * Math.sin(degrees_to_radians(long_diff)/2) * Math.cos(degrees_to_radians(lat1)) * Math.cos(degrees_to_radians(lat2))
+        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+        
+        return @earth_radius * c
+    end
+
+    private 
+        def degrees_to_radians(degrees)
+            degrees * Math::PI / 180
+        end
+end

data/lib/gps_tools/geometry.rb

@@ -0,0 +1,101 @@
+class Geometry
+    def in_radius?(radius, center, coord)
+        distance = Distance.new.get_distance(center, coord)
+        distance <= radius
+    end
+
+    def in_polygon?(polygon, coord)
+        n = polygon.length
+
+        # Polygon must have at least 3 points
+        if n < 3
+            return false
+        end
+        
+        extreme_point = [10000, coord[1]]
+
+        intersections = 0
+        i = 0
+
+        while i < n do
+            if i == n -1
+                next_point = polygon[0]
+            else
+                next_point = polygon[i+1]
+            end
+
+            if intersect?(polygon[i], next_point, coord, extreme_point)
+
+                # Special case - catches case where point is on an edge
+                # if lies on an edge, return true right away
+                if orientation(polygon[i], coord, next_point) == 0 && on_segment(polygon[i], coord, next_point)
+                    return true
+                end
+
+                intersections += 1
+            end
+            i += 1
+        end
+
+        # If odd number of intersections, we're good, if even, outside of polygon
+        intersections % 2 == 1
+    end
+
+    private
+        def max(a, b)
+            a > b ? a : b
+        end
+
+        def min(a, b)
+            a > b ? b : a
+        end
+
+        # Checks if point q is on the line between point p and point r
+        def on_segment(p, q, r)
+            q[0] <= max(p[0], r[0]) && q[0] >= min(p[0], r[0]) && q[1] <= max(p[1], r[1]) && q[1] >= min(p[1], r[1])
+        end
+
+
+        # Determine how three points are oriented relative to each other in given order
+        # 0 => colinear
+        # 1 => clockwise
+        # 2 => counter-clockwise
+        def orientation(p, q, r)
+            val = ((q[1] - p[1]) * (r[0] - q[0])) - ((q[0] - p[0]) * (r[1] - q[1]))
+
+            # If above calculation is exactly 0, the three points must be colinear
+            if val == 0
+                return 0
+            else
+                # Positive value from above calculation means oriented clockwise
+                if val > 0
+                    return 1
+                # PNegative value from above calculation means oriented counter-clockwise
+                else
+                    return 2
+                end
+            end
+        end
+
+        # Check if two lines (p1q1 and p2q2) intersect
+        # This is used to determine if a point is within a polygon
+        def intersect?(p1, q1, p2, q2)
+            # We need to look at 4 different orientations to determine intersection
+            o1 = orientation(p1, q1, p2)
+            o2 = orientation(p1, q1, q2)
+            o3 = orientation(p2, q2, p1)
+            o4 = orientation(p2, q2, q1)
+
+            # General case - if these two pairs are both unequal, we know we have an intersection
+            if o1 != o2 && o3 != o4
+                return true
+            end
+
+            # Edge cases
+            if (o1 == 0 && on_segment(p1, p2, q1)) || (o2 == 0 && on_segment(p1, q2, q1)) || (o3 == 0 && on_segment(p2, p1, q2)) || (o4 == 0 && on_segment(p2, q1, q2))
+                return true
+            end
+
+            return false
+        end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: gps_tools
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dave Van Fleet
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Library of tools for gps coordinates.  Useful for quickly calculating
+  distances, calculating if location is within specified polygon or radius, etc.
+email: dvfleet413@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/gps_tools.rb
+- lib/gps_tools/distance.rb
+- lib/gps_tools/geometry.rb
+homepage: https://rubygems.org/gems/gps_tools
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options:
+- "-m"
+- README.rdoc
+- "-x"
+- lib/(?!gps_tools.rb).*
+- lib/gps_tools.rb
+- LICENSE
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Library of tools for gps coordinates.
+test_files: []