landxml 0.6.6 → 0.8.0

package/dist/index.js

@@ -79,9 +79,11 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  precomputeSurfaceData: () => precomputeSurfaceData,
   reprojectGeoJson: () => reproject_geojson_default,
   toGeojsonContours: () => to_geojson_contours_default,
-  toGlb: () => to_glb_default
+  toGlb: () => to_glb_default,
+  toGlbAndContours: () => to_glb_and_contours_default
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -113,18 +115,30 @@ var findXYAxisMedians = (vertices) => {
 };
 var getGlb = (data, customCenter) => __async(null, null, function* () {
   const center = customCenter || findXYAxisMedians(data.surfaceDefinition.points);
-  const vertices = [...data.surfaceDefinition.points].map((p) => p.slice()).map(([x, y, z]) => {
-    return [x - center[0], z, -(y - center[1])];
-  }).reduce((prev, curr) => prev.concat(curr), []);
-  const triangles = data.surfaceDefinition.faces.reduce((prev, curr) => prev.concat(curr), []);
+  const pts = data.surfaceDefinition.points;
+  const facesFlat = data.surfaceDefinition.faces;
+  const vertexBuffer = new Float32Array(pts.length * 3);
+  for (let i = 0; i < pts.length; i++) {
+    const [x, y, z] = pts[i];
+    vertexBuffer[i * 3] = x - center[0];
+    vertexBuffer[i * 3 + 1] = z;
+    vertexBuffer[i * 3 + 2] = -(y - center[1]);
+  }
+  const indexBuffer = new Uint32Array(facesFlat.length * 3);
+  for (let i = 0; i < facesFlat.length; i++) {
+    const [a, b, c] = facesFlat[i];
+    indexBuffer[i * 3] = a;
+    indexBuffer[i * 3 + 1] = b;
+    indexBuffer[i * 3 + 2] = c;
+  }
   const doc = new import_core.Document();
   const buffer = doc.createBuffer();
-  const position = doc.createAccessor().setType("VEC3").setArray(new Float32Array(vertices)).setBuffer(buffer);
-  const indices = doc.createAccessor().setType("SCALAR").setArray(new Uint32Array(triangles)).setBuffer(buffer);
+  const position = doc.createAccessor().setType("VEC3").setArray(vertexBuffer).setBuffer(buffer);
+  const indices = doc.createAccessor().setType("SCALAR").setArray(indexBuffer).setBuffer(buffer);
   const prim = doc.createPrimitive().setAttribute("POSITION", position).setIndices(indices);
   const mesh = doc.createMesh().addPrimitive(prim);
   const node = doc.createNode().setMesh(mesh);
-  const scene = doc.createScene().addChild(node);
+  doc.createScene().addChild(node);
   const glb = yield new import_core.WebIO().writeBinary(doc);
   return { glb, center };
 });
@@ -168,14 +182,29 @@ var surfaceDefWorker = (0, import_easy_web_worker.createEasyWebWorker)(
             })
           );
         } else if (task === "find-neighboring-faces") {
-          const { faces, range: { start, end } } = message.payload;
-          const faceNeighbors = [];
-          for (let i = start; i < end; i++) {
-            const sourceFace = faces[i];
-            const neighborA = faces.findIndex((f, j) => f.findIndex((v) => v === sourceFace[0]) >= 0 && f.findIndex((v) => v === sourceFace[1]) >= 0 && j !== i);
-            const neighborB = faces.findIndex((f, j) => f.findIndex((v) => v === sourceFace[1]) >= 0 && f.findIndex((v) => v === sourceFace[2]) >= 0 && j !== i);
-            const neighborC = faces.findIndex((f, j) => f.findIndex((v) => v === sourceFace[0]) >= 0 && f.findIndex((v) => v === sourceFace[2]) >= 0 && j !== i);
-            faceNeighbors.push([neighborA, neighborB, neighborC]);
+          const { faces } = message.payload;
+          const edgeMap = /* @__PURE__ */ new Map();
+          const edgeKey = (a, b) => a < b ? `${a},${b}` : `${b},${a}`;
+          for (let i = 0; i < faces.length; i++) {
+            const [v0, v1, v2] = faces[i];
+            for (const key of [edgeKey(v0, v1), edgeKey(v1, v2), edgeKey(v0, v2)]) {
+              const existing = edgeMap.get(key);
+              if (!existing) {
+                edgeMap.set(key, [i]);
+              } else if (existing.length === 1) {
+                existing.push(i);
+              }
+            }
+          }
+          const faceNeighbors = new Array(faces.length);
+          for (let i = 0; i < faces.length; i++) {
+            const [v0, v1, v2] = faces[i];
+            const resolve = (key) => {
+              const pair = edgeMap.get(key);
+              if (!pair || pair.length < 2) return -1;
+              return pair[0] === i ? pair[1] : pair[0];
+            };
+            faceNeighbors[i] = [resolve(edgeKey(v0, v1)), resolve(edgeKey(v1, v2)), resolve(edgeKey(v0, v2))];
           }
           message.resolve(faceNeighbors);
         }
@@ -186,134 +215,99 @@ var surfaceDefWorker = (0, import_easy_web_worker.createEasyWebWorker)(
   },
   { maxWorkers: 16 }
 );
-var parseXML = (xmlString) => __async(null, null, function* () {
-  return new Promise((resolve, reject) => __async(null, null, function* () {
-    var _a, _b, _c, _d, _e;
-    const parsed = import_xml_js.default.xml2js(xmlString, {
-      compact: true,
-      attributesKey: "attr",
-      textKey: "content"
-    });
-    if (typeof ((_b = (_a = parsed.LandXML) == null ? void 0 : _a.Surfaces) == null ? void 0 : _b.Surface) === "undefined") {
-      throw new Error("LandXML doesn't contain any surfaces");
-      return;
-    }
-    if (!Array.isArray(parsed.LandXML.Surfaces.Surface)) {
-      parsed.LandXML.Surfaces.Surface = [parsed.LandXML.Surfaces.Surface];
-    }
-    let sourceFile = parsed.LandXML.Project.attr.name || "Undefined source";
-    let timeStamp = parsed.LandXML.Application.attr.timeStamp || "";
-    let wktString = ((_e = (_d = (_c = parsed.LandXML) == null ? void 0 : _c.CoordinateSystem) == null ? void 0 : _d.attr) == null ? void 0 : _e.ogcWktCode) || void 0;
-    const surfaces = parsed.LandXML.Surfaces.Surface.map(
-      (surface) => __async(null, null, function* () {
-        return new Promise((resolve2, reject2) => __async(null, null, function* () {
-          const { name, desc } = surface.attr;
-          const Pnts = surface.Definition.Pnts.P;
-          const Faces = surface.Definition.Faces.F;
-          let ptsIdArray = [];
-          let faces = [];
-          let faceNeighbors = [];
-          if (Pnts.length > 1e4) {
-            const sliceIndexes = [...Array(20).keys()].map((i) => Math.round(Pnts.length / 20 * i));
-            ptsIdArray = (yield Promise.all(
-              sliceIndexes.map(
-                (v, i, a) => new Promise((resolve3, reject3) => __async(null, null, function* () {
-                  const pts = yield surfaceDefWorker.send({
-                    task: "parse-surface-points",
-                    points: Pnts.slice(a[i], a[i + 1] || Pnts.length)
-                  });
-                  resolve3(pts);
-                }))
-              )
-            )).reduce((prev, curr) => [...prev, ...curr], []);
-          } else {
-            ptsIdArray = yield surfaceDefWorker.send({ task: "parse-surface-points", points: Pnts });
-          }
-          const points = ptsIdArray.map((v) => v[1]);
-          const pointsIdMap = ptsIdArray.map((v) => v[0]);
-          if (Faces.length > 1e4) {
-            const sliceIndexes = [...Array(20).keys()].map((i) => Math.round(Faces.length / 20 * i));
-            faces = (yield Promise.all(
-              sliceIndexes.map(
-                (v, i, a) => new Promise((resolve3, reject3) => __async(null, null, function* () {
-                  const fcs = yield surfaceDefWorker.send({
-                    task: "parse-surface-faces",
-                    faces: Faces.slice(a[i], a[i + 1] || Faces.length),
-                    idMap: pointsIdMap
-                  });
-                  resolve3(fcs);
-                }))
-              )
-            )).reduce((prev, curr) => [...prev, ...curr], []);
-          } else {
-            faces = yield surfaceDefWorker.send({
-              task: "parse-surface-faces",
-              faces: Faces,
-              idMap: pointsIdMap
-            });
-          }
-          if (Faces.length > 1e4) {
-            const sliceIndexes = [...Array(20).keys()].map((i) => Math.round((faces.length - 1) / 20 * i));
-            faceNeighbors = (yield Promise.all(
-              sliceIndexes.map(
-                (v, i, a) => new Promise((resolve3, reject3) => __async(null, null, function* () {
-                  const fcs = yield surfaceDefWorker.send({
-                    task: "find-neighboring-faces",
-                    faces,
-                    range: {
-                      start: a[i],
-                      end: a[i + 1] || faces.length
-                    }
-                  });
-                  resolve3(fcs);
-                }))
-              )
-            )).reduce((prev, curr) => [...prev, ...curr], []);
-          } else {
-            faceNeighbors = yield surfaceDefWorker.send({
-              task: "find-neighboring-faces",
-              faces,
-              range: {
-                start: 0,
-                end: faces.length
-              }
-            });
-          }
-          resolve2({
-            sourceFile,
-            timeStamp: timeStamp || "",
-            name,
-            description: desc || "",
-            wktString,
-            surfaceDefinition: {
-              points,
-              faces,
-              faceNeighbors
-            }
-          });
-        }));
+function parallelChunks(items, count, makePayload) {
+  return __async(this, null, function* () {
+    const sliceIndexes = [...Array(count).keys()].map((i) => Math.round(items.length / count * i));
+    const chunks = yield Promise.all(
+      sliceIndexes.map((start, i, arr) => {
+        var _a;
+        const end = (_a = arr[i + 1]) != null ? _a : items.length;
+        return surfaceDefWorker.send(makePayload(items.slice(start, end), start, end));
       })
     );
-    resolve(yield Promise.all(surfaces));
+    return chunks.reduce((acc, c) => acc.concat(c), []);
+  });
+}
+var CHUNK_THRESHOLD = 1e4;
+var CHUNK_COUNT = 20;
+var parseXML = (xmlString) => __async(null, null, function* () {
+  var _a, _b, _c, _d, _e;
+  const parsed = import_xml_js.default.xml2js(xmlString, {
+    compact: true,
+    attributesKey: "attr",
+    textKey: "content"
+  });
+  if (typeof ((_b = (_a = parsed.LandXML) == null ? void 0 : _a.Surfaces) == null ? void 0 : _b.Surface) === "undefined") {
+    throw new Error("LandXML doesn't contain any surfaces");
+  }
+  if (!Array.isArray(parsed.LandXML.Surfaces.Surface)) {
+    parsed.LandXML.Surfaces.Surface = [parsed.LandXML.Surfaces.Surface];
+  }
+  const sourceFile = parsed.LandXML.Project.attr.name || "Undefined source";
+  const timeStamp = parsed.LandXML.Application.attr.timeStamp || "";
+  const wktString = ((_e = (_d = (_c = parsed.LandXML) == null ? void 0 : _c.CoordinateSystem) == null ? void 0 : _d.attr) == null ? void 0 : _e.ogcWktCode) || void 0;
+  const surfaces = parsed.LandXML.Surfaces.Surface.map((surface) => __async(null, null, function* () {
+    const { name, desc } = surface.attr;
+    const Pnts = surface.Definition.Pnts.P;
+    const Faces = surface.Definition.Faces.F;
+    const ptsIdArray = Pnts.length > CHUNK_THRESHOLD ? yield parallelChunks(Pnts, CHUNK_COUNT, (chunk) => ({
+      task: "parse-surface-points",
+      points: chunk
+    })) : yield surfaceDefWorker.send({
+      task: "parse-surface-points",
+      points: Pnts
+    });
+    const points = ptsIdArray.map((v) => v[1]);
+    const pointsIdMap = ptsIdArray.map((v) => v[0]);
+    const faces = Faces.length > CHUNK_THRESHOLD ? yield parallelChunks(Faces, CHUNK_COUNT, (chunk) => ({
+      task: "parse-surface-faces",
+      faces: chunk,
+      idMap: pointsIdMap
+    })) : yield surfaceDefWorker.send({
+      task: "parse-surface-faces",
+      faces: Faces,
+      idMap: pointsIdMap
+    });
+    const faceNeighbors = yield surfaceDefWorker.send({
+      task: "find-neighboring-faces",
+      faces
+    });
+    return {
+      sourceFile,
+      timeStamp,
+      name,
+      description: desc || "",
+      wktString,
+      surfaceDefinition: { points, faces, faceNeighbors }
+    };
   }));
+  return Promise.all(surfaces);
 });
 var parse_xml_default = parseXML;
 
 // src/public/to-glb.ts
 var toGlb = (landXmlString, center = "auto", surfaceId = -1) => __async(null, null, function* () {
-  const requestedCenter = center == "origin" ? [0, 0] : center === "auto" ? void 0 : center;
   let requestedParsedSurfaces = filter_by_surfaceId_default(yield parse_xml_default(landXmlString), surfaceId);
+  let resolvedCenter;
+  if (center === "origin") {
+    resolvedCenter = [0, 0];
+  } else if (center === "auto") {
+    const allPoints = requestedParsedSurfaces.flatMap((s) => s.surfaceDefinition.points);
+    resolvedCenter = findXYAxisMedians(allPoints);
+  } else {
+    resolvedCenter = center;
+  }
   const glbs = yield Promise.all(
     requestedParsedSurfaces.map(
       (surface) => new Promise((resolve, reject) => __async(null, null, function* () {
         try {
-          const { glb, center: center2 } = yield get_glb_default(surface, requestedCenter);
+          const { glb } = yield get_glb_default(surface, resolvedCenter);
           const _a = surface, { surfaceDefinition } = _a, rest = __objRest(_a, ["surfaceDefinition"]);
           resolve(__spreadProps(__spreadValues({}, rest), {
             glb,
-            center: center2,
+            center: resolvedCenter,
             download: () => {
-              download_glb_default(glb, surface.name.replace(/\.xml$/, `${JSON.stringify(center2)}.glb`));
+              download_glb_default(glb, surface.name.replace(/\.xml$/, `${JSON.stringify(resolvedCenter)}.glb`));
             }
           }));
         } catch (e) {
@@ -334,49 +328,45 @@ var contoursWorker = (0, import_easy_web_worker2.createEasyWebWorker)(
       let vertsAtElevation = 0;
       let line = [];
       for (let i = 0; i < face.length; i++) {
-        let vertex1 = face[i];
-        let vertex2 = face[(i + 1) % face.length];
+        const vertex1 = face[i];
+        const vertex2 = face[(i + 1) % face.length];
         if (vertex1[2] === z) vertsAtElevation++;
         if ((vertex1[2] <= z && vertex2[2] >= z || vertex1[2] >= z && vertex2[2] <= z) && !Number.isNaN((z - vertex1[2]) / (vertex2[2] - vertex1[2]))) {
-          let t = (z - vertex1[2]) / (vertex2[2] - vertex1[2]);
+          const t = (z - vertex1[2]) / (vertex2[2] - vertex1[2]);
           line.push([vertex1[0] + t * (vertex2[0] - vertex1[0]), vertex1[1] + t * (vertex2[1] - vertex1[1])]);
         }
       }
       if (vertsAtElevation >= 2 && face.map((f) => f[2]).reduce((a, b) => a + b) > z * face.length) return void 0;
-      if (line.length === 2 && line[0][0] === line[1][0] && line[0][1] === line[1][1])
-        return void 0;
+      if (line.length === 2 && line[0][0] === line[1][0] && line[0][1] === line[1][1]) return void 0;
       if (line.length > 2) {
         line = [...new Set(line.map((v) => JSON.stringify(v)))].map((s) => JSON.parse(s));
       }
       return line.length > 0 ? line : void 0;
     };
     const linesToPolyLines3 = (lineSegments) => {
-      var _a, _b;
-      if (!Array.isArray(lineSegments) || (lineSegments == null ? void 0 : lineSegments.length) === 0) {
-        return [];
-      }
+      if (!Array.isArray(lineSegments) || lineSegments.length === 0) return [];
       const segmentsMapIndexes = {};
       const polylines = [];
-      const parsedSegmentIndexes = [];
+      const parsedSegmentIndexes = /* @__PURE__ */ new Set();
       const lineSegmentStrings = lineSegments.map((v) => v.map((c) => c.join(",")));
-      lineSegmentStrings.forEach(([start, end], i) => {
-        segmentsMapIndexes[start] = segmentsMapIndexes[start] ? [...segmentsMapIndexes[start] || [], i] : [i];
-        segmentsMapIndexes[end] = segmentsMapIndexes[end] ? [...segmentsMapIndexes[end] || [], i] : [i];
-      });
       for (let i = 0; i < lineSegmentStrings.length; i++) {
-        if (parsedSegmentIndexes.includes(i)) continue;
-        parsedSegmentIndexes.push(i);
+        const [start, end] = lineSegmentStrings[i];
+        segmentsMapIndexes[start] = segmentsMapIndexes[start] ? [...segmentsMapIndexes[start], i] : [i];
+        segmentsMapIndexes[end] = segmentsMapIndexes[end] ? [...segmentsMapIndexes[end], i] : [i];
+      }
+      for (let i = 0; i < lineSegmentStrings.length; i++) {
+        if (parsedSegmentIndexes.has(i)) continue;
+        parsedSegmentIndexes.add(i);
         let [start, end] = lineSegmentStrings[i];
-        let polyline = [start, end];
+        const polyline = [start, end];
         while (start && segmentsMapIndexes[start]) {
-          const nextLineIndex = (_a = segmentsMapIndexes[start]) == null ? void 0 : _a.find(
-            (lineIndex) => !parsedSegmentIndexes.includes(lineIndex)
+          const nextLineIndex = segmentsMapIndexes[start].find(
+            (li) => !parsedSegmentIndexes.has(li)
           );
-          if (nextLineIndex) {
-            parsedSegmentIndexes.push(nextLineIndex);
-            const nextLineSegment = lineSegmentStrings[nextLineIndex];
-            const nextLineSegmentPointIndex = nextLineSegment[0] === start ? 1 : 0;
-            const newPoint = nextLineSegment[nextLineSegmentPointIndex];
+          if (nextLineIndex !== void 0) {
+            parsedSegmentIndexes.add(nextLineIndex);
+            const [a, b] = lineSegmentStrings[nextLineIndex];
+            const newPoint = a === start ? b : a;
             polyline.unshift(newPoint);
             start = newPoint;
           } else {
@@ -384,14 +374,13 @@ var contoursWorker = (0, import_easy_web_worker2.createEasyWebWorker)(
           }
         }
         while (end && segmentsMapIndexes[end]) {
-          const nextLineIndex = (_b = segmentsMapIndexes[end]) == null ? void 0 : _b.find(
-            (lineIndex) => !parsedSegmentIndexes.includes(lineIndex)
+          const nextLineIndex = segmentsMapIndexes[end].find(
+            (li) => !parsedSegmentIndexes.has(li)
           );
-          if (nextLineIndex) {
-            parsedSegmentIndexes.push(nextLineIndex);
-            const nextLineSegment = lineSegmentStrings[nextLineIndex];
-            const nextLineSegmentPointIndex = nextLineSegment[0] === end ? 1 : 0;
-            const newPoint = nextLineSegment[nextLineSegmentPointIndex];
+          if (nextLineIndex !== void 0) {
+            parsedSegmentIndexes.add(nextLineIndex);
+            const [a, b] = lineSegmentStrings[nextLineIndex];
+            const newPoint = a === end ? b : a;
             polyline.push(newPoint);
             end = newPoint;
           } else {
@@ -404,66 +393,51 @@ var contoursWorker = (0, import_easy_web_worker2.createEasyWebWorker)(
     };
     onMessage((message) => {
       const { triangles, elevation } = message.payload;
-      const linesAtElevationE = triangles.reduce((prev, curr) => {
+      const linesAtElevation = triangles.reduce((prev, curr) => {
         const line = contourLineOnFace(curr, elevation);
         if (line) prev.push(line);
         return prev;
       }, []);
-      message.resolve({
-        elevation,
-        polylines: linesToPolyLines3(linesAtElevationE)
-      });
+      message.resolve({ elevation, polylines: linesToPolyLines3(linesAtElevation) });
     });
   },
   { maxWorkers: 10 }
 );
 var linesToPolyLines = (lineSegments) => {
-  var _a, _b;
-  if (!Array.isArray(lineSegments) || (lineSegments == null ? void 0 : lineSegments.length) === 0) {
-    return [];
-  }
+  if (!Array.isArray(lineSegments) || lineSegments.length === 0) return [];
   const segmentsMapIndexes = {};
   const polylines = [];
-  const parsedSegmentIndexes = [];
+  const parsedSegmentIndexes = /* @__PURE__ */ new Set();
   const lineSegmentStrings = lineSegments.map((v) => v.map((c) => c.join(",")));
-  lineSegmentStrings.forEach(([start, end], i) => {
-    segmentsMapIndexes[start] = segmentsMapIndexes[start] ? [...segmentsMapIndexes[start] || [], i] : [i];
-    segmentsMapIndexes[end] = segmentsMapIndexes[end] ? [...segmentsMapIndexes[end] || [], i] : [i];
-  });
   for (let i = 0; i < lineSegmentStrings.length; i++) {
-    if (parsedSegmentIndexes.includes(i)) continue;
-    parsedSegmentIndexes.push(i);
+    const [start, end] = lineSegmentStrings[i];
+    segmentsMapIndexes[start] = segmentsMapIndexes[start] ? [...segmentsMapIndexes[start], i] : [i];
+    segmentsMapIndexes[end] = segmentsMapIndexes[end] ? [...segmentsMapIndexes[end], i] : [i];
+  }
+  for (let i = 0; i < lineSegmentStrings.length; i++) {
+    if (parsedSegmentIndexes.has(i)) continue;
+    parsedSegmentIndexes.add(i);
     let [start, end] = lineSegmentStrings[i];
-    let polyline = [start, end];
+    const polyline = [start, end];
     while (start && segmentsMapIndexes[start]) {
-      const nextLineIndex = (_a = segmentsMapIndexes[start]) == null ? void 0 : _a.find(
-        (lineIndex) => !parsedSegmentIndexes.includes(lineIndex)
-      );
-      if (nextLineIndex) {
-        parsedSegmentIndexes.push(nextLineIndex);
-        const nextLineSegment = lineSegmentStrings[nextLineIndex];
-        const nextLineSegmentPointIndex = nextLineSegment[0] === start ? 1 : 0;
-        const newPoint = nextLineSegment[nextLineSegmentPointIndex];
+      const nextLineIndex = segmentsMapIndexes[start].find((li) => !parsedSegmentIndexes.has(li));
+      if (nextLineIndex !== void 0) {
+        parsedSegmentIndexes.add(nextLineIndex);
+        const [a, b] = lineSegmentStrings[nextLineIndex];
+        const newPoint = a === start ? b : a;
         polyline.unshift(newPoint);
         start = newPoint;
-      } else {
-        start = null;
-      }
+      } else start = null;
     }
     while (end && segmentsMapIndexes[end]) {
-      const nextLineIndex = (_b = segmentsMapIndexes[end]) == null ? void 0 : _b.find(
-        (lineIndex) => !parsedSegmentIndexes.includes(lineIndex)
-      );
-      if (nextLineIndex) {
-        parsedSegmentIndexes.push(nextLineIndex);
-        const nextLineSegment = lineSegmentStrings[nextLineIndex];
-        const nextLineSegmentPointIndex = nextLineSegment[0] === end ? 1 : 0;
-        const newPoint = nextLineSegment[nextLineSegmentPointIndex];
+      const nextLineIndex = segmentsMapIndexes[end].find((li) => !parsedSegmentIndexes.has(li));
+      if (nextLineIndex !== void 0) {
+        parsedSegmentIndexes.add(nextLineIndex);
+        const [a, b] = lineSegmentStrings[nextLineIndex];
+        const newPoint = a === end ? b : a;
         polyline.push(newPoint);
         end = newPoint;
-      } else {
-        end = null;
-      }
+      } else end = null;
     }
     polylines.push(polyline.map((coord) => coord.split(",").map((v) => parseFloat(v))));
   }
@@ -477,10 +451,10 @@ var contourElevations = (minElevation, maxElevation, interval) => {
     throw new Error(`No contour lines at interval: ${interval} between elevation ${minElevation} and ${maxElevation}`);
   }
   const elevations = [];
-  let elevation = Math.ceil(minElevation / interval) * interval;
-  while (elevation < maxElevation) {
-    elevations.push(elevation);
-    elevation += interval;
+  const firstStep = Math.ceil(minElevation / interval);
+  const lastStep = Math.ceil(maxElevation / interval) - 1;
+  for (let step = firstStep; step <= lastStep; step++) {
+    elevations.push(step * interval);
   }
   return elevations;
 };
@@ -490,31 +464,55 @@ var constructGeojson = (elevationData) => {
     return prev.concat(
       polylines.map((polyline) => ({
         type: "Feature",
-        geometry: {
-          type: "LineString",
-          coordinates: polyline
-        },
-        properties: {
-          z: elevation
-        }
+        geometry: { type: "LineString", coordinates: polyline },
+        properties: { z: elevation }
       }))
     );
   }, []);
-  return {
-    type: "FeatureCollection",
-    features
-  };
+  return { type: "FeatureCollection", features };
 };
-var getContours = (data, interval = 2) => __async(null, null, function* () {
-  const triangles = data.surfaceDefinition.faces.map(
-    (face) => face.map((vert) => data.surfaceDefinition.points[vert])
-  );
-  const [minElevation, maxElevation] = data.surfaceDefinition.points.reduce(
-    ([prevMin, prevMax], curr) => [Math.min(prevMin, curr[2]), Math.max(prevMax, curr[2])],
-    [Infinity, -Infinity]
-  );
+var precomputeSurfaceData = (data) => {
+  const { points, faces } = data.surfaceDefinition;
+  let minElevation = Infinity;
+  let maxElevation = -Infinity;
+  for (const pt of points) {
+    if (pt[2] < minElevation) minElevation = pt[2];
+    if (pt[2] > maxElevation) maxElevation = pt[2];
+  }
+  const triangles = faces.map((face) => face.map((vert) => points[vert]));
+  return { triangles, minElevation, maxElevation };
+};
+var bucketTrianglesByElevation = (triangles, elevations, interval) => {
+  const trianglesByElevation = /* @__PURE__ */ new Map();
+  for (const e of elevations) trianglesByElevation.set(e, []);
+  for (const tri of triangles) {
+    const zMin = Math.min(tri[0][2], tri[1][2], tri[2][2]);
+    const zMax = Math.max(tri[0][2], tri[1][2], tri[2][2]);
+    const firstStep = Math.ceil(zMin / interval);
+    const lastStep = Math.floor(zMax / interval);
+    for (let step = firstStep; step <= lastStep; step++) {
+      const rounded = step * interval;
+      const bucket = trianglesByElevation.get(rounded);
+      if (bucket) bucket.push(tri);
+    }
+  }
+  return trianglesByElevation;
+};
+var getContours = (data, interval = 2, precomputed) => __async(null, null, function* () {
+  const { triangles, minElevation, maxElevation } = precomputed != null ? precomputed : precomputeSurfaceData(data);
   const elevations = contourElevations(minElevation, maxElevation, interval);
-  const elevationPolylines = yield Promise.all(elevations.map((elevation) => contoursWorker.send({ triangles, elevation })));
+  const trianglesByElevation = bucketTrianglesByElevation(triangles, elevations, interval);
+  const elevationPolylines = yield Promise.all(
+    elevations.map(
+      (elevation) => {
+        var _a;
+        return contoursWorker.send({
+          triangles: (_a = trianglesByElevation.get(elevation)) != null ? _a : [],
+          elevation
+        });
+      }
+    )
+  );
   return constructGeojson(elevationPolylines);
 });
 var get_contours_default = getContours;
@@ -597,9 +595,49 @@ var reprojectGeoJson = (geojson, sourceProjection, targetProjection = "WGS84", k
   return geojson;
 };
 var reproject_geojson_default = reprojectGeoJson;
+
+// src/public/to-glb-and-contours.ts
+var toGlbAndContours = (landXmlString, contourInterval = 2, generateOutline = true, center = "auto", surfaceId = -1) => __async(null, null, function* () {
+  const requestedParsedSurfaces = filter_by_surfaceId_default(yield parse_xml_default(landXmlString), surfaceId);
+  let resolvedCenter;
+  if (center === "origin") {
+    resolvedCenter = [0, 0];
+  } else if (center === "auto") {
+    const allPoints = requestedParsedSurfaces.flatMap((s) => s.surfaceDefinition.points);
+    resolvedCenter = findXYAxisMedians(allPoints);
+  } else {
+    resolvedCenter = center;
+  }
+  const results = yield Promise.all(
+    requestedParsedSurfaces.map((surface) => __async(null, null, function* () {
+      const precomputed = precomputeSurfaceData(surface);
+      const [{ glb }, geojson] = yield Promise.all([
+        get_glb_default(surface, resolvedCenter),
+        get_contours_default(surface, contourInterval, precomputed)
+      ]);
+      if (generateOutline) {
+        const outlineGeojson = get_outline_default(surface);
+        geojson.features = [...geojson.features, ...outlineGeojson.features];
+      }
+      const _a = surface, { surfaceDefinition } = _a, rest = __objRest(_a, ["surfaceDefinition"]);
+      return __spreadProps(__spreadValues({}, rest), {
+        glb,
+        center: resolvedCenter,
+        download: () => {
+          download_glb_default(glb, surface.name.replace(/\.xml$/, `${JSON.stringify(resolvedCenter)}.glb`));
+        },
+        geojson
+      });
+    }))
+  );
+  return results;
+});
+var to_glb_and_contours_default = toGlbAndContours;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  precomputeSurfaceData,
   reprojectGeoJson,
   toGeojsonContours,
-  toGlb
+  toGlb,
+  toGlbAndContours
 });