[meta] add coordeach implementation (#50)

* [meta] add coordeach implementation * [benchmark] add coordeach benchmark using test fixtures
dartclub · Feb 20, 2022 · 2aff26e · 2aff26e
1 parent fde7642
commit 2aff26e
Show file tree

Hide file tree

Showing 4 changed files with 571 additions and 4 deletions.
diff --git a/README.md b/README.md
@@ -129,19 +129,19 @@ Any new benchmarks must be named `*_benchmark.dart` and reside in the
 
 ### META
 - [ ] coordAll
-- [ ] coordEach
+- [x] coordEach
 - [ ] coordReduce
-- [ ] featureEach
+- [x] featureEach
 - [ ] featureReduce
 - [ ] flattenEach
 - [ ] flattenReduce
 - [ ] getCoord
 - [ ] getCoords
 - [ ] getGeom
 - [ ] getType
-- [ ] geomEach
+- [x] geomEach
 - [ ] geomReduce
-- [ ] propEach
+- [x] propEach
 - [ ] propReduce
 - [ ] segmentEach
 - [ ] segmentReduce

diff --git a/benchmark/meta_benchmark.dart b/benchmark/meta_benchmark.dart
@@ -2,6 +2,9 @@ import 'package:benchmark/benchmark.dart';
 import 'package:turf/helpers.dart';
 import 'package:turf/meta.dart';
 
+import 'dart:convert';
+import 'dart:io';
+
 void main() {
   Point pt = Point.fromJson({
     'coordinates': [0, 0]
@@ -25,6 +28,43 @@ void main() {
     features: pointFeatures,
   );
 
+  group('coordEach', () {
+    void coordEachNoopCB(
+      CoordinateType? currentCoord,
+      int? coordIndex,
+      int? featureIndex,
+      int? multiFeatureIndex,
+      int? geometryIndex,
+    ) {}
+
+    benchmark('geometry', () {
+      coordEach(pt, coordEachNoopCB);
+    });
+
+    benchmark('feature', () {
+      coordEach(featurePt, coordEachNoopCB);
+    });
+
+    benchmark('geometry collection', () {
+      coordEach(geomCollection, coordEachNoopCB);
+    });
+
+    benchmark('feature collection', () {
+      coordEach(featureCollection, coordEachNoopCB);
+    });
+
+    var dir = Directory('./test/examples');
+    for (var file in dir.listSync(recursive: true)) {
+      if (file is File && file.path.endsWith('.geojson')) {
+        var source = (file).readAsStringSync();
+        var geoJSON = GeoJSONObject.fromJson(jsonDecode(source));
+        benchmark(file.path, () {
+          coordEach(geoJSON, coordEachNoopCB);
+        });
+      }
+    }
+  });
+
   group('geomEach', () {
     void geomEachNoopCB(
       GeometryObject? currentGeometry,

diff --git a/lib/src/meta.dart b/lib/src/meta.dart
@@ -1,5 +1,149 @@
 import 'geojson.dart';
 
+typedef CoordEachCallback = dynamic Function(
+  CoordinateType? currentCoord,
+  int? coordIndex,
+  int? featureIndex,
+  int? multiFeatureIndex,
+  int? geometryIndex,
+);
+
+///
+/// Iterate over coordinates in any [geoJSON] object, similar to Array.forEach()
+///
+/// For example:
+///
+/// ```dart
+/// // TODO add example
+/// ```
+void coordEach(GeoJSONObject geoJSON, CoordEachCallback callback,
+    [bool excludeWrapCoord = false]) {
+  dynamic coords;
+  dynamic geometry;
+  int stopG;
+  GeoJSONObject? geometryMaybeCollection;
+  int wrapShrink = 0;
+  int coordIndex = 0;
+  bool isGeometryCollection;
+  bool isFeatureCollection = geoJSON is FeatureCollection;
+  bool isFeature = geoJSON is Feature;
+  int stop = isFeatureCollection ? geoJSON.features.length : 1;
+
+  try {
+    for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
+      geometryMaybeCollection = isFeatureCollection
+          ? geoJSON.features[featureIndex].geometry
+          : isFeature
+              ? geoJSON.geometry
+              : geoJSON;
+
+      isGeometryCollection = geometryMaybeCollection != null
+          ? geometryMaybeCollection is GeometryCollection
+          : false;
+
+      stopG =
+          isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+
+      for (int geomIndex = 0; geomIndex < stopG; geomIndex++) {
+        int multiFeatureIndex = 0;
+        int geometryIndex = 0;
+        geometry = isGeometryCollection
+            ? geometryMaybeCollection.geometries[geomIndex]
+            : geometryMaybeCollection;
+
+        // Handles null Geometry -- Skips this geometry
+        if (geometry == null) {
+          continue;
+        }
+        coords = geometry.coordinates as Iterable;
+        GeoJSONObjectType geomType = geometry.type;
+
+        wrapShrink = excludeWrapCoord &&
+                (geomType == GeoJSONObjectType.polygon ||
+                    geomType == GeoJSONObjectType.multiLineString)
+            ? 1
+            : 0;
+
+        if (geomType == GeoJSONObjectType.point) {
+          if (callback(coords as CoordinateType, coordIndex, featureIndex,
+                  multiFeatureIndex, geometryIndex) ==
+              false) {
+            throw _ShortCircuit();
+          }
+          coordIndex++;
+          multiFeatureIndex++;
+          break;
+        } else if (geomType == GeoJSONObjectType.lineString ||
+            geomType == GeoJSONObjectType.multiPoint) {
+          for (var j = 0; j < coords.length; j++) {
+            if (callback(coords[j], coordIndex, featureIndex, multiFeatureIndex,
+                    geometryIndex) ==
+                false) {
+              throw _ShortCircuit();
+            }
+            coordIndex++;
+            if (geomType == GeoJSONObjectType.multiPoint) {
+              multiFeatureIndex++;
+            }
+          }
+          if (geomType == GeoJSONObjectType.lineString) {
+            multiFeatureIndex++;
+          }
+        } else if (geomType == GeoJSONObjectType.polygon ||
+            geomType == GeoJSONObjectType.multiLineString) {
+          for (var j = 0; j < coords.length; j++) {
+            for (var k = 0; k < coords[j].length - wrapShrink; k++) {
+              if (callback(coords[j][k], coordIndex, featureIndex,
+                      multiFeatureIndex, geometryIndex) ==
+                  false) {
+                throw _ShortCircuit();
+              }
+              coordIndex++;
+            }
+            if (geomType == GeoJSONObjectType.multiLineString) {
+              multiFeatureIndex++;
+            }
+            if (geomType == GeoJSONObjectType.polygon) {
+              geometryIndex++;
+            }
+          }
+          if (geomType == GeoJSONObjectType.polygon) {
+            multiFeatureIndex++;
+          }
+        } else if (geomType == GeoJSONObjectType.multiPolygon) {
+          for (var j = 0; j < coords.length; j++) {
+            geometryIndex = 0;
+            for (var k = 0; k < coords[j].length; k++) {
+              for (var l = 0; l < coords[j][k].length - wrapShrink; l++) {
+                if (callback(coords[j][k][l], coordIndex, featureIndex,
+                        multiFeatureIndex, geometryIndex) ==
+                    false) {
+                  throw _ShortCircuit();
+                }
+                coordIndex++;
+              }
+              geometryIndex++;
+            }
+            multiFeatureIndex++;
+          }
+        } else if (geomType == GeoJSONObjectType.geometryCollection) {
+          for (var j = 0; j < geometry.geometries.length; j++) {
+            try {
+              coordEach(geometry.geometries[j], callback, excludeWrapCoord);
+            } on _ShortCircuit {
+              rethrow;
+            }
+          }
+        } else {
+          throw Exception('Unknown Geometry Type');
+        }
+      }
+    }
+  } on _ShortCircuit {
+    return;
+  }
+}
+
 typedef GeomEachCallback = dynamic Function(
   GeometryObject? currentGeometry,
   int? featureIndex,