turf-ruby 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a1a13828f696140452584b283d12c6d8c9f365d97cbc0995ccbd275756a84e8
-  data.tar.gz: 8c9b413efdd827194c98535eb64dfe61bb5057c5aa0c61bc1e3899cf9b79a24c
+  metadata.gz: 1449d9f733898e30a4773786b5bf8af4484e90387b2eabea1514673675808bf5
+  data.tar.gz: a90f6e2fa677344a1ab82f855dd288dd1ebd7067e8a96bbc36c14c23088aa740
 SHA512:
-  metadata.gz: b8ba31f189e103c965d96cf6e424e0e229221e3bf0391a0d45156f841b64d43cdbc690be5fe58555c41bd4d800313d177467b3f00b3fc599f87925f4261d3864
-  data.tar.gz: e56c866eef2ff30d099e459a4d0d095931de7ce1c72f5d5a91f569600fbb694c3ef410d6ab050ea614dc565a014d36643ab53b9910eeada430c9fc3bbb5da220
+  metadata.gz: 57668c76b16fba5796e74b217a2f5e9dcd9b00c5f3898e79ed55ac6b81f9788ec70a74f21639e91129a8930d277c791bae1e62028901079ab17467b2329089c2
+  data.tar.gz: 8878e5cc910cf52781b349cc7ac2a3051abed0e46fc7a94bde316185b59930098d0fe2a02014a3cb6b1de0adaf82aade91b7767cd98d098cc57ffe6db91bb81d

data/lib/turf/area.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+#:nodoc:
+module Turf
+  # Takes one or more features and returns their area in square meters.
+  # @see https://turfjs.org/docs/#area
+  # @param geojson [GeoJSON] input GeoJSON feature(s)
+  # @return [number] aria in square meters
+  def area(geojson)
+    geom_reduce(geojson, initial_value: 0) do |value, geom|
+      value + area_calculate_area(geom)
+    end
+  end
+
+  private
+
+  def area_calculate_area(geom)
+    case geom[:type]
+    when "Polygon"
+      area_polygon_area(geom[:coordinates])
+    when "MultiPolygon"
+      geom[:coordinates].map do |coordinate|
+        area_polygon_area(coordinate)
+      end.sum
+    else
+      0
+    end
+  end
+
+  def area_polygon_area(coords)
+    outline, *holes = coords
+    total = area_ring_area(outline).abs
+    holes.each do |hole|
+      total -= area_ring_area(hole).abs
+    end
+    total
+  end
+
+  AREA_RADIUS = 6_378_137
+
+  def area_ring_area(coords)
+    return 0 if coords.size <= 2
+
+    total = 0
+
+    coords.each_with_index do |_coord, index|
+      lower_index, middle_index, upper_index =
+        case index
+        when coords.size - 2
+          [
+            coords.size - 2,
+            coords.size - 1,
+            0,
+          ]
+        when coords.size - 1
+          [
+            coords.size - 1,
+            0,
+            1,
+          ]
+        else
+          [
+            index,
+            index + 1,
+            index + 2,
+          ]
+        end
+      p1 = coords[lower_index]
+      p2 = coords[middle_index]
+      p3 = coords[upper_index]
+      total += (area_rad(p3[0]) - area_rad(p1[0])) * Math.sin(area_rad(p2[1]))
+    end
+
+    total * AREA_RADIUS * AREA_RADIUS / 2
+  end
+
+  def area_rad(num)
+    num * Math::PI / 180
+  end
+end

data/lib/turf/helpers.rb

@@ -59,12 +59,43 @@ module Turf
     fc
   end
 
+  # Creates a Feature based on a coordinate array. Properties can be added optionally.
+  # @see https://turfjs.org/docs/#geometryCollection
+  # @param geometries [Array<Geometry>] an array of GeoJSON Geometries
+  # @param properties [Hash] a Hash of key-value pairs to add as properties
+  # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
+  # @param id [string|number] Identifier associated with the Feature
+  # @return [Feature<GeometryCollection>] a GeoJSON GeometryCollection Feature
+  def geometry_collection(geometries, bbox: nil, id: nil, properties: {})
+    geom = {
+      type: "GeometryCollection",
+      geometries: geometries
+    }
+
+    feature(geom, properties: properties, bbox: bbox, id: id)
+  end
+
+  # Creates a Feature based on a coordinate array. Properties can be added optionally.
+  # @param coordinates [Array<Array<number>>] an array of Positions
+  # @param properties [Hash] a Hash of key-value pairs to add as properties
+  # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
+  # @param id [string|number] Identifier associated with the Feature
+  # @return [Feature<MultiPoint>] a MultiPoint feature
+  def multi_point(coordinates, properties: {}, bbox: nil, id: nil)
+    geom = {
+      type: "MultiPoint",
+      coordinates: coordinates
+    }
+
+    feature(geom, properties: properties, bbox: bbox, id: id)
+  end
+
   # Creates a LineString Feature from an Array of Positions.
   # @see https://turfjs.org/docs/#lineString
   # @param coordinates [Array<Array<number>>] an array of Positions
   # @param properties [Hash] an Hash of key-value pairs to add as properties
   # @param bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
-  # @param id [string | number] Identifier associated with the Feature
+  # @param id [string|number] Identifier associated with the Feature
   # @return [Feature<LineString>] LineString Feature
   def line_string(coordinates, properties: {}, bbox: nil, id: nil)
     if coordinates.size < 2

data/lib/turf/meta.rb

@@ -13,65 +13,169 @@ module Turf
   # @yieldparam current_coord [Array<number>] The current coordinate being processed.
   # @yieldparam coord_index [number] The current index of the coordinate being processed.
   def coord_each(geojson, exclude_wrap_coord: false, &block)
+    coord_all(geojson, exclude_wrap_coord: exclude_wrap_coord).each_with_index(&block)
+  end
+
+  # Get all coordinates from any GeoJSON object.
+  # @see https://turfjs.org/docs/#coordAll
+  # @param geojson [FeatureCollection|Feature|Geometry] any GeoJSON object
+  # @param exclude_wrap_coord [boolean] whether or not to include the final coordinate of LinearRings that wraps the
+  # ring in its iteration
+  # @return [Array<Array<number>>] coordinate position array
+  def coord_all(geojson, exclude_wrap_coord: false)
+    geometries = self.geometries(geojson)
+    geometries.flat_map do |geometry|
+      next [] if geometry.nil?
+
+      case geometry[:type]
+      when "Point"
+        [geometry[:coordinates]]
+      when "LineString", "MultiPoint"
+        geometry[:coordinates]
+      when "Polygon", "MultiLineString"
+        geometry[:coordinates].flat_map do |line_coords|
+          (
+            exclude_wrap_coord ? line_coords.slice(0...-1) : line_coords
+          )
+        end
+      when "MultiPolygon"
+        geometry[:coordinates].flat_map do |polygon_coords|
+          polygon_coords.flat_map do |line_coords|
+            (
+              exclude_wrap_coord ? line_coords.slice(0...-1) : line_coords
+            )
+          end
+        end
+      when "Feature"
+        [].tap do |feature_coords|
+          coord_each geometry, exclude_wrap_coord: exclude_wrap_coord do |coord|
+            feature_coords.push coord
+          end
+        end
+      else
+        raise Error, "Unknown Geometry Type: #{geometry[:type]}"
+      end
+    end
+  end
+
+  # Reduce coordinates in any GeoJSON object, similar to Array.reduce()
+  # @see https://turfjs.org/docs/#coordReduce
+  # @param geojson [FeatureCollection|Geometry|Feature] any GeoJSON object
+  # @param initial_value [*] Value to use as the first argument to the first call of the callback.
+  # @param exclude_wrap_coord [Boolean] whether or not to include the final coordinate of LinearRings that wraps the
+  # ring in its iteration.
+  # @return [*] The value that results from the reduction.
+  def coord_reduce(geojson, initial_value: nil, exclude_wrap_coord: false)
+    previous_value = initial_value
+
+    coord_each(
+      geojson,
+      exclude_wrap_coord: exclude_wrap_coord,
+    ) do |current_coord, coord_index|
+      previous_value =
+        if coord_index.zero? && initial_value.nil?
+          current_coord
+        else
+          yield(
+            previous_value,
+            current_coord,
+            coord_index
+          )
+        end
+    end
+
+    previous_value
+  end
+
+  # Iterate over each geometry in any GeoJSON object, similar to Array.forEach()
+  # @see https://turfjs.org/docs/#geomReduce
+  # @param geojson [FeatureCollection|Feature|Geometry] any GeoJSON object
+  # @yieldparam geom [Geometry] The current Feature being processed.
+  # @yieldparam feature_index [number] The current index of the Feature being processed.
+  # @yieldparam properties [Hash] an Object of key-value pairs to add as properties
+  # @yieldparam bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
+  # @yieldparam id [string|number] Identifier associated with the Feature
+  def geom_each(geojson)
     return unless geojson
 
     geojson = deep_symbolize_keys geojson
-    geometries = []
+
+    # [geometry, properties, bbox, id]
+    entries = []
+
     case geojson[:type]
     when "FeatureCollection"
       geojson[:features].each do |feature|
-        geometries.push feature[:geometry]
+        entries.push [feature[:geometry], feature[:properties], feature[:bbox], feature[:id]]
       end
     when "Feature"
-      geometries.push geojson[:geometry]
+      entries.push [geojson[:geometry], geojson[:properties], geojson[:bbox], geojson[:id]]
     else
-      geometries.push geojson
+      entries.push [geojson, {}, nil, nil]
     end
 
     # flatten GeometryCollection
-    geometries =
-      geometries.map do |geometry|
-        next if geometry.nil?
-        next geometry unless geometry[:type] == "GeometryCollection"
-
-        geometry[:geometries]
-      end.flatten
-
-    coords =
-      geometries.flat_map do |geometry|
-        next nil if geometry.nil?
-
-        case geometry[:type]
-        when "Point"
-          [geometry[:coordinates]]
-        when "LineString", "MultiPoint"
-          geometry[:coordinates]
-        when "Polygon", "MultiLineString"
-          geometry[:coordinates].flat_map do |line_coords|
-            (
-              exclude_wrap_coord ? line_coords.slice(0...-1) : line_coords
-            )
-          end
-        when "MultiPolygon"
-          geometry[:coordinates].flat_map do |polygon_coords|
-            polygon_coords.flat_map do |line_coords|
-              (
-                exclude_wrap_coord ? line_coords.slice(0...-1) : line_coords
-              )
-            end
-          end
-        when "Feature"
-          [].tap do |feature_coords|
-            coord_each geometry, exclude_wrap_coord: exclude_wrap_coord do |coord|
-              feature_coords.push coord
-            end
-          end
+    entries =
+      entries.flat_map do |entry|
+        geometry, properties, bbox, id = entry
+        next [entry] if geometry.nil?
+        next [entry] unless geometry[:type] == "GeometryCollection"
+
+        geometry[:geometries].map do |sub_geometry|
+          [sub_geometry, properties, bbox, id]
+        end
+      end
+
+    entries.each_with_index do |entry, entry_index|
+      geometry, properties, bbox, id = entry
+      yield geometry, entry_index, properties, bbox, id
+    end
+  end
+
+  # Reduce geometry in any GeoJSON object, similar to Array.reduce().
+  # @see https://turfjs.org/docs/#geomReduce
+  # @param geojson [FeatureCollection|Feature|Geometry] any GeoJSON object
+  # @param initial_value [*] Value to use as the first argument to the first call of the callback.
+  # @yieldparam previous_value [*] Result of previous reduction
+  # @yieldparam geom [Geometry] The current Feature being processed.
+  # @yieldparam geom_index [number] The current index of the Feature being processed.
+  # @yieldparam properties [Hash] an Object of key-value pairs to add as properties
+  # @yieldparam bbox [Array<number>] Bounding Box Array [west, south, east, north] associated with the Feature
+  # @yieldparam id [string|number] Identifier associated with the Feature
+  # @return [*] The value that results from the reduction.
+  def geom_reduce(geojson, initial_value: nil)
+    previous_value = initial_value
+
+    geom_each(
+      geojson,
+    ) do |geom, geom_index, properties, bbox, id|
+      previous_value =
+        if geom_index.zero? && initial_value.nil?
+          geom
         else
-          raise Error, "Unknown Geometry Type: #{geometry[:type]}"
+          yield(
+            previous_value,
+            geom,
+            geom_index,
+            properties,
+            bbox,
+            id
+          )
         end
-      end.compact
+    end
+
+    previous_value
+  end
 
-    coords.each_with_index(&block)
+  # Get all Geometry
+  # @param geojson [FeatureCollection|Feature|Geometry] any GeoJSON object
+  # @return [Array<Geometry>] list of Geometry
+  def geometries(geojson)
+    [].tap do |geometries|
+      geom_each(geojson) do |geometry|
+        geometries.push(geometry)
+      end
+    end
   end
 
   # Iterate over features in any GeoJSON object, similar to Array.forEach.
@@ -83,12 +187,115 @@ module Turf
   def feature_each(geojson, &block)
     return unless geojson
 
+    features = []
     geojson = deep_symbolize_keys geojson
     case geojson[:type]
     when "Feature"
-      yield geojson, 0
+      features.push geojson
     when "FeatureCollection"
-      geojson[:features].each_with_index(&block)
+      features.push(*geojson[:features])
+    end
+
+    features.each_with_index(&block)
+  end
+
+  # Reduce features in any GeoJSON object, similar to Array.reduce().
+  # @see https://turfjs.org/docs/#featureReduce
+  # @param geojson [FeatureCollection|Feature|Geometry] any GeoJSON object
+  # @param initial_value [*] Value to use as the first argument to the first call of the callback.
+  # @yieldparam previous_value [*] Result of previous reduction
+  # @yieldparam feature [Feature<any>] The current Feature being processed.
+  # @yieldparam feature_index [number] The current index of the Feature being processed.
+  # @return [*] The value that results from the reduction.
+  def feature_reduce(geojson, initial_value: nil)
+    previous_value = initial_value
+
+    feature_each(
+      geojson,
+    ) do |feature, feature_index|
+      previous_value =
+        if feature_index.zero? && initial_value.nil?
+          feature
+        else
+          yield(
+            previous_value,
+            feature,
+            feature_index
+          )
+        end
     end
+
+    previous_value
+  end
+
+  # Iterate over flattened features in any GeoJSON object, similar to Array.forEach.
+  # @see https://turfjs.org/docs/#flattenEach
+  # @param geojson [FeatureCollection|Feature|Geometry] any GeoJSON object
+  # @yieldparam feature [Feature<any>] The current Feature being processed.
+  # @yieldparam feature_index [number] The current index of the Feature being processed.
+  # @yieldparam multi_feature_index [number] The current index of the Feature in the multi-Feature
+  def flatten_each(geojson)
+    geom_each(geojson) do |geometry, feature_index, properties, bbox, id|
+      if geometry.nil?
+        next yield(
+          feature(nil, properties: properties, bbox: bbox, id: id),
+          feature_index,
+          0
+        )
+      end
+
+      case geometry[:type]
+      when "Point", "LineString", "Polygon"
+        yield(
+          feature(geometry, properties: properties, bbox: bbox, id: id),
+          feature_index,
+          0
+        )
+      when "MultiPoint", "MultiLineString", "MultiPolygon"
+        geom_type = geometry[:type].sub(/^Multi/, "")
+        geometry[:coordinates].each_with_index do |coordinate, multi_feature_index|
+          geom = {
+            type: geom_type,
+            coordinates: coordinate
+          }
+          yield(
+            feature(geom, properties: properties),
+            feature_index,
+            multi_feature_index
+          )
+        end
+      end
+    end
+  end
+
+  # Reduce flattened features in any GeoJSON object, similar to Array.reduce().
+  # @see https://turfjs.org/docs/#flattenEach
+  # @param geojson [FeatureCollection|Feature|Geometry] any GeoJSON object
+  # @param initial_value [*] Value to use as the first argument to the first call of the callback.
+  # @yieldparam previous_value [*] Result of previous reduction
+  # @yieldparam feature [Feature<any>] The current Feature being processed.
+  # @yieldparam feature_index [number] The current index of the Feature being processed.
+  # @yieldparam multi_feature_index [number] The current index of the Feature in the multi-Feature
+  # @return [*] The value that results from the reduction.
+  def flatten_reduce(geojson, initial_value: nil)
+    previous_value = initial_value
+
+    flatten_each(
+      geojson,
+    ) do |feature, feature_index, multi_feature_index|
+      previous_value =
+        if feature_index.zero? && multi_feature_index.zero? && initial_value.nil?
+          feature
+        else
+          yield(
+            previous_value,
+            feature,
+            feature_index,
+            multi_feature_index
+          )
+        end
+    end
+
+    previous_value
   end
 end

data/lib/turf/version.rb

@@ -2,5 +2,5 @@
 
 module Turf
   # Version of turf-ruby
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/turf_ruby.rb

@@ -13,5 +13,6 @@ require "turf/invariant"
 require "turf/boolean_point_in_polygon"
 require "turf/centroid"
 require "turf/meta"
+require "turf/area"
 
 require "turf"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: turf-ruby
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Rafael Santos
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-06-23 00:00:00.000000000 Z
+date: 2021-07-06 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
@@ -21,6 +21,7 @@ extra_rdoc_files: []
 files:
 - lib/turf.rb
 - lib/turf/along.rb
+- lib/turf/area.rb
 - lib/turf/bearing.rb
 - lib/turf/boolean_point_in_polygon.rb
 - lib/turf/centroid.rb