Geofencing multiple polygons for a single point about geojson HOT 14 OPEN

extension GeoFenceGeoJsonX on GeoJson {
  Future<GeoJsonFeature> findGeofence(
      GeoJsonFeatureCollection geofences, GeoJsonPoint query) async {
    final futures = [
      for (var geofence in geofences.collection)
        () async {
          final results = await geofencePolygon(
            polygon: geofence.geometry,
            points: [query],
          );

          /// No results
          if (results.isEmpty) return null;

          /// Found a result
          if (results.first.name == query.name) return geofence;
        }(),
    ];

    return Stream.fromFutures(futures)
        .firstWhere((e) => e != null)
        .catchError((e) => null);
  }
}

final boundingBoxes = <int, GeoRect>{};

for (var geofence in geofences) {
  final wmdNumber = geofence.wmdNumber;

  double maxLat;
  double minLat;
  double maxLong;
  double minLong;

  for (var geoSerie in geofence.geometry.geoSeries) {
    for (var geoPoint in geoSerie.geoPoints) {
      final lat = geoPoint.latitude;
      final long = geoPoint.longitude;

      /// Make sure they get seeded if they are null
      maxLat ??= lat;
      minLat ??= lat;
      maxLong ??= long;
      minLong ??= long;

      /// Update values
      if (maxLat < lat) maxLat = lat;
      if (minLat > lat) minLat = lat;
      if (maxLong < long) maxLong = long;
      if (minLong > long) minLong = long;
    }
  }

  boundingBoxes[wmdNumber] = GeoRect(
    minLat: minLat,
    maxLong: maxLong,
    maxLat: maxLat,
    minLong: minLong,
  );
}

class GeoRect {
  GeoRect({
    @required this.maxLat,
    @required this.maxLong,
    @required this.minLat,
    @required this.minLong,
  });

  final double maxLat;
  final double maxLong;
  final double minLat;
  final double minLong;

  bool contains(double lat, double long) {
    final containsLat = maxLat >= lat && minLat <= lat;
    final containsLong = maxLong >= long && minLong <= long;
    return containsLat && containsLong;
  }

  @override
  String toString() => 'GeoRect($minLat,$minLong,$maxLat,$maxLong)';
}

import 'package:flutter/foundation.dart';
import 'package:geojson/geojson.dart';

extension GeoJsonSearchX on GeoJson {
  /// Given a list of polygons, find which one contains a given point.
  ///
  /// If the point isn't within any of these polygons, return `null`.
  Future<List<GeoJsonFeature<GeoJsonPolygon>>> geofenceSearch(
    List<GeoJsonFeature<GeoJsonPolygon>> geofences,
    GeoJsonPoint query,
  ) async {
    final boundingBoxes = getBoundingBoxes(geofences);

    final filteredGeofences = [
      for (var box in boundingBoxes)
        if (box.contains(query.geoPoint.latitude, query.geoPoint.longitude))
          box.feature
    ];

    return await _geofencesContainingPointNaive(filteredGeofences, query);
  }

  /// Return all geofences that contain the point provided.
  ///
  /// Naive implementation. The geofences should be filtered first using a method such
  /// as searching bounding boxes first.
  Future<List<GeoJsonFeature<GeoJsonPolygon>>> _geofencesContainingPointNaive(
    List<GeoJsonFeature<GeoJsonPolygon>> geofences,
    GeoJsonPoint query,
  ) async {
    final futures = [
      for (var geofence in geofences)
        geofencePolygon(
          polygon: geofence.geometry,
          points: [query],
        ).then((results) {
          /// Nothing found
          if (results.isEmpty) return null;

          /// Found a result
          if (results.first.name == query.name) return geofence;
        })
    ];

    final unfilteredResults = await Future.wait(futures);
    return unfilteredResults.where((e) => e != null).toList();
  }

  /// Given a set of geofence polygons, find all of their bounding boxes, and the index at which they were found.
  List<GeoBoundingBox> getBoundingBoxes(
      List<GeoJsonFeature<GeoJsonPolygon>> geofences) {
    final boundingBoxes = <GeoBoundingBox>[];

    for (var i = 0; i <= geofences.length - 1; i++) {
      final geofence = geofences[i];

      double maxLat;
      double minLat;
      double maxLong;
      double minLong;

      for (var geoSerie in geofence.geometry.geoSeries) {
        for (var geoPoint in geoSerie.geoPoints) {
          final lat = geoPoint.latitude;
          final long = geoPoint.longitude;

          /// Make sure they get seeded if they are null
          maxLat ??= lat;
          minLat ??= lat;
          maxLong ??= long;
          minLong ??= long;

          /// Update values
          if (maxLat < lat) maxLat = lat;
          if (minLat > lat) minLat = lat;
          if (maxLong < long) maxLong = long;
          if (minLong > long) minLong = long;
        }
      }

      boundingBoxes.add(GeoBoundingBox(
        feature: geofence,
        minLat: minLat,
        maxLong: maxLong,
        maxLat: maxLat,
        minLong: minLong,
      ));
    }

    return boundingBoxes;
  }
}

class GeoBoundingBox {
  /// A geographical rectangle. Typically used as a bounding box for a polygon
  /// for fast search of point-in-multiple-polygon.
  GeoBoundingBox({
    @required this.feature,
    @required this.maxLat,
    @required this.maxLong,
    @required this.minLat,
    @required this.minLong,
  });

  /// The polygon bounded by this bounding box
  final GeoJsonFeature<GeoJsonPolygon> feature;
  final double maxLat;
  final double maxLong;
  final double minLat;
  final double minLong;

  double get left => minLat;
  double get top => maxLong;
  double get right => maxLat;
  double get bottom => minLong;

  bool contains(double lat, double long) {
    final containsLat = maxLat >= lat && minLat <= lat;
    final containsLong = maxLong >= long && minLong <= long;
    return containsLat && containsLong;
  }

  @override
  String toString() => 'GeoRect($minLat,$minLong,$maxLat,$maxLong)';
}