@team-geospan/structuresio 0.0.4 → 0.0.6

package/lib/geojson.js

@@ -19,59 +19,68 @@
  * Convert a StructuresJSON Structure or StructureCollection to GeoJSON
  */
 
-import { isCollection } from "./helpers";
+import { isCollection } from "./helpers.js";
 
 /**
- * toCoordinateArray converts the surface topology to a GeoJSON style
- * Polygon geometry coordinates array.
- *
- * This is written to be as clear and testable as possible.
- * There are likely more efficient ways to loop through this loop,
- * but this version works and is relatively easy to read.
- *
+ * simplifyRing converts a single surface ring and coverts it to a list
+ * of points.
  */
-export const toCoordinateArray = (surface, edges, points) => {
-  // the "edges" array is structued similar to a simple features polygon.
-  // [outer ring, inner ring, inner ring]
-  // And each ring is composed of [edgeId, edgeId, edgeId]
-  // edges contains points [pointId, pointId]
-  const coords = surface.edges.map((edgeIds) => {
-    const edgePoints = [];
-    edgeIds.forEach((edgeId, edgeIdx) => {
-      const edge = edges[edgeId];
-      // copy the points to ensure the origin edge is not mutated.
-      const nextPoints = [...edge.points];
-      if (edgeIdx === 0) {
-        // determine whether to start the line with the first segment reversed
-        const testPoints = edges[edgeIds[1]].points;
-        if (nextPoints[0] === testPoints[0]) {
-          // flip it
-          nextPoints.reverse();
-        }
-      } else {
-        // keep the line contiguous, flip the next set of points
-        //  when the lastPoint in the line does not match the
-        //  first point of the next edge.
-        const lastPoint = edgePoints[edgePoints.length - 1];
-        if (nextPoints[0] !== lastPoint) {
-          nextPoints.reverse();
-        }
+export const simplifyRing = (ringEdges) => {
+  if (ringEdges.length === 0) {
+    return [];
+  }
+
+  let edges = structuredClone(ringEdges);
+  const sortedList = [];
+
+  sortedList.push(edges.shift());
+
+  // ensure the iterations of the while loop do not exceed
+  // O(n^2), the input edge structure is likely degenerate.
+  let maxIter = edges.length * edges.length;
+  while (maxIter > 0 && edges.length > 0) {
+    for (let i = 0, len = edges.length; i < len; i++) {
+      const edge = edges[i];
+      const len = sortedList.length - 1;
+      if (sortedList[len][1] === edge[0]) {
+        sortedList.push(edge);
+        edges = edges.slice(0, i).concat(edges.slice(i + 1));
+        break;
+      } else if (sortedList[len][1] === edge[edge.length - 1]) {
+        sortedList.push(edge.reverse());
+        edges = edges.slice(0, i).concat(edges.slice(i + 1));
+        break;
       }
-      // use slice(1) to prevent duplicate points.
-      nextPoints.slice(1).forEach((p) => edgePoints.push(p));
-    });
-    // ensure the polygon is closed.
-    if (edgePoints[0] !== edgePoints[edgePoints.length - 1]) {
-      edgePoints.push(edgePoints[0]);
     }
-    // convert all the point ids into [x, y, z] coordinates.
-    return edgePoints.map((ptId) => points[ptId].coordinates);
+    maxIter--;
+  }
+
+  // flatten the list
+  const asPoints = sortedList.map((edge) => edge[0]);
+  // ensure the polygon is closed
+  asPoints.push(sortedList[0][0]);
+  return asPoints;
+};
+
+// surfaceRings returns a list of point ids based on the surfaces edges
+const surfaceRings = (surfaceId, { surfaces, edges }) => {
+  return surfaces[surfaceId].edges.map((ring) => {
+    return ring.map((edgeId) => {
+      return edges[edgeId].points;
+    });
   });
-  return coords;
 };
 
 const structureToPolygonFeature = ({ surfaces, points, edges }) => {
   const features = Object.keys(surfaces).map((surfaceId) => {
+    const rings = surfaceRings(surfaceId, { surfaces, edges }).map((ring) =>
+      simplifyRing(ring),
+    );
+    // convert all the rings into coordinates
+    const coordinates = rings.map((ring) =>
+      ring.map((pointId) => points[pointId].coordinates),
+    );
+
     return {
       type: "Feature",
       properties: {
@@ -81,7 +90,7 @@ const structureToPolygonFeature = ({ surfaces, points, edges }) => {
       },
       geometry: {
         type: "Polygon",
-        coordinates: toCoordinateArray(surfaces[surfaceId], edges, points),
+        coordinates,
       },
     };
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-geospan/structuresio",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Collection of utilities for working with StructuresJSON",
   "type": "module",
   "exports": {
@@ -26,16 +26,21 @@
     },
     "extends": [
       "eslint:recommended",
-      "plugin:prettier/recommended"
+      "plugin:prettier/recommended",
+      "plugin:import/recommended"
     ],
     "rules": {
-      "prettier/prettier": "error"
+      "prettier/prettier": "error",
+      "import/extensions": ["error", "always", {
+       "js": "always"
+      }]
     }
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^3.1.1",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-prettier": "^5.2.3",
     "vitest": "^3.1.1"
   },