smart rewind (beta)

Author: neocarto

doc_index.md

@@ -120,6 +120,7 @@ geotoolbox.intersects(data1, data2);
 - [**`reverse()`**](global.html#reverse) - Converts CCW rings to CW. Reverses direction of LineStrings.
 - [**`rewind()`**](global.html#rewind) - Rewind a geoJSON (Fil recipe).
 - [**`rewind2()`**](global.html#rewind2) - Rewind a geoJSON (Mapbox recipe).
+- [**`smartrewind()`**](global.html#smartrewind) - Rewind a geoJSON (Homemade recipe).
 - [**`roundcoordinates()`**](global.html#roundcoordinates) - The function allows to round the coordinates of geometries.
 
 **3 - Tests**

src/index.js

@@ -30,6 +30,7 @@ export { centroid } from "./centroid.js";
 export { aggregate } from "./aggregate.js";
 export { rewind } from "./rewind.js";
 export { rewind2 } from "./rewind2.js";
+export { smartrewind } from "./smartrewind.js";
 export { reverse } from "./reverse.js";
 export { dissolve } from "./dissolve.js";
 export { clip } from "./clip.js";

src/smartrewind.js

@@ -0,0 +1,129 @@
+/**
+ * Rewind a GeoJSON FeatureCollection. A homemade approach that tries to work in most cases. The rewindPole parameter allows forcing the rewind of polar polygons.
+ * @param {GeoJSON} data - The input GeoJSON FeatureCollection
+ * @param {Object} options
+ * @param {boolean} [options.mutate=false] - If false, a copy of the GeoJSON is returned; the original is not modified
+ * @param {boolean} [options.rewindPole=false] - If true, forces rewind of polar polygons (Antarctic/Arctic)
+ */
+export function smartrewind(data, options = {}) {
+  const mutate = options.mutate === true;
+  const rewindPole = options.rewindPole === true;
+
+  // Work on a copy if mutate is false
+  const geo = mutate ? data : structuredClone(data);
+
+  for (const feature of geo.features) {
+    let geom = feature.geometry;
+    if (!geom) continue;
+
+    // Clean up geometry (remove duplicate points, invalid rings)
+    geom = cleanGeom(geom);
+    if (!geom) {
+      feature.geometry = null;
+      continue;
+    }
+
+    // ---------------------
+    // Detect polar polygons
+    // ---------------------
+    let isPolar = false;
+    let minLat = Infinity;
+    let maxLat = -Infinity;
+
+    const coords =
+      geom.type === "Polygon"
+        ? geom.coordinates.flat()
+        : geom.type === "MultiPolygon"
+          ? geom.coordinates.flat(2)
+          : [];
+
+    for (const [, lat] of coords) {
+      if (lat < minLat) minLat = lat;
+      if (lat > maxLat) maxLat = lat;
+    }
+
+    if (minLat <= -89.9) isPolar = "south";
+    else if (maxLat >= 89.9) isPolar = "north";
+
+    // ---------------------
+    // Rewind polar polygons if requested
+    // ---------------------
+    if (isPolar && rewindPole) {
+      if (geom.type === "Polygon") geom.coordinates[0].reverse();
+      else if (geom.type === "MultiPolygon")
+        geom.coordinates.forEach((poly) => poly[0].reverse());
+
+      feature.geometry = geom;
+      continue; // skip normal rewind
+    }
+
+    // ---------------------
+    // Rewind regular polygons
+    // ---------------------
+    if (geom.type === "Polygon")
+      geom.coordinates = fixPolySpherical(geom.coordinates);
+    else if (geom.type === "MultiPolygon")
+      geom.coordinates = geom.coordinates.map(fixPolySpherical);
+
+    feature.geometry =
+      geom.coordinates && geom.coordinates.length ? geom : null;
+  }
+
+  return geo;
+}
+
+// ---------------------
+// Helper functions
+// ---------------------
+
+// Clean rings: remove duplicate points, close rings, remove too-short rings
+function cleanGeom(geom) {
+  function cleanRing(ring) {
+    if (!ring || ring.length < 2) return null;
+    const cleaned = [ring[0]];
+    for (let i = 1; i < ring.length; i++) {
+      const [x, y] = ring[i];
+      const [x0, y0] = cleaned[cleaned.length - 1];
+      if (x !== x0 || y !== y0) cleaned.push(ring[i]);
+    }
+    const f = cleaned[0],
+      l = cleaned[cleaned.length - 1];
+    if (f[0] !== l[0] || f[1] !== l[1]) cleaned.push([...f]);
+    if (cleaned.length < 4) return null;
+    return cleaned;
+  }
+
+  if (geom.type === "Polygon") {
+    const rings = geom.coordinates.map(cleanRing).filter(Boolean);
+    return rings.length ? { ...geom, coordinates: rings } : null;
+  }
+  if (geom.type === "MultiPolygon") {
+    const polys = geom.coordinates
+      .map((poly) => poly.map(cleanRing).filter(Boolean))
+      .filter((p) => p.length);
+    return polys.length ? { ...geom, coordinates: polys } : null;
+  }
+  return geom;
+}
+
+// Fix polygon orientation using spherical method
+function fixPolySpherical(rings) {
+  const outer = rings[0];
+  const inners = rings.slice(1);
+  rewindRing(outer, true); // outer ring clockwise
+  inners.forEach((r) => rewindRing(r, false)); // inner rings counter-clockwise
+  return [outer, ...inners];
+}
+
+// Rewind a ring based on desired direction
+function rewindRing(ring, dir) {
+  let tArea = 0,
+    err = 0;
+  for (let i = 0, len = ring.length, j = len - 1; i < len; j = i++) {
+    const k = (ring[i][0] - ring[j][0]) * (ring[j][1] + ring[i][1]);
+    const m = tArea + k;
+    err += Math.abs(tArea) >= Math.abs(k) ? tArea - m + k : k - m + tArea;
+    tArea = m;
+  }
+  if (tArea + err >= 0 !== !!dir) ring.reverse();
+}