turf-boolean-contains + turf-boolean-within: Fix line in polygon (#2848)

* fix boolean-contains and boolean-within isLineInPoly
* update esri-contains and esri-within diagrams
* check if line is contained in boundary after splitting on intersections
* fix line simply containes in polygon, and tidy up test examples
* split linestring segments on polygon before checking midpoints
* add explanatory comments and update docs

---------

Co-authored-by: samuelarbibe <samuel.arbibe@gmail.com>
Co-authored-by: James Beard <james@smallsaucepan.com>

Author: 3 people

packages/turf-boolean-contains/README.md

@@ -4,10 +4,9 @@
 
 ## booleanContains
 
-Boolean-contains returns True if the second geometry is completely contained by the first geometry.
-The interiors of both geometries must intersect and, the interior and boundary of the secondary (geometry b)
-must not intersect the exterior of the primary (geometry a).
-Boolean-contains returns the exact opposite result of the `@turf/boolean-within`.
+Tests whether geometry a contains geometry b.
+The interiors of both geometries must intersect, and the interior and boundary of geometry b must not intersect the exterior of geometry a.
+booleanContains(a, b) is equivalent to booleanWithin(b, a)
 
 ### Parameters
 
@@ -55,4 +54,4 @@ $ npm install @turf/turf
 
 ### Diagrams
 
-![esri-contains](diagrams/esri-contains.gif)
+![esri-contains](diagrams/esri-contains.png)

packages/turf-boolean-contains/diagrams/esri-contains.gif

@@ -12,12 +12,13 @@ import { bbox as calcBbox } from "@turf/bbox";
 import { booleanPointInPolygon } from "@turf/boolean-point-in-polygon";
 import { booleanPointOnLine as isPointOnLine } from "@turf/boolean-point-on-line";
 import { getGeom } from "@turf/invariant";
+import { feature, featureCollection, lineString } from "@turf/helpers";
+import { lineSplit } from "@turf/line-split";
 
 /**
- * Boolean-contains returns True if the second geometry is completely contained by the first geometry.
- * The interiors of both geometries must intersect and, the interior and boundary of the secondary (geometry b)
- * must not intersect the exterior of the primary (geometry a).
- * Boolean-contains returns the exact opposite result of the `@turf/boolean-within`.
+ * Tests whether geometry a contains geometry b.
+ * The interiors of both geometries must intersect, and the interior and boundary of geometry b must not intersect the exterior of geometry a.
+ * booleanContains(a, b) is equivalent to booleanWithin(b, a)
  *
  * @function
  * @param {Geometry|Feature<any>} feature1 GeoJSON Feature or Geometry
@@ -177,30 +178,67 @@ function isLineOnLine(lineString1: LineString, lineString2: LineString) {
   return haveFoundInteriorPoint;
 }
 
-function isLineInPoly(polygon: Polygon, linestring: LineString) {
-  let output = false;
-  let i = 0;
+function splitLineIntoSegmentsOnPolygon(
+  linestring: LineString,
+  polygon: Polygon
+) {
+  const coords = linestring.coordinates;
+
+  const outputSegments: Feature<LineString>[] = [];
+
+  for (let i = 0; i < coords.length - 1; i++) {
+    const seg = lineString([coords[i], coords[i + 1]]);
+    const split = lineSplit(seg, feature(polygon));
+
+    if (split.features.length === 0) {
+      outputSegments.push(seg);
+    } else {
+      outputSegments.push(...split.features);
+    }
+  }
+
+  return featureCollection(outputSegments);
+}
 
+function isLineInPoly(polygon: Polygon, linestring: LineString) {
   const polyBbox = calcBbox(polygon);
   const lineBbox = calcBbox(linestring);
+
   if (!doBBoxOverlap(polyBbox, lineBbox)) {
     return false;
   }
-  for (i; i < linestring.coordinates.length - 1; i++) {
-    const midPoint = getMidpoint(
-      linestring.coordinates[i],
-      linestring.coordinates[i + 1]
+
+  for (const coord of linestring.coordinates) {
+    if (!booleanPointInPolygon(coord, polygon)) {
+      return false;
+    }
+  }
+
+  let isContainedByPolygonBoundary = false;
+  // split intersecting segments and verify their inclusion
+  const lineSegments = splitLineIntoSegmentsOnPolygon(linestring, polygon);
+
+  for (const lineSegment of lineSegments.features) {
+    const midpoint = getMidpoint(
+      lineSegment.geometry.coordinates[0],
+      lineSegment.geometry.coordinates[1]
     );
+
+    // make sure all segments do not intersect with polygon exterior
+    if (!booleanPointInPolygon(midpoint, polygon)) {
+      return false;
+    }
+
+    // make sure at least 1 segment intersects with the polygon's interior
     if (
-      booleanPointInPolygon({ type: "Point", coordinates: midPoint }, polygon, {
-        ignoreBoundary: true,
-      })
+      !isContainedByPolygonBoundary &&
+      booleanPointInPolygon(midpoint, polygon, { ignoreBoundary: true })
     ) {
-      output = true;
-      break;
+      isContainedByPolygonBoundary = true;
     }
   }
-  return output;
+
+  return isContainedByPolygonBoundary;
 }
 
 /**

packages/turf-boolean-contains/diagrams/esri-contains.png

@@ -5,7 +5,8 @@
   "author": "Turf Authors",
   "contributors": [
     "Rowan Winsemius <@rowanwins>",
-    "Denis Carriere <@DenisCarriere>"
+    "Denis Carriere <@DenisCarriere>",
+    "Samuel Arbibe <@samuelarbibe>"
   ],
   "license": "MIT",
   "bugs": {
@@ -73,6 +74,7 @@
     "@turf/boolean-point-on-line": "workspace:*",
     "@turf/helpers": "workspace:*",
     "@turf/invariant": "workspace:*",
+    "@turf/line-split": "workspace:*",
     "@types/geojson": "^7946.0.10",
     "tslib": "^2.8.1"
   }

packages/turf-boolean-contains/index.ts

@@ -0,0 +1,35 @@
+{
+  "type": "FeatureCollection",
+  "features": [
+    {
+      "type": "Feature",
+      "properties": {},
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [9.6459207, -1.2281524],
+            [11.0822393, -1.2461022],
+            [11.405411, -0.1869151],
+            [11.1181473, 1.9133448],
+            [10.0588623, 1.4646914],
+            [10.6692977, -0.0253296],
+            [10.6692977, -0.0253296],
+            [9.6459207, -1.2281524]
+          ]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {},
+      "geometry": {
+        "type": "LineString",
+        "coordinates": [
+          [10.2166256, -0.7379163],
+          [11.0362904, 1.794324]
+        ]
+      }
+    }
+  ]
+}