Adds lineSlice method (#158)

* Implement lineSlice with tests

* add line_slice link

---------

Co-authored-by: Lukas Himsel <[email protected]>

README.md

@@ -149,7 +149,7 @@ Any new benchmarks must be named `*_benchmark.dart` and reside in the
 - [ ] [lineIntersect](https://github.com/dartclub/turf_dart/blob/main/lib/src/line_intersect.dart)
 - [ ] lineOverlap
 - [x] [lineSegment](https://github.com/dartclub/turf_dart/blob/main/lib/src/line_segment.dart)
-- [ ] lineSlice
+- [x] [lineSlice](https://github.com/dartclub/turf_dart/blob/main/lib/src/line_slice.dart)
 - [ ] lineSliceAlong
 - [ ] lineSplit
 - [ ] mask

lib/line_slice.dart

@@ -0,0 +1,3 @@
+library turf_along;
+
+export "src/line_slice.dart";

lib/src/line_slice.dart

@@ -0,0 +1,47 @@
+import 'package:turf/helpers.dart';
+import 'package:turf/nearest_point_on_line.dart';
+import 'package:turf/src/invariant.dart';
+
+/// Takes a [line], at a start point [startPt], and a stop point [stopPt]
+/// and returns a subsection of the line in-between those points.
+/// The start & stop points don't need to fall exactly on the line.
+///
+/// If [startPt] and [stopPt] resolve to the same point on [line], null is returned
+/// as the resolved line would only contain one point which isn't supported by LineString.
+///
+/// This can be useful for extracting only the part of a route between waypoints.
+Feature<LineString> lineSlice(
+ Feature<Point> startPt, Feature<Point> stopPt, Feature<LineString> line) {
+ final coords = line.geometry;
+ final startPtGeometry = startPt.geometry;
+ final stopPtGeometry = stopPt.geometry;
+ if (coords == null) {
+ throw Exception('line has no geometry');
+ }
+ if (startPtGeometry == null) {
+ throw Exception('startPt has no geometry');
+ }
+ if (stopPtGeometry == null) {
+ throw Exception('stopPt has no geometry');
+ }
+
+ final startVertex = nearestPointOnLine(coords, startPtGeometry);
+ final stopVertex = nearestPointOnLine(coords, stopPtGeometry);
+ late final List<Feature<Point>> ends;
+ if (startVertex.properties!['index'] <= stopVertex.properties!['index']) {
+ ends = [startVertex, stopVertex];
+ } else {
+ ends = [stopVertex, startVertex];
+ }
+ final List<Position> clipCoords = [getCoord(ends[0])];
+ for (var i = ends[0].properties!['index'] + 1;
+ i < ends[1].properties!['index'];
+ i++) {
+ clipCoords.add(coords.coordinates[i]);
+ }
+ clipCoords.add(getCoord(ends[1]));
+ return Feature<LineString>(
+ geometry: LineString(coordinates: clipCoords),
+ properties: line.properties,
+ );
+}

test/components/line_slice_test.dart

@@ -0,0 +1,78 @@
+import 'package:test/test.dart';
+import 'package:turf/along.dart';
+import 'package:turf/distance.dart';
+import 'package:turf/helpers.dart';
+import 'package:turf/length.dart';
+import 'package:turf/src/line_slice.dart';
+
+void main() {
+ test('lineSlice - exact points', () {
+ final slice = lineSlice(startFeature, viaFeature, lineFeature);
+ expect(slice, isNotNull);
+ expect(slice.properties, isNotNull);
+ expect(slice.properties!.keys, contains(propName));
+ expect(slice.properties![propName], equals(propValue));
+
+ final expectedLineFeature = Feature<LineString>(
+ geometry: LineString(coordinates: [start, via]),
+ );
+ expect(slice.geometry, isNotNull);
+ expect(slice.geometry!.coordinates, hasLength(2));
+ expect(length(slice).round(), equals(length(expectedLineFeature).round()));
+ });
+ test('lineSlice - interpolation', () {
+ const skipDist = 10;
+
+ final sliceFrom = along(lineFeature, skipDist, Unit.meters);
+ expect(sliceFrom, isNotNull);
+
+ final slice = lineSlice(sliceFrom, viaFeature, lineFeature);
+ expect(slice, isNotNull);
+ expect(slice.properties, isNotNull);
+ expect(slice.properties!.keys, contains(propName));
+ expect(slice.properties![propName], equals(propValue));
+
+ final expectedLine = Feature<LineString>(
+ geometry: LineString(coordinates: [start, via]),
+ );
+ expect(slice.geometry, isNotNull);
+ expect(slice.geometry!.coordinates, hasLength(2));
+ expect(
+ length(slice, Unit.meters).round(),
+ equals(length(expectedLine, Unit.meters).round() - skipDist),
+ );
+
+ // Sanity check of test data. No interpolation occurs if start and via are skipDist apart.
+ expect(distance(Point(coordinates: start), Point(coordinates: via)).round(),
+ isNot(equals(skipDist)));
+ });
+}
+
+final start = Position.named(
+ lat: 55.7090430186194,
+ lng: 13.184645393920405,
+);
+final via = Position.named(
+ lat: 55.70901279569489,
+ lng: 13.185546616182755,
+);
+final end = Position.named(
+ lat: 55.70764669578079,
+ lng: 13.187563637197076,
+);
+const propName = 'prop1';
+const propValue = 1;
+final lineFeature = Feature<LineString>(
+ geometry: LineString(
+ coordinates: [
+ start,
+ via,
+ end,
+ ],
+ ),
+ properties: {
+ propName: propValue,
+ },
+);
+final startFeature = Feature<Point>(geometry: Point(coordinates: start));
+final viaFeature = Feature<Point>(geometry: Point(coordinates: via));