landxml 0.0.1 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+# landxml
+
+## 0.2.0
+
+### Minor Changes
+
+- ae3bcf7: Swapped xml reader package from `xml2json` to `xml-js`
+- ae3bcf7: Added `glb` download example into README.md
+
+### Patch Changes
+
+- ae3bcf7: Fixed dependency list
+
+## 0.1.0
+
+### Minor Changes
+
+- e0fa5a8: Added tests
+- e0fa5a8: Added contour lines geojson export
+- e0fa5a8: Added GLB file export
+- e0fa5a8: Exposed functions for extenal use
+- e0fa5a8: Added README.md
+- e0fa5a8: Added LandXML parser
+
+### Patch Changes
+
+- 4e2c14f: Fixed test imports
+- 3c53b08: Fixed types on toGeojsonContours to reflect that surface may have a wktString
+- 3c53b08: Updated README GeoJSON Contours code example

package/README.md

@@ -1 +1,48 @@
-Just a landxml parser for the web.
+# LandXML Parser for Contour Geojson and 3D Models
+
+Easily transform LandXML surfaces into stunning GeoJSON contours or immersive GLB models to explore within threeJS or any popular 3D software.
+
+### Features
+
+- **toGlb:** Generate GLB models from LandXML surfaces.
+- **toGeojsonContours:** Convert LandXML data into detailed contour GeoJSON representations.
+- **reprojectGeojson:** Effortlessly reproject GeoJSON data to desired projection using `proj4`
+
+### Example: Retrieve GeoJSON Contours
+
+```typescript
+import { toGeojsonContours, reprojectGeoJson } from "landxml";
+
+const loadGeojson = async () => {
+    const landXmlString = "<?xml version="1.0"?>...</LandXML>";
+    const contourInterval = 2;
+    const geojsonSurfaces = await toGeojsonContours(landXmlString, contourInterval);
+
+    // Retrieve geojson with raw LandXML coordinates
+    let { geojson, wktString } = geojsonSurfaces[0];
+
+    // Reproject GeoJSON to a desired coordinate system (e.g., WGS84)
+    const targetCoordinateSystem = wktString || "WGS84";
+    const keepOriginalGeometryAsFeatureProperties = false;
+    return reprojectGeoJson(geojson, wktString, targetCoordinateSystem, keepOriginalGeometryAsFeatureProperties);
+}
+```
+
+### Example: Convert to GLB 3D model
+
+```typescript
+import { toGlb } from "landxml";
+
+const LandXml2GlbModel = async () => {
+    const landXmlString = "<?xml version="1.0"?>...</LandXML>";
+
+    // Define how the model's origin should be positioned (options: "origin" | "auto" | [x: number, y: number])
+    const center = "auto";
+    const glbSurfaces = await toGlb(landXmlString, center);
+
+    let { download, glb } = glbSurfaces[0];
+    download()
+
+    // Alternatively, process the raw binary data from the 'glb' variable (Uint8Array)
+}
+```

package/dist/index.d.mts

@@ -1,3 +1,62 @@
-declare const _default: () => void;
+import * as geojson from 'geojson';
+import { FeatureCollection, LineString } from 'geojson';
 
-export { _default as default };
+/**
+ * @param landXmlString
+ * @param center 3D models don't work well when they're far from origin (coordinate `[0,0,0]`), therefore by default your center is moved to the median of x and y axis of your surface
+ * @param surfaceId Surface name or index if your LandXML contains multiple surfaces. By default all surfaces are converted and returns an array of glb Uint8Array
+ * @returns {Object[]} glbs - Array of processed glbs (will also return an array when just one surface has been processed)
+ * @returns {string} glbs[].name - Name of surface as defined in LandXML
+ * @returns {string} glbs[].description - Description of surface as defined in LandXML
+ * @returns {string} glbs[].sourceFile - Source file of where the LandXML was generated from.
+ * @returns {string} glbs[].timeStamp - Timestamp of when the surface was exported into LandXML
+ * @returns {Uint8Array} glbs[].glb - Uint8Array binary data of glb
+ * @returns {[number, number]} glbs[].center - Offset center of the processed glb
+ * @returns {function(): void} glbs[].download - Convenient way to download the GLB, within the filename the new center will be appended.
+ */
+declare const toGlb: (landXmlString: string, center?: "auto" | "origin" | [
+    x: number,
+    y: number
+], surfaceId?: string | number) => Promise<{
+    name: string;
+    description: string;
+    sourceFile: string;
+    timeStamp: string;
+    glb: Uint8Array;
+    center: [x: number, y: number];
+    download: () => void;
+}[]>;
+
+/**
+ * @param landXmlString
+ * @param contourInterval Interval at which you would like to generate contour lines
+ * @param surfaceId Surface name or index if your LandXML contains multiple surfaces. By default all surfaces are converted and returns an array of glb Uint8Array
+ * @returns {Object[]} surfaceContours - Array of processed surface contours (will also return an array when just one surface has been processed)
+ * @returns {string} surfaceContours[].name - Name of surface as defined in LandXML
+ * @returns {string} surfaceContours[].description - Description of surface as defined in LandXML
+ * @returns {string} surfaceContours[].sourceFile - Source file of where the LandXML was generated from.
+ * @returns {string} surfaceContours[].timeStamp - Timestamp of when the surface was exported into LandXML
+ * @returns {string} surfaceContours[].wktString - WKT string of LandXML coordinate system projection
+ * @returns {Object} surfaceContours[].geojson - Geojson feature collection of contour lines
+ */
+declare const toGeojsonContours: (landXmlString: string, contourInterval?: number, surfaceId?: string | number) => Promise<{
+    name: string;
+    description: string;
+    sourceFile: string;
+    timeStamp: string;
+    wktString?: string;
+    geojson: FeatureCollection<LineString, {
+        z: number;
+    }>;
+}[]>;
+
+/**
+ * @param geojson
+ * @param sourceProjection can be a proj4 string or WKT string, you will likely have a wkt string available with your LandXML if you used Civil 3D exporter and had your drawing geo-referenced
+ * @param targetProjection you will most likely want to use WGS84 for online viewing, however any other projection you might need can be used as long as it's valid
+ * @param keepOriginalGeometryAsFeatureProperty if you intend to repurpose the original geometry, it can be added to geojson feature properties
+ * @returns {FeatureCollection} Geojson FeatureCollection with updated geometry coordinates
+ */
+declare const reprojectGeoJson: (geojson: FeatureCollection, sourceProjection: string, targetProjection?: string, keepOriginalGeometryAsFeatureProperty?: boolean) => FeatureCollection<geojson.Geometry, geojson.GeoJsonProperties>;
+
+export { reprojectGeoJson, toGeojsonContours, toGlb };

package/dist/index.d.ts

@@ -1,3 +1,62 @@
-declare const _default: () => void;
+import * as geojson from 'geojson';
+import { FeatureCollection, LineString } from 'geojson';
 
-export { _default as default };
+/**
+ * @param landXmlString
+ * @param center 3D models don't work well when they're far from origin (coordinate `[0,0,0]`), therefore by default your center is moved to the median of x and y axis of your surface
+ * @param surfaceId Surface name or index if your LandXML contains multiple surfaces. By default all surfaces are converted and returns an array of glb Uint8Array
+ * @returns {Object[]} glbs - Array of processed glbs (will also return an array when just one surface has been processed)
+ * @returns {string} glbs[].name - Name of surface as defined in LandXML
+ * @returns {string} glbs[].description - Description of surface as defined in LandXML
+ * @returns {string} glbs[].sourceFile - Source file of where the LandXML was generated from.
+ * @returns {string} glbs[].timeStamp - Timestamp of when the surface was exported into LandXML
+ * @returns {Uint8Array} glbs[].glb - Uint8Array binary data of glb
+ * @returns {[number, number]} glbs[].center - Offset center of the processed glb
+ * @returns {function(): void} glbs[].download - Convenient way to download the GLB, within the filename the new center will be appended.
+ */
+declare const toGlb: (landXmlString: string, center?: "auto" | "origin" | [
+    x: number,
+    y: number
+], surfaceId?: string | number) => Promise<{
+    name: string;
+    description: string;
+    sourceFile: string;
+    timeStamp: string;
+    glb: Uint8Array;
+    center: [x: number, y: number];
+    download: () => void;
+}[]>;
+
+/**
+ * @param landXmlString
+ * @param contourInterval Interval at which you would like to generate contour lines
+ * @param surfaceId Surface name or index if your LandXML contains multiple surfaces. By default all surfaces are converted and returns an array of glb Uint8Array
+ * @returns {Object[]} surfaceContours - Array of processed surface contours (will also return an array when just one surface has been processed)
+ * @returns {string} surfaceContours[].name - Name of surface as defined in LandXML
+ * @returns {string} surfaceContours[].description - Description of surface as defined in LandXML
+ * @returns {string} surfaceContours[].sourceFile - Source file of where the LandXML was generated from.
+ * @returns {string} surfaceContours[].timeStamp - Timestamp of when the surface was exported into LandXML
+ * @returns {string} surfaceContours[].wktString - WKT string of LandXML coordinate system projection
+ * @returns {Object} surfaceContours[].geojson - Geojson feature collection of contour lines
+ */
+declare const toGeojsonContours: (landXmlString: string, contourInterval?: number, surfaceId?: string | number) => Promise<{
+    name: string;
+    description: string;
+    sourceFile: string;
+    timeStamp: string;
+    wktString?: string;
+    geojson: FeatureCollection<LineString, {
+        z: number;
+    }>;
+}[]>;
+
+/**
+ * @param geojson
+ * @param sourceProjection can be a proj4 string or WKT string, you will likely have a wkt string available with your LandXML if you used Civil 3D exporter and had your drawing geo-referenced
+ * @param targetProjection you will most likely want to use WGS84 for online viewing, however any other projection you might need can be used as long as it's valid
+ * @param keepOriginalGeometryAsFeatureProperty if you intend to repurpose the original geometry, it can be added to geojson feature properties
+ * @returns {FeatureCollection} Geojson FeatureCollection with updated geometry coordinates
+ */
+declare const reprojectGeoJson: (geojson: FeatureCollection, sourceProjection: string, targetProjection?: string, keepOriginalGeometryAsFeatureProperty?: boolean) => FeatureCollection<geojson.Geometry, geojson.GeoJsonProperties>;
+
+export { reprojectGeoJson, toGeojsonContours, toGlb };

package/dist/index.js

@@ -1,8 +1,39 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,14 +46,350 @@ var __copyProps = (to, from, except, desc) => {
   }
   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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  default: () => src_default
+  reprojectGeoJson: () => reproject_geojson_default,
+  toGeojsonContours: () => to_geojson_contours_default,
+  toGlb: () => to_glb_default
 });
 module.exports = __toCommonJS(src_exports);
-var src_default = () => {
-  console.log("Hello world");
+
+// src/private/filter-by-surfaceId.ts
+var filterBySurfaceId = (parsedSurfaces, surfaceId) => {
+  let filtered = [...parsedSurfaces];
+  if (typeof surfaceId === "string") {
+    filtered = filtered.filter((s) => s.name === surfaceId);
+    if (filtered.length === 0)
+      throw "Provided SurfaceId doesn't exist within provided LandXML";
+  }
+  if (typeof surfaceId === "number" && surfaceId > 0) {
+    if (!filtered[surfaceId])
+      throw `Provided SurfaceId index is out of range. Provided LandXML has ${filtered.length} surfaces.`;
+    filtered = [filtered[surfaceId]];
+  }
+  return filtered;
+};
+var filter_by_surfaceId_default = filterBySurfaceId;
+
+// src/private/get-glb.ts
+var import_core = require("@gltf-transform/core");
+var findXYAxisMedians = (vertices) => {
+  var _a, _b;
+  vertices = vertices.slice().filter(Boolean);
+  const middleIndex = Math.floor(vertices.length / 2);
+  const medianX = (_a = vertices.slice().sort((a, b) => a[0] - b[0])[middleIndex]) == null ? void 0 : _a[0];
+  const medianY = (_b = vertices.slice().sort((a, b) => a[1] - b[1])[middleIndex]) == null ? void 0 : _b[1];
+  return [medianX, medianY];
 };
+var getGlb = (data, customCenter) => __async(void 0, 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 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 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);
+  const glb = yield new import_core.WebIO().writeBinary(doc);
+  return { glb, center };
+});
+var get_glb_default = getGlb;
+
+// src/private/download-glb.ts
+var downloadGlb = (glbData, fileName) => {
+  const blobUrl = URL.createObjectURL(new Blob([glbData], { type: "model/gltf-binary" }));
+  const link = document.createElement("a");
+  link.href = blobUrl;
+  link.download = fileName;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(blobUrl);
+};
+var download_glb_default = downloadGlb;
+
+// src/private/parse-xml.ts
+var import_xml_js = __toESM(require("xml-js"));
+var parseXML = (xmlString) => __async(void 0, null, function* () {
+  const { LandXML } = import_xml_js.default.xml2js(xmlString, {
+    compact: true,
+    attributesKey: "attr",
+    textKey: "content"
+  });
+  const landXML_surfaces = Array.isArray(LandXML.Surfaces.Surface) ? LandXML.Surfaces.Surface : [LandXML.Surfaces.Surface];
+  return landXML_surfaces.map((surface) => {
+    var _a, _b;
+    let points = [];
+    let faces = [];
+    let pointIdMap = {};
+    surface.Definition.Pnts.P.forEach((pt) => {
+      const { attr, content } = pt;
+      const [y, x, z] = content.split(" ").map((v) => parseFloat(v));
+      points.push([x, y, z]);
+      pointIdMap[attr.id] = points.length - 1;
+    }, []);
+    faces = surface.Definition.Faces.F.map((face) => {
+      const { content } = face;
+      const [a, b, c] = content.split(" ").map((v) => pointIdMap[v]);
+      if ([a, b, c].filter((v) => typeof v === "undefined").length > 0) {
+        throw `Invalid LandXML. A face is referencing a point that doesn't exist. Face is referencing points: ${content}`;
+      }
+      return [a, b, c];
+    });
+    return {
+      sourceFile: LandXML.Project.attr.name,
+      timeStamp: LandXML.Application.attr.timeStamp,
+      name: surface.attr.name,
+      description: surface.attr.desc,
+      wktString: (_b = (_a = LandXML.CoordinateSystem) == null ? void 0 : _a.attr) == null ? void 0 : _b.ogcWktCode,
+      surfaceDefinition: {
+        points,
+        faces
+      }
+    };
+  });
+});
+var parse_xml_default = parseXML;
+
+// src/public/to-glb.ts
+var toGlb = (landXmlString, center = "auto", surfaceId = -1) => __async(void 0, 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);
+  const glbs = yield Promise.all(
+    requestedParsedSurfaces.map(
+      (surface) => new Promise((resolve, reject) => __async(void 0, null, function* () {
+        try {
+          const { glb, center: center2 } = yield get_glb_default(surface, requestedCenter);
+          const _a = surface, { surfaceDefinition } = _a, rest = __objRest(_a, ["surfaceDefinition"]);
+          resolve(__spreadProps(__spreadValues({}, rest), {
+            glb,
+            center: center2,
+            download: () => {
+              download_glb_default(glb, surface.name.replace(/\.xml$/, `${JSON.stringify(center2)}.glb`));
+            }
+          }));
+        } catch (e) {
+          reject(e);
+        }
+      }))
+    )
+  );
+  return glbs;
+});
+var to_glb_default = toGlb;
+
+// src/private/get-contours.ts
+var contourLineOnFace = (face, z) => {
+  let line = [];
+  for (let i = 0; i < face.length; i++) {
+    let vertex1 = face[i];
+    let vertex2 = face[(i + 1) % face.length];
+    if (vertex1[2] <= z && vertex2[2] >= z || vertex1[2] >= z && vertex2[2] <= z) {
+      let t = (z - vertex1[2]) / (vertex2[2] - vertex1[2]);
+      line.push([vertex1[0] + t * (vertex2[0] - vertex1[0]), vertex1[1] + t * (vertex2[1] - vertex1[1])]);
+    }
+  }
+  return line.length > 0 ? line : void 0;
+};
+var linesToPolyLines = (lineSegments) => {
+  if (!Array.isArray(lineSegments) || lineSegments.length === 0) {
+    throw new Error("Invalid input: Please provide a non-empty array of line segments.");
+  }
+  const segmentsMap = /* @__PURE__ */ new Map();
+  const polylines = [];
+  lineSegments.forEach(([start, end]) => {
+    const startKey = start.join(",");
+    const endKey = end.join(",");
+    segmentsMap.set(startKey, segmentsMap.get(startKey) || []);
+    segmentsMap.set(endKey, segmentsMap.get(endKey) || []);
+    segmentsMap.get(startKey).push(end);
+    segmentsMap.get(endKey).push(start);
+  });
+  const constructPolyline = (start, polyline) => {
+    let current = start;
+    while (segmentsMap.has(current.join(",")) && segmentsMap.get(current.join(",")).length > 0) {
+      const next = segmentsMap.get(current.join(",")).pop();
+      polyline.push(current);
+      if (next) {
+        const nextKey = next.join(",");
+        segmentsMap.delete(current.join(","));
+        current = next;
+        if (segmentsMap.has(nextKey)) {
+          segmentsMap.set(
+            nextKey,
+            (segmentsMap.get(nextKey) || []).filter((point) => point.join(",") !== current.join(","))
+          );
+        }
+      }
+    }
+    polyline.push(current);
+    return polyline;
+  };
+  const traverseSegmentsMap = (endpoints, startKey) => {
+    let start = startKey.split(",").map(Number);
+    while (endpoints.length > 0) {
+      const newPolyline = constructPolyline(start, []);
+      polylines.push(newPolyline);
+      start = endpoints.pop();
+    }
+  };
+  for (const [startKey, endpoints] of segmentsMap.entries()) {
+    if (endpoints && endpoints.length === 0) {
+      continue;
+    }
+    traverseSegmentsMap(endpoints || [], startKey);
+  }
+  return polylines;
+};
+var contourElevations = (minElevation, maxElevation, increment) => {
+  const elevations = [];
+  const start = Math.ceil(minElevation * 2) / 2;
+  const end = Math.floor(maxElevation * 2) / 2;
+  for (let elevation = start; elevation <= end; elevation += increment) {
+    elevations.push(elevation);
+  }
+  return elevations;
+};
+var constructGeojson = (elevationData) => {
+  const features = elevationData.reduce((prev, data) => {
+    const { elevation, polylines } = data;
+    return prev.concat(
+      polylines.map((polyline) => ({
+        type: "Feature",
+        geometry: {
+          type: "LineString",
+          coordinates: polyline
+        },
+        properties: {
+          z: elevation
+        }
+      }))
+    );
+  }, []);
+  return {
+    type: "FeatureCollection",
+    features
+  };
+};
+var getContours = (data, interval = 2) => __async(void 0, 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]
+  );
+  const elevations = contourElevations(minElevation, maxElevation, interval);
+  const elevationPolylines = elevations.map((e) => ({
+    elevation: e,
+    polylines: linesToPolyLines(
+      triangles.reduce((prev, curr) => {
+        const line = contourLineOnFace(curr, e);
+        if (line)
+          prev.push(line);
+        return prev;
+      }, [])
+    )
+  }));
+  return constructGeojson(elevationPolylines);
+});
+var get_contours_default = getContours;
+
+// src/public/to-geojson-contours.ts
+var toGeojsonContours = (landXmlString, contourInterval = 2, surfaceId = -1) => __async(void 0, null, function* () {
+  let requestedParsedSurfaces = filter_by_surfaceId_default(yield parse_xml_default(landXmlString), surfaceId);
+  const contours = yield Promise.all(
+    requestedParsedSurfaces.map(
+      (surface) => new Promise((resolve, reject) => __async(void 0, null, function* () {
+        try {
+          const geojson = yield get_contours_default(surface, contourInterval);
+          const _a = surface, { surfaceDefinition } = _a, rest = __objRest(_a, ["surfaceDefinition"]);
+          resolve(__spreadProps(__spreadValues({}, rest), {
+            geojson
+          }));
+        } catch (e) {
+          reject(e);
+        }
+      }))
+    )
+  );
+  return contours;
+});
+var to_geojson_contours_default = toGeojsonContours;
+
+// src/public/reproject-geojson.ts
+var import_proj4 = __toESM(require("proj4"));
+var reprojectGeoJson = (geojson, sourceProjection, targetProjection = "WGS84", keepOriginalGeometryAsFeatureProperty = true) => {
+  const transformCoordinates = (coordinates, sourceProjection2, targetProjection2) => {
+    if (Array.isArray(coordinates[0])) {
+      coordinates = coordinates.map(
+        (subCoordinates) => transformCoordinates(subCoordinates, sourceProjection2, targetProjection2)
+      );
+    } else {
+      coordinates = (0, import_proj4.default)(sourceProjection2, targetProjection2, coordinates);
+    }
+    return coordinates;
+  };
+  if (!geojson || !geojson.features || !Array.isArray(geojson.features) || !sourceProjection) {
+    throw new Error("Invalid GeoJSON or source projection.");
+  }
+  geojson.features.forEach((feature) => {
+    if (keepOriginalGeometryAsFeatureProperty)
+      feature.properties = feature.properties || {};
+    if (feature.geometry) {
+      if (keepOriginalGeometryAsFeatureProperty && feature.properties)
+        feature.properties._rawGeometry = __spreadValues({}, feature.geometry);
+      if (sourceProjection !== targetProjection) {
+        feature.geometry.coordinates = transformCoordinates(
+          feature.geometry.coordinates,
+          sourceProjection,
+          targetProjection
+        );
+      }
+    }
+  });
+  return geojson;
+};
+var reproject_geojson_default = reprojectGeoJson;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  reprojectGeoJson,
+  toGeojsonContours,
+  toGlb
+});

package/dist/index.mjs

@@ -1,7 +1,359 @@
-// src/index.ts
-var src_default = () => {
-  console.log("Hello world");
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/private/filter-by-surfaceId.ts
+var filterBySurfaceId = (parsedSurfaces, surfaceId) => {
+  let filtered = [...parsedSurfaces];
+  if (typeof surfaceId === "string") {
+    filtered = filtered.filter((s) => s.name === surfaceId);
+    if (filtered.length === 0)
+      throw "Provided SurfaceId doesn't exist within provided LandXML";
+  }
+  if (typeof surfaceId === "number" && surfaceId > 0) {
+    if (!filtered[surfaceId])
+      throw `Provided SurfaceId index is out of range. Provided LandXML has ${filtered.length} surfaces.`;
+    filtered = [filtered[surfaceId]];
+  }
+  return filtered;
+};
+var filter_by_surfaceId_default = filterBySurfaceId;
+
+// src/private/get-glb.ts
+import { Document, WebIO } from "@gltf-transform/core";
+var findXYAxisMedians = (vertices) => {
+  var _a, _b;
+  vertices = vertices.slice().filter(Boolean);
+  const middleIndex = Math.floor(vertices.length / 2);
+  const medianX = (_a = vertices.slice().sort((a, b) => a[0] - b[0])[middleIndex]) == null ? void 0 : _a[0];
+  const medianY = (_b = vertices.slice().sort((a, b) => a[1] - b[1])[middleIndex]) == null ? void 0 : _b[1];
+  return [medianX, medianY];
+};
+var getGlb = (data, customCenter) => __async(void 0, 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 doc = new 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 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);
+  const glb = yield new WebIO().writeBinary(doc);
+  return { glb, center };
+});
+var get_glb_default = getGlb;
+
+// src/private/download-glb.ts
+var downloadGlb = (glbData, fileName) => {
+  const blobUrl = URL.createObjectURL(new Blob([glbData], { type: "model/gltf-binary" }));
+  const link = document.createElement("a");
+  link.href = blobUrl;
+  link.download = fileName;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(blobUrl);
+};
+var download_glb_default = downloadGlb;
+
+// src/private/parse-xml.ts
+import convert from "xml-js";
+var parseXML = (xmlString) => __async(void 0, null, function* () {
+  const { LandXML } = convert.xml2js(xmlString, {
+    compact: true,
+    attributesKey: "attr",
+    textKey: "content"
+  });
+  const landXML_surfaces = Array.isArray(LandXML.Surfaces.Surface) ? LandXML.Surfaces.Surface : [LandXML.Surfaces.Surface];
+  return landXML_surfaces.map((surface) => {
+    var _a, _b;
+    let points = [];
+    let faces = [];
+    let pointIdMap = {};
+    surface.Definition.Pnts.P.forEach((pt) => {
+      const { attr, content } = pt;
+      const [y, x, z] = content.split(" ").map((v) => parseFloat(v));
+      points.push([x, y, z]);
+      pointIdMap[attr.id] = points.length - 1;
+    }, []);
+    faces = surface.Definition.Faces.F.map((face) => {
+      const { content } = face;
+      const [a, b, c] = content.split(" ").map((v) => pointIdMap[v]);
+      if ([a, b, c].filter((v) => typeof v === "undefined").length > 0) {
+        throw `Invalid LandXML. A face is referencing a point that doesn't exist. Face is referencing points: ${content}`;
+      }
+      return [a, b, c];
+    });
+    return {
+      sourceFile: LandXML.Project.attr.name,
+      timeStamp: LandXML.Application.attr.timeStamp,
+      name: surface.attr.name,
+      description: surface.attr.desc,
+      wktString: (_b = (_a = LandXML.CoordinateSystem) == null ? void 0 : _a.attr) == null ? void 0 : _b.ogcWktCode,
+      surfaceDefinition: {
+        points,
+        faces
+      }
+    };
+  });
+});
+var parse_xml_default = parseXML;
+
+// src/public/to-glb.ts
+var toGlb = (landXmlString, center = "auto", surfaceId = -1) => __async(void 0, 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);
+  const glbs = yield Promise.all(
+    requestedParsedSurfaces.map(
+      (surface) => new Promise((resolve, reject) => __async(void 0, null, function* () {
+        try {
+          const { glb, center: center2 } = yield get_glb_default(surface, requestedCenter);
+          const _a = surface, { surfaceDefinition } = _a, rest = __objRest(_a, ["surfaceDefinition"]);
+          resolve(__spreadProps(__spreadValues({}, rest), {
+            glb,
+            center: center2,
+            download: () => {
+              download_glb_default(glb, surface.name.replace(/\.xml$/, `${JSON.stringify(center2)}.glb`));
+            }
+          }));
+        } catch (e) {
+          reject(e);
+        }
+      }))
+    )
+  );
+  return glbs;
+});
+var to_glb_default = toGlb;
+
+// src/private/get-contours.ts
+var contourLineOnFace = (face, z) => {
+  let line = [];
+  for (let i = 0; i < face.length; i++) {
+    let vertex1 = face[i];
+    let vertex2 = face[(i + 1) % face.length];
+    if (vertex1[2] <= z && vertex2[2] >= z || vertex1[2] >= z && vertex2[2] <= z) {
+      let t = (z - vertex1[2]) / (vertex2[2] - vertex1[2]);
+      line.push([vertex1[0] + t * (vertex2[0] - vertex1[0]), vertex1[1] + t * (vertex2[1] - vertex1[1])]);
+    }
+  }
+  return line.length > 0 ? line : void 0;
+};
+var linesToPolyLines = (lineSegments) => {
+  if (!Array.isArray(lineSegments) || lineSegments.length === 0) {
+    throw new Error("Invalid input: Please provide a non-empty array of line segments.");
+  }
+  const segmentsMap = /* @__PURE__ */ new Map();
+  const polylines = [];
+  lineSegments.forEach(([start, end]) => {
+    const startKey = start.join(",");
+    const endKey = end.join(",");
+    segmentsMap.set(startKey, segmentsMap.get(startKey) || []);
+    segmentsMap.set(endKey, segmentsMap.get(endKey) || []);
+    segmentsMap.get(startKey).push(end);
+    segmentsMap.get(endKey).push(start);
+  });
+  const constructPolyline = (start, polyline) => {
+    let current = start;
+    while (segmentsMap.has(current.join(",")) && segmentsMap.get(current.join(",")).length > 0) {
+      const next = segmentsMap.get(current.join(",")).pop();
+      polyline.push(current);
+      if (next) {
+        const nextKey = next.join(",");
+        segmentsMap.delete(current.join(","));
+        current = next;
+        if (segmentsMap.has(nextKey)) {
+          segmentsMap.set(
+            nextKey,
+            (segmentsMap.get(nextKey) || []).filter((point) => point.join(",") !== current.join(","))
+          );
+        }
+      }
+    }
+    polyline.push(current);
+    return polyline;
+  };
+  const traverseSegmentsMap = (endpoints, startKey) => {
+    let start = startKey.split(",").map(Number);
+    while (endpoints.length > 0) {
+      const newPolyline = constructPolyline(start, []);
+      polylines.push(newPolyline);
+      start = endpoints.pop();
+    }
+  };
+  for (const [startKey, endpoints] of segmentsMap.entries()) {
+    if (endpoints && endpoints.length === 0) {
+      continue;
+    }
+    traverseSegmentsMap(endpoints || [], startKey);
+  }
+  return polylines;
+};
+var contourElevations = (minElevation, maxElevation, increment) => {
+  const elevations = [];
+  const start = Math.ceil(minElevation * 2) / 2;
+  const end = Math.floor(maxElevation * 2) / 2;
+  for (let elevation = start; elevation <= end; elevation += increment) {
+    elevations.push(elevation);
+  }
+  return elevations;
+};
+var constructGeojson = (elevationData) => {
+  const features = elevationData.reduce((prev, data) => {
+    const { elevation, polylines } = data;
+    return prev.concat(
+      polylines.map((polyline) => ({
+        type: "Feature",
+        geometry: {
+          type: "LineString",
+          coordinates: polyline
+        },
+        properties: {
+          z: elevation
+        }
+      }))
+    );
+  }, []);
+  return {
+    type: "FeatureCollection",
+    features
+  };
+};
+var getContours = (data, interval = 2) => __async(void 0, 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]
+  );
+  const elevations = contourElevations(minElevation, maxElevation, interval);
+  const elevationPolylines = elevations.map((e) => ({
+    elevation: e,
+    polylines: linesToPolyLines(
+      triangles.reduce((prev, curr) => {
+        const line = contourLineOnFace(curr, e);
+        if (line)
+          prev.push(line);
+        return prev;
+      }, [])
+    )
+  }));
+  return constructGeojson(elevationPolylines);
+});
+var get_contours_default = getContours;
+
+// src/public/to-geojson-contours.ts
+var toGeojsonContours = (landXmlString, contourInterval = 2, surfaceId = -1) => __async(void 0, null, function* () {
+  let requestedParsedSurfaces = filter_by_surfaceId_default(yield parse_xml_default(landXmlString), surfaceId);
+  const contours = yield Promise.all(
+    requestedParsedSurfaces.map(
+      (surface) => new Promise((resolve, reject) => __async(void 0, null, function* () {
+        try {
+          const geojson = yield get_contours_default(surface, contourInterval);
+          const _a = surface, { surfaceDefinition } = _a, rest = __objRest(_a, ["surfaceDefinition"]);
+          resolve(__spreadProps(__spreadValues({}, rest), {
+            geojson
+          }));
+        } catch (e) {
+          reject(e);
+        }
+      }))
+    )
+  );
+  return contours;
+});
+var to_geojson_contours_default = toGeojsonContours;
+
+// src/public/reproject-geojson.ts
+import proj4 from "proj4";
+var reprojectGeoJson = (geojson, sourceProjection, targetProjection = "WGS84", keepOriginalGeometryAsFeatureProperty = true) => {
+  const transformCoordinates = (coordinates, sourceProjection2, targetProjection2) => {
+    if (Array.isArray(coordinates[0])) {
+      coordinates = coordinates.map(
+        (subCoordinates) => transformCoordinates(subCoordinates, sourceProjection2, targetProjection2)
+      );
+    } else {
+      coordinates = proj4(sourceProjection2, targetProjection2, coordinates);
+    }
+    return coordinates;
+  };
+  if (!geojson || !geojson.features || !Array.isArray(geojson.features) || !sourceProjection) {
+    throw new Error("Invalid GeoJSON or source projection.");
+  }
+  geojson.features.forEach((feature) => {
+    if (keepOriginalGeometryAsFeatureProperty)
+      feature.properties = feature.properties || {};
+    if (feature.geometry) {
+      if (keepOriginalGeometryAsFeatureProperty && feature.properties)
+        feature.properties._rawGeometry = __spreadValues({}, feature.geometry);
+      if (sourceProjection !== targetProjection) {
+        feature.geometry.coordinates = transformCoordinates(
+          feature.geometry.coordinates,
+          sourceProjection,
+          targetProjection
+        );
+      }
+    }
+  });
+  return geojson;
+};
+var reproject_geojson_default = reprojectGeoJson;
 export {
-  src_default as default
+  reproject_geojson_default as reprojectGeoJson,
+  to_geojson_contours_default as toGeojsonContours,
+  to_glb_default as toGlb
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "landxml",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Parse LandXML surfaces on the modern web.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -23,9 +23,16 @@
   "license": "MIT",
   "devDependencies": {
     "@changesets/cli": "^2.26.2",
+    "@types/geojson": "^7946.0.13",
+    "@types/proj4": "^2.5.5",
+    "@types/xml2json": "^0.11.6",
     "tsup": "^8.0.0",
     "typescript": "^5.2.2",
     "vitest": "^0.34.6"
   },
-  "dependencies": {}
+  "dependencies": {
+    "@gltf-transform/core": "^3.9.0",
+    "proj4": "^2.9.2",
+    "xml-js": "^1.6.11"
+  }
 }