Utilities to work with geojson data in Dart. Features:

• Parser with a reactive api: streams are available to retrieve the geojson features as soon as they are parsed
• Search: search for properties
• Geofencing: geofence points in a polygon or from a distance

Note: the data is parsed in an isolate to avoid slowing down the main thread

featuresFromGeoJson: get a FeaturesCollection from geojson string data. Parameters:

• data: a string with the geojson data, required
• nameProperty: the property used for the geoserie name, automaticaly set if null
• verbose: print the parsed data if true

featuresFromGeoJsonFile: get a FeaturesCollection from a geojson file. Parameters:

• file: the file to load, required
• nameProperty: the property used for the geoserie name, automaticaly set if null
• verbose: print the parsed data if true

These functions are suitable for small data. Example:

final features = await featuresFromGeoJson(data);

Typed streams are available to retrieve the features as soon as they are parsed. This is useful when the data is big.

• processedFeatures: the parsed features: all the geometries
• processedPoints: the parsed points
• processedMultipoints: the parsed multipoints
• processedLines: the parsed lines
• processedMultilines: the parsed multilines
• processedPolygons: the parsed polygons
• processedMultipolygons: the parsed multipolygons
• endSignal: parsing is finished indicator

Example: add assets on a Flutter map:

  import 'package:flutter/services.dart' show rootBundle;
  import 'package:geojson/geojson.dart';
  import 'package:flutter_map/flutter_map.dart';

  /// Data for the Flutter map polylines layer
  final lines = <Polyline>[];

  Future<void> parseAndDrawAssetsOnMap() async {
    final geo = GeoJson();
    geo.processedLines.listen((GeoJsonLine line) {
      /// when a line is parsed add it to the map right away
      setState(() => lines.add(Polyline(
          strokeWidth: 2.0, color: Colors.blue, points: line.geoSerie.toLatLng())));
    });
    geo.endSignal.listen((_) => geo.dispose());
    final data = await rootBundle
        .loadString('assets/railroads_of_north_america.geojson');
    await geo.parse(data, verbose: true);
  }

After the data is parsed the GeoJson instance has properties to access the data:

List<GeoJsonFeature> features;
List<GeoJsonPoint> points;
List<GeoJsonMultiPoint> multipoints;
List<GeoJsonLine> lines;
List<GeoJsonMultiLine> multilines;
List<GeoJsonPolygon> polygons;
List<GeoJsonMultiPolygon> multipolygons;

Example:

final List<GeoJsonLine> lines = geo.lines;

Search in a geojson file:

final geo = GeoJson();
await geo.searchInFile("countries.geojson",
    query: GeoJsonQuery(
        geometryType: GeoJsonFeatureType.multipolygon,
        matchCase: false,
        property: "name",
        value: "Zimbabwe"),
    verbose: true);
List<GeoJsonMultiPolygon> result = geo.multipolygons;

A search method is also available, taking string data in parameter instead of a file path. The streams are available to retrieve the data as soon as it is found

Geofence points within a distance of a given point:

final geo = GeoJson();
/// `point` is the [GeoJsonPoint] to search from
/// `points` is the list of [GeoJsonPoint] to search in
/// `distance` is the distance to search in meters
await geo.geofenceDistance(
      point: point, points: points, distance: distance);
 List<GeoPoint> foundPoints = geo.points;

Geofence points in a polygon:

final geo = GeoJson();
/// `polygon` is the [GeoJsonPolygon] to check
/// `points` is the list of [GeoJsonPoint] to search in
await geo.geofencePolygon(polygon: polygon, points: points);
 List<GeoPoint> foundPoints = geo.points;

Note: the processedPoints stream is available to retrieve geofenced points as soon as they are found

To draw geojson data on a map check the Map controller package

All the data structures use GeoPoint and GeoSerie from the GeoPoint package to store the geometry data. Data structures used:

GeoJsonFeatureCollection:

• String name
• List<GeoJsonFeature> collection

GeoJsonFeature:

• GeoJsonFeatureType type: types

• Map<String, dynamic> properties: the json properties of the feature

• dynamic geometry: the geometry data, depends on the feature type, see below

GeoJsonPoint:

• String name
• GeoPoint geoPoint: the geometry data

GeoJsonMultiPoint:

• String name
• GeoSerie geoSerie: the geometry data: this will produce a geoSerie of type GeoSerieType.group

GeoJsonLine:

• String name
• GeoSerie geoSerie: the geometry data: this will produce a geoSerie of type GeoSerieType.line

GeoJsonMultiLine:

• String name
• List<GeoJsonLine> lines

GeoJsonPolygon:

• String name
• List<GeoSerie> geoSeries: the geometry data: this will produce a list of geoSerie of type GeoSerieType.polygon*

GeoJsonMultiPolygon:

• String name
• List<GeoJsonPolygon> polygons

GeoJsonGeometryCollection:

• String name
• List<GeoJsonFeature> geometries

Note: none of the parameters is final for all of these data structures