turf-ruby 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 934aa7ef548c273fb906a74bd0d16b5344002274a8148ea4ec05ea7cf1b82cb6
-  data.tar.gz: 429c123473d5db24ec4aaf3562a1104c9c815d9b2579b843267f1cd451f6d639
+  metadata.gz: aace9437eb9fd63a23fb1cae270444dffa0dbf58f371ce88abf1ff7dc483fb5b
+  data.tar.gz: 15ef3f0c1cc5dd1d9ebfaf298512f0a509bb524a432b002cccfe48a4b5d2d011
 SHA512:
-  metadata.gz: 2fcdbcbb0a61f0a6ccf80c9f848fb0a60025bcb70803617ca211594228f9ab0a1d44f4d0563a63d3ac3399da812bbbe61140552d029d1987b4af00abbedd37f3
-  data.tar.gz: 0debca6e4ee62bfad49f9d7c3124fe295dbf361f67c2c340aa03a8ff2e3fc5aa564cd435e5ee929d4965a49b9dacea8d6730ba7932f3b9e4e0e2dae73d2a1f8f
+  metadata.gz: e56d69dd9c440438b5de0734b7c8068e745a111a27c17fa7c6fc5883eed7c42fcdc1765234605f533fb9becfc22d7009c95199111665a147738e38abe0c5c30c
+  data.tar.gz: c5cf79e1af361fb5010c4f997445ddc7d6378422e07252b01f105464863d2253a0d8de89ed889ec872f958a81b0cfccd6c983076d80b92aaf236f75b05c6e6c4

data/README.md

@@ -1,4 +1,7 @@
-# turf-ruby [![Build Status](https://travis-ci.com/formigarafa/turf-ruby.svg?branch=master)](https://travis-ci.com/formigarafa/turf-ruby)
+# turf-ruby
+
+[![Gem Version](https://badge.fury.io/rb/turf-ruby.svg)](https://badge.fury.io/rb/turf-ruby)
+[![Build Status](https://github.com/formigarafa/turf-ruby/actions/workflows/tests.yml/badge.svg)](https://github.com/formigarafa/turf-ruby)
 
 Ruby port of [Turf.js](https://turfjs.org/), an advance geospatial analysis library.
 

data/lib/turf/boolean_clockwise.rb

@@ -1,8 +1,26 @@
 # frozen_string_literal: true
 
-# :nodoc:
+# Takes a ring and returns true or false whether or not the ring is clockwise or counter-clockwise.
+#
+# @param [Array<Array<Number>>] line to be evaluated
+# @return [Boolean] true/false
+# @example
+#   clockwise_ring = [[0, 0], [1, 1], [1, 0], [0, 0]]
+#   counter_clockwise_ring = [[0, 0], [1, 0], [1, 1], [0, 0]]
+#
+#   boolean_clockwise(clockwise_ring)
+#   # => true
+#   boolean_clockwise(counter_clockwise_ring)
+#   # => false
 module Turf
-  def boolean_clockwise(*args)
-    raise NotImplementedError
+  def boolean_clockwise(line)
+    ring = get_coords(line)
+    sum = 0
+
+    ring.each_cons(2) do |prev, cur|
+      sum += (cur[0] - prev[0]) * (cur[1] + prev[1])
+    end
+
+    sum > 0
   end
 end

data/lib/turf/boolean_concave.rb

@@ -2,7 +2,39 @@
 
 # :nodoc:
 module Turf
-  def boolean_concave(*args)
-    raise NotImplementedError
+  # 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_point_on_line.rb

@@ -2,7 +2,127 @@
 
 # :nodoc:
 module Turf
-  def boolean_point_on_line(*args)
-    raise NotImplementedError
+  # 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/length.rb

@@ -18,7 +18,7 @@ module Turf
     segment_reduce(geojson, 0) do |previous_value, segment|
       previous_value ||= 0
       coords = segment.dig(:geometry, :coordinates)
-      previous_value + Turf.distance(coords[0], coords[1], options)
+      previous_value + distance(coords[0], coords[1], options)
     end
   end
 end

data/lib/turf/meta.rb

@@ -419,7 +419,7 @@ module Turf
           next
         end
 
-        segment = Turf.line_string([previous_coords, current_coord], feature[:properties])
+        segment = line_string([previous_coords, current_coord], feature[:properties])
         next unless yield(segment, feature_index, multi_feature_index, geometry_index, segment_index)
 
         segment_index += 1

data/lib/turf/version.rb

@@ -3,5 +3,5 @@
 # :nodoc:
 module Turf
   # Version of turf-ruby
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: turf-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Rafael Santos
 bindir: exe
 cert_chain: []
-date: 2025-04-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Turf Ruby is a Ruby library for spatial analysis. It includes traditional
   spatial operations, helper functions for creating GeoJSON data, and data classification
@@ -161,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: A modular geospatial engine. Ruby port of TurfJS.
 test_files: []