@turf/boolean-within: add MultiPolygon support, de-duplicate logic (#3011)

Author: rexxars

packages/turf-boolean-within/index.ts

@@ -1,19 +1,5 @@
-import {
-  BBox,
-  Feature,
-  Geometry,
-  LineString,
-  MultiPoint,
-  MultiPolygon,
-  Point,
-  Polygon,
-} from "geojson";
-import { bbox as calcBbox } from "@turf/bbox";
-import { booleanPointOnLine } from "@turf/boolean-point-on-line";
-import { booleanPointInPolygon } from "@turf/boolean-point-in-polygon";
-import { getGeom } from "@turf/invariant";
-import { feature, featureCollection, lineString } from "@turf/helpers";
-import { lineSplit } from "@turf/line-split";
+import { Feature, Geometry } from "geojson";
+import { booleanContains } from "@turf/boolean-contains";
 
 /**
  * Tests whether geometry a is contained by geometry b.
@@ -35,252 +21,7 @@ function booleanWithin(
   feature1: Feature<any> | Geometry,
   feature2: Feature<any> | Geometry
 ): boolean {
-  var geom1 = getGeom(feature1);
-  var geom2 = getGeom(feature2);
-  var type1 = geom1.type;
-  var type2 = geom2.type;
-
-  switch (type1) {
-    case "Point":
-      switch (type2) {
-        case "MultiPoint":
-          return isPointInMultiPoint(geom1, geom2);
-        case "LineString":
-          return booleanPointOnLine(geom1, geom2, { ignoreEndVertices: true });
-        case "Polygon":
-        case "MultiPolygon":
-          return booleanPointInPolygon(geom1, geom2, { ignoreBoundary: true });
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    case "MultiPoint":
-      switch (type2) {
-        case "MultiPoint":
-          return isMultiPointInMultiPoint(geom1, geom2);
-        case "LineString":
-          return isMultiPointOnLine(geom1, geom2);
-        case "Polygon":
-        case "MultiPolygon":
-          return isMultiPointInPoly(geom1, geom2);
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    case "LineString":
-      switch (type2) {
-        case "LineString":
-          return isLineOnLine(geom1, geom2);
-        case "Polygon":
-        case "MultiPolygon":
-          return isLineInPoly(geom1, geom2);
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    case "Polygon":
-      switch (type2) {
-        case "Polygon":
-        case "MultiPolygon":
-          return isPolyInPoly(geom1, geom2);
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    default:
-      throw new Error("feature1 " + type1 + " geometry not supported");
-  }
-}
-
-function isPointInMultiPoint(point: Point, multiPoint: MultiPoint) {
-  var i;
-  var output = false;
-  for (i = 0; i < multiPoint.coordinates.length; i++) {
-    if (compareCoords(multiPoint.coordinates[i], point.coordinates)) {
-      output = true;
-      break;
-    }
-  }
-  return output;
-}
-
-function isMultiPointInMultiPoint(
-  multiPoint1: MultiPoint,
-  multiPoint2: MultiPoint
-) {
-  for (var i = 0; i < multiPoint1.coordinates.length; i++) {
-    var anyMatch = false;
-    for (var i2 = 0; i2 < multiPoint2.coordinates.length; i2++) {
-      if (
-        compareCoords(multiPoint1.coordinates[i], multiPoint2.coordinates[i2])
-      ) {
-        anyMatch = true;
-      }
-    }
-    if (!anyMatch) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function isMultiPointOnLine(multiPoint: MultiPoint, lineString: LineString) {
-  var foundInsidePoint = false;
-
-  for (var i = 0; i < multiPoint.coordinates.length; i++) {
-    if (!booleanPointOnLine(multiPoint.coordinates[i], lineString)) {
-      return false;
-    }
-    if (!foundInsidePoint) {
-      foundInsidePoint = booleanPointOnLine(
-        multiPoint.coordinates[i],
-        lineString,
-        { ignoreEndVertices: true }
-      );
-    }
-  }
-  return foundInsidePoint;
-}
-
-function isMultiPointInPoly(multiPoint: MultiPoint, polygon: Polygon) {
-  var oneInside = false;
-  for (var i = 0; i < multiPoint.coordinates.length; i++) {
-    // All points must be inside polygon (boundary OK)
-    if (!booleanPointInPolygon(multiPoint.coordinates[i], polygon)) {
-      return false;
-    }
-    // Track if at least one point is strictly in the interior
-    if (!oneInside) {
-      oneInside = booleanPointInPolygon(multiPoint.coordinates[i], polygon, {
-        ignoreBoundary: true,
-      });
-    }
-  }
-  // At least one point must be in the interior (not just on boundary)
-  return oneInside;
-}
-
-function isLineOnLine(lineString1: LineString, lineString2: LineString) {
-  for (var i = 0; i < lineString1.coordinates.length; i++) {
-    if (!booleanPointOnLine(lineString1.coordinates[i], lineString2)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-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(linestring: LineString, polygon: Polygon) {
-  const polyBbox = calcBbox(polygon);
-  const lineBbox = calcBbox(linestring);
-
-  if (!doBBoxOverlap(polyBbox, lineBbox)) {
-    return false;
-  }
-
-  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 (
-      !isContainedByPolygonBoundary &&
-      booleanPointInPolygon(midpoint, polygon, { ignoreBoundary: true })
-    ) {
-      isContainedByPolygonBoundary = true;
-    }
-  }
-
-  return isContainedByPolygonBoundary;
-}
-
-/**
- * Is Polygon2 in Polygon1
- * Only takes into account outer rings
- *
- * @private
- * @param {Polygon} geometry1
- * @param {Polygon|MultiPolygon} geometry2
- * @returns {boolean} true/false
- */
-function isPolyInPoly(geometry1: Polygon, geometry2: Polygon | MultiPolygon) {
-  var poly1Bbox = calcBbox(geometry1);
-  var poly2Bbox = calcBbox(geometry2);
-  if (!doBBoxOverlap(poly2Bbox, poly1Bbox)) {
-    return false;
-  }
-  for (var i = 0; i < geometry1.coordinates[0].length; i++) {
-    if (!booleanPointInPolygon(geometry1.coordinates[0][i], geometry2)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function doBBoxOverlap(bbox1: BBox, bbox2: BBox) {
-  if (bbox1[0] > bbox2[0]) return false;
-  if (bbox1[2] < bbox2[2]) return false;
-  if (bbox1[1] > bbox2[1]) return false;
-  if (bbox1[3] < bbox2[3]) return false;
-  return true;
-}
-
-/**
- * compareCoords
- *
- * @private
- * @param {Position} pair1 point [x,y]
- * @param {Position} pair2 point [x,y]
- * @returns {boolean} true/false if coord pairs match
- */
-function compareCoords(pair1: number[], pair2: number[]) {
-  return pair1[0] === pair2[0] && pair1[1] === pair2[1];
-}
-
-/**
- * getMidpoint
- *
- * @private
- * @param {Position} pair1 point [x,y]
- * @param {Position} pair2 point [x,y]
- * @returns {Position} midpoint of pair1 and pair2
- */
-function getMidpoint(pair1: number[], pair2: number[]) {
-  return [(pair1[0] + pair2[0]) / 2, (pair1[1] + pair2[1]) / 2];
+  return booleanContains(feature2, feature1);
 }
 
 export { booleanWithin };

packages/turf-boolean-within/package.json

@@ -5,7 +5,9 @@
   "author": "Turf Authors",
   "contributors": [
     "Rowan Winsemius <@rowanwins>",
-    "Samuel Arbibe <@samuelarbibe>"
+    "Denis Carriere <@DenisCarriere>",
+    "Samuel Arbibe <@samuelarbibe>",
+    "Espen Hovlandsdal <@rexxars>"
   ],
   "license": "MIT",
   "bugs": {
@@ -57,6 +59,7 @@
     "test:types": "tsc --esModuleInterop --module node16 --moduleResolution node16 --noEmit --strict types.ts"
   },
   "devDependencies": {
+    "@turf/helpers": "workspace:*",
     "@types/benchmark": "catalog:",
     "@types/tape": "catalog:",
     "benchmark": "catalog:",
@@ -69,12 +72,7 @@
     "typescript": "catalog:"
   },
   "dependencies": {
-    "@turf/bbox": "workspace:*",
-    "@turf/boolean-point-in-polygon": "workspace:*",
-    "@turf/boolean-point-on-line": "workspace:*",
-    "@turf/helpers": "workspace:*",
-    "@turf/invariant": "workspace:*",
-    "@turf/line-split": "workspace:*",
+    "@turf/boolean-contains": "workspace:*",
     "@types/geojson": "catalog:",
     "tslib": "catalog:"
   }

packages/turf-boolean-within/test/false/LineString/MultiPolygon/LineStringOnBoundary.geojson

@@ -0,0 +1,43 @@
+{
+  "type": "FeatureCollection",
+  "features": [
+    {
+      "type": "Feature",
+      "properties": {},
+      "geometry": {
+        "type": "LineString",
+        "coordinates": [
+          [0, 2],
+          [0, 8]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {},
+      "geometry": {
+        "type": "MultiPolygon",
+        "coordinates": [
+          [
+            [
+              [0, 0],
+              [10, 0],
+              [10, 10],
+              [0, 10],
+              [0, 0]
+            ]
+          ],
+          [
+            [
+              [20, 0],
+              [30, 0],
+              [30, 10],
+              [20, 10],
+              [20, 0]
+            ]
+          ]
+        ]
+      }
+    }
+  ]
+}

packages/turf-boolean-within/test/false/LineString/MultiPolygon/LineStringOutside.geojson

@@ -0,0 +1,43 @@
+{
+  "type": "FeatureCollection",
+  "features": [
+    {
+      "type": "Feature",
+      "properties": {},
+      "geometry": {
+        "type": "LineString",
+        "coordinates": [
+          [12, 5],
+          [18, 5]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {},
+      "geometry": {
+        "type": "MultiPolygon",
+        "coordinates": [
+          [
+            [
+              [0, 0],
+              [10, 0],
+              [10, 10],
+              [0, 10],
+              [0, 0]
+            ]
+          ],
+          [
+            [
+              [20, 0],
+              [30, 0],
+              [30, 10],
+              [20, 10],
+              [20, 0]
+            ]
+          ]
+        ]
+      }
+    }
+  ]
+}