planefill 0.1.0

package/dist/index.cjs

@@ -0,0 +1,588 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var src_exports = {};
+__export(src_exports, {
+  DIVISION_STRATEGIES: () => DIVISION_STRATEGIES,
+  STRATEGIES: () => STRATEGIES,
+  dividePolygon: () => dividePolygon,
+  planMultiPath: () => planMultiPath,
+  planPath: () => planPath
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/planner.js
+var turf7 = __toESM(require("@turf/turf"), 1);
+
+// src/strategies/boustrophedon.js
+var turf2 = __toESM(require("@turf/turf"), 1);
+
+// src/utils/coords.js
+function metersToDegreesLat(meters) {
+  return meters / 111e3;
+}
+function metersToDegreesLng(meters, latDeg) {
+  const cosLat = Math.cos(latDeg * Math.PI / 180);
+  if (Math.abs(cosLat) < 1e-10) return 0;
+  return meters / (111e3 * cosLat);
+}
+
+// src/utils/geometry.js
+var turf = __toESM(require("@turf/turf"), 1);
+function clipScanLine(polygon4, y, xMin, xMax) {
+  const EPS = 1e-10;
+  const scanLine = turf.lineString([
+    [xMin - 1, y + EPS],
+    [xMax + 1, y + EPS]
+  ]);
+  const hits = turf.lineIntersect(scanLine, polygon4);
+  if (!hits || hits.features.length === 0) return [];
+  let xs = hits.features.map((f) => f.geometry.coordinates[0]).sort((a, b) => a - b);
+  xs = xs.filter((x, i) => i === 0 || Math.abs(x - xs[i - 1]) > 1e-8);
+  if (xs.length % 2 !== 0) xs.pop();
+  const segments = [];
+  for (let i = 0; i + 1 < xs.length; i += 2) {
+    segments.push([xs[i], xs[i + 1]]);
+  }
+  return segments;
+}
+function findClosestIndex(coords, target) {
+  let bestIdx = 0;
+  let bestDist = Infinity;
+  for (let i = 0; i < coords.length; i++) {
+    const dx = coords[i][0] - target[0];
+    const dy = coords[i][1] - target[1];
+    const d = dx * dx + dy * dy;
+    if (d < bestDist) {
+      bestDist = d;
+      bestIdx = i;
+    }
+  }
+  return bestIdx;
+}
+function reorderRing(coords, startIndex) {
+  const isClosed = coords[0][0] === coords[coords.length - 1][0] && coords[0][1] === coords[coords.length - 1][1];
+  const ring = isClosed ? coords.slice(0, -1) : coords.slice();
+  return [...ring.slice(startIndex), ...ring.slice(0, startIndex)];
+}
+function getLargestPolygon(feature) {
+  if (!feature) return null;
+  const geom = feature.geometry ?? feature;
+  if (!geom) return null;
+  if (geom.type === "Polygon") {
+    return { type: "Feature", geometry: geom, properties: {} };
+  }
+  if (geom.type === "MultiPolygon") {
+    let best = null;
+    let bestArea = -Infinity;
+    for (const coords of geom.coordinates) {
+      const poly = turf.polygon(coords);
+      const a = turf.area(poly);
+      if (a > bestArea) {
+        bestArea = a;
+        best = poly;
+      }
+    }
+    return best;
+  }
+  return null;
+}
+
+// src/strategies/boustrophedon.js
+function boustrophedon(polygon4, { spacing, angle = 0 }) {
+  const centroidPt = turf2.centroid(polygon4);
+  const rotated = angle !== 0 ? turf2.transformRotate(polygon4, -angle, { pivot: centroidPt }) : polygon4;
+  const [minX, minY, maxX, maxY] = turf2.bbox(rotated);
+  const spacingDeg = metersToDegreesLat(spacing);
+  const ys = [];
+  for (let y = minY + spacingDeg / 2; y < maxY + spacingDeg / 2; y += spacingDeg) {
+    ys.push(y);
+  }
+  if (ys.length === 0) {
+    const c = centroidPt.geometry.coordinates;
+    return turf2.lineString([c, c]);
+  }
+  const coords = [];
+  let leftToRight = true;
+  for (const y of ys) {
+    const segments = clipScanLine(rotated, y, minX, maxX);
+    if (segments.length === 0) continue;
+    if (leftToRight) {
+      for (const [x0, x1] of segments) {
+        coords.push([x0, y]);
+        coords.push([x1, y]);
+      }
+    } else {
+      for (const [x0, x1] of [...segments].reverse()) {
+        coords.push([x1, y]);
+        coords.push([x0, y]);
+      }
+    }
+    leftToRight = !leftToRight;
+  }
+  if (coords.length < 2) {
+    const c = centroidPt.geometry.coordinates;
+    return turf2.lineString([c, c]);
+  }
+  const path = turf2.lineString(coords);
+  return angle !== 0 ? turf2.transformRotate(path, angle, { pivot: centroidPt }) : path;
+}
+
+// src/strategies/outerIn.js
+var turf3 = __toESM(require("@turf/turf"), 1);
+function outerIn(polygon4, { spacing }) {
+  const rings = collectRings(polygon4, spacing);
+  if (rings.length === 0) {
+    const c = turf3.centroid(polygon4).geometry.coordinates;
+    return turf3.lineString([c, c]);
+  }
+  return connectRings(rings);
+}
+function collectRings(polygon4, spacingMeters) {
+  const spacingKm = spacingMeters / 1e3;
+  const rings = [];
+  rings.push(polygon4.geometry.coordinates[0].slice());
+  let current = polygon4;
+  for (let i = 0; i < 1e3; i++) {
+    let eroded;
+    try {
+      eroded = turf3.buffer(current, -spacingKm, { units: "kilometers", steps: 16 });
+    } catch {
+      break;
+    }
+    if (!eroded) break;
+    const largest = getLargestPolygon(eroded);
+    if (!largest) break;
+    const outerRing = largest.geometry.coordinates[0];
+    if (!outerRing || outerRing.length < 4) break;
+    rings.push(outerRing.slice());
+    current = largest;
+  }
+  return rings;
+}
+function connectRings(rings) {
+  const path = [];
+  for (const ring of rings) {
+    const isClosed = ring[0][0] === ring[ring.length - 1][0] && ring[0][1] === ring[ring.length - 1][1];
+    const open = isClosed ? ring.slice(0, -1) : ring.slice();
+    if (path.length === 0) {
+      path.push(...open);
+    } else {
+      const lastPt = path[path.length - 1];
+      const startIdx = findClosestIndex(open, lastPt);
+      path.push(...reorderRing(open, startIdx));
+    }
+  }
+  if (path.length < 2) return turf3.lineString([path[0], path[0]]);
+  return turf3.lineString(path);
+}
+
+// src/strategies/innerOut.js
+var turf4 = __toESM(require("@turf/turf"), 1);
+function innerOut(polygon4, { spacing }) {
+  const rings = collectRings(polygon4, spacing);
+  if (rings.length === 0) {
+    const c = turf4.centroid(polygon4).geometry.coordinates;
+    return turf4.lineString([c, c]);
+  }
+  return connectRings([...rings].reverse());
+}
+
+// src/strategies/hilbert.js
+var turf5 = __toESM(require("@turf/turf"), 1);
+var MAX_N = 512;
+function hilbert(polygon4, { spacing }) {
+  const [minX, minY, maxX, maxY] = turf5.bbox(polygon4);
+  const centerLat = (minY + maxY) / 2;
+  const cellW = metersToDegreesLng(spacing, centerLat);
+  const cellH = metersToDegreesLat(spacing);
+  const numCols = Math.max(1, Math.ceil((maxX - minX) / cellW));
+  const numRows = Math.max(1, Math.ceil((maxY - minY) / cellH));
+  const n = Math.min(MAX_N, nextPowerOf2(Math.max(numCols, numRows)));
+  const insideCoords = [];
+  for (let d = 0; d < n * n; d++) {
+    const { x, y } = hilbertDToXY(n, d);
+    if (x >= numCols || y >= numRows) continue;
+    const lng = minX + (x + 0.5) * cellW;
+    const lat = minY + (y + 0.5) * cellH;
+    if (turf5.booleanPointInPolygon(turf5.point([lng, lat]), polygon4)) {
+      insideCoords.push([lng, lat]);
+    }
+  }
+  if (insideCoords.length === 0) {
+    const c = turf5.centroid(polygon4).geometry.coordinates;
+    return turf5.lineString([c, c]);
+  }
+  if (insideCoords.length === 1) {
+    return turf5.lineString([insideCoords[0], insideCoords[0]]);
+  }
+  return turf5.lineString(insideCoords);
+}
+function hilbertDToXY(n, d) {
+  let x = 0, y = 0;
+  let t = d;
+  for (let s = 1; s < n; s *= 2) {
+    const rx = 1 & Math.floor(t / 2);
+    const ry = 1 & (t ^ rx);
+    if (ry === 0) {
+      if (rx === 1) {
+        x = s - 1 - x;
+        y = s - 1 - y;
+      }
+      const tmp = x;
+      x = y;
+      y = tmp;
+    }
+    x += s * rx;
+    y += s * ry;
+    t = Math.floor(t / 4);
+  }
+  return { x, y };
+}
+function nextPowerOf2(n) {
+  if (n <= 1) return 1;
+  let p = 1;
+  while (p < n) p *= 2;
+  return p;
+}
+
+// src/strategies/gridSpiral.js
+var turf6 = __toESM(require("@turf/turf"), 1);
+function gridSpiral(polygon4, { spacing }) {
+  const [minX, minY, maxX, maxY] = turf6.bbox(polygon4);
+  const centerLat = (minY + maxY) / 2;
+  const cellW = metersToDegreesLng(spacing, centerLat);
+  const cellH = metersToDegreesLat(spacing);
+  const numCols = Math.max(1, Math.ceil((maxX - minX) / cellW));
+  const numRows = Math.max(1, Math.ceil((maxY - minY) / cellH));
+  const [cx, cy] = turf6.centroid(polygon4).geometry.coordinates;
+  const startCol = Math.min(numCols - 1, Math.max(0, Math.floor((cx - minX) / cellW)));
+  const startRow = Math.min(numRows - 1, Math.max(0, Math.floor((cy - minY) / cellH)));
+  const insideCoords = [];
+  for (const [col, row] of spiralOrder(startCol, startRow, numCols, numRows)) {
+    const lng = minX + (col + 0.5) * cellW;
+    const lat = minY + (row + 0.5) * cellH;
+    if (turf6.booleanPointInPolygon(turf6.point([lng, lat]), polygon4)) {
+      insideCoords.push([lng, lat]);
+    }
+  }
+  if (insideCoords.length === 0) {
+    const c = turf6.centroid(polygon4).geometry.coordinates;
+    return turf6.lineString([c, c]);
+  }
+  if (insideCoords.length === 1) {
+    return turf6.lineString([insideCoords[0], insideCoords[0]]);
+  }
+  return turf6.lineString(insideCoords);
+}
+function* spiralOrder(startCol, startRow, numCols, numRows) {
+  const DIRS = [[1, 0], [0, 1], [-1, 0], [0, -1]];
+  let col = startCol;
+  let row = startRow;
+  yield [col, row];
+  const maxRadius = Math.max(numCols, numRows);
+  let dirIdx = 0;
+  for (let stepSize = 1; stepSize <= maxRadius * 2; stepSize++) {
+    for (let turn = 0; turn < 2; turn++) {
+      const [dc, dr] = DIRS[dirIdx];
+      for (let i = 0; i < stepSize; i++) {
+        col += dc;
+        row += dr;
+        if (col >= 0 && col < numCols && row >= 0 && row < numRows) {
+          yield [col, row];
+        }
+      }
+      dirIdx = (dirIdx + 1) % 4;
+    }
+  }
+}
+
+// src/utils/simplify.js
+function simplifyPath(coords, toleranceMeters) {
+  if (coords.length <= 2) return coords;
+  const result = rdp(coords, 0, coords.length - 1, toleranceMeters);
+  return result.map((i) => coords[i]);
+}
+function rdp(coords, lo, hi, tol) {
+  if (hi - lo < 2) {
+    const out = [];
+    for (let i = lo; i <= hi; i++) out.push(i);
+    return out;
+  }
+  let maxDist = 0;
+  let maxIdx = lo;
+  for (let i = lo + 1; i < hi; i++) {
+    const d = ptSegDistMeters(coords[i], coords[lo], coords[hi]);
+    if (d > maxDist) {
+      maxDist = d;
+      maxIdx = i;
+    }
+  }
+  if (maxDist > tol) {
+    const left = rdp(coords, lo, maxIdx, tol);
+    const right = rdp(coords, maxIdx, hi, tol);
+    return [...left, ...right.slice(1)];
+  }
+  return [lo, hi];
+}
+function ptSegDistMeters(p, a, b) {
+  const M_PER_DEG_LAT = 111e3;
+  const cosLat = Math.cos(p[1] * Math.PI / 180);
+  const px = p[0] * cosLat * M_PER_DEG_LAT, py = p[1] * M_PER_DEG_LAT;
+  const ax = a[0] * cosLat * M_PER_DEG_LAT, ay = a[1] * M_PER_DEG_LAT;
+  const bx = b[0] * cosLat * M_PER_DEG_LAT, by = b[1] * M_PER_DEG_LAT;
+  const dx = bx - ax, dy = by - ay;
+  const lenSq = dx * dx + dy * dy;
+  let cx, cy;
+  if (lenSq === 0) {
+    cx = px - ax;
+    cy = py - ay;
+  } else {
+    const t = Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / lenSq));
+    cx = px - (ax + t * dx);
+    cy = py - (ay + t * dy);
+  }
+  return Math.sqrt(cx * cx + cy * cy);
+}
+
+// src/planner.js
+var STRATEGIES = {
+  boustrophedon: (polygon4, opts) => boustrophedon(polygon4, opts),
+  diagonal: (polygon4, opts) => boustrophedon(polygon4, { ...opts, angle: 45 }),
+  "outer-in": (polygon4, opts) => outerIn(polygon4, opts),
+  "inner-out": (polygon4, opts) => innerOut(polygon4, opts),
+  hilbert: (polygon4, opts) => hilbert(polygon4, opts),
+  "grid-spiral": (polygon4, opts) => gridSpiral(polygon4, opts)
+};
+function planPath(geojson, options = {}) {
+  const { strategy = "boustrophedon", spacing, angle = 0 } = options;
+  if (!spacing || spacing <= 0) {
+    throw new Error("options.spacing must be a positive number (metres)");
+  }
+  if (!(strategy in STRATEGIES)) {
+    throw new Error(
+      `Unknown strategy "${strategy}". Valid strategies: ${Object.keys(STRATEGIES).join(", ")}`
+    );
+  }
+  const polygon4 = normalizeToPolygon(geojson);
+  const stratFn = STRATEGIES[strategy];
+  let result;
+  try {
+    result = stratFn(polygon4, { spacing, angle });
+  } catch (err) {
+    throw new Error(`Strategy "${strategy}" failed: ${err.message}`);
+  }
+  if (!result || result.geometry.coordinates.length < 2) {
+    const c = turf7.centroid(polygon4).geometry.coordinates;
+    return turf7.lineString([c, c], { strategy, spacing, degenerate: true });
+  }
+  const simplified = simplifyPath(result.geometry.coordinates, spacing * 0.12);
+  result = turf7.lineString(
+    simplified.length >= 2 ? simplified : result.geometry.coordinates,
+    result.properties
+  );
+  result.properties = { ...result.properties, strategy, spacing };
+  return result;
+}
+function normalizeToPolygon(geojson) {
+  if (!geojson) throw new Error("geojson is required");
+  const feature = geojson.type === "Feature" ? geojson : { type: "Feature", geometry: geojson, properties: {} };
+  const geom = feature.geometry;
+  if (!geom) throw new Error("GeoJSON feature has no geometry");
+  if (geom.type === "Polygon") return feature;
+  if (geom.type === "MultiPolygon") {
+    let best = null;
+    let bestArea = -Infinity;
+    for (const coords of geom.coordinates) {
+      const poly = turf7.polygon(coords);
+      const a = turf7.area(poly);
+      if (a > bestArea) {
+        bestArea = a;
+        best = poly;
+      }
+    }
+    if (!best) throw new Error("MultiPolygon contains no valid polygons");
+    return best;
+  }
+  throw new Error(
+    `Unsupported geometry type "${geom.type}". planPath accepts Polygon or MultiPolygon.`
+  );
+}
+
+// src/multi.js
+var turf8 = __toESM(require("@turf/turf"), 1);
+var DIVISION_STRATEGIES = ["vertical", "horizontal", "grid", "balanced"];
+function planMultiPath(geojson, {
+  parties = 2,
+  divisionStrategy = "vertical",
+  coverageStrategy = "boustrophedon",
+  spacing,
+  angle = 0
+} = {}) {
+  if (!spacing || spacing <= 0) {
+    throw new Error("options.spacing must be a positive number (metres)");
+  }
+  if (!Number.isInteger(parties) || parties < 1) {
+    throw new Error("options.parties must be a positive integer");
+  }
+  const polygon4 = normalizeToPolygon2(geojson);
+  const regions = dividePolygon(polygon4, parties, divisionStrategy);
+  if (regions.length === 0) {
+    throw new Error("No regions produced \u2014 polygon may be too small for the requested division");
+  }
+  const features = regions.map((region, i) => {
+    const path = planPath(region, { strategy: coverageStrategy, spacing, angle });
+    path.properties = { ...path.properties, party: i };
+    return path;
+  });
+  return turf8.featureCollection(features);
+}
+function dividePolygon(polygon4, n, strategy = "vertical") {
+  if (n === 1) return [polygon4];
+  switch (strategy) {
+    case "vertical":
+      return stripDivide(polygon4, n, "x");
+    case "horizontal":
+      return stripDivide(polygon4, n, "y");
+    case "grid":
+      return gridDivide(polygon4, n);
+    case "balanced":
+      return balancedDivide(polygon4, n);
+    default:
+      throw new Error(
+        `Unknown division strategy "${strategy}". Valid: ${DIVISION_STRATEGIES.join(", ")}`
+      );
+  }
+}
+function stripDivide(polygon4, n, axis) {
+  const [minX, minY, maxX, maxY] = turf8.bbox(polygon4);
+  const regions = [];
+  for (let i = 0; i < n; i++) {
+    const t0 = i / n, t1 = (i + 1) / n;
+    const clip = axis === "x" ? turf8.bboxPolygon([minX + t0 * (maxX - minX), minY, minX + t1 * (maxX - minX), maxY]) : turf8.bboxPolygon([minX, minY + t0 * (maxY - minY), maxX, minY + t1 * (maxY - minY)]);
+    const region = turf8.intersect(polygon4, clip);
+    if (region) regions.push(largestPolygon(region));
+  }
+  return regions;
+}
+function gridDivide(polygon4, n) {
+  const [minX, minY, maxX, maxY] = turf8.bbox(polygon4);
+  const cols = Math.ceil(Math.sqrt(n));
+  const rows = Math.ceil(n / cols);
+  const cellW = (maxX - minX) / cols;
+  const cellH = (maxY - minY) / rows;
+  const regions = [];
+  outer: for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      if (regions.length >= n) break outer;
+      const clip = turf8.bboxPolygon([
+        minX + c * cellW,
+        minY + r * cellH,
+        minX + (c + 1) * cellW,
+        minY + (r + 1) * cellH
+      ]);
+      const region = turf8.intersect(polygon4, clip);
+      if (region) regions.push(largestPolygon(region));
+    }
+  }
+  return regions;
+}
+function balancedDivide(polygon4, n) {
+  if (n <= 1) return [polygon4];
+  const nLeft = Math.floor(n / 2);
+  const nRight = n - nLeft;
+  const [minX, minY, maxX, maxY] = turf8.bbox(polygon4);
+  const cosLat = Math.cos((minY + maxY) / 2 * Math.PI / 180);
+  const widthM = (maxX - minX) * cosLat * 111e3;
+  const heightM = (maxY - minY) * 111e3;
+  const axis = widthM >= heightM ? "x" : "y";
+  const [half1, half2] = bisectPolygon(polygon4, axis, nLeft / n);
+  return [
+    ...half1 ? balancedDivide(half1, nLeft) : [],
+    ...half2 ? balancedDivide(half2, nRight) : []
+  ];
+}
+function bisectPolygon(polygon4, axis, targetFraction) {
+  const [minX, minY, maxX, maxY] = turf8.bbox(polygon4);
+  const totalArea = turf8.area(polygon4);
+  const targetArea = totalArea * targetFraction;
+  let lo = axis === "x" ? minX : minY;
+  let hi = axis === "x" ? maxX : maxY;
+  for (let i = 0; i < 24; i++) {
+    const mid2 = (lo + hi) / 2;
+    const clip = axis === "x" ? turf8.bboxPolygon([minX, minY, mid2, maxY]) : turf8.bboxPolygon([minX, minY, maxX, mid2]);
+    const part = turf8.intersect(polygon4, clip);
+    const partArea = part ? turf8.area(part) : 0;
+    if (partArea < targetArea) lo = mid2;
+    else hi = mid2;
+  }
+  const mid = (lo + hi) / 2;
+  const clipLeft = axis === "x" ? turf8.bboxPolygon([minX, minY, mid, maxY]) : turf8.bboxPolygon([minX, minY, maxX, mid]);
+  const clipRight = axis === "x" ? turf8.bboxPolygon([mid, minY, maxX, maxY]) : turf8.bboxPolygon([minX, mid, maxX, maxY]);
+  const left = turf8.intersect(polygon4, clipLeft);
+  const right = turf8.intersect(polygon4, clipRight);
+  return [
+    left ? largestPolygon(left) : null,
+    right ? largestPolygon(right) : null
+  ];
+}
+function largestPolygon(feature) {
+  if (feature.geometry.type === "Polygon") return feature;
+  let best = null, bestArea = -Infinity;
+  for (const coords of feature.geometry.coordinates) {
+    const poly = turf8.polygon(coords);
+    const a = turf8.area(poly);
+    if (a > bestArea) {
+      bestArea = a;
+      best = poly;
+    }
+  }
+  return best;
+}
+function normalizeToPolygon2(geojson) {
+  if (!geojson) throw new Error("geojson is required");
+  const feature = geojson.type === "Feature" ? geojson : { type: "Feature", geometry: geojson, properties: {} };
+  const geom = feature.geometry;
+  if (!geom) throw new Error("GeoJSON feature has no geometry");
+  if (geom.type === "Polygon") return feature;
+  if (geom.type === "MultiPolygon") {
+    let best = null, bestArea = -Infinity;
+    for (const coords of geom.coordinates) {
+      const poly = turf8.polygon(coords);
+      const a = turf8.area(poly);
+      if (a > bestArea) {
+        bestArea = a;
+        best = poly;
+      }
+    }
+    return best;
+  }
+  throw new Error(`Unsupported geometry type "${geom.type}"`);
+}
+//# sourceMappingURL=index.cjs.map