turf-ruby 0.8.1 → 1.1.0

data/lib/turf/boolean_concave.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  # frozen_string_literal: true
+
+  # Takes a polygon and returns true or false as to whether it is concave or not.
+  #
+  # @function
+  # @param [Feature<Polygon>, Polygon] polygon to be evaluated
+  # @return [Boolean] true/false
+  # @example
+  #   convex_polygon = polygon([[[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]])
+  #
+  #   boolean_concave(convex_polygon)
+  #   # => false
+  def boolean_concave(polygon)
+    coords = get_geom(polygon)[:coordinates]
+    return false if coords[0].length <= 4
+
+    sign = nil
+    n = coords[0].length - 1
+
+    (0...n).each do |i|
+      dx1 = coords[0][(i + 2) % n][0] - coords[0][(i + 1) % n][0]
+      dy1 = coords[0][(i + 2) % n][1] - coords[0][(i + 1) % n][1]
+      dx2 = coords[0][i][0] - coords[0][(i + 1) % n][0]
+      dy2 = coords[0][i][1] - coords[0][(i + 1) % n][1]
+      zcrossproduct = (dx1 * dy2) - (dy1 * dx2)
+
+      if i.zero?
+        sign = zcrossproduct.positive?
+      elsif sign != zcrossproduct.positive?
+        return true
+      end
+    end
+
+    false
+  end
+end

data/lib/turf/boolean_contains.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def boolean_contains(*args)
+    raise NotImplementedError
+  end
+
+  def is_polygon_in_multi_polygon(*args)
+    raise NotImplementedError
+  end
+
+  def is_point_in_multi_point(*args)
+    raise NotImplementedError
+  end
+
+  def is_multi_point_in_multi_point(*args)
+    raise NotImplementedError
+  end
+
+  def is_multi_point_on_line(*args)
+    raise NotImplementedError
+  end
+
+  def is_multi_point_in_poly(*args)
+    raise NotImplementedError
+  end
+
+  def is_line_on_line(*args)
+    raise NotImplementedError
+  end
+
+  def is_line_in_poly(*args)
+    raise NotImplementedError
+  end
+
+  def is_poly_in_poly(*args)
+    raise NotImplementedError
+  end
+
+  def do_b_box_overlap(*args)
+    raise NotImplementedError
+  end
+
+  def compare_coords(*args)
+    raise NotImplementedError
+  end
+
+  def get_midpoint(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/boolean_crosses.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def boolean_crosses(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/boolean_disjoint.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def boolean_disjoint(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/boolean_equal.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def boolean_equal(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/boolean_intersects.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def boolean_intersects(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/boolean_overlap.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def boolean_overlap(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/boolean_parallel.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def boolean_parallel(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/boolean_point_in_polygon.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "invariant"
+
 # :nodoc:
 module Turf
   # @!group Booleans
@@ -13,7 +15,7 @@ module Turf
   # inside
   # the polygon otherwise false.
   # @return [boolean] true if the Point is inside the Polygon; false if the Point is not inside the Polygon
-  def boolean_point_in_polygon(point, polygon, ignore_boundary: false)
+  def boolean_point_in_polygon(point, polygon, options = {})
     polygon = deep_symbolize_keys(polygon)
     pt = get_coord(point)
     geom = get_geom(polygon)
@@ -30,13 +32,13 @@ module Turf
     inside_poly = false
     polys.each do |poly|
       # check if it is in the outer ring first
-      next unless in_ring(pt, poly[0], ignore_boundary)
+      next unless in_ring(pt, poly[0], options[:ignore_boundary])
 
       in_hole = false
 
       # check for the point in any of the holes
       poly.slice(1, poly.size - 1).each do |hole|
-        if in_ring(pt, hole, !ignore_boundary)
+        if in_ring(pt, hole, !options[:ignore_boundary])
           in_hole = true
         end
       end

data/lib/turf/boolean_point_on_line.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  # Returns true if a point is on a line. Accepts an optional parameter to ignore the
+  # start and end vertices of the linestring.
+  #
+  # @param [Hash] pt GeoJSON Point
+  # @param [Hash] line GeoJSON LineString
+  # @param [Hash] options Optional parameters
+  # @option options [Boolean] :ignore_end_vertices whether to ignore the start and end vertices.
+  # @option options [Float] :epsilon Fractional number to compare with the cross product result.
+  # Useful for dealing with floating points such as lng/lat points
+  # @return [Boolean] true/false
+  # @example
+  #   pt = turf_point([0, 0])
+  #   line = turf_line_string([[-1, -1], [1, 1], [1.5, 2.2]])
+  #   is_point_on_line = boolean_point_on_line(pt, line)
+  #   # => true
+  def boolean_point_on_line(point, line, options = nil)
+    options ||= {}
+    # Normalize inputs
+    pt_coords = get_coord(point)
+    line_coords = get_coords(line)
+
+    # Main
+    line_coords.each_cons(2) do |line_segment_start, line_segment_end|
+      ignore_boundary = false
+      if options[:ignore_end_vertices]
+        first_segment = (line_coords.first == line_segment_start)
+        last_segment = (line_coords.last == line_segment_end)
+
+        if first_segment && last_segment
+          ignore_boundary = :both
+        elsif first_segment
+          ignore_boundary = :start
+        elsif last_segment
+          ignore_boundary = :end
+        end
+      end
+
+      return true if is_point_on_line_segment(
+        line_segment_start,
+        line_segment_end,
+        pt_coords,
+        ignore_boundary,
+        options[:epsilon],
+      )
+    end
+
+    false
+  end
+
+  # Determines if a point is on a line segment.
+  #
+  # @param [Array<Float>] line_segment_start Coordinate pair of the start of the line segment [x1, y1].
+  # @param [Array<Float>] line_segment_end Coordinate pair of the end of the line segment [x2, y2].
+  # @param [Array<Float>] pt Coordinate pair of the point to check [px, py].
+  # @param [Boolean, String] exclude_boundary Whether the point is allowed to fall on the line ends.
+  # Can be true, false, or one of "start", "end", or "both".
+  # @param [Float, NilClass] epsilon Fractional tolerance for cross-product
+  # comparison (useful for floating-point coordinates).
+  # @return [Boolean] true if the point is on the line segment, false otherwise.
+  def is_point_on_line_segment(line_segment_start, line_segment_end, point, exclude_boundary, epsilon = nil)
+    x, y = point
+    x1, y1 = line_segment_start
+    x2, y2 = line_segment_end
+
+    dxc = x - x1
+    dyc = y - y1
+    dxl = x2 - x1
+    dyl = y2 - y1
+    cross = (dxc * dyl) - (dyc * dxl)
+
+    if epsilon
+      return false if cross.abs > epsilon
+    elsif cross != 0
+      return false
+    end
+
+    # Special case: zero-length line segments
+    if dxl == 0 && dyl == 0
+      return false if exclude_boundary
+
+      return point == line_segment_start
+    end
+
+    case exclude_boundary
+    when false
+      if dxl.abs >= dyl.abs
+        if dxl > 0
+          x.between?(x1,
+                     x2)
+        else
+          x.between?(x2,
+                     x1)
+        end
+      else
+        (if dyl > 0
+           y.between?(y1,
+                      y2)
+         else
+           y.between?(y2, y1)
+         end)
+      end
+    when :start
+      if dxl.abs >= dyl.abs
+        dxl > 0 ? x1 < x && x <= x2 : x2 <= x && x < x1
+      else
+        (dyl > 0 ? y1 < y && y <= y2 : y2 < y && y < y1)
+      end
+    when :end
+      if dxl.abs >= dyl.abs
+        dxl > 0 ? x1 <= x && x < x2 : x2 < x && x <= x1
+      else
+        (dyl > 0 ? y1 <= y && y < y2 : y2 < y && y <= y1)
+      end
+    when :both
+      if dxl.abs >= dyl.abs
+        dxl > 0 ? x1 < x && x < x2 : x2 < x && x < x1
+      else
+        (dyl > 0 ? y1 < y && y < y2 : y2 < y && y < y1)
+      end
+    else
+      false
+    end
+  end
+end

data/lib/turf/boolean_touches.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def boolean_touches(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/boolean_valid.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def boolean_valid(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/boolean_within.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def boolean_within(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/buffer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def buffer(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/center.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  # frozen_string_literal: true
+
+  # Takes a Feature or FeatureCollection and returns the absolute center point of all features.
+  #
+  # @param [GeoJSON] geojson GeoJSON to be centered
+  # @param [Hash] options Optional parameters
+  # @option options [Hash] :properties Translate GeoJSON Properties to Point
+  # @option options [Array] :bbox Translate GeoJSON BBox to Point
+  # @option options [String, Integer] :id Translate GeoJSON Id to Point
+  # @return [Feature<Point>] a Point feature at the absolute center point of all input features
+  # @example
+  #   features = points([
+  #     [-97.522259, 35.4691],
+  #     [-97.502754, 35.463455],
+  #     [-97.508269, 35.463245]
+  #   ])
+  #   center = center(features)
+  #   # Add to map
+  #   add_to_map = [features, center]
+  #   center[:properties]['marker-size'] = 'large'
+  #   center[:properties]['marker-color'] = '#000'
+  def center(geojson, options = {})
+    ext = bbox(geojson)
+    x = (ext[0] + ext[2]) / 2.0
+    y = (ext[1] + ext[3]) / 2.0
+    point([x, y], options[:properties] || {}, options)
+  end
+end

data/lib/turf/center_mean.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def center_mean(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/center_median.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def center_median(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/center_of_mass.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def center_of_mass(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/centroid.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "helpers"
+require_relative "meta"
+
 # :nodoc:
 module Turf
   # @!group Measurement
@@ -10,7 +13,7 @@ module Turf
   # @param geojson [GeoJSON] GeoJSON to be centered
   # @param properties [Hash] a [Hash] that is used as the Feature's properties
   # @return [Feature<Point>] the centroid of the input features
-  def centroid(geojson, properties: {})
+  def centroid(geojson, properties = nil)
     x_sum = 0.0
     y_sum = 0.0
     len = 0.0
@@ -23,7 +26,7 @@ module Turf
 
     point(
       [x_sum / len, y_sum / len],
-      properties: properties,
+      properties,
     )
   end
 end

data/lib/turf/circle.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "destination"
+require_relative "helpers"
+
 # :nodoc:
 module Turf
   # Takes a Point and calculates the circle polygon given a radius in degrees, radians, miles, or kilometers;
@@ -22,10 +25,10 @@ module Turf
     # main
     coordinates = []
     steps.times do |i|
-      coordinates.push(destination(center, radius, (i * -360.0) / steps, **options).dig(:geometry, :coordinates))
+      coordinates.push(destination(center, radius, (i * -360.0) / steps, options).dig(:geometry, :coordinates))
     end
     coordinates.push(coordinates[0])
 
-    polygon([coordinates], properties: properties)
+    polygon([coordinates], properties)
   end
 end

data/lib/turf/clean_coords.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def clean_coords(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/clone.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def clone(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/clusters.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def get_cluster(*args)
+    raise NotImplementedError
+  end
+
+  def cluster_each(*args)
+    raise NotImplementedError
+  end
+
+  def cluster_reduce(*args)
+    raise NotImplementedError
+  end
+
+  def create_bins(*args)
+    raise NotImplementedError
+  end
+
+  def apply_filter(*args)
+    raise NotImplementedError
+  end
+
+  def properties_contains_filter(*args)
+    raise NotImplementedError
+  end
+
+  def filter_properties(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/clusters_dbscan.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def clusters_dbscan(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/clusters_kmeans.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def clusters_kmeans(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/collect.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def collect(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/combine.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def combine(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/concave.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def concave(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/convex.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def convex(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/destination.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "helpers"
+require_relative "invariant"
+
 # :nodoc:
 module Turf
   # @!group Measurement
@@ -10,8 +13,8 @@ module Turf
   # @param origin [Coord] starting point
   # @param distance [number] distance from the origin point
   # @param bearing [number] ranging from -180 to 180
-  # @param units [string] miles, kilometers, degrees, or radians
-  # @param properties [Hash] Translate properties to Point
+  # @param options[:units] [string] miles, kilometers, degrees, or radians
+  # @param options[:properties] [Hash] Translate properties to Point
   # @return [Feature<Point>] destination point
   def destination(origin, distance, bearing, options = {})
     coordinates1 = get_coord origin
@@ -29,6 +32,6 @@ module Turf
     lng = radians_to_degrees(longitude2)
     lat = radians_to_degrees(latitude2)
 
-    point([lng, lat], properties: options[:properties])
+    point([lng, lat], options[:properties])
   end
 end

data/lib/turf/difference.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def difference(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/directional_mean.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def directional_mean(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/dissolve.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def dissolve(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/distance.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "helpers"
+require_relative "invariant"
+
 # :nodoc:
 module Turf
   # @!group Measurement
@@ -11,7 +14,7 @@ module Turf
   # @param to [Coord] destination point
   # @param units [string] can be degrees, radians, miles, or kilometers
   # @return [number] distance between the two points
-  def distance(from, to, units: "kilometers")
+  def distance(from, to, options = {})
     coordinates1 = get_coord from
     coordinates2 = get_coord to
 
@@ -31,7 +34,7 @@ module Turf
         Math.sqrt(a),
         Math.sqrt(1 - a),
       ),
-      units,
+      options[:units],
     )
   end
 end

data/lib/turf/distance_weight.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def p_norm_distance(*args)
+    raise NotImplementedError
+  end
+
+  def distance_weight(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/ellipse.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def ellipse(*args)
+    raise NotImplementedError
+  end
+end