///|
pub suberror TerrainWriteError {
InvalidTerrainOutput(String)
}
///|
priv struct LandXmlUnits {
element : String
linear : String
area : String
volume : String
temperature : String
pressure : String
}
///|
fn output_units(linear : String) -> LandXmlUnits raise TerrainWriteError {
match linear {
"meter" | "millimeter" | "centimeter" | "kilometer" =>
{
element: "Metric",
linear,
area: "squareMeter",
volume: "cubicMeter",
temperature: "celsius",
pressure: "milliBars",
}
"foot" | "USSurveyFoot" | "inch" | "mile" =>
{
element: "Imperial",
linear,
area: "squareFoot",
volume: "cubicFeet",
temperature: "fahrenheit",
pressure: "inHG",
}
_ => raise InvalidTerrainOutput("unsupported linear unit '\{linear}'")
}
}
///|
priv struct WritableSurface {
name : String
points : Array[Point]
faces : Array[Face]
output_ids : Map[String, String]
}
///|
fn valid_landxml_id(value : String) -> Bool {
if value.is_empty() {
return false
}
for ch in value {
if ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n' {
return false
}
}
true
}
///|
fn prepare_writable_surface(
surface : Surface,
visible_only : Bool,
renumber_points : Bool,
) -> WritableSurface? raise TerrainWriteError {
let names : Map[String, Point] = Map([])
for point in surface.points {
if !valid_landxml_id(point.id) || names.contains(point.id) {
raise InvalidTerrainOutput(
"surface '\{surface.name}': blank, whitespace-delimited or duplicate point ID '\{point.id}'",
)
}
if !point_is_finite(point) {
raise InvalidTerrainOutput(
"surface '\{surface.name}': non-finite coordinates for point '\{point.id}'",
)
}
names[point.id] = point
}
let used : Map[String, Bool] = Map([])
let face_keys : Map[(String, String, String), Bool] = Map([])
let faces = []
for index, face in surface.faces {
if visible_only && !face.visible {
continue
}
let (a, b, c) = face.vertices
guard (names.get(a), names.get(b), names.get(c))
is (Some(first), Some(second), Some(third)) else {
raise InvalidTerrainOutput(
"surface '\{surface.name}': face #\{index + 1} references a missing point",
)
}
let ids = [a, b, c]
ids.sort()
let key = (ids[0], ids[1], ids[2])
let area = projected_area(first, second, third)
if a == b || b == c || a == c || !finite_sample_value(area) || area <= 0.0 {
raise InvalidTerrainOutput(
"surface '\{surface.name}': invalid face #\{index + 1}",
)
}
if face_keys.contains(key) {
raise InvalidTerrainOutput(
"surface '\{surface.name}': duplicate face #\{index + 1}",
)
}
face_keys[key] = true
for id in ids {
used[id] = true
}
faces.push(face)
}
if faces.is_empty() {
return None
}
let points = []
let output_ids = Map([])
for point in surface.points {
if visible_only && !used.contains(point.id) {
continue
}
points.push(point)
output_ids[point.id] = if renumber_points {
points.length().to_string()
} else {
point.id
}
}
Some({ name: surface.name, points, faces, output_ids, })
}
///|
fn write_landxml_units(
writer : @xml.Writer,
units : LandXmlUnits,
) -> Unit raise {
writer.start_element("Units", [])
writer.empty_element(units.element, [
("linearUnit", units.linear),
("areaUnit", units.area),
("volumeUnit", units.volume),
("temperatureUnit", units.temperature),
("pressureUnit", units.pressure),
])
writer.end_element("Units")
}
///|
fn write_landxml_surface(
writer : @xml.Writer,
surface : WritableSurface,
) -> Unit raise {
writer.start_element("Surface", [("name", surface.name)])
writer.start_element("Definition", [("surfType", "TIN")])
writer.start_element("Pnts", [])
for point in surface.points {
writer.start_element("P", [("id", surface.output_ids[point.id])])
writer.text("\{point.northing} \{point.easting} \{point.elevation}")
writer.end_element("P")
}
writer.end_element("Pnts")
writer.start_element("Faces", [])
for face in surface.faces {
let attributes = if face.visible { [] } else { [("i", "1")] }
let (a, b, c) = face.vertices
writer.start_element("F", attributes)
writer.text(
"\{surface.output_ids[a]} \{surface.output_ids[b]} \{surface.output_ids[c]}",
)
writer.end_element("F")
}
writer.end_element("Faces")
writer.end_element("Definition")
writer.end_element("Surface")
}
///|
/// Writes the supported TIN subset of LandXML.
/// Visible-only output removes hidden faces and points no remaining face references.
pub fn write_landxml(
terrain : Terrain,
surface_name? : String,
visible_only? : Bool = false,
renumber_points? : Bool = false,
metadata? : LandXmlMetadata,
) -> String raise {
let units = match terrain.linear_unit {
Some(unit) => Some(output_units(unit))
None => None
}
let surfaces = []
for surface in terrain.surfaces {
if surface_name is Some(name) && name != surface.name {
continue
}
match prepare_writable_surface(surface, visible_only, renumber_points) {
Some(output) => surfaces.push(output)
None =>
if !visible_only {
raise InvalidTerrainOutput(
"surface '\{surface.name}' contains no faces",
)
}
}
}
if surfaces.is_empty() {
raise InvalidTerrainOutput("no matching TIN surfaces with exportable faces")
}
let writer = @xml.Writer::new()
let attributes = [("xmlns", LANDXML_NAMESPACE), ("version", "1.2")]
if metadata is Some(data) {
add_landxml_timestamp(attributes, data)
}
writer.start_element("LandXML", attributes)
if units is Some(spec) {
write_landxml_units(writer, spec)
}
if metadata is Some(data) {
write_landxml_project(writer, data)
}
writer.start_element("Surfaces", [])
for surface in surfaces {
write_landxml_surface(writer, surface)
}
writer.end_element("Surfaces")
writer.end_element("LandXML")
"\n" + writer.to_string() + "\n"
}