GitLocker: The Coding Marketplace

Description:

geojson

Geojson #

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
Simple functions #
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);
copied to clipboard
Web support #
featuresFromGeoJsonMainThread: as the web do not support isolates use this function to parse in the main thread. 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

Reactive api #
Parse and listen #
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);
}
copied to clipboard
Data properties #
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;
copied to clipboard
Example:
final List<GeoJsonLine> lines = geo.lines;
copied to clipboard
Search #
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;
copied to clipboard
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
Geofencing #
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;
copied to clipboard
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;
copied to clipboard
Note: the processedPoints stream is available to retrieve geofenced points as soon as they are found
Maps #
To draw geojson data on a map check the Map controller package
Supported geojson features #
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