AIXM Reader Library

Key Features

Multiplatform library supporting Linux/Windows/Android/iOS/web based applications
Streaming, low‑memory parsing of large AIXM datasets
Per‑timeslice indexing of features and lifetimes
Relations index (cross‑feature references with time context)
Geometry extraction for point, curve, surface, and airspace features
Support for GeoBorder references and airspace aggregation
CRS‑aware coordinate handling (including CRS:84 / EPSG:4326)
Detailed issue reporting instead of silent failures
Developed in Kotlin with multiplatform bindings

Detailed Capabilities

Streaming Indexer

Reads AIXM messages in a single forward pass using a range‑based reader
Extracts FeatureMeta (type, UUID, designator) and TimesliceMeta (validity, interpretation, sequence/correction)
Handles large national datasets without loading the full XML into memory

Descriptor Extraction

Configurable descriptor definitions per feature type (JSON config)
Direct property extraction (e.g., aixm:designator, aixm:name)
Related descriptors via xlink:href (e.g., RunwayDirection → Runway)
Normalizes UUIDs from multiple href formats (e.g., #uuid.*, urn:uuid:*, urn.uuid.*)

Relations Index

Extracts and normalizes all xlink:href relations between features
Stores source type/UUID, target UUID, relation name, and validity window
Available via in‑memory structures and REST endpoints in the test server

Geometry Engine

Primitive Types

Point/ElevatedPoint: gml:pos, gml:pointProperty

Curve/ElevatedCurve (geometryType: linestring):

gml:GeodesicString (great‑circle segments)
gml:LineStringSegment (densified rhumb‑line segments)
gml:ArcByCenterPoint and gml:CircleByCenterPoint

Surface/ElevatedSurface (geometryType: surface):

Single gml:PolygonPatch / gml:exterior / gml:Ring
gml:curveMember inline curves or xlink:href to GeoBorder

Airspace Geometry

Computes horizontal projections from:

Inline surfaces (aixm:horizontalProjection)
Referenced GeoBorders (with cutting along shared borders)
contributorAirspace dependencies

Multi‑component operations:

BASE, UNION, INTERS, SUBTR over component geometries
Time‑aware dependency resolution: picks contributor geometries valid at a given instant

Multipart Geometries

repeating_element + variants config allows RunwayMarking, VerticalStructure, etc., to expose mixed point/line/polygon geometries per part
Each part is indexed per timeslice with its own geometry

CRS & Antimeridian Handling

CRS‑aware normalization for CRS84 vs EPSG:4326 (lat/lon vs lon/lat)
Poles: expands pole points into explicit segments for map projections
Anti‑meridian: splits polygons crossing ±180° into multiple parts, suitable for mapping

Decimation & Performance

Optional line simplification (Douglas‑Peucker) with configurable tolerance
JTS‑backed slicing and boolean ops on JVM; pure Kotlin equivalents on JS

Issue Reporting

Every failed or partial geometry is recorded as a GeometryIssue:

Feature type, UUID, sequence/correction, geometry type, reason, and phase (streaming / deferred)
Examples of reasons:
- "Segment ArcByCenterPoint is not supported"
- "Missing contributor airspace geometry for …"
- "Surface missing gml:PolygonPatch", "Curve produced insufficient coordinates"
Makes the geometry pipeline auditable: no silent drop of problematic features

Multiplatform & Integration

Kotlin/JVM for backend processing and heavy geometry (JTS integration)
Kotlin/JS for browser‑side inspection or light processing
Designed to be embedded into existing AIM systems, validation pipelines, or visualization tools

Usage Examples

1. Index a Dataset and Compute Geometries (JVM)

val dataset = indexWithReader(
    fileSize = fileLength,
    readRange = { start, end -> readBytesFromFile(start, end) },
    computeDescriptors = true,
    descriptorConfig = defaultDescriptorConfig(),
    strategy = DescriptorStrategy.Topological,
    featureFilter = null,
    indexTimeslices = true,
    indexRelations = true,
    computeGeometries = true,
    geometryConfig = defaultGeometryConfig(),
    progress = { update ->
        println("Phase=${update.phase}, done=${update.done}/${update.total}")
    }
)

// Query geometries for a specific feature UUID
val geometryApi = DatasetGeometryLookup(dataset.timesliceGeometries)
val geometries = geometryApi.findGeometries("8C4199C9-2D93-4C5D-A673-368292013551")

2. JS: Load Geometries in the Browser

@JsExport
suspend fun loadAndIndexAixm(xml: String): IndexedDataset {
    return indexWithReader(
        fileSize = xml.length.toLong(),
        readRange = { start, end ->
            xml.substring(start.toInt(), end.toInt()).encodeToByteArray()
        },
        computeDescriptors = false,
        descriptorConfig = emptyMap(),
        strategy = DescriptorStrategy.Topological,
        featureFilter = null,
        indexTimeslices = true,
        indexRelations = false,
        computeGeometries = true,
        geometryConfig = defaultGeometryConfig(),
        progress = null
    )
}

3. Use the Relations Index

for (rel in dataset.relations) {
    println("${rel.sourceFeatureType} ${rel.sourceFeatureUuid} " +
            "--${rel.relation}--> ${rel.targetFeatureUuid}")
}

Credits

Developed by: Annea s.r.o.

Lead Developers: Michal Kadlec

Contributors: Branislav Klčo

Developed with AI assistance.

Copyright

Annea s.r.o.

Contact

info@annea.sk