Repository: maplibre/maplibre-tile-spec
Branch: main
Commit: ad5e4b051edc
Files: 1794
Total size: 71.3 MB
Directory structure:
gitextract_0pgzvh0v/
├── .clang-format
├── .cursor/
│ └── rules/
│ └── karpathy-guidelines.mdc
├── .gitattributes
├── .github/
│ ├── FUNDING.yml
│ ├── actions/
│ │ ├── mlt-setup-java/
│ │ │ └── action.yml
│ │ ├── mlt-setup-node/
│ │ │ └── action.yml
│ │ └── mlt-setup-rust/
│ │ └── action.yml
│ ├── dependabot.yml
│ └── workflows/
│ ├── autofix.yml
│ ├── ci.yml
│ ├── cpp.yml
│ ├── dependabot.yml
│ ├── gh-pages.yml
│ ├── hotpath-comment.yml
│ ├── hotpath-profile.yml
│ ├── java-release.yml
│ ├── java.yml
│ ├── python-release.yml
│ ├── rust.yml
│ ├── ts-bump-version.yml
│ ├── ts-release.yml
│ └── ts.yml
├── .gitignore
├── .gitmodules
├── .pre-commit-config.yaml
├── CODE_OF_CONDUCT.md
├── LICENSE-APACHE
├── LICENSE-CC0
├── LICENSE-MIT
├── MODULE.bazel
├── README.md
├── SECURITY_POLICY.txt
├── biome.json
├── cpp/
│ ├── .clang-tidy
│ ├── .gitignore
│ ├── .nvmrc
│ ├── BUILD.bazel
│ ├── CMakeLists.txt
│ ├── CTestCustom.cmake
│ ├── README.md
│ ├── bazel/
│ │ └── check/
│ │ ├── BUILD.bazel
│ │ ├── avx.c
│ │ ├── avx2.c
│ │ └── sse42.c
│ ├── cmake/
│ │ └── AddCXXCompilerFlag.cmake
│ ├── include/
│ │ └── mlt/
│ │ ├── common.hpp
│ │ ├── coordinate.hpp
│ │ ├── decoder.hpp
│ │ ├── feature.hpp
│ │ ├── geometry.hpp
│ │ ├── geometry_vector.hpp
│ │ ├── json.hpp
│ │ ├── layer.hpp
│ │ ├── metadata/
│ │ │ ├── stream.hpp
│ │ │ ├── tileset.hpp
│ │ │ └── type_map.hpp
│ │ ├── polyfill.hpp
│ │ ├── projection.hpp
│ │ ├── properties.hpp
│ │ ├── tile.hpp
│ │ └── util/
│ │ ├── buffer_stream.hpp
│ │ ├── noncopyable.hpp
│ │ ├── packed_bitset.hpp
│ │ ├── stl.hpp
│ │ └── varint.hpp
│ ├── mod.just
│ ├── package.json
│ ├── src/
│ │ └── mlt/
│ │ ├── decode/
│ │ │ ├── geometry.hpp
│ │ │ ├── int.cpp
│ │ │ ├── int.hpp
│ │ │ ├── int_template.hpp
│ │ │ ├── property.hpp
│ │ │ └── string.hpp
│ │ ├── decoder.cpp
│ │ ├── feature.cpp
│ │ ├── geometry_vector.cpp
│ │ ├── layer.cpp
│ │ ├── metadata/
│ │ │ ├── stream.cpp
│ │ │ └── tileset.cpp
│ │ ├── properties.cpp
│ │ └── util/
│ │ ├── json_diff.hpp
│ │ ├── morton_curve.hpp
│ │ ├── raw.hpp
│ │ ├── rle.cpp
│ │ ├── rle.hpp
│ │ ├── space_filling_curve.hpp
│ │ ├── vectorized.hpp
│ │ └── zigzag.hpp
│ ├── test/
│ │ ├── CMakeLists.txt
│ │ ├── test_decode.cpp
│ │ ├── test_fastpfor.cpp
│ │ ├── test_fsst.cpp
│ │ ├── test_packed_bitset.cpp
│ │ ├── test_util.cpp
│ │ └── test_varint.cpp
│ ├── tool/
│ │ ├── CMakeLists.txt
│ │ ├── mlt-json.cpp
│ │ ├── synthetic-geojson.cpp
│ │ ├── synthetic-geojson.hpp
│ │ └── synthetic.test.ts
│ └── vendor/
│ └── fastpfor.cmake
├── docs/
│ ├── assets/
│ │ ├── extra.css
│ │ └── spec/
│ │ ├── mlt_tileset_metadata.json
│ │ └── place_feature.json
│ ├── encodings.md
│ ├── implementation-status.md
│ ├── index.md
│ ├── snippets/
│ │ └── live-spec-note
│ └── specification.md
├── java/
│ ├── .gitignore
│ ├── CONTRIBUTING.md
│ ├── README-Decode.md
│ ├── README-Encode.md
│ ├── README.MD
│ ├── encoding-server/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── config.json
│ │ ├── config.mjs
│ │ ├── convert.mjs
│ │ ├── eslint.config.mjs
│ │ ├── package.json
│ │ └── server.mjs
│ ├── gradle/
│ │ ├── libs.versions.toml
│ │ └── wrapper/
│ │ ├── gradle-wrapper.jar
│ │ └── gradle-wrapper.properties
│ ├── gradlew
│ ├── gradlew.bat
│ ├── lombok.config
│ ├── mlt-cli/
│ │ ├── build.gradle
│ │ └── src/
│ │ ├── main/
│ │ │ ├── kotlin/
│ │ │ │ └── org/
│ │ │ │ └── maplibre/
│ │ │ │ └── mlt/
│ │ │ │ └── cli/
│ │ │ │ ├── Conversion.kt
│ │ │ │ ├── Decode.kt
│ │ │ │ ├── Encode.kt
│ │ │ │ ├── EncodeCommandLine.kt
│ │ │ │ ├── EncodeConfig.kt
│ │ │ │ ├── Environment.kt
│ │ │ │ ├── Json.kt
│ │ │ │ ├── Logging.kt
│ │ │ │ ├── MBTiles.kt
│ │ │ │ ├── OfflineDB.kt
│ │ │ │ ├── PMTiles.kt
│ │ │ │ ├── ReadablePmtiles.kt
│ │ │ │ ├── SerialTaskRunner.kt
│ │ │ │ ├── Server.kt
│ │ │ │ ├── TaskRunner.kt
│ │ │ │ ├── ThreadPoolTaskRunner.kt
│ │ │ │ └── Timer.kt
│ │ │ └── resources/
│ │ │ └── log4j2.json
│ │ └── test/
│ │ └── kotlin/
│ │ └── org/
│ │ └── maplibre/
│ │ └── mlt/
│ │ └── cli/
│ │ ├── EncodeCommandLineTest.kt
│ │ ├── EnvironmentResolverTest.kt
│ │ ├── LoggingTest.kt
│ │ ├── ReadablePmtilesMapDirectoryTest.kt
│ │ ├── TaskRunnerTest.kt
│ │ ├── TestUtil.kt
│ │ └── TileCoordRangeTest.kt
│ ├── mlt-core/
│ │ ├── build.gradle
│ │ └── src/
│ │ ├── jmh/
│ │ │ └── java/
│ │ │ └── org/
│ │ │ └── maplibre/
│ │ │ └── mlt/
│ │ │ ├── BenchmarkUtils.java
│ │ │ ├── OmtDecoderBenchmark.java
│ │ │ ├── converter/
│ │ │ │ └── encodings/
│ │ │ │ └── fsst/
│ │ │ │ └── FsstBenchmark.java
│ │ │ └── data/
│ │ │ ├── rle_PartOffsets.csv
│ │ │ ├── rle_class_ratio17.csv
│ │ │ └── rle_id_ratio22_45k.csv
│ │ ├── main/
│ │ │ └── java/
│ │ │ ├── org/
│ │ │ │ └── maplibre/
│ │ │ │ └── mlt/
│ │ │ │ ├── compare/
│ │ │ │ │ └── CompareHelper.java
│ │ │ │ ├── converter/
│ │ │ │ │ ├── CollectionUtils.java
│ │ │ │ │ ├── ColumnMapping.java
│ │ │ │ │ ├── ColumnMappingConfig.java
│ │ │ │ │ ├── ConversionConfig.java
│ │ │ │ │ ├── FeatureTableOptimizations.java
│ │ │ │ │ ├── MltConverter.java
│ │ │ │ │ ├── MortonSettings.java
│ │ │ │ │ ├── encodings/
│ │ │ │ │ │ ├── BooleanEncoder.java
│ │ │ │ │ │ ├── ByteRleEncoder.java
│ │ │ │ │ │ ├── DoubleEncoder.java
│ │ │ │ │ │ ├── EncodingUtils.java
│ │ │ │ │ │ ├── FloatEncoder.java
│ │ │ │ │ │ ├── GeometryEncoder.java
│ │ │ │ │ │ ├── IntegerEncoder.java
│ │ │ │ │ │ ├── LinearRegression.java
│ │ │ │ │ │ ├── MltTypeMap.java
│ │ │ │ │ │ ├── PropertyEncoder.java
│ │ │ │ │ │ ├── StringEncoder.java
│ │ │ │ │ │ └── fsst/
│ │ │ │ │ │ ├── Fsst.java
│ │ │ │ │ │ ├── FsstDebug.java
│ │ │ │ │ │ ├── FsstEncoder.java
│ │ │ │ │ │ ├── FsstJava.java
│ │ │ │ │ │ ├── FsstJni.java
│ │ │ │ │ │ ├── Symbol.java
│ │ │ │ │ │ ├── SymbolTable.java
│ │ │ │ │ │ └── SymbolTableBuilder.java
│ │ │ │ │ ├── geometry/
│ │ │ │ │ │ ├── GeometryType.java
│ │ │ │ │ │ ├── GeometryUtils.java
│ │ │ │ │ │ ├── Hilbert.java
│ │ │ │ │ │ ├── HilbertCurve.java
│ │ │ │ │ │ ├── SpaceFillingCurve.java
│ │ │ │ │ │ ├── Vertex.java
│ │ │ │ │ │ └── ZOrderCurve.java
│ │ │ │ │ ├── mvt/
│ │ │ │ │ │ └── MvtUtils.java
│ │ │ │ │ └── tessellation/
│ │ │ │ │ ├── TessellatedPolygon.java
│ │ │ │ │ └── TessellationUtils.java
│ │ │ │ ├── data/
│ │ │ │ │ ├── Feature.java
│ │ │ │ │ ├── FeatureInterface.java
│ │ │ │ │ ├── IndexedProperty.java
│ │ │ │ │ ├── Layer.java
│ │ │ │ │ ├── LayerSource.java
│ │ │ │ │ ├── MLTFeature.java
│ │ │ │ │ ├── MVTFeature.java
│ │ │ │ │ ├── MapLibreTile.java
│ │ │ │ │ ├── MapboxVectorTile.java
│ │ │ │ │ ├── Property.java
│ │ │ │ │ └── unsigned/
│ │ │ │ │ ├── U32.java
│ │ │ │ │ ├── U64.java
│ │ │ │ │ ├── U8.java
│ │ │ │ │ └── Unsigned.java
│ │ │ │ ├── decoder/
│ │ │ │ │ ├── ByteRleDecoder.java
│ │ │ │ │ ├── DecodingUtils.java
│ │ │ │ │ ├── DoubleDecoder.java
│ │ │ │ │ ├── FloatDecoder.java
│ │ │ │ │ ├── GeometryDecoder.java
│ │ │ │ │ ├── IntegerDecoder.java
│ │ │ │ │ ├── MltDecoder.java
│ │ │ │ │ ├── PropertyDecoder.java
│ │ │ │ │ ├── StringDecoder.java
│ │ │ │ │ └── vectorized/
│ │ │ │ │ └── VectorizedDecodingUtils.java
│ │ │ │ ├── json/
│ │ │ │ │ └── Json.java
│ │ │ │ ├── metadata/
│ │ │ │ │ ├── stream/
│ │ │ │ │ │ ├── DictionaryType.java
│ │ │ │ │ │ ├── LengthType.java
│ │ │ │ │ │ ├── LogicalLevelTechnique.java
│ │ │ │ │ │ ├── LogicalStreamType.java
│ │ │ │ │ │ ├── MortonEncodedStreamMetadata.java
│ │ │ │ │ │ ├── OffsetType.java
│ │ │ │ │ │ ├── PhysicalLevelTechnique.java
│ │ │ │ │ │ ├── PhysicalStreamType.java
│ │ │ │ │ │ ├── RleEncodedStreamMetadata.java
│ │ │ │ │ │ ├── StreamMetadata.java
│ │ │ │ │ │ └── StreamMetadataDecoder.java
│ │ │ │ │ └── tileset/
│ │ │ │ │ └── MltMetadata.java
│ │ │ │ └── util/
│ │ │ │ ├── ByteArrayUtil.java
│ │ │ │ ├── ExceptionUtil.java
│ │ │ │ ├── OptionalUtil.java
│ │ │ │ └── StreamUtil.java
│ │ │ └── springmeyer/
│ │ │ ├── Pbf.java
│ │ │ ├── Point.java
│ │ │ ├── VectorTile.java
│ │ │ ├── VectorTileFeature.java
│ │ │ └── VectorTileLayer.java
│ │ └── test/
│ │ └── java/
│ │ └── org/
│ │ └── maplibre/
│ │ └── mlt/
│ │ ├── MltGenerator.java
│ │ ├── TestSettings.java
│ │ ├── TestUtils.java
│ │ ├── benchmarks/
│ │ │ ├── CompressionBenchmarksTest.java
│ │ │ └── MltDecoderBenchmarkTest.java
│ │ ├── compare/
│ │ │ └── CompareHelperTest.java
│ │ ├── converter/
│ │ │ ├── ConversionConfigTest.java
│ │ │ ├── MltConverterTest.java
│ │ │ ├── encodings/
│ │ │ │ ├── EncodingUtilsTest.java
│ │ │ │ ├── LinearRegressionTest.java
│ │ │ │ ├── MltTypeMapTest.java
│ │ │ │ ├── VarintTest.java
│ │ │ │ └── fsst/
│ │ │ │ ├── FsstTest.java
│ │ │ │ └── SymbolTest.java
│ │ │ ├── geometry/
│ │ │ │ ├── HilbertCurveTest.java
│ │ │ │ ├── SpaceFillingCurveTest.java
│ │ │ │ └── ZOrderCurveTest.java
│ │ │ └── tessellation/
│ │ │ └── TessellationUtilsTest.java
│ │ ├── data/
│ │ │ └── unsigned/
│ │ │ └── UnsignedTest.java
│ │ ├── decoder/
│ │ │ ├── ByteRleTest.java
│ │ │ ├── DecodingUtilsTest.java
│ │ │ ├── DoubleDecoderTest.java
│ │ │ ├── IntegerDecoderTest.java
│ │ │ ├── MltDecoderTest.java
│ │ │ ├── MltDecoderTest2.java
│ │ │ └── StringDecoderTest.java
│ │ ├── json/
│ │ │ └── JsonTest.java
│ │ ├── metadata/
│ │ │ └── tileset/
│ │ │ └── MltMetadataColumnTest.java
│ │ ├── synthetics/
│ │ │ └── SyntheticsTest.java
│ │ └── util/
│ │ ├── OptionalUtilTest.java
│ │ └── StreamUtilTest.java
│ ├── mlt-tools/
│ │ ├── build.gradle
│ │ └── src/
│ │ └── main/
│ │ └── java/
│ │ └── org/
│ │ └── maplibre/
│ │ └── mlt/
│ │ └── tools/
│ │ ├── SyntheticMltGenerator.java
│ │ └── SyntheticMltUtil.java
│ ├── mod.just
│ ├── resources/
│ │ ├── CMakeLists.txt
│ │ ├── FsstWrapper.cpp
│ │ ├── FsstWrapper.h
│ │ ├── compile
│ │ └── compile-windows.bat
│ ├── settings.gradle
│ └── tessellation/
│ ├── index.mjs
│ └── package.json
├── justfile
├── mkdocs.yml
├── qgis/
│ ├── .gitignore
│ ├── README.md
│ └── mlt_plugin/
│ ├── __init__.py
│ ├── loader.py
│ ├── metadata.txt
│ ├── plugin.py
│ └── tile_coords.py
├── release-plz.toml
├── rust/
│ ├── .gitignore
│ ├── CONTRIBUTING.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── bench_param.sh
│ ├── clippy.toml
│ ├── mlt/
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ └── src/
│ │ ├── convert/
│ │ │ ├── files.rs
│ │ │ ├── mod.rs
│ │ │ └── tileset.rs
│ │ ├── dump.rs
│ │ ├── ls.rs
│ │ ├── main.rs
│ │ └── ui/
│ │ ├── mbt.rs
│ │ ├── mod.rs
│ │ ├── rendering/
│ │ │ ├── files.rs
│ │ │ ├── help.rs
│ │ │ ├── layers.rs
│ │ │ ├── map.rs
│ │ │ └── mod.rs
│ │ └── state.rs
│ ├── mlt-core/
│ │ ├── .gitignore
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── benches/
│ │ │ ├── bench_utils.rs
│ │ │ ├── decoding_e2e.rs
│ │ │ ├── decoding_strings.rs
│ │ │ ├── decoding_utils.rs
│ │ │ ├── encoding_e2e.rs
│ │ │ └── encoding_from_mvt.rs
│ │ ├── fuzz/
│ │ │ ├── .gitignore
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── fuzz_targets/
│ │ │ │ ├── decoded_layer.rs
│ │ │ │ └── layer.rs
│ │ │ ├── src/
│ │ │ │ ├── decoded_layer.rs
│ │ │ │ ├── layer.rs
│ │ │ │ └── lib.rs
│ │ │ └── tests/
│ │ │ └── reproduce.rs
│ │ ├── src/
│ │ │ ├── codecs/
│ │ │ │ ├── bytes.rs
│ │ │ │ ├── fastpfor.rs
│ │ │ │ ├── fsst.rs
│ │ │ │ ├── hilbert.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── morton.rs
│ │ │ │ ├── rle.rs
│ │ │ │ ├── varint.rs
│ │ │ │ └── zigzag.rs
│ │ │ ├── convert/
│ │ │ │ ├── geojson.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── mvt.rs
│ │ │ ├── decoder/
│ │ │ │ ├── analyze.rs
│ │ │ │ ├── column.rs
│ │ │ │ ├── fuzzing.rs
│ │ │ │ ├── geometry/
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── geotype.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── model.rs
│ │ │ │ ├── id/
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── model.rs
│ │ │ │ ├── iterators.rs
│ │ │ │ ├── layer.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── model.rs
│ │ │ │ ├── property/
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── geojson.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ └── strings.rs
│ │ │ │ ├── root.rs
│ │ │ │ ├── stream/
│ │ │ │ │ ├── analyze.rs
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── logical.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ ├── parse.rs
│ │ │ │ │ └── physical.rs
│ │ │ │ └── tile.rs
│ │ │ ├── encoder/
│ │ │ │ ├── analyze.rs
│ │ │ │ ├── fuzzing.rs
│ │ │ │ ├── geometry/
│ │ │ │ │ ├── encode.rs
│ │ │ │ │ ├── geotype.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ └── tests.rs
│ │ │ │ ├── id/
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── staged_id.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── model.rs
│ │ │ │ ├── optimizer.rs
│ │ │ │ ├── property/
│ │ │ │ │ ├── encode.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ ├── shared_dict.rs
│ │ │ │ │ ├── strings.rs
│ │ │ │ │ └── tests.rs
│ │ │ │ ├── sort.rs
│ │ │ │ ├── stream/
│ │ │ │ │ ├── codecs.rs
│ │ │ │ │ ├── encode_stream.rs
│ │ │ │ │ ├── encoder.rs
│ │ │ │ │ ├── logical.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ ├── optimizer.rs
│ │ │ │ │ ├── physical.rs
│ │ │ │ │ ├── tests.rs
│ │ │ │ │ └── write.rs
│ │ │ │ ├── tests.rs
│ │ │ │ ├── tile.rs
│ │ │ │ ├── unknown.rs
│ │ │ │ └── writer.rs
│ │ │ ├── errors.rs
│ │ │ ├── lib.rs
│ │ │ └── utils/
│ │ │ ├── analyze.rs
│ │ │ ├── extensions.rs
│ │ │ ├── formatter.rs
│ │ │ ├── lazy_state.rs
│ │ │ ├── mod.rs
│ │ │ ├── parse.rs
│ │ │ ├── presence.rs
│ │ │ ├── serialize.rs
│ │ │ └── test_helpers.rs
│ │ └── tests/
│ │ ├── geojson.rs
│ │ ├── snapshots.rs
│ │ └── unknown_layer.rs
│ ├── mlt-py/
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── maplibre_tiles.pyi
│ │ ├── pyproject.toml
│ │ └── src/
│ │ ├── bins/
│ │ │ └── stub_gen.rs
│ │ ├── feature.rs
│ │ ├── lib.rs
│ │ └── tile_transform.rs
│ ├── mlt-synthetics/
│ │ ├── Cargo.toml
│ │ └── src/
│ │ ├── layer.rs
│ │ ├── main.rs
│ │ └── writer.rs
│ ├── mlt-wasm/
│ │ ├── .gitignore
│ │ ├── .nvmrc
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── js/
│ │ │ ├── decoder.bench.ts
│ │ │ ├── index.ts
│ │ │ ├── synthetic.spec.ts
│ │ │ └── vectorTile.ts
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── geometry.rs
│ │ │ ├── layer.rs
│ │ │ ├── lib.rs
│ │ │ ├── properties.rs
│ │ │ └── tile.rs
│ │ ├── tsconfig.json
│ │ └── vitest.config.ts
│ ├── mod.just
│ └── tomlfmt.toml
├── spec/
│ └── schema/
│ └── mlt_tileset_metadata.proto
├── test/
│ ├── .gitignore
│ ├── .java-version
│ ├── convert_tiles
│ ├── expected/
│ │ └── tag0x01/
│ │ ├── amazon/
│ │ │ ├── 10_518_352.mlt
│ │ │ ├── 11_1037_704.mlt
│ │ │ ├── 5_16_11.mlt
│ │ │ ├── 5_5_11.mlt
│ │ │ ├── 5_6_21.mlt
│ │ │ ├── 5_8_12.mlt
│ │ │ ├── 6_33_21.mlt
│ │ │ ├── 6_33_22.mlt
│ │ │ ├── 7_68_44.mlt
│ │ │ ├── 8_136_89.mlt
│ │ │ └── 9_259_176.mlt
│ │ ├── amazon_here/
│ │ │ ├── 4_8_5.mlt
│ │ │ ├── 4_9_4.mlt
│ │ │ ├── 5_16_10.mlt
│ │ │ ├── 6_33_22.mlt
│ │ │ └── 8_132_85.mlt
│ │ ├── bing/
│ │ │ ├── 4-12-6.mlt
│ │ │ ├── 4-13-6.mlt
│ │ │ ├── 4-8-5.mlt
│ │ │ ├── 4-9-5.mlt
│ │ │ ├── 5-15-10.mlt
│ │ │ ├── 5-16-11.mlt
│ │ │ ├── 5-16-9.mlt
│ │ │ ├── 5-17-10.mlt
│ │ │ ├── 5-17-11.mlt
│ │ │ ├── 6-32-21.mlt
│ │ │ ├── 6-32-22.mlt
│ │ │ ├── 6-32-23.mlt
│ │ │ ├── 6-33-22.mlt
│ │ │ ├── 7-65-42.mlt
│ │ │ ├── 7-66-42.mlt
│ │ │ ├── 7-66-43.mlt
│ │ │ └── 7-66-44.mlt
│ │ ├── omt/
│ │ │ ├── 0_0_0.mlt
│ │ │ ├── 10_530_682.mlt
│ │ │ ├── 10_530_683.mlt
│ │ │ ├── 10_530_684.mlt
│ │ │ ├── 10_531_682.mlt
│ │ │ ├── 10_531_683.mlt
│ │ │ ├── 10_531_684.mlt
│ │ │ ├── 10_532_682.mlt
│ │ │ ├── 10_532_683.mlt
│ │ │ ├── 10_532_684.mlt
│ │ │ ├── 10_533_682.mlt
│ │ │ ├── 10_533_683.mlt
│ │ │ ├── 10_533_684.mlt
│ │ │ ├── 11_1062_1366.mlt
│ │ │ ├── 11_1062_1367.mlt
│ │ │ ├── 11_1062_1368.mlt
│ │ │ ├── 11_1063_1366.mlt
│ │ │ ├── 11_1063_1367.mlt
│ │ │ ├── 11_1063_1368.mlt
│ │ │ ├── 11_1064_1366.mlt
│ │ │ ├── 11_1064_1367.mlt
│ │ │ ├── 11_1064_1368.mlt
│ │ │ ├── 11_1065_1366.mlt
│ │ │ ├── 11_1065_1367.mlt
│ │ │ ├── 11_1065_1368.mlt
│ │ │ ├── 12_2130_2733.mlt
│ │ │ ├── 12_2130_2734.mlt
│ │ │ ├── 12_2131_2733.mlt
│ │ │ ├── 12_2131_2734.mlt
│ │ │ ├── 12_2132_2733.mlt
│ │ │ ├── 12_2132_2734.mlt
│ │ │ ├── 12_2133_2733.mlt
│ │ │ ├── 12_2133_2734.mlt
│ │ │ ├── 12_2134_2733.mlt
│ │ │ ├── 12_2134_2734.mlt
│ │ │ ├── 13_4264_5467.mlt
│ │ │ ├── 13_4264_5468.mlt
│ │ │ ├── 13_4265_5467.mlt
│ │ │ ├── 13_4265_5468.mlt
│ │ │ ├── 13_4266_5467.mlt
│ │ │ ├── 13_4266_5468.mlt
│ │ │ ├── 13_4267_5467.mlt
│ │ │ ├── 13_4267_5468.mlt
│ │ │ ├── 14_8296_10748.mlt
│ │ │ ├── 14_8296_10749.mlt
│ │ │ ├── 14_8297_10748.mlt
│ │ │ ├── 14_8297_10749.mlt
│ │ │ ├── 14_8298_10748.mlt
│ │ │ ├── 14_8298_10749.mlt
│ │ │ ├── 14_8299_10748.mlt
│ │ │ ├── 14_8299_10749.mlt
│ │ │ ├── 14_8300_10748.mlt
│ │ │ ├── 14_8300_10749.mlt
│ │ │ ├── 1_1_1.mlt
│ │ │ ├── 2_2_2.mlt
│ │ │ ├── 3_4_5.mlt
│ │ │ ├── 4_3_9.mlt
│ │ │ ├── 4_8_10.mlt
│ │ │ ├── 5_16_11.mlt
│ │ │ ├── 5_16_20.mlt
│ │ │ ├── 5_16_21.mlt
│ │ │ ├── 5_17_20.mlt
│ │ │ ├── 5_17_21.mlt
│ │ │ ├── 6_32_41.mlt
│ │ │ ├── 6_32_42.mlt
│ │ │ ├── 6_33_41.mlt
│ │ │ ├── 6_33_42.mlt
│ │ │ ├── 6_34_41.mlt
│ │ │ ├── 6_34_42.mlt
│ │ │ ├── 7_66_83.mlt
│ │ │ ├── 7_66_84.mlt
│ │ │ ├── 7_66_85.mlt
│ │ │ ├── 7_67_83.mlt
│ │ │ ├── 7_67_84.mlt
│ │ │ ├── 7_67_85.mlt
│ │ │ ├── 7_68_83.mlt
│ │ │ ├── 7_68_84.mlt
│ │ │ ├── 7_68_85.mlt
│ │ │ ├── 8_132_170.mlt
│ │ │ ├── 8_132_171.mlt
│ │ │ ├── 8_133_170.mlt
│ │ │ ├── 8_133_171.mlt
│ │ │ ├── 8_134_170.mlt
│ │ │ ├── 8_134_171.mlt
│ │ │ ├── 8_135_170.mlt
│ │ │ ├── 8_135_171.mlt
│ │ │ ├── 9_264_340.mlt
│ │ │ ├── 9_264_341.mlt
│ │ │ ├── 9_264_342.mlt
│ │ │ ├── 9_265_340.mlt
│ │ │ ├── 9_265_341.mlt
│ │ │ ├── 9_265_342.mlt
│ │ │ ├── 9_266_340.mlt
│ │ │ ├── 9_266_341.mlt
│ │ │ └── 9_266_342.mlt
│ │ └── simple/
│ │ ├── LICENSE
│ │ ├── line-boolean.mlt
│ │ ├── line-boolean.mlt.geojson
│ │ ├── multiline-boolean.mlt
│ │ ├── multiline-boolean.mlt.geojson
│ │ ├── multipoint-boolean.mlt
│ │ ├── multipoint-boolean.mlt.geojson
│ │ ├── multipolygon-boolean.mlt
│ │ ├── multipolygon-boolean.mlt.geojson
│ │ ├── point-boolean.mlt
│ │ ├── point-boolean.mlt.geojson
│ │ ├── polygon-boolean.mlt
│ │ └── polygon-boolean.mlt.geojson
│ ├── fixtures/
│ │ ├── amazon/
│ │ │ ├── 10_518_352.mvt
│ │ │ ├── 11_1037_704.mvt
│ │ │ ├── 5_16_11.mvt
│ │ │ ├── 5_5_11.mvt
│ │ │ ├── 5_6_21.mvt
│ │ │ ├── 5_8_12.mvt
│ │ │ ├── 6_33_21.mvt
│ │ │ ├── 6_33_22.mvt
│ │ │ ├── 7_68_44.mvt
│ │ │ ├── 8_136_89.mvt
│ │ │ └── 9_259_176.mvt
│ │ ├── amazon_here/
│ │ │ ├── 4_8_5.mvt
│ │ │ ├── 4_9_4.mvt
│ │ │ ├── 5_16_10.mvt
│ │ │ ├── 6_33_22.mvt
│ │ │ └── 8_132_85.mvt
│ │ ├── bing/
│ │ │ ├── 4-12-6.mvt
│ │ │ ├── 4-13-6.mvt
│ │ │ ├── 4-8-5.mvt
│ │ │ ├── 4-9-5.mvt
│ │ │ ├── 5-15-10.mvt
│ │ │ ├── 5-16-11.mvt
│ │ │ ├── 5-16-9.mvt
│ │ │ ├── 5-17-10.mvt
│ │ │ ├── 5-17-11.mvt
│ │ │ ├── 6-32-21.mvt
│ │ │ ├── 6-32-22.mvt
│ │ │ ├── 6-32-23.mvt
│ │ │ ├── 6-33-22.mvt
│ │ │ ├── 7-65-42.mvt
│ │ │ ├── 7-66-42.mvt
│ │ │ ├── 7-66-43.mvt
│ │ │ └── 7-66-44.mvt
│ │ ├── fastpfor/
│ │ │ └── README.md
│ │ ├── omt/
│ │ │ ├── 0_0_0.mvt
│ │ │ ├── 10_530_682.mvt
│ │ │ ├── 10_530_683.mvt
│ │ │ ├── 10_530_684.mvt
│ │ │ ├── 10_531_682.mvt
│ │ │ ├── 10_531_683.mvt
│ │ │ ├── 10_531_684.mvt
│ │ │ ├── 10_532_682.mvt
│ │ │ ├── 10_532_683.mvt
│ │ │ ├── 10_532_684.mvt
│ │ │ ├── 10_533_682.mvt
│ │ │ ├── 10_533_683.mvt
│ │ │ ├── 10_533_684.mvt
│ │ │ ├── 11_1062_1366.mvt
│ │ │ ├── 11_1062_1367.mvt
│ │ │ ├── 11_1062_1368.mvt
│ │ │ ├── 11_1063_1366.mvt
│ │ │ ├── 11_1063_1367.mvt
│ │ │ ├── 11_1063_1368.mvt
│ │ │ ├── 11_1064_1366.mvt
│ │ │ ├── 11_1064_1367.mvt
│ │ │ ├── 11_1064_1368.mvt
│ │ │ ├── 11_1065_1366.mvt
│ │ │ ├── 11_1065_1367.mvt
│ │ │ ├── 11_1065_1368.mvt
│ │ │ ├── 12_2130_2733.mvt
│ │ │ ├── 12_2130_2734.mvt
│ │ │ ├── 12_2131_2733.mvt
│ │ │ ├── 12_2131_2734.mvt
│ │ │ ├── 12_2132_2733.mvt
│ │ │ ├── 12_2132_2734.mvt
│ │ │ ├── 12_2133_2733.mvt
│ │ │ ├── 12_2133_2734.mvt
│ │ │ ├── 12_2134_2733.mvt
│ │ │ ├── 12_2134_2734.mvt
│ │ │ ├── 13_4264_5467.mvt
│ │ │ ├── 13_4264_5468.mvt
│ │ │ ├── 13_4265_5467.mvt
│ │ │ ├── 13_4265_5468.mvt
│ │ │ ├── 13_4266_5467.mvt
│ │ │ ├── 13_4266_5468.mvt
│ │ │ ├── 13_4267_5467.mvt
│ │ │ ├── 13_4267_5468.mvt
│ │ │ ├── 14_8296_10748.mvt
│ │ │ ├── 14_8296_10749.mvt
│ │ │ ├── 14_8297_10748.mvt
│ │ │ ├── 14_8297_10749.mvt
│ │ │ ├── 14_8298_10748.mvt
│ │ │ ├── 14_8298_10749.mvt
│ │ │ ├── 14_8299_10748.mvt
│ │ │ ├── 14_8299_10749.mvt
│ │ │ ├── 14_8300_10748.mvt
│ │ │ ├── 14_8300_10749.mvt
│ │ │ ├── 1_1_1.mvt
│ │ │ ├── 2_2_2.mvt
│ │ │ ├── 3_4_5.mvt
│ │ │ ├── 4_3_9.mvt
│ │ │ ├── 4_8_10.mvt
│ │ │ ├── 5_16_11.mvt
│ │ │ ├── 5_16_20.mvt
│ │ │ ├── 5_16_21.mvt
│ │ │ ├── 5_17_20.mvt
│ │ │ ├── 5_17_21.mvt
│ │ │ ├── 6_32_41.mvt
│ │ │ ├── 6_32_42.mvt
│ │ │ ├── 6_33_41.mvt
│ │ │ ├── 6_33_42.mvt
│ │ │ ├── 6_34_41.mvt
│ │ │ ├── 6_34_42.mvt
│ │ │ ├── 7_66_83.mvt
│ │ │ ├── 7_66_84.mvt
│ │ │ ├── 7_66_85.mvt
│ │ │ ├── 7_67_83.mvt
│ │ │ ├── 7_67_84.mvt
│ │ │ ├── 7_67_85.mvt
│ │ │ ├── 7_68_83.mvt
│ │ │ ├── 7_68_84.mvt
│ │ │ ├── 7_68_85.mvt
│ │ │ ├── 8_132_170.mvt
│ │ │ ├── 8_132_171.mvt
│ │ │ ├── 8_133_170.mvt
│ │ │ ├── 8_133_171.mvt
│ │ │ ├── 8_134_170.mvt
│ │ │ ├── 8_134_171.mvt
│ │ │ ├── 8_135_170.mvt
│ │ │ ├── 8_135_171.mvt
│ │ │ ├── 9_264_340.mvt
│ │ │ ├── 9_264_341.mvt
│ │ │ ├── 9_264_342.mvt
│ │ │ ├── 9_265_340.mvt
│ │ │ ├── 9_265_341.mvt
│ │ │ ├── 9_265_342.mvt
│ │ │ ├── 9_266_340.mvt
│ │ │ ├── 9_266_341.mvt
│ │ │ └── 9_266_342.mvt
│ │ ├── omt-planet-20260112.mvt.max1.pmtiles
│ │ ├── omt-planet-20260112.mvt.max1.pmtiles.txt
│ │ ├── omt.max1.mbtiles
│ │ └── simple/
│ │ ├── LICENSE
│ │ ├── line-boolean.mvt
│ │ ├── multiline-boolean.mvt
│ │ ├── multipoint-boolean.mvt
│ │ ├── multipolygon-boolean.mvt
│ │ ├── point-boolean.mvt
│ │ └── polygon-boolean.mvt
│ ├── omt-advanced-mlt.mbtiles
│ ├── omt-basic-mlt.mbtiles
│ ├── omt-ref.mbtiles
│ └── synthetic/
│ ├── 0x01/
│ │ ├── extent_1073741824.json
│ │ ├── extent_1073741824.mlt
│ │ ├── extent_131072.json
│ │ ├── extent_131072.mlt
│ │ ├── extent_4096.json
│ │ ├── extent_4096.mlt
│ │ ├── extent_512.json
│ │ ├── extent_512.mlt
│ │ ├── extent_buf_1073741824.json
│ │ ├── extent_buf_1073741824.mlt
│ │ ├── extent_buf_131072.json
│ │ ├── extent_buf_131072.mlt
│ │ ├── extent_buf_4096.json
│ │ ├── extent_buf_4096.mlt
│ │ ├── extent_buf_512.json
│ │ ├── extent_buf_512.mlt
│ │ ├── fpf_align_1.json
│ │ ├── fpf_align_1.mlt
│ │ ├── fpf_align_2.json
│ │ ├── fpf_align_2.mlt
│ │ ├── fpf_align_3.json
│ │ ├── fpf_align_3.mlt
│ │ ├── fpf_align_4.json
│ │ ├── fpf_align_4.mlt
│ │ ├── fpf_align_5.json
│ │ ├── fpf_align_5.mlt
│ │ ├── fpf_align_6.json
│ │ ├── fpf_align_6.mlt
│ │ ├── fpf_align_7.json
│ │ ├── fpf_align_7.mlt
│ │ ├── fpf_align_8.json
│ │ ├── fpf_align_8.mlt
│ │ ├── id.json
│ │ ├── id.mlt
│ │ ├── id64.json
│ │ ├── id64.mlt
│ │ ├── id_min.json
│ │ ├── id_min.mlt
│ │ ├── ids.json
│ │ ├── ids.mlt
│ │ ├── ids64.json
│ │ ├── ids64.mlt
│ │ ├── ids64_delta.json
│ │ ├── ids64_delta.mlt
│ │ ├── ids64_delta_rle.json
│ │ ├── ids64_delta_rle.mlt
│ │ ├── ids64_opt.json
│ │ ├── ids64_opt.mlt
│ │ ├── ids64_opt_delta.json
│ │ ├── ids64_opt_delta.mlt
│ │ ├── ids64_rle.json
│ │ ├── ids64_rle.mlt
│ │ ├── ids_delta.json
│ │ ├── ids_delta.mlt
│ │ ├── ids_delta_rle.json
│ │ ├── ids_delta_rle.mlt
│ │ ├── ids_opt.json
│ │ ├── ids_opt.mlt
│ │ ├── ids_opt_delta.json
│ │ ├── ids_opt_delta.mlt
│ │ ├── ids_rle.json
│ │ ├── ids_rle.mlt
│ │ ├── line.json
│ │ ├── line.mlt
│ │ ├── line_morton_curve_morton.json
│ │ ├── line_morton_curve_morton.mlt
│ │ ├── line_morton_curve_no_morton.json
│ │ ├── line_morton_curve_no_morton.mlt
│ │ ├── line_zero_length.json
│ │ ├── line_zero_length.mlt
│ │ ├── mix_2_line_line.json
│ │ ├── mix_2_line_line.mlt
│ │ ├── mix_2_line_mline.json
│ │ ├── mix_2_line_mline.mlt
│ │ ├── mix_2_line_mpoly.json
│ │ ├── mix_2_line_mpoly.mlt
│ │ ├── mix_2_line_mpt.json
│ │ ├── mix_2_line_mpt.mlt
│ │ ├── mix_2_line_poly.json
│ │ ├── mix_2_line_poly.mlt
│ │ ├── mix_2_line_polyh.json
│ │ ├── mix_2_line_polyh.mlt
│ │ ├── mix_2_mline_mline.json
│ │ ├── mix_2_mline_mline.mlt
│ │ ├── mix_2_mline_mpoly.json
│ │ ├── mix_2_mline_mpoly.mlt
│ │ ├── mix_2_mpoly_mpoly.json
│ │ ├── mix_2_mpoly_mpoly.mlt
│ │ ├── mix_2_mpoly_mpoly_tes.json
│ │ ├── mix_2_mpoly_mpoly_tes.mlt
│ │ ├── mix_2_mpt_mline.json
│ │ ├── mix_2_mpt_mline.mlt
│ │ ├── mix_2_mpt_mpoly.json
│ │ ├── mix_2_mpt_mpoly.mlt
│ │ ├── mix_2_mpt_mpt.json
│ │ ├── mix_2_mpt_mpt.mlt
│ │ ├── mix_2_poly_mline.json
│ │ ├── mix_2_poly_mline.mlt
│ │ ├── mix_2_poly_mpoly.json
│ │ ├── mix_2_poly_mpoly.mlt
│ │ ├── mix_2_poly_mpoly_tes.json
│ │ ├── mix_2_poly_mpoly_tes.mlt
│ │ ├── mix_2_poly_mpt.json
│ │ ├── mix_2_poly_mpt.mlt
│ │ ├── mix_2_poly_poly.json
│ │ ├── mix_2_poly_poly.mlt
│ │ ├── mix_2_poly_poly_tes.json
│ │ ├── mix_2_poly_poly_tes.mlt
│ │ ├── mix_2_poly_polyh.json
│ │ ├── mix_2_poly_polyh.mlt
│ │ ├── mix_2_poly_polyh_tes.json
│ │ ├── mix_2_poly_polyh_tes.mlt
│ │ ├── mix_2_polyh_mline.json
│ │ ├── mix_2_polyh_mline.mlt
│ │ ├── mix_2_polyh_mpoly.json
│ │ ├── mix_2_polyh_mpoly.mlt
│ │ ├── mix_2_polyh_mpoly_tes.json
│ │ ├── mix_2_polyh_mpoly_tes.mlt
│ │ ├── mix_2_polyh_mpt.json
│ │ ├── mix_2_polyh_mpt.mlt
│ │ ├── mix_2_polyh_polyh.json
│ │ ├── mix_2_polyh_polyh.mlt
│ │ ├── mix_2_polyh_polyh_tes.json
│ │ ├── mix_2_polyh_polyh_tes.mlt
│ │ ├── mix_2_pt_line.json
│ │ ├── mix_2_pt_line.mlt
│ │ ├── mix_2_pt_mline.json
│ │ ├── mix_2_pt_mline.mlt
│ │ ├── mix_2_pt_mpoly.json
│ │ ├── mix_2_pt_mpoly.mlt
│ │ ├── mix_2_pt_mpt.json
│ │ ├── mix_2_pt_mpt.mlt
│ │ ├── mix_2_pt_poly.json
│ │ ├── mix_2_pt_poly.mlt
│ │ ├── mix_2_pt_polyh.json
│ │ ├── mix_2_pt_polyh.mlt
│ │ ├── mix_2_pt_pt.json
│ │ ├── mix_2_pt_pt.mlt
│ │ ├── mix_3_line_mline_line.json
│ │ ├── mix_3_line_mline_line.mlt
│ │ ├── mix_3_line_mline_mpoly.json
│ │ ├── mix_3_line_mline_mpoly.mlt
│ │ ├── mix_3_line_mpoly_line.json
│ │ ├── mix_3_line_mpoly_line.mlt
│ │ ├── mix_3_line_mpt_line.json
│ │ ├── mix_3_line_mpt_line.mlt
│ │ ├── mix_3_line_mpt_mline.json
│ │ ├── mix_3_line_mpt_mline.mlt
│ │ ├── mix_3_line_mpt_mpoly.json
│ │ ├── mix_3_line_mpt_mpoly.mlt
│ │ ├── mix_3_line_poly_line.json
│ │ ├── mix_3_line_poly_line.mlt
│ │ ├── mix_3_line_poly_mline.json
│ │ ├── mix_3_line_poly_mline.mlt
│ │ ├── mix_3_line_poly_mpoly.json
│ │ ├── mix_3_line_poly_mpoly.mlt
│ │ ├── mix_3_line_poly_mpt.json
│ │ ├── mix_3_line_poly_mpt.mlt
│ │ ├── mix_3_line_poly_polyh.json
│ │ ├── mix_3_line_poly_polyh.mlt
│ │ ├── mix_3_line_polyh_line.json
│ │ ├── mix_3_line_polyh_line.mlt
│ │ ├── mix_3_line_polyh_mline.json
│ │ ├── mix_3_line_polyh_mline.mlt
│ │ ├── mix_3_line_polyh_mpoly.json
│ │ ├── mix_3_line_polyh_mpoly.mlt
│ │ ├── mix_3_line_polyh_mpt.json
│ │ ├── mix_3_line_polyh_mpt.mlt
│ │ ├── mix_3_line_pt_line.json
│ │ ├── mix_3_line_pt_line.mlt
│ │ ├── mix_3_mline_line_mline.json
│ │ ├── mix_3_mline_line_mline.mlt
│ │ ├── mix_3_mline_mpoly_mline.json
│ │ ├── mix_3_mline_mpoly_mline.mlt
│ │ ├── mix_3_mline_mpt_mline.json
│ │ ├── mix_3_mline_mpt_mline.mlt
│ │ ├── mix_3_mline_poly_mline.json
│ │ ├── mix_3_mline_poly_mline.mlt
│ │ ├── mix_3_mline_polyh_mline.json
│ │ ├── mix_3_mline_polyh_mline.mlt
│ │ ├── mix_3_mline_pt_mline.json
│ │ ├── mix_3_mline_pt_mline.mlt
│ │ ├── mix_3_mpoly_line_mpoly.json
│ │ ├── mix_3_mpoly_line_mpoly.mlt
│ │ ├── mix_3_mpoly_mline_mpoly.json
│ │ ├── mix_3_mpoly_mline_mpoly.mlt
│ │ ├── mix_3_mpoly_mpt_mpoly.json
│ │ ├── mix_3_mpoly_mpt_mpoly.mlt
│ │ ├── mix_3_mpoly_poly_mpoly.json
│ │ ├── mix_3_mpoly_poly_mpoly.mlt
│ │ ├── mix_3_mpoly_poly_mpoly_tes.json
│ │ ├── mix_3_mpoly_poly_mpoly_tes.mlt
│ │ ├── mix_3_mpoly_polyh_mpoly.json
│ │ ├── mix_3_mpoly_polyh_mpoly.mlt
│ │ ├── mix_3_mpoly_polyh_mpoly_tes.json
│ │ ├── mix_3_mpoly_polyh_mpoly_tes.mlt
│ │ ├── mix_3_mpoly_pt_mpoly.json
│ │ ├── mix_3_mpoly_pt_mpoly.mlt
│ │ ├── mix_3_mpt_line_mpt.json
│ │ ├── mix_3_mpt_line_mpt.mlt
│ │ ├── mix_3_mpt_mline_mpoly.json
│ │ ├── mix_3_mpt_mline_mpoly.mlt
│ │ ├── mix_3_mpt_mline_mpt.json
│ │ ├── mix_3_mpt_mline_mpt.mlt
│ │ ├── mix_3_mpt_mpoly_mpt.json
│ │ ├── mix_3_mpt_mpoly_mpt.mlt
│ │ ├── mix_3_mpt_poly_mpt.json
│ │ ├── mix_3_mpt_poly_mpt.mlt
│ │ ├── mix_3_mpt_polyh_mpt.json
│ │ ├── mix_3_mpt_polyh_mpt.mlt
│ │ ├── mix_3_mpt_pt_mpt.json
│ │ ├── mix_3_mpt_pt_mpt.mlt
│ │ ├── mix_3_poly_line_poly.json
│ │ ├── mix_3_poly_line_poly.mlt
│ │ ├── mix_3_poly_mline_mpoly.json
│ │ ├── mix_3_poly_mline_mpoly.mlt
│ │ ├── mix_3_poly_mline_poly.json
│ │ ├── mix_3_poly_mline_poly.mlt
│ │ ├── mix_3_poly_mpoly_poly.json
│ │ ├── mix_3_poly_mpoly_poly.mlt
│ │ ├── mix_3_poly_mpoly_poly_tes.json
│ │ ├── mix_3_poly_mpoly_poly_tes.mlt
│ │ ├── mix_3_poly_mpt_mline.json
│ │ ├── mix_3_poly_mpt_mline.mlt
│ │ ├── mix_3_poly_mpt_mpoly.json
│ │ ├── mix_3_poly_mpt_mpoly.mlt
│ │ ├── mix_3_poly_mpt_poly.json
│ │ ├── mix_3_poly_mpt_poly.mlt
│ │ ├── mix_3_poly_polyh_mline.json
│ │ ├── mix_3_poly_polyh_mline.mlt
│ │ ├── mix_3_poly_polyh_mpoly.json
│ │ ├── mix_3_poly_polyh_mpoly.mlt
│ │ ├── mix_3_poly_polyh_mpoly_tes.json
│ │ ├── mix_3_poly_polyh_mpoly_tes.mlt
│ │ ├── mix_3_poly_polyh_mpt.json
│ │ ├── mix_3_poly_polyh_mpt.mlt
│ │ ├── mix_3_poly_polyh_poly.json
│ │ ├── mix_3_poly_polyh_poly.mlt
│ │ ├── mix_3_poly_polyh_poly_tes.json
│ │ ├── mix_3_poly_polyh_poly_tes.mlt
│ │ ├── mix_3_poly_pt_poly.json
│ │ ├── mix_3_poly_pt_poly.mlt
│ │ ├── mix_3_polyh_line_polyh.json
│ │ ├── mix_3_polyh_line_polyh.mlt
│ │ ├── mix_3_polyh_mline_mpoly.json
│ │ ├── mix_3_polyh_mline_mpoly.mlt
│ │ ├── mix_3_polyh_mline_polyh.json
│ │ ├── mix_3_polyh_mline_polyh.mlt
│ │ ├── mix_3_polyh_mpoly_polyh.json
│ │ ├── mix_3_polyh_mpoly_polyh.mlt
│ │ ├── mix_3_polyh_mpoly_polyh_tes.json
│ │ ├── mix_3_polyh_mpoly_polyh_tes.mlt
│ │ ├── mix_3_polyh_mpt_mline.json
│ │ ├── mix_3_polyh_mpt_mline.mlt
│ │ ├── mix_3_polyh_mpt_mpoly.json
│ │ ├── mix_3_polyh_mpt_mpoly.mlt
│ │ ├── mix_3_polyh_mpt_polyh.json
│ │ ├── mix_3_polyh_mpt_polyh.mlt
│ │ ├── mix_3_polyh_poly_polyh.json
│ │ ├── mix_3_polyh_poly_polyh.mlt
│ │ ├── mix_3_polyh_poly_polyh_tes.json
│ │ ├── mix_3_polyh_poly_polyh_tes.mlt
│ │ ├── mix_3_polyh_pt_polyh.json
│ │ ├── mix_3_polyh_pt_polyh.mlt
│ │ ├── mix_3_pt_line_mline.json
│ │ ├── mix_3_pt_line_mline.mlt
│ │ ├── mix_3_pt_line_mpoly.json
│ │ ├── mix_3_pt_line_mpoly.mlt
│ │ ├── mix_3_pt_line_mpt.json
│ │ ├── mix_3_pt_line_mpt.mlt
│ │ ├── mix_3_pt_line_poly.json
│ │ ├── mix_3_pt_line_poly.mlt
│ │ ├── mix_3_pt_line_polyh.json
│ │ ├── mix_3_pt_line_polyh.mlt
│ │ ├── mix_3_pt_line_pt.json
│ │ ├── mix_3_pt_line_pt.mlt
│ │ ├── mix_3_pt_mline_mpoly.json
│ │ ├── mix_3_pt_mline_mpoly.mlt
│ │ ├── mix_3_pt_mline_pt.json
│ │ ├── mix_3_pt_mline_pt.mlt
│ │ ├── mix_3_pt_mpoly_pt.json
│ │ ├── mix_3_pt_mpoly_pt.mlt
│ │ ├── mix_3_pt_mpt_mline.json
│ │ ├── mix_3_pt_mpt_mline.mlt
│ │ ├── mix_3_pt_mpt_mpoly.json
│ │ ├── mix_3_pt_mpt_mpoly.mlt
│ │ ├── mix_3_pt_mpt_pt.json
│ │ ├── mix_3_pt_mpt_pt.mlt
│ │ ├── mix_3_pt_poly_mline.json
│ │ ├── mix_3_pt_poly_mline.mlt
│ │ ├── mix_3_pt_poly_mpoly.json
│ │ ├── mix_3_pt_poly_mpoly.mlt
│ │ ├── mix_3_pt_poly_mpt.json
│ │ ├── mix_3_pt_poly_mpt.mlt
│ │ ├── mix_3_pt_poly_polyh.json
│ │ ├── mix_3_pt_poly_polyh.mlt
│ │ ├── mix_3_pt_poly_pt.json
│ │ ├── mix_3_pt_poly_pt.mlt
│ │ ├── mix_3_pt_polyh_mline.json
│ │ ├── mix_3_pt_polyh_mline.mlt
│ │ ├── mix_3_pt_polyh_mpoly.json
│ │ ├── mix_3_pt_polyh_mpoly.mlt
│ │ ├── mix_3_pt_polyh_mpt.json
│ │ ├── mix_3_pt_polyh_mpt.mlt
│ │ ├── mix_3_pt_polyh_pt.json
│ │ ├── mix_3_pt_polyh_pt.mlt
│ │ ├── mix_4_line_mpt_mline_mpoly.json
│ │ ├── mix_4_line_mpt_mline_mpoly.mlt
│ │ ├── mix_4_line_poly_mline_mpoly.json
│ │ ├── mix_4_line_poly_mline_mpoly.mlt
│ │ ├── mix_4_line_poly_mpt_mline.json
│ │ ├── mix_4_line_poly_mpt_mline.mlt
│ │ ├── mix_4_line_poly_mpt_mpoly.json
│ │ ├── mix_4_line_poly_mpt_mpoly.mlt
│ │ ├── mix_4_line_poly_polyh_mline.json
│ │ ├── mix_4_line_poly_polyh_mline.mlt
│ │ ├── mix_4_line_poly_polyh_mpoly.json
│ │ ├── mix_4_line_poly_polyh_mpoly.mlt
│ │ ├── mix_4_line_poly_polyh_mpt.json
│ │ ├── mix_4_line_poly_polyh_mpt.mlt
│ │ ├── mix_4_line_polyh_mline_mpoly.json
│ │ ├── mix_4_line_polyh_mline_mpoly.mlt
│ │ ├── mix_4_line_polyh_mpt_mline.json
│ │ ├── mix_4_line_polyh_mpt_mline.mlt
│ │ ├── mix_4_line_polyh_mpt_mpoly.json
│ │ ├── mix_4_line_polyh_mpt_mpoly.mlt
│ │ ├── mix_4_poly_mpt_mline_mpoly.json
│ │ ├── mix_4_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_4_poly_polyh_mline_mpoly.json
│ │ ├── mix_4_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_4_poly_polyh_mpt_mline.json
│ │ ├── mix_4_poly_polyh_mpt_mline.mlt
│ │ ├── mix_4_poly_polyh_mpt_mpoly.json
│ │ ├── mix_4_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_4_polyh_mpt_mline_mpoly.json
│ │ ├── mix_4_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_4_pt_line_mline_mpoly.json
│ │ ├── mix_4_pt_line_mline_mpoly.mlt
│ │ ├── mix_4_pt_line_mpt_mline.json
│ │ ├── mix_4_pt_line_mpt_mline.mlt
│ │ ├── mix_4_pt_line_mpt_mpoly.json
│ │ ├── mix_4_pt_line_mpt_mpoly.mlt
│ │ ├── mix_4_pt_line_poly_mline.json
│ │ ├── mix_4_pt_line_poly_mline.mlt
│ │ ├── mix_4_pt_line_poly_mpoly.json
│ │ ├── mix_4_pt_line_poly_mpoly.mlt
│ │ ├── mix_4_pt_line_poly_mpt.json
│ │ ├── mix_4_pt_line_poly_mpt.mlt
│ │ ├── mix_4_pt_line_poly_polyh.json
│ │ ├── mix_4_pt_line_poly_polyh.mlt
│ │ ├── mix_4_pt_line_polyh_mline.json
│ │ ├── mix_4_pt_line_polyh_mline.mlt
│ │ ├── mix_4_pt_line_polyh_mpoly.json
│ │ ├── mix_4_pt_line_polyh_mpoly.mlt
│ │ ├── mix_4_pt_line_polyh_mpt.json
│ │ ├── mix_4_pt_line_polyh_mpt.mlt
│ │ ├── mix_4_pt_mpt_mline_mpoly.json
│ │ ├── mix_4_pt_mpt_mline_mpoly.mlt
│ │ ├── mix_4_pt_poly_mline_mpoly.json
│ │ ├── mix_4_pt_poly_mline_mpoly.mlt
│ │ ├── mix_4_pt_poly_mpt_mline.json
│ │ ├── mix_4_pt_poly_mpt_mline.mlt
│ │ ├── mix_4_pt_poly_mpt_mpoly.json
│ │ ├── mix_4_pt_poly_mpt_mpoly.mlt
│ │ ├── mix_4_pt_poly_polyh_mline.json
│ │ ├── mix_4_pt_poly_polyh_mline.mlt
│ │ ├── mix_4_pt_poly_polyh_mpoly.json
│ │ ├── mix_4_pt_poly_polyh_mpoly.mlt
│ │ ├── mix_4_pt_poly_polyh_mpt.json
│ │ ├── mix_4_pt_poly_polyh_mpt.mlt
│ │ ├── mix_4_pt_polyh_mline_mpoly.json
│ │ ├── mix_4_pt_polyh_mline_mpoly.mlt
│ │ ├── mix_4_pt_polyh_mpt_mline.json
│ │ ├── mix_4_pt_polyh_mpt_mline.mlt
│ │ ├── mix_4_pt_polyh_mpt_mpoly.json
│ │ ├── mix_4_pt_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_line_poly_mpt_mline_mpoly.json
│ │ ├── mix_5_line_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_5_line_poly_polyh_mline_mpoly.json
│ │ ├── mix_5_line_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_5_line_poly_polyh_mpt_mline.json
│ │ ├── mix_5_line_poly_polyh_mpt_mline.mlt
│ │ ├── mix_5_line_poly_polyh_mpt_mpoly.json
│ │ ├── mix_5_line_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_line_polyh_mpt_mline_mpoly.json
│ │ ├── mix_5_line_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_5_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_5_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_mpt_mline_mpoly.json
│ │ ├── mix_5_pt_line_mpt_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_mline_mpoly.json
│ │ ├── mix_5_pt_line_poly_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_mpt_mline.json
│ │ ├── mix_5_pt_line_poly_mpt_mline.mlt
│ │ ├── mix_5_pt_line_poly_mpt_mpoly.json
│ │ ├── mix_5_pt_line_poly_mpt_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_polyh_mline.json
│ │ ├── mix_5_pt_line_poly_polyh_mline.mlt
│ │ ├── mix_5_pt_line_poly_polyh_mpoly.json
│ │ ├── mix_5_pt_line_poly_polyh_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_polyh_mpt.json
│ │ ├── mix_5_pt_line_poly_polyh_mpt.mlt
│ │ ├── mix_5_pt_line_polyh_mline_mpoly.json
│ │ ├── mix_5_pt_line_polyh_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_polyh_mpt_mline.json
│ │ ├── mix_5_pt_line_polyh_mpt_mline.mlt
│ │ ├── mix_5_pt_line_polyh_mpt_mpoly.json
│ │ ├── mix_5_pt_line_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_pt_poly_mpt_mline_mpoly.json
│ │ ├── mix_5_pt_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_5_pt_poly_polyh_mline_mpoly.json
│ │ ├── mix_5_pt_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_5_pt_poly_polyh_mpt_mline.json
│ │ ├── mix_5_pt_poly_polyh_mpt_mline.mlt
│ │ ├── mix_5_pt_poly_polyh_mpt_mpoly.json
│ │ ├── mix_5_pt_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_pt_polyh_mpt_mline_mpoly.json
│ │ ├── mix_5_pt_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_6_line_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_6_line_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_6_pt_line_poly_mpt_mline_mpoly.json
│ │ ├── mix_6_pt_line_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_6_pt_line_poly_polyh_mline_mpoly.json
│ │ ├── mix_6_pt_line_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mline.json
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mline.mlt
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mpoly.json
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_6_pt_line_polyh_mpt_mline_mpoly.json
│ │ ├── mix_6_pt_line_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_6_pt_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_6_pt_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_7_pt_line_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_7_pt_line_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── multiline.json
│ │ ├── multiline.mlt
│ │ ├── multiline_morton.json
│ │ ├── multiline_morton.mlt
│ │ ├── multipoint.json
│ │ ├── multipoint.mlt
│ │ ├── multipoint_morton.json
│ │ ├── multipoint_morton.mlt
│ │ ├── point.json
│ │ ├── point.mlt
│ │ ├── poly.json
│ │ ├── poly.mlt
│ │ ├── poly_collinear.json
│ │ ├── poly_collinear.mlt
│ │ ├── poly_collinear_fpf.json
│ │ ├── poly_collinear_fpf.mlt
│ │ ├── poly_collinear_fpf_tes.json
│ │ ├── poly_collinear_fpf_tes.mlt
│ │ ├── poly_collinear_tes.json
│ │ ├── poly_collinear_tes.mlt
│ │ ├── poly_fpf.json
│ │ ├── poly_fpf.mlt
│ │ ├── poly_fpf_tes.json
│ │ ├── poly_fpf_tes.mlt
│ │ ├── poly_hole.json
│ │ ├── poly_hole.mlt
│ │ ├── poly_hole_fpf.json
│ │ ├── poly_hole_fpf.mlt
│ │ ├── poly_hole_fpf_tes.json
│ │ ├── poly_hole_fpf_tes.mlt
│ │ ├── poly_hole_tes.json
│ │ ├── poly_hole_tes.mlt
│ │ ├── poly_hole_touching.json
│ │ ├── poly_hole_touching.mlt
│ │ ├── poly_hole_touching_fpf.json
│ │ ├── poly_hole_touching_fpf.mlt
│ │ ├── poly_hole_touching_fpf_tes.json
│ │ ├── poly_hole_touching_fpf_tes.mlt
│ │ ├── poly_hole_touching_tes.json
│ │ ├── poly_hole_touching_tes.mlt
│ │ ├── poly_morton_hole_morton.json
│ │ ├── poly_morton_hole_morton.mlt
│ │ ├── poly_morton_ring_morton.json
│ │ ├── poly_morton_ring_morton.mlt
│ │ ├── poly_morton_ring_no_morton.json
│ │ ├── poly_morton_ring_no_morton.mlt
│ │ ├── poly_multi.json
│ │ ├── poly_multi.mlt
│ │ ├── poly_multi_fpf.json
│ │ ├── poly_multi_fpf.mlt
│ │ ├── poly_multi_fpf_tes.json
│ │ ├── poly_multi_fpf_tes.mlt
│ │ ├── poly_multi_morton_hole_morton.json
│ │ ├── poly_multi_morton_hole_morton.mlt
│ │ ├── poly_multi_morton_ring_morton.json
│ │ ├── poly_multi_morton_ring_morton.mlt
│ │ ├── poly_multi_morton_ring_no_morton.json
│ │ ├── poly_multi_morton_ring_no_morton.mlt
│ │ ├── poly_multi_tes.json
│ │ ├── poly_multi_tes.mlt
│ │ ├── poly_self_intersect.json
│ │ ├── poly_self_intersect.mlt
│ │ ├── poly_self_intersect_fpf.json
│ │ ├── poly_self_intersect_fpf.mlt
│ │ ├── poly_self_intersect_fpf_tes.json
│ │ ├── poly_self_intersect_fpf_tes.mlt
│ │ ├── poly_self_intersect_tes.json
│ │ ├── poly_self_intersect_tes.mlt
│ │ ├── poly_tes.json
│ │ ├── poly_tes.mlt
│ │ ├── prop_bool.json
│ │ ├── prop_bool.mlt
│ │ ├── prop_bool_false.json
│ │ ├── prop_bool_false.mlt
│ │ ├── prop_bool_false_null.json
│ │ ├── prop_bool_false_null.mlt
│ │ ├── prop_bool_null_false.json
│ │ ├── prop_bool_null_false.mlt
│ │ ├── prop_bool_null_true.json
│ │ ├── prop_bool_null_true.mlt
│ │ ├── prop_bool_true_null.json
│ │ ├── prop_bool_true_null.mlt
│ │ ├── prop_empty_name.json
│ │ ├── prop_empty_name.mlt
│ │ ├── prop_f32.json
│ │ ├── prop_f32.mlt
│ │ ├── prop_f32_max.json
│ │ ├── prop_f32_max.mlt
│ │ ├── prop_f32_min_norm.json
│ │ ├── prop_f32_min_norm.mlt
│ │ ├── prop_f32_min_val.json
│ │ ├── prop_f32_min_val.mlt
│ │ ├── prop_f32_nan.json
│ │ ├── prop_f32_nan.mlt
│ │ ├── prop_f32_neg_inf.json
│ │ ├── prop_f32_neg_inf.mlt
│ │ ├── prop_f32_neg_zero.json
│ │ ├── prop_f32_neg_zero.mlt
│ │ ├── prop_f32_null_val.json
│ │ ├── prop_f32_null_val.mlt
│ │ ├── prop_f32_pos_inf.json
│ │ ├── prop_f32_pos_inf.mlt
│ │ ├── prop_f32_val_null.json
│ │ ├── prop_f32_val_null.mlt
│ │ ├── prop_f32_zero.json
│ │ ├── prop_f32_zero.mlt
│ │ ├── prop_f64.json
│ │ ├── prop_f64.mlt
│ │ ├── prop_f64_max.json
│ │ ├── prop_f64_max.mlt
│ │ ├── prop_f64_min_norm.json
│ │ ├── prop_f64_min_norm.mlt
│ │ ├── prop_f64_min_val.json
│ │ ├── prop_f64_min_val.mlt
│ │ ├── prop_f64_nan.json
│ │ ├── prop_f64_nan.mlt
│ │ ├── prop_f64_neg_inf.json
│ │ ├── prop_f64_neg_inf.mlt
│ │ ├── prop_f64_neg_zero.json
│ │ ├── prop_f64_neg_zero.mlt
│ │ ├── prop_f64_null_val.json
│ │ ├── prop_f64_null_val.mlt
│ │ ├── prop_f64_pos_inf.json
│ │ ├── prop_f64_pos_inf.mlt
│ │ ├── prop_f64_val_null.json
│ │ ├── prop_f64_val_null.mlt
│ │ ├── prop_f64_zero.json
│ │ ├── prop_f64_zero.mlt
│ │ ├── prop_i32.json
│ │ ├── prop_i32.mlt
│ │ ├── prop_i32_max.json
│ │ ├── prop_i32_max.mlt
│ │ ├── prop_i32_min.json
│ │ ├── prop_i32_min.mlt
│ │ ├── prop_i32_neg.json
│ │ ├── prop_i32_neg.mlt
│ │ ├── prop_i32_null_val.json
│ │ ├── prop_i32_null_val.mlt
│ │ ├── prop_i32_val_null.json
│ │ ├── prop_i32_val_null.mlt
│ │ ├── prop_i64.json
│ │ ├── prop_i64.mlt
│ │ ├── prop_i64_max.json
│ │ ├── prop_i64_max.mlt
│ │ ├── prop_i64_min.json
│ │ ├── prop_i64_min.mlt
│ │ ├── prop_i64_neg.json
│ │ ├── prop_i64_neg.mlt
│ │ ├── prop_i64_null_val.json
│ │ ├── prop_i64_null_val.mlt
│ │ ├── prop_i64_val_null.json
│ │ ├── prop_i64_val_null.mlt
│ │ ├── prop_special_name.json
│ │ ├── prop_special_name.mlt
│ │ ├── prop_str_ascii.json
│ │ ├── prop_str_ascii.mlt
│ │ ├── prop_str_empty.json
│ │ ├── prop_str_empty.mlt
│ │ ├── prop_str_empty_val.json
│ │ ├── prop_str_empty_val.mlt
│ │ ├── prop_str_escape.json
│ │ ├── prop_str_escape.mlt
│ │ ├── prop_str_null_val.json
│ │ ├── prop_str_null_val.mlt
│ │ ├── prop_str_special.json
│ │ ├── prop_str_special.mlt
│ │ ├── prop_str_unicode.json
│ │ ├── prop_str_unicode.mlt
│ │ ├── prop_str_val_empty.json
│ │ ├── prop_str_val_empty.mlt
│ │ ├── prop_str_val_null.json
│ │ ├── prop_str_val_null.mlt
│ │ ├── prop_u32.json
│ │ ├── prop_u32.mlt
│ │ ├── prop_u32_max.json
│ │ ├── prop_u32_max.mlt
│ │ ├── prop_u32_min.json
│ │ ├── prop_u32_min.mlt
│ │ ├── prop_u32_null_val.json
│ │ ├── prop_u32_null_val.mlt
│ │ ├── prop_u32_val_null.json
│ │ ├── prop_u32_val_null.mlt
│ │ ├── prop_u64.json
│ │ ├── prop_u64.mlt
│ │ ├── prop_u64_max.json
│ │ ├── prop_u64_max.mlt
│ │ ├── prop_u64_min.json
│ │ ├── prop_u64_min.mlt
│ │ ├── prop_u64_null_val.json
│ │ ├── prop_u64_null_val.mlt
│ │ ├── prop_u64_val_null.json
│ │ ├── prop_u64_val_null.mlt
│ │ ├── props_i32.json
│ │ ├── props_i32.mlt
│ │ ├── props_i32_delta.json
│ │ ├── props_i32_delta.mlt
│ │ ├── props_i32_delta_rle.json
│ │ ├── props_i32_delta_rle.mlt
│ │ ├── props_i32_rle.json
│ │ ├── props_i32_rle.mlt
│ │ ├── props_i64.json
│ │ ├── props_i64.mlt
│ │ ├── props_i64_delta.json
│ │ ├── props_i64_delta.mlt
│ │ ├── props_i64_delta_rle.json
│ │ ├── props_i64_delta_rle.mlt
│ │ ├── props_i64_rle.json
│ │ ├── props_i64_rle.mlt
│ │ ├── props_mixed.json
│ │ ├── props_mixed.mlt
│ │ ├── props_no_shared_dict.json
│ │ ├── props_no_shared_dict.mlt
│ │ ├── props_offset_str.json
│ │ ├── props_offset_str.mlt
│ │ ├── props_offset_str_fsst.json
│ │ ├── props_offset_str_fsst.mlt
│ │ ├── props_shared_dict.json
│ │ ├── props_shared_dict.mlt
│ │ ├── props_shared_dict_2_same_prefix.json
│ │ ├── props_shared_dict_2_same_prefix.mlt
│ │ ├── props_shared_dict_fsst.json
│ │ ├── props_shared_dict_fsst.mlt
│ │ ├── props_shared_dict_no_child_name.json
│ │ ├── props_shared_dict_no_child_name.mlt
│ │ ├── props_shared_dict_no_child_name_fsst.json
│ │ ├── props_shared_dict_no_child_name_fsst.mlt
│ │ ├── props_shared_dict_no_struct_name.json
│ │ ├── props_shared_dict_no_struct_name.mlt
│ │ ├── props_shared_dict_no_struct_name_fsst.json
│ │ ├── props_shared_dict_no_struct_name_fsst.mlt
│ │ ├── props_shared_dict_one_child.json
│ │ ├── props_shared_dict_one_child.mlt
│ │ ├── props_shared_dict_one_child_fsst.json
│ │ ├── props_shared_dict_one_child_fsst.mlt
│ │ ├── props_str.json
│ │ ├── props_str.mlt
│ │ ├── props_str_fsst.json
│ │ ├── props_str_fsst.mlt
│ │ ├── props_u32.json
│ │ ├── props_u32.mlt
│ │ ├── props_u32_delta.json
│ │ ├── props_u32_delta.mlt
│ │ ├── props_u32_delta_rle.json
│ │ ├── props_u32_delta_rle.mlt
│ │ ├── props_u32_fpf_127.json
│ │ ├── props_u32_fpf_127.mlt
│ │ ├── props_u32_fpf_128.json
│ │ ├── props_u32_fpf_128.mlt
│ │ ├── props_u32_fpf_129.json
│ │ ├── props_u32_fpf_129.mlt
│ │ ├── props_u32_fpf_255.json
│ │ ├── props_u32_fpf_255.mlt
│ │ ├── props_u32_fpf_256.json
│ │ ├── props_u32_fpf_256.mlt
│ │ ├── props_u32_fpf_257.json
│ │ ├── props_u32_fpf_257.mlt
│ │ ├── props_u32_fpf_383.json
│ │ ├── props_u32_fpf_383.mlt
│ │ ├── props_u32_fpf_384.json
│ │ ├── props_u32_fpf_384.mlt
│ │ ├── props_u32_fpf_385.json
│ │ ├── props_u32_fpf_385.mlt
│ │ ├── props_u32_fpf_511.json
│ │ ├── props_u32_fpf_511.mlt
│ │ ├── props_u32_fpf_512.json
│ │ ├── props_u32_fpf_512.mlt
│ │ ├── props_u32_fpf_513.json
│ │ ├── props_u32_fpf_513.mlt
│ │ ├── props_u32_rle.json
│ │ ├── props_u32_rle.mlt
│ │ ├── props_u64.json
│ │ ├── props_u64.mlt
│ │ ├── props_u64_delta.json
│ │ ├── props_u64_delta.mlt
│ │ ├── props_u64_delta_rle.json
│ │ ├── props_u64_delta_rle.mlt
│ │ ├── props_u64_rle.json
│ │ └── props_u64_rle.mlt
│ ├── 0x01-rust/
│ │ ├── id64_max.json
│ │ ├── id64_max.mlt
│ │ ├── id_max.json
│ │ ├── id_max.mlt
│ │ ├── ids64_minmax.json
│ │ ├── ids64_minmax.mlt
│ │ ├── ids64_minmax_delta.json
│ │ ├── ids64_minmax_delta.mlt
│ │ ├── ids_delta_fpf.json
│ │ ├── ids_delta_fpf.mlt
│ │ ├── ids_fpf.json
│ │ ├── ids_fpf.mlt
│ │ ├── mix_2_poly_poly_tes_ns.json
│ │ ├── mix_2_poly_poly_tes_ns.mlt
│ │ ├── mix_2_poly_polyh_tes_ns.json
│ │ ├── mix_2_poly_polyh_tes_ns.mlt
│ │ ├── mix_2_polyh_polyh_tes_ns.json
│ │ ├── mix_2_polyh_polyh_tes_ns.mlt
│ │ ├── mix_3_poly_polyh_poly_tes_ns.json
│ │ ├── mix_3_poly_polyh_poly_tes_ns.mlt
│ │ ├── mix_3_polyh_poly_polyh_tes_ns.json
│ │ ├── mix_3_polyh_poly_polyh_tes_ns.mlt
│ │ ├── poly_collinear_fpf_tes_ns.json
│ │ ├── poly_collinear_fpf_tes_ns.mlt
│ │ ├── poly_collinear_tes_ns.json
│ │ ├── poly_collinear_tes_ns.mlt
│ │ ├── poly_fpf_tes_ns.json
│ │ ├── poly_fpf_tes_ns.mlt
│ │ ├── poly_hole_fpf_tes_ns.json
│ │ ├── poly_hole_fpf_tes_ns.mlt
│ │ ├── poly_hole_tes_ns.json
│ │ ├── poly_hole_tes_ns.mlt
│ │ ├── poly_hole_touching_fpf_tes_ns.json
│ │ ├── poly_hole_touching_fpf_tes_ns.mlt
│ │ ├── poly_hole_touching_tes_ns.json
│ │ ├── poly_hole_touching_tes_ns.mlt
│ │ ├── poly_self_intersect_fpf_tes_ns.json
│ │ ├── poly_self_intersect_fpf_tes_ns.mlt
│ │ ├── poly_self_intersect_tes_ns.json
│ │ ├── poly_self_intersect_tes_ns.mlt
│ │ ├── poly_tes_ns.json
│ │ ├── poly_tes_ns.mlt
│ │ ├── prop_bool_false_np.json
│ │ ├── prop_bool_false_np.mlt
│ │ ├── prop_bool_np.json
│ │ ├── prop_bool_np.mlt
│ │ ├── prop_empty_name_np.json
│ │ ├── prop_empty_name_np.mlt
│ │ ├── prop_f32_max_np.json
│ │ ├── prop_f32_max_np.mlt
│ │ ├── prop_f32_min_norm_np.json
│ │ ├── prop_f32_min_norm_np.mlt
│ │ ├── prop_f32_min_val_np.json
│ │ ├── prop_f32_min_val_np.mlt
│ │ ├── prop_f32_nan_np.json
│ │ ├── prop_f32_nan_np.mlt
│ │ ├── prop_f32_neg_inf_np.json
│ │ ├── prop_f32_neg_inf_np.mlt
│ │ ├── prop_f32_neg_zero_np.json
│ │ ├── prop_f32_neg_zero_np.mlt
│ │ ├── prop_f32_np.json
│ │ ├── prop_f32_np.mlt
│ │ ├── prop_f32_pos_inf_np.json
│ │ ├── prop_f32_pos_inf_np.mlt
│ │ ├── prop_f32_zero_np.json
│ │ ├── prop_f32_zero_np.mlt
│ │ ├── prop_f64_max_np.json
│ │ ├── prop_f64_max_np.mlt
│ │ ├── prop_f64_min_norm_np.json
│ │ ├── prop_f64_min_norm_np.mlt
│ │ ├── prop_f64_min_val_np.json
│ │ ├── prop_f64_min_val_np.mlt
│ │ ├── prop_f64_nan_np.json
│ │ ├── prop_f64_nan_np.mlt
│ │ ├── prop_f64_neg_inf_np.json
│ │ ├── prop_f64_neg_inf_np.mlt
│ │ ├── prop_f64_neg_zero_np.json
│ │ ├── prop_f64_neg_zero_np.mlt
│ │ ├── prop_f64_np.json
│ │ ├── prop_f64_np.mlt
│ │ ├── prop_f64_pos_inf_np.json
│ │ ├── prop_f64_pos_inf_np.mlt
│ │ ├── prop_f64_zero_np.json
│ │ ├── prop_f64_zero_np.mlt
│ │ ├── prop_i32_max_np.json
│ │ ├── prop_i32_max_np.mlt
│ │ ├── prop_i32_min_np.json
│ │ ├── prop_i32_min_np.mlt
│ │ ├── prop_i32_neg_np.json
│ │ ├── prop_i32_neg_np.mlt
│ │ ├── prop_i32_np.json
│ │ ├── prop_i32_np.mlt
│ │ ├── prop_i64_max_np.json
│ │ ├── prop_i64_max_np.mlt
│ │ ├── prop_i64_min_np.json
│ │ ├── prop_i64_min_np.mlt
│ │ ├── prop_i64_neg_np.json
│ │ ├── prop_i64_neg_np.mlt
│ │ ├── prop_i64_np.json
│ │ ├── prop_i64_np.mlt
│ │ ├── prop_special_name_np.json
│ │ ├── prop_special_name_np.mlt
│ │ ├── prop_str_ascii_np.json
│ │ ├── prop_str_ascii_np.mlt
│ │ ├── prop_str_empty_np.json
│ │ ├── prop_str_empty_np.mlt
│ │ ├── prop_str_escape_np.json
│ │ ├── prop_str_escape_np.mlt
│ │ ├── prop_str_special_np.json
│ │ ├── prop_str_special_np.mlt
│ │ ├── prop_str_unicode_np.json
│ │ ├── prop_str_unicode_np.mlt
│ │ ├── prop_u32_max_np.json
│ │ ├── prop_u32_max_np.mlt
│ │ ├── prop_u32_min_np.json
│ │ ├── prop_u32_min_np.mlt
│ │ ├── prop_u32_np.json
│ │ ├── prop_u32_np.mlt
│ │ ├── prop_u64_max_np.json
│ │ ├── prop_u64_max_np.mlt
│ │ ├── prop_u64_min_np.json
│ │ ├── prop_u64_min_np.mlt
│ │ ├── prop_u64_np.json
│ │ ├── prop_u64_np.mlt
│ │ ├── props_i32_delta_np.json
│ │ ├── props_i32_delta_np.mlt
│ │ ├── props_i32_delta_rle_np.json
│ │ ├── props_i32_delta_rle_np.mlt
│ │ ├── props_i32_np.json
│ │ ├── props_i32_np.mlt
│ │ ├── props_i32_rle_np.json
│ │ ├── props_i32_rle_np.mlt
│ │ ├── props_mixed_np.json
│ │ ├── props_mixed_np.mlt
│ │ ├── props_no_shared_dict_np.json
│ │ ├── props_no_shared_dict_np.mlt
│ │ ├── props_offset_str_fsst.json
│ │ ├── props_offset_str_fsst.mlt
│ │ ├── props_offset_str_fsst_np.json
│ │ ├── props_offset_str_fsst_np.mlt
│ │ ├── props_offset_str_np.json
│ │ ├── props_offset_str_np.mlt
│ │ ├── props_shared_dict_2_same_prefix_np.json
│ │ ├── props_shared_dict_2_same_prefix_np.mlt
│ │ ├── props_shared_dict_fsst.json
│ │ ├── props_shared_dict_fsst.mlt
│ │ ├── props_shared_dict_fsst_np.json
│ │ ├── props_shared_dict_fsst_np.mlt
│ │ ├── props_shared_dict_no_child_name_fsst.json
│ │ ├── props_shared_dict_no_child_name_fsst.mlt
│ │ ├── props_shared_dict_no_child_name_fsst_np.json
│ │ ├── props_shared_dict_no_child_name_fsst_np.mlt
│ │ ├── props_shared_dict_no_child_name_np.json
│ │ ├── props_shared_dict_no_child_name_np.mlt
│ │ ├── props_shared_dict_no_struct_name_fsst.json
│ │ ├── props_shared_dict_no_struct_name_fsst.mlt
│ │ ├── props_shared_dict_no_struct_name_fsst_np.json
│ │ ├── props_shared_dict_no_struct_name_fsst_np.mlt
│ │ ├── props_shared_dict_no_struct_name_np.json
│ │ ├── props_shared_dict_no_struct_name_np.mlt
│ │ ├── props_shared_dict_np.json
│ │ ├── props_shared_dict_np.mlt
│ │ ├── props_shared_dict_one_child_fsst.json
│ │ ├── props_shared_dict_one_child_fsst.mlt
│ │ ├── props_shared_dict_one_child_fsst_np.json
│ │ ├── props_shared_dict_one_child_fsst_np.mlt
│ │ ├── props_shared_dict_one_child_np.json
│ │ ├── props_shared_dict_one_child_np.mlt
│ │ ├── props_shared_dict_presence_variants.json
│ │ ├── props_shared_dict_presence_variants.mlt
│ │ ├── props_shared_dict_presence_variants_np.json
│ │ ├── props_shared_dict_presence_variants_np.mlt
│ │ ├── props_str_fsst.json
│ │ ├── props_str_fsst.mlt
│ │ ├── props_str_fsst_np.json
│ │ ├── props_str_fsst_np.mlt
│ │ ├── props_str_np.json
│ │ ├── props_str_np.mlt
│ │ ├── props_u32_delta_np.json
│ │ ├── props_u32_delta_np.mlt
│ │ ├── props_u32_delta_rle_np.json
│ │ ├── props_u32_delta_rle_np.mlt
│ │ ├── props_u32_fpf_127_np.json
│ │ ├── props_u32_fpf_127_np.mlt
│ │ ├── props_u32_fpf_128_np.json
│ │ ├── props_u32_fpf_128_np.mlt
│ │ ├── props_u32_fpf_129_np.json
│ │ ├── props_u32_fpf_129_np.mlt
│ │ ├── props_u32_fpf_255_np.json
│ │ ├── props_u32_fpf_255_np.mlt
│ │ ├── props_u32_fpf_256_np.json
│ │ ├── props_u32_fpf_256_np.mlt
│ │ ├── props_u32_fpf_257_np.json
│ │ ├── props_u32_fpf_257_np.mlt
│ │ ├── props_u32_fpf_383_np.json
│ │ ├── props_u32_fpf_383_np.mlt
│ │ ├── props_u32_fpf_384_np.json
│ │ ├── props_u32_fpf_384_np.mlt
│ │ ├── props_u32_fpf_385_np.json
│ │ ├── props_u32_fpf_385_np.mlt
│ │ ├── props_u32_fpf_511_np.json
│ │ ├── props_u32_fpf_511_np.mlt
│ │ ├── props_u32_fpf_512_np.json
│ │ ├── props_u32_fpf_512_np.mlt
│ │ ├── props_u32_fpf_513_np.json
│ │ ├── props_u32_fpf_513_np.mlt
│ │ ├── props_u32_np.json
│ │ ├── props_u32_np.mlt
│ │ ├── props_u32_rle_np.json
│ │ ├── props_u32_rle_np.mlt
│ │ ├── props_u64_delta_np.json
│ │ ├── props_u64_delta_np.mlt
│ │ ├── props_u64_delta_rle_np.json
│ │ ├── props_u64_delta_rle_np.mlt
│ │ ├── props_u64_np.json
│ │ ├── props_u64_np.mlt
│ │ ├── props_u64_rle_np.json
│ │ └── props_u64_rle_np.mlt
│ ├── java.txt
│ ├── rust.txt
│ └── synthetic-test-utils/
│ ├── index.ts
│ └── package.json
└── ts/
├── .gitignore
├── .nvmrc
├── README.md
├── RELEASE.md
├── biome.json
├── buf.gen.yaml
├── eslint.config.mjs
├── mod.just
├── package.json
├── src/
│ ├── decoding/
│ │ ├── bigEndianDecode.spec.ts
│ │ ├── bigEndianDecode.ts
│ │ ├── decodingTestUtils.ts
│ │ ├── decodingUtils.spec.ts
│ │ ├── decodingUtils.ts
│ │ ├── fastPforCrossLanguage.spec.ts
│ │ ├── fastPforDecoder.spec.ts
│ │ ├── fastPforDecoder.ts
│ │ ├── fastPforShared.spec.ts
│ │ ├── fastPforShared.ts
│ │ ├── fastPforUnpack.spec.ts
│ │ ├── fastPforUnpack.ts
│ │ ├── fsstDecoder.spec.ts
│ │ ├── fsstDecoder.ts
│ │ ├── geometryDecoder.ts
│ │ ├── geometryScaling.ts
│ │ ├── intWrapper.ts
│ │ ├── integerDecodingUtils.spec.ts
│ │ ├── integerDecodingUtils.ts
│ │ ├── integerStreamDecoder.spec.ts
│ │ ├── integerStreamDecoder.ts
│ │ ├── propertyDecoder.spec.ts
│ │ ├── propertyDecoder.ts
│ │ ├── stringDecoder.spec.ts
│ │ ├── stringDecoder.ts
│ │ ├── unpackNullableUtils.spec.ts
│ │ └── unpackNullableUtils.ts
│ ├── encoding/
│ │ ├── bigEndianEncode.ts
│ │ ├── constGeometryVectorEncoder.ts
│ │ ├── embeddedTilesetMetadataEncoder.ts
│ │ ├── encodingUtils.ts
│ │ ├── fastPforEncoder.spec.ts
│ │ ├── fastPforEncoder.ts
│ │ ├── fsstEncoder.ts
│ │ ├── integerEncodingUtils.ts
│ │ ├── integerStreamEncoder.ts
│ │ ├── packNullableUtils.ts
│ │ ├── propertyEncoder.ts
│ │ ├── stringEncoder.ts
│ │ └── zOrderCurveEncoder.ts
│ ├── index.ts
│ ├── metadata/
│ │ ├── tile/
│ │ │ ├── dictionaryType.ts
│ │ │ ├── lengthType.ts
│ │ │ ├── logicalLevelTechnique.ts
│ │ │ ├── logicalStreamType.ts
│ │ │ ├── offsetType.ts
│ │ │ ├── physicalLevelTechnique.ts
│ │ │ ├── physicalStreamType.ts
│ │ │ ├── scalarType.ts
│ │ │ └── streamMetadataDecoder.ts
│ │ └── tileset/
│ │ ├── embeddedTilesetMetadataDecoder.spec.ts
│ │ ├── embeddedTilesetMetadataDecoder.ts
│ │ ├── tilesetMetadata.ts
│ │ ├── typeMap.spec.ts
│ │ └── typeMap.ts
│ ├── mltDecoder.spec.ts
│ ├── mltDecoder.ts
│ ├── mltMetadata.ts
│ ├── synthetic.spec.ts
│ └── vector/
│ ├── constant/
│ │ ├── int32ConstVector.ts
│ │ └── int64ConstVector.ts
│ ├── dictionary/
│ │ └── stringDictionaryVector.ts
│ ├── featureTable.ts
│ ├── filter/
│ │ ├── flatSelectionVector.spec.ts
│ │ ├── flatSelectionVector.ts
│ │ ├── selectionVector.ts
│ │ ├── selectionVectorUtil.spec.ts
│ │ ├── selectionVectorUtils.ts
│ │ ├── sequenceSelectionVector.spec.ts
│ │ └── sequenceSelectionVector.ts
│ ├── fixedSizeVector.ts
│ ├── flat/
│ │ ├── bitVector.ts
│ │ ├── booleanFlatVector.ts
│ │ ├── doubleFlatVector.ts
│ │ ├── floatFlatVector.spec.ts
│ │ ├── floatFlatVector.ts
│ │ ├── int32FlatVector.spec.ts
│ │ ├── int32FlatVector.ts
│ │ ├── int64FlatVector.spec.ts
│ │ ├── int64FlatVector.ts
│ │ └── stringFlatVector.ts
│ ├── fsst-dictionary/
│ │ ├── stringFsstDictionaryVector.spec.ts
│ │ └── stringFsstDictionaryVector.ts
│ ├── geometry/
│ │ ├── constGeometryVector.ts
│ │ ├── constGpuVector.ts
│ │ ├── flatGeometryVector.ts
│ │ ├── flatGpuVector.ts
│ │ ├── geometryType.ts
│ │ ├── geometryVector.ts
│ │ ├── geometryVectorConverter.spec.ts
│ │ ├── geometryVectorConverter.ts
│ │ ├── gpuVector.ts
│ │ ├── topologyVector.ts
│ │ ├── vertexBufferType.ts
│ │ ├── zOrderCurve.spec.ts
│ │ └── zOrderCurve.ts
│ ├── idVector.ts
│ ├── sequence/
│ │ ├── int32SequenceVector.ts
│ │ ├── int64SequenceVector.spec.ts
│ │ ├── int64SequenceVector.ts
│ │ └── sequenceVector.ts
│ ├── variableSizeVector.ts
│ ├── vector.ts
│ └── vectorType.ts
├── tsconfig.json
└── tsconfig.lint.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
---
BasedOnStyle: Google
AccessModifierOffset: -4
AllowShortEnumsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Inline
AllowShortLambdasOnASingleLine: Inline
BinPackArguments: false
BinPackParameters: false
ColumnLimit: 120
IncludeBlocks: Preserve
IndentWidth: 4
PackConstructorInitializers: Never
PenaltyBreakAssignment: 80
SortIncludes: false
SpacesBeforeTrailingComments: 1
Standard: c++20
---
Language: Cpp
---
Language: ObjC
BasedOnStyle: Google
ObjCSpaceAfterProperty: true
...
================================================
FILE: .cursor/rules/karpathy-guidelines.mdc
================================================
---
description:
alwaysApply: true
---
# Karpathy behavioral guidelines
Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
## 1. Think Before Coding
**Don't assume. Don't hide confusion. Surface tradeoffs.**
Before implementing:
- State your assumptions explicitly. If uncertain, ask.
- If multiple interpretations exist, present them - don't pick silently.
- If a simpler approach exists, say so. Push back when warranted.
- If something is unclear, stop. Name what's confusing. Ask.
## 2. Simplicity First
**Minimum code that solves the problem. Nothing speculative.**
- No features beyond what was asked.
- No abstractions for single-use code.
- No "flexibility" or "configurability" that wasn't requested.
- No error handling for impossible scenarios.
- If you write 200 lines and it could be 50, rewrite it.
Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
## 3. Surgical Changes
**Touch only what you must. Clean up only your own mess.**
When editing existing code:
- Don't "improve" adjacent code, comments, or formatting.
- Don't refactor things that aren't broken.
- Match existing style, even if you'd do it differently.
- If you notice unrelated dead code, mention it - don't delete it.
When your changes create orphans:
- Remove imports/variables/functions that YOUR changes made unused.
- Don't remove pre-existing dead code unless asked.
The test: Every changed line should trace directly to the user's request.
## 4. Goal-Driven Execution
**Define success criteria. Loop until verified.**
Transform tasks into verifiable goals:
- "Add validation" → "Write tests for invalid inputs, then make them pass"
- "Fix the bug" → "Write a test that reproduces it, then make it pass"
- "Refactor X" → "Ensure tests pass before and after"
For multi-step tasks, state a brief plan:
```
1. [Step] → verify: [check]
2. [Step] → verify: [check]
3. [Step] → verify: [check]
```
Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
---
**These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.
================================================
FILE: .gitattributes
================================================
* text=auto eol=lf
================================================
FILE: .github/FUNDING.yml
================================================
github: [maplibre]
open_collective: maplibre
================================================
FILE: .github/actions/mlt-setup-java/action.yml
================================================
name: mlt-setup-java
description: Setup Java requirements
inputs: {}
runs:
using: "composite"
steps:
- name: Setup Java
uses: actions/setup-java@v5
with:
distribution: 'temurin'
java-version: '21'
- name: Setup Java Gradle
uses: gradle/actions/setup-gradle@v5
================================================
FILE: .github/actions/mlt-setup-node/action.yml
================================================
name: mlt-setup-node
description: Setup Node-JS requirements
inputs: {}
runs:
using: "composite"
steps:
- name: Setup Node.js
uses: actions/setup-node@v5
with:
node-version-file: 'ts/.nvmrc'
cache: 'npm'
cache-dependency-path: 'ts/package-lock.json'
registry-url: 'https://registry.npmjs.org'
================================================
FILE: .github/actions/mlt-setup-rust/action.yml
================================================
name: mlt-setup-rust
description: Setup Rust requirements
inputs:
toolchain:
description: 'Rust toolchain to install: stable (default), nightly, or msrv'
required: false
default: 'stable'
runs:
using: "composite"
steps:
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall,cargo-hack,fd-find,cargo-insta,cargo-sort,git-delta' }
# Install the requested toolchain (stable, nightly, or msrv)
- if: ${{ inputs.toolchain == 'stable' }}
name: Install Rust stable
uses: dtolnay/rust-toolchain@stable
- if: ${{ inputs.toolchain == 'nightly' }}
name: Install Rust nightly
uses: dtolnay/rust-toolchain@nightly
- if: ${{ inputs.toolchain == 'msrv' }}
name: Read MSRV
id: msrv
shell: bash
run: echo "value=$(just rust::get-msrv)" >> $GITHUB_OUTPUT
- if: ${{ inputs.toolchain == 'msrv' }}
name: Install Rust MSRV ${{ steps.msrv.outputs.value }}
uses: dtolnay/rust-toolchain@stable
with:
toolchain: ${{ steps.msrv.outputs.value }}
- name: Cache Cargo registry and build artifacts
if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
uses: Swatinem/rust-cache@v2
with: { workspaces: rust }
================================================
FILE: .github/dependabot.yml
================================================
# To get started with Dependabot version updates, you'll need to specify which
# package ecosystems to update and where the package manifests are located.
# Please see the documentation for all configuration options:
# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
#
# Config file spec:
# https://docs.github.com/en/enterprise-cloud@latest/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#package-ecosystem
version: 2
updates:
# Maintain dependencies for GitHub Actions
- package-ecosystem: github-actions
directory: "/"
schedule:
interval: weekly
groups:
all-actions-version-updates:
applies-to: version-updates
patterns:
- "*"
all-actions-security-updates:
applies-to: security-updates
patterns:
- "*"
- package-ecosystem: gradle # should this be "maven" or "gradle"?
directory: "/java"
schedule:
interval: daily
time: "02:00"
groups:
all-gradle-version-updates:
applies-to: version-updates
patterns:
- "*"
all-gradle-security-updates:
applies-to: security-updates
patterns:
- "*"
- package-ecosystem: "npm"
directory: "/ts"
schedule:
interval: daily
versioning-strategy: increase
groups:
all-npm-version-updates:
applies-to: version-updates
patterns:
- "*"
all-npm-security-updates:
applies-to: security-updates
patterns:
- "*"
# Update Rust dependencies
- package-ecosystem: cargo
directory: "/rust"
schedule:
interval: daily
time: "02:00"
open-pull-requests-limit: 10
groups:
all-cargo-version-updates:
applies-to: version-updates
patterns:
- "*"
all-cargo-security-updates:
applies-to: security-updates
patterns:
- "*"
================================================
FILE: .github/workflows/autofix.yml
================================================
name: autofix.ci # See https://autofix.ci/security why this name
on:
pull_request:
types: [labeled, opened, synchronize, reopened]
workflow_dispatch:
permissions: {}
jobs:
rust-fmt-toml:
name: Format Cargo.toml
runs-on: ubuntu-latest
permissions:
contents: read
if: |
github.event.action == 'opened' ||
github.event.action == 'synchronize' ||
github.event.action == 'reopened'
steps:
- name: Checkout sources
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with: { persist-credentials: false }
- uses: taiki-e/install-action@763e3324d4fd026c9bd284c504378585777a87d5 # v2.62.57
with: { tool: 'just,cargo-sort' }
- name: Format Cargo.toml
run: just rust::fmt-toml
- uses: autofix-ci/action@c5b2d67aa2274e7b5a18224e8171550871fc7e4a # v1.3.4
with: { commit-message: "chore: sort Cargo.toml" }
rust-sync-versions:
name: Sync Rust-provided bindings version indicators
runs-on: ubuntu-latest
permissions:
contents: read
if: |
github.event.action == 'opened' ||
github.event.action == 'synchronize' ||
github.event.action == 'reopened'
steps:
- name: Checkout sources
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with: { persist-credentials: false }
- name: Setup Rust
run: rustup update stable && rustup default stable
- uses: taiki-e/install-action@763e3324d4fd026c9bd284c504378585777a87d5 # v2.62.57
with: { tool: 'just' }
- run: sudo apt update && sudo apt install -y jq
- name: Sync package.json version from Cargo.toml
working-directory: rust
run: just rust::sync-wasm-version
- name: Sync pyproject.toml version from Cargo.toml
working-directory: rust
run: just rust::sync-pyo3-version
- uses: autofix-ci/action@c5b2d67aa2274e7b5a18224e8171550871fc7e4a # v1.3.4
with: {commit-message: "chore: sync secondary version indicators"}
rust-gen-pyo3-stubs:
name: Regenerate maplibre_tiles.pyi stub
runs-on: ubuntu-latest
permissions:
contents: read
if: |
github.event.action == 'opened' ||
github.event.action == 'synchronize' ||
github.event.action == 'reopened'
steps:
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with: { persist-credentials: false }
- uses: taiki-e/install-action@v2
with: { tool: 'just' }
- uses: ./.github/actions/mlt-setup-rust
- name: Regenerate stub
run: just rust::sync-pyo3-stubs
# run pre-commit as a formatting tiebreaker
- name: Install uv
uses: astral-sh/setup-uv@681c641aba71e4a1c380be3ab5e12ad51f415867 # v7.1.6
- run: uvx pre-commit run --all-files
continue-on-error: true
- uses: autofix-ci/action@c5b2d67aa2274e7b5a18224e8171550871fc7e4a
with: {commit-message: "chore: regenerate maplibre_tiles.pyi stub"}
bless:
name: Bless test output
runs-on: ubuntu-latest
permissions:
contents: read
if: |
github.event.action == 'labeled' &&
github.event.label.name == 'bless'
steps:
- name: Checkout sources
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with: { persist-credentials: false }
- uses: BRAINSia/free-disk-space@7048ffbf50819342ac964ef3998a51c2564a8a75 # v2.1.3
with:
tool-cache: false
mandb: false
android: true
dotnet: true
haskell: true
large-packages: false
docker-images: false
swap-storage: true
- name: Setup Rust
run: rustup update stable && rustup default stable
- name: Install just
uses: taiki-e/install-action@cc33365ec7e3350bc47bf935f247582cc6f68344 # v2.65.12
with:
tool: just,cargo-binstall
- name: Setup Node.js
uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
- run: just bless
continue-on-error: true
# run pre-commit as a formatting tiebreaker
- name: Install uv
uses: astral-sh/setup-uv@681c641aba71e4a1c380be3ab5e12ad51f415867 # v7.1.6
- run: uvx pre-commit run --all-files
continue-on-error: true
- uses: autofix-ci/action@c5b2d67aa2274e7b5a18224e8171550871fc7e4a # v1.3.4
with: {commit-message: "chore: update blessed test snapshots across all components"}
================================================
FILE: .github/workflows/ci.yml
================================================
name: CI
on:
pull_request:
push:
branches: [main]
workflow_dispatch:
jobs:
changes:
runs-on: ubuntu-latest
outputs:
rust: ${{ steps.filter.outputs.rust }}
java: ${{ steps.filter.outputs.java }}
ts: ${{ steps.filter.outputs.ts }}
cpp: ${{ steps.filter.outputs.cpp }}
steps:
- uses: actions/checkout@v6.0.2
- uses: dorny/paths-filter@v4
id: filter
with:
filters: |
rust:
- 'justfile'
- 'rust/mod.just'
- '.github/**'
- 'rust/**'
- 'test/**'
java:
- 'justfile'
- 'java/mod.just'
- '.github/**'
- 'java/**'
- 'test/**'
ts:
- 'justfile'
- 'ts/mod.just'
- '.github/**'
- 'ts/**'
- 'test/**'
cpp:
- 'justfile'
- 'cpp/mod.just'
- '.github/**'
- 'cpp/**'
- 'test/**'
rust:
needs: changes
if: needs.changes.outputs.rust == 'true'
uses: ./.github/workflows/rust.yml
with:
run-release: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
secrets: inherit
permissions:
contents: write
id-token: write
java:
needs: changes
if: needs.changes.outputs.java == 'true'
uses: ./.github/workflows/java.yml
permissions:
id-token: write
contents: read
ts:
needs: changes
if: needs.changes.outputs.ts == 'true'
uses: ./.github/workflows/ts.yml
permissions:
contents: read
cpp:
needs: changes
if: needs.changes.outputs.cpp == 'true'
uses: ./.github/workflows/cpp.yml
permissions:
id-token: write
contents: read
docs:
uses: ./.github/workflows/gh-pages.yml
permissions:
contents: write
ci-passed:
needs: [rust, java, ts, cpp, docs]
if: always()
runs-on: ubuntu-latest
steps:
- run: echo "${{ toJSON(needs) }}"
- if: contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled')
run: exit 1
================================================
FILE: .github/workflows/cpp.yml
================================================
name: C++ CI
on:
workflow_call:
workflow_dispatch:
jobs:
cpp-build:
permissions:
id-token: write # for OIDC Codecov
strategy:
matrix:
os: [macos-15, ubuntu-24.04]
runs-on: ${{ matrix.os }}
steps:
- name: Checkout repository
uses: actions/checkout@v6.0.2
with:
submodules: recursive
fetch-depth: 1
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version-file: 'cpp/.nvmrc'
- name: install gcovr (macOS)
if: runner.os == 'macOS'
run: brew install gcovr
- name: install gcovr (Linux)
if: runner.os == 'Linux'
run: pip3 install gcovr
- name: Build, test and generate coverage report
run: just -v cpp::coverage
- name: Upload coverage to Codecov
if: github.repository_owner == 'maplibre'
uses: codecov/codecov-action@v6
with:
use_oidc: true
fail_ci_if_error: true
disable_file_fixes: true
disable_search: true
files: cpp/build/coverage.xml
- name: Sanity test for mlt-cpp-json tool
run: just -v cpp::test-json
- name: Build with Bazel
run: just -v cpp::bazel-build
- run: just -v assert-git-is-clean
================================================
FILE: .github/workflows/dependabot.yml
================================================
name: Dependabot auto-merge
on: pull_request
permissions: write-all
jobs:
dependabot:
runs-on: ubuntu-latest
if: github.actor == 'dependabot[bot]'
steps:
- name: Dependabot metadata
id: metadata
uses: dependabot/fetch-metadata@v3
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
- name: Approve Dependabot PRs
if: steps.metadata.outputs.update-type == 'version-update:semver-patch'
run: gh pr review --approve "$PR_URL"
env:
PR_URL: ${{ github.event.pull_request.html_url }}
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- name: Enable auto-merge for Dependabot PRs
if: steps.metadata.outputs.update-type == 'version-update:semver-patch'
run: gh pr merge --auto --squash "$PR_URL"
env:
PR_URL: ${{ github.event.pull_request.html_url }}
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
================================================
FILE: .github/workflows/gh-pages.yml
================================================
name: Publish docs
on:
workflow_call:
workflow_dispatch:
jobs:
gh-pages:
runs-on: ubuntu-latest
steps:
- name: Checkout 🛎️
uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v4
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- name: Build MLT documentation
run: just -v docs-build
- name: Deploy 🚀
if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main' && github.repository_owner == 'maplibre'
uses: JamesIves/github-pages-deploy-action@d92aa235d04922e8f08b40ce78cc5442fcfbfa2f # v4.8.0
with: { branch: gh-pages, folder: site }
- run: just -v assert-git-is-clean
================================================
FILE: .github/workflows/hotpath-comment.yml
================================================
name: Rust Hotpath Comment
on:
workflow_run:
workflows: ["Rust Hotpath Profile"]
types:
- completed
permissions:
contents: read
pull-requests: write
jobs:
comment:
runs-on: ubuntu-latest
if: ${{ github.event.workflow_run.conclusion == 'success' }}
steps:
- uses: actions/checkout@v6.0.2
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2
- uses: actions/download-artifact@v8
with:
name: profile-metrics
path: /tmp/metrics/
github-token: ${{ secrets.GITHUB_TOKEN }}
run-id: ${{ github.event.workflow_run.id }}
- name: Install hotpath-utils CLI
run: cargo install hotpath --bin hotpath-utils --features=utils
- name: Post PR comment
env:
GH_TOKEN: ${{ github.token }}
run: |
set -euo pipefail
GITHUB_BASE_REF=$(cat /tmp/metrics/base_ref.txt)
export GITHUB_BASE_REF
GITHUB_HEAD_REF=$(cat /tmp/metrics/head_ref.txt)
export GITHUB_HEAD_REF
hotpath-utils profile-pr \
--head-metrics /tmp/metrics/head_timing.json \
--base-metrics /tmp/metrics/base_timing.json \
--github-token "$GH_TOKEN" \
--pr-number "$(cat /tmp/metrics/pr_number.txt)" \
--benchmark-id "mlt-convert"
================================================
FILE: .github/workflows/hotpath-profile.yml
================================================
name: Rust Hotpath Profile
on:
pull_request:
paths:
- "rust/**"
permissions:
contents: read
jobs:
profile:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
with:
fetch-depth: 0
- uses: ./.github/actions/mlt-setup-rust
- name: Create metrics directory
run: mkdir -p /tmp/metrics
# ── Download benchmark tiles (cached) ──────────────────────────────
# 95 fixture tiles are too few for stable hotpath numbers.
# See `just rust::download-benchmark-tiles` for details.
- name: Cache benchmark tiles
id: cache-tiles
uses: actions/cache@v5
with:
path: /tmp/benchmark-tiles
key: hotpath-tiles-protomaps-z6-v1
- name: Download benchmark tiles
if: steps.cache-tiles.outputs.cache-hit != 'true'
env:
GITHUB_TOKEN: ${{ github.token }}
run: just rust::download-benchmark-tiles
- name: Head benchmark (timing + alloc)
working-directory: rust
env:
HOTPATH_OUTPUT_FORMAT: json
HOTPATH_OUTPUT_PATH: /tmp/metrics/head_timing.json
run: |
cargo run --release -p mlt --features='__hotpath,__hotpath-alloc' -- \
convert /tmp/benchmark-tiles/ /tmp/mlt-head-out/
- name: Checkout base
run: git checkout ${{ github.event.pull_request.base.sha }}
- name: Base benchmark (timing + alloc)
working-directory: rust
env:
HOTPATH_OUTPUT_FORMAT: json
HOTPATH_OUTPUT_PATH: /tmp/metrics/base_timing.json
run: |
cargo run --release -p mlt --features='__hotpath,__hotpath-alloc' -- \
convert /tmp/benchmark-tiles/ /tmp/mlt-base-out/
- name: Save PR metadata
env:
PR_NUMBER: ${{ github.event.pull_request.number }}
BASE_REF: ${{ github.base_ref }}
HEAD_REF: ${{ github.head_ref }}
run: |
echo "$PR_NUMBER" > /tmp/metrics/pr_number.txt
echo "$BASE_REF" > /tmp/metrics/base_ref.txt
echo "$HEAD_REF" > /tmp/metrics/head_ref.txt
- uses: actions/upload-artifact@v7
with:
name: profile-metrics
path: /tmp/metrics/
retention-days: 1
================================================
FILE: .github/workflows/java-release.yml
================================================
name: Java - Release
on:
push:
tags:
- 'java-v*.*.*'
workflow_dispatch:
jobs:
release:
runs-on: ubuntu-latest
permissions:
contents: write
steps:
- name: Checkout code
uses: actions/checkout@v6.0.2
- name: Set up JDK
uses: actions/setup-java@v5
with:
java-version: '21'
distribution: 'temurin'
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- name: Get version from tag
id: get_version
run: |
version="$(just ci-extract-version java ${{ github.ref_name }})"
echo version="$version" >> "$GITHUB_ENV"
- name: Make gradlew executable
run: chmod +x ./java/gradlew
- name: Publish to Maven Central
working-directory: java
run: ./gradlew publishToMavenCentral -Pversion=${{ env.version }}
env:
ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.MAVEN_CENTRAL_PASSWORD }}
ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.SIGNING_PRIVATE_KEY }}
ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.SIGNING_PASSWORD }}
- name: Build CLI tool
working-directory: java
run: ./gradlew cli
- run: just -v assert-git-is-clean
- name: Rename CLI artifacts
run: |
cp java/mlt-cli/build/libs/encode.jar mlt-encode.jar
cp java/mlt-cli/build/libs/decode.jar mlt-decode.jar
- name: Add CLI artifacts to GitHub release
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
tag_name: java-v${{ env.version }}
fail_on_unmatched_files: true
name: java-v${{ env.version }}
files: |
mlt-encode.jar
mlt-decode.jar
================================================
FILE: .github/workflows/java.yml
================================================
name: Java CI
on:
workflow_call:
workflow_dispatch:
defaults:
run:
shell: bash
jobs:
test-java:
permissions:
id-token: write # for OIDC Codecov
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-latest, windows-latest, macos-latest]
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- uses: ./.github/actions/mlt-setup-java
- run: just -v java::env-info
- if: matrix.os == 'ubuntu-latest'
name: Lint Java code. If fails, run `just java::fmt` to reformat, and `just java::lint` to see issues locally
run: just -v java::lint
- run: just -v java::test-coverage
- run: just -v java::test-cli
- name: Test Maven local publishing
run: just -v java::test-publish
- run: npm ci
working-directory: java/encoding-server
- run: npm run lint
working-directory: java/encoding-server
- run: just -v assert-git-is-clean
- name: Upload coverage to Codecov
if: github.repository_owner == 'maplibre'
uses: codecov/codecov-action@v6
with:
use_oidc: true
directory: java
- name: Test synthetic MLT generation
run: just -v java::ci-check-synthetic-mlts
================================================
FILE: .github/workflows/python-release.yml
================================================
# This file is autogenerated by maturin v1.12.4
# To update, run the following command, but make sure to keep the adjustments that we did.
# maturin generate-ci github
name: Python Release
on:
push:
branches:
- main
tags:
- 'python-mlt-v*'
pull_request:
paths:
- 'justfile'
- 'rust/mod.just'
- '.github/**'
- 'rust/**'
- 'test/**'
workflow_dispatch:
permissions:
contents: read
jobs:
linux:
runs-on: ${{ matrix.platform.runner }}
strategy:
fail-fast: false
matrix:
platform:
- runner: ubuntu-22.04
target: x86_64
# FIXME: FSST does not seem to support 32bit targets
#- runner: ubuntu-22.04
# target: x86
# FIXME: Python::initialize not avaliable for linking
#- runner: ubuntu-22.04
# target: aarch64
# FIXME: error: unknown type name '__m128i' and related
#- runner: ubuntu-22.04
# target: armv7
# FIXME: cpp standard mismatch
#- runner: ubuntu-22.04
# target: s390x
# FIXME: error: unknown type name '__m128i' and related
#- runner: ubuntu-22.04
# target: ppc64le
steps:
- uses: actions/checkout@v6
- uses: ./.github/actions/mlt-setup-rust
- uses: actions/setup-python@v6
with: { python-version: '3.x' }
- name: Build wheels
uses: PyO3/maturin-action@v1
with:
target: ${{ matrix.platform.target }}
args: --release --zig --out dist --find-interpreter --locked --compatibility pypi --future-incompat-report --manifest-path rust/mlt-py/Cargo.toml
sccache: false
manylinux: auto
- name: Upload wheels
uses: actions/upload-artifact@v7
with:
name: wheels-linux-${{ matrix.platform.target }}
path: dist
# FIXME: our --bin bins/stub-gen requires pyo3::Python::initialize, but unsure how to do that on musllinux. We don't need it for the library!
#musllinux:
# runs-on: ${{ matrix.platform.runner }}
# strategy:
# fail-fast: false
# matrix:
# platform:
# - runner: ubuntu-22.04
# target: x86_64
# - runner: ubuntu-22.04
# target: x86
# - runner: ubuntu-22.04
# target: aarch64
# - runner: ubuntu-22.04
# # FIXME: FSST does not seem to support 32bit targets
# #- runner: ubuntu-22.04
# # target: x86
# # FIXME: Python::initialize not avaliable for linking
# #- runner: ubuntu-22.04
# # target: aarch64
# # FIXME: error: unknown type name '__m128i' and related
# #- runner: ubuntu-22.04
# # target: armv7
# steps:
# - uses: actions/checkout@v6
# - uses: ./.github/actions/mlt-setup-rust
# - uses: actions/setup-python@v6
# with: { python-version: '3.x' }
# - name: Build wheels
# uses: PyO3/maturin-action@v1
# with:
# target: ${{ matrix.platform.target }}
# args: --release --zig --out dist --find-interpreter --locked --compatibility pypi --future-incompat-report --manifest-path rust/mlt-py/Cargo.toml
# sccache: false
# manylinux: musllinux_1_2
# - name: Upload wheels
# uses: actions/upload-artifact@v7
# with:
# name: wheels-musllinux-${{ matrix.platform.target }}
# path: dist
# FIXME: Failed to run `zig cc -v` with status exit code: 1: error: unable to create compilation: LibCStdLibHeaderNotFound
#windows:
# runs-on: ${{ matrix.platform.runner }}
# strategy:
# fail-fast: false
# matrix:
# platform:
# - runner: windows-latest
# target: x64
# python_arch: x64
# - runner: windows-latest
# target: x86
# python_arch: x86
# - runner: windows-11-arm
# target: aarch64
# python_arch: arm64
# steps:
# - uses: actions/checkout@v6
# - uses: ./.github/actions/mlt-setup-rust
# - uses: actions/setup-python@v6
# with:
# python-version: 3.13
# architecture: ${{ matrix.platform.python_arch }}
# - name: Build wheels
# uses: PyO3/maturin-action@v1
# with:
# target: ${{ matrix.platform.target }}
# args: --release --zig --out dist --find-interpreter --locked --compatibility pypi --future-incompat-report --manifest-path rust/mlt-py/Cargo.toml
# sccache: false
# - name: Upload wheels
# uses: actions/upload-artifact@v7
# with:
# name: wheels-windows-${{ matrix.platform.target }}
# path: dist
macos:
runs-on: ${{ matrix.platform.runner }}
strategy:
fail-fast: false
matrix:
platform:
- runner: macos-15-intel
target: x86_64
- runner: macos-latest
target: aarch64
steps:
- uses: actions/checkout@v6
- uses: ./.github/actions/mlt-setup-rust
- uses: actions/setup-python@v6
with: { python-version: '3.x' }
- name: Build wheels
uses: PyO3/maturin-action@v1
with:
target: ${{ matrix.platform.target }}
args: --release --zig --out dist --find-interpreter --locked --compatibility pypi --future-incompat-report --manifest-path rust/mlt-py/Cargo.toml
sccache: false
- name: Upload wheels
uses: actions/upload-artifact@v7
with:
name: wheels-macos-${{ matrix.platform.target }}
path: dist
sdist:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
- name: Build sdist
uses: PyO3/maturin-action@v1
with:
command: sdist
args: --out dist --manifest-path rust/mlt-py/Cargo.toml
- name: Upload sdist
uses: actions/upload-artifact@v7
with: { name: 'wheels-sdist', path: 'dist' }
release:
name: Release
runs-on: ubuntu-latest
if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
needs:
- linux
# FIXME: does seem to require dev-only dependencys
#- musllinux
# FIXME: Failed to run `zig cc -v` with status exit code: 1: error: unable to create compilation: LibCStdLibHeaderNotFound
#- windows
- macos
- sdist
permissions:
# Use to sign the release artifacts
id-token: write
# Used to upload release artifacts
contents: write
# Used to generate artifact attestation
attestations: write
steps:
- uses: actions/download-artifact@v8
- name: Generate artifact attestation
uses: actions/attest-build-provenance@v4
with: { subject-path: 'wheels-*/*' }
- name: Install uv
if: ${{ startsWith(github.ref, 'refs/tags/') }}
uses: astral-sh/setup-uv@v7
- name: Publish to PyPI
if: ${{ startsWith(github.ref, 'refs/tags/') }}
run: uv publish 'wheels-*/*'
================================================
FILE: .github/workflows/rust.yml
================================================
name: Rust CI
on:
workflow_call:
inputs:
run-release:
type: boolean
default: false
workflow_dispatch:
jobs:
lint:
name: Lint
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
- run: just -v rust::ci-check
- run: just -v rust::ci-lint
coverage:
name: Coverage
permissions:
id-token: write # for OIDC Codecov
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
with: { toolchain: nightly } # because of covs --doctests
- uses: taiki-e/install-action@v2
with: { tool: "cargo-llvm-cov" }
- run: just -v rust::ci-coverage
- name: Upload coverage to Codecov
if: github.repository_owner == 'maplibre'
uses: codecov/codecov-action@v6
with:
use_oidc: true
fail_ci_if_error: true
disable_search: true
files: rust/target/llvm-cov/lcov.info
- run: just -v assert-git-is-clean
test-wasm:
name: Test wasm
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
- run: rustup component add rust-src --toolchain nightly-x86_64-unknown-linux-gnu
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version-file: "rust/mlt-wasm/.nvmrc"
cache: "npm"
cache-dependency-path: "rust/mlt-wasm/package-lock.json"
- run: just -v rust::ci-test-wasm
fuzz:
name: Fuzz ${{ matrix.target }}
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
include:
- target: layer
- target: decoded_layer
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
with: { toolchain: nightly }
- run: just -v rust::ci-fuzz-build ${{ matrix.target }}
- if: matrix.target == 'layer'
run: just -v rust::fuzz-seed ${{ matrix.target }}
- run: just -v rust::ci-fuzz-run ${{ matrix.target }}
- name: Generate fuzz coverage
if: github.repository_owner == 'maplibre'
run: just -v rust::ci-fuzz-cov ${{ matrix.target }}
- name: Upload fuzz coverage artifact
if: github.repository_owner == 'maplibre'
uses: actions/upload-artifact@v7
with:
name: fuzz-coverage-${{ matrix.target }}
path: rust/target/llvm-cov/fuzz-${{ matrix.target }}.lcov
# MSRV Testing is not really needed at this stage of code completeness
# test-msrv:
# name: Test MSRV
# runs-on: ubuntu-latest
# steps:
# - uses: actions/checkout@v6.0.2
# - uses: ./.github/actions/mlt-setup-rust
# with: { toolchain: msrv }
# - run: just -v rust::ci-test-msrv
test-publish:
name: Test workspace publishing using --dry-run
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
- name: Test workspace publishing
run: just -v rust::test-publish
- run: just -v assert-git-is-clean
build-release-binaries:
name: Build release binaries for ${{ matrix.target }}
strategy:
fail-fast: false
matrix:
include:
- os: ubuntu-latest
target: x86_64-unknown-linux-gnu
artifact_name: mlt-x86_64-unknown-linux-gnu.tar.gz
- os: ubuntu-24.04-arm
target: aarch64-unknown-linux-gnu
artifact_name: mlt-aarch64-unknown-linux-gnu.tar.gz
- os: macos-latest
target: aarch64-apple-darwin
artifact_name: mlt-aarch64-apple-darwin.tar.gz
- os: windows-latest
target: x86_64-pc-windows-msvc
artifact_name: mlt-x86_64-pc-windows-msvc.zip
runs-on: ${{ matrix.os }}
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
- run: just -v rust::ci-build-release ${{ matrix.target }} ${{ matrix.artifact_name }}
- name: Upload artifacts
uses: actions/upload-artifact@v7
with:
name: ${{ matrix.artifact_name }}
path: ${{ matrix.artifact_name }}
build-wasm-npm:
name: Build @maplibre/mlt-wasm npm package
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
with: { toolchain: nightly }
- run: rustup component add rust-src --toolchain nightly-x86_64-unknown-linux-gnu
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version-file: "rust/mlt-wasm/.nvmrc"
cache: "npm"
cache-dependency-path: "rust/mlt-wasm/package-lock.json"
- name: Build
run: just -v rust::wasm-build
- name: Merge license files into LICENSE.txt
working-directory: rust/mlt-wasm
run: |
{
echo "===== MIT License ====="
cat ../../LICENSE-MIT
echo
echo "===== Apache License 2.0 ====="
cat ../../LICENSE-APACHE
} > LICENSE.txt
- name: Pack
working-directory: rust/mlt-wasm
run: npm pack
- name: Upload npm package artifact
uses: actions/upload-artifact@v7
with:
name: mlt-wasm-npm
path: rust/mlt-wasm/maplibre-mlt-wasm-*.tgz
# This job checks if any of the previous jobs failed or were canceled.
# This approach also allows some jobs to be skipped if they are not needed.
ci-passed-rust:
needs:
- lint
- coverage
# re-enable once we have stability guarantees regarding MSRV
# - test-msrv
- test-wasm
- build-release-binaries
- test-publish
- build-wasm-npm
if: always()
runs-on: ubuntu-latest
steps:
- name: Result of the needed steps
run: echo "${{ toJSON(needs) }}"
- if: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') }}
run: exit 1
# Release unpublished packages or create a PR with changes
release-plz:
needs: [ci-passed-rust]
if: |
always()
&& needs.ci-passed-rust.result == 'success'
&& inputs.run-release
&& github.repository_owner == 'maplibre'
runs-on: ubuntu-latest
permissions:
contents: read
id-token: write
concurrency:
group: release-plz-${{ github.ref }}
cancel-in-progress: false
steps:
- run: rustup update stable && rustup default stable
- uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
with: { fetch-depth: 0, persist-credentials: false }
- uses: ./.github/actions/mlt-setup-rust
- name: Publish to crates.io if crate's version is newer
uses: release-plz/action@1528104d2ca23787631a1c1f022abb64b34c1e11 # v0.5.128
id: release
with: { command: release, manifest_path: ./rust/Cargo.toml }
env:
GITHUB_TOKEN: ${{ secrets.RELEASE_PLZ_TOKEN }}
- if: ${{ steps.release.outputs.releases_created == 'false' }}
name: If version is the same, create a PR proposing new version and changelog for the next release
uses: release-plz/action@1528104d2ca23787631a1c1f022abb64b34c1e11 # v0.5.128
with: { command: release-pr, manifest_path: ./rust/Cargo.toml }
env:
GITHUB_TOKEN: ${{ secrets.RELEASE_PLZ_TOKEN }}
outputs:
releases_created: ${{ steps.release.outputs.releases_created }}
releases: ${{ steps.release.outputs.releases }}
upload-release-binaries:
name: Upload release binaries to GitHub releases
needs: [release-plz]
if: ${{ needs.release-plz.outputs.releases_created == 'true' }}
runs-on: ubuntu-latest
permissions:
contents: write
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: "just" }
- name: Get mlt version for release tag
id: get_version
shell: bash
run: just -v rust::ci-get-release-info mlt >> $GITHUB_OUTPUT
- name: Download all artifacts
uses: actions/download-artifact@v8
with: { path: artifacts }
- name: Add binaries to GitHub release
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
tag_name: ${{ steps.get_version.outputs.tag }}
files: |
artifacts/**/*.tar.gz
artifacts/**/*.zip
fail_on_unmatched_files: true
# Publish @maplibre/mlt-wasm to npm after mlt-wasm is released to crates.io.
# The npm package tarball was already built and uploaded as an artifact by build-wasm-npm.
publish-wasm-npm:
name: Publish @maplibre/mlt-wasm to npm
needs: [release-plz]
if: |
needs.release-plz.outputs.releases_created == 'true'
&& contains(fromJSON(needs.release-plz.outputs.releases || '[]').*.package_name, 'mlt-wasm')
runs-on: ubuntu-latest
permissions:
contents: write
id-token: write
steps:
- name: Get mlt-wasm release version
id: version
env:
RELEASES: ${{ needs.release-plz.outputs.releases }}
run: |
echo "value=$(echo "$RELEASES" | jq -r '.[] | select(.package_name == "mlt-wasm") | .version')" >> $GITHUB_OUTPUT
- name: Set prerelease flag
run: |
version="${{ steps.version.outputs.value }}"
echo version="$version" >> "$GITHUB_ENV"
if [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
echo prerelease=false >> "$GITHUB_ENV"
else
echo prerelease=true >> "$GITHUB_ENV"
fi
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version: "24"
registry-url: "https://registry.npmjs.org"
- name: Download npm package artifact
uses: actions/download-artifact@v8
with:
name: mlt-wasm-npm
path: mlt-wasm-pkg
- name: Release (GitHub) - Create Draft
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
name: mlt-wasm-js-v${{ env.version }}
tag_name: mlt-wasm-js-v${{ env.version }}
prerelease: ${{ env.prerelease }}
draft: true
- name: Publish npm package
run: |
package_tgz="$(find mlt-wasm-pkg -type f -name 'maplibre-mlt-wasm-*.tgz' -print -quit)"
test -n "$package_tgz" || { echo "::error::Package file not found in mlt-wasm-pkg"; exit 1; }
npm publish "$package_tgz" --access=public
- name: Publish GitHub release (remove draft)
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
tag_name: mlt-wasm-js-v${{ env.version }}
name: mlt-wasm-js-v${{ env.version }}
draft: false
================================================
FILE: .github/workflows/ts-bump-version.yml
================================================
name: Manual TypeScript Version Bump
on:
workflow_dispatch:
inputs:
release_type:
type: choice
description: 'Type of version bump'
options:
- major
- minor
- patch
- premajor
- preminor
- prepatch
- prerelease
jobs:
js-bump-version:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- name: Update version, commit, and create tag
working-directory: ts
run: |
npm version ${{ github.event.inputs.release_type }} --no-git-tag-version
echo version="$(node -p "require('./package.json').version")" >> "$GITHUB_ENV"
- name: Create Pull Request
uses: peter-evans/create-pull-request@5f6978faf089d4d20b00c7766989d076bb2fc7f1 # v8.1.1
with:
commit-message: bump @maplibre/mlt version to ${{ env.version }}
branch: mlt-js-version-${{ env.version }}
title: bump @maplibre/mlt version to ${{ env.version }}
- run: just -v assert-git-is-clean
================================================
FILE: .github/workflows/ts-release.yml
================================================
name: TypeScript - Release
permissions:
id-token: write # Required for trusted publishing
contents: write
on:
push:
branches:
- main
workflow_dispatch:
jobs:
release-check:
name: Check if version changed
runs-on: ubuntu-latest
defaults:
run:
shell: bash
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- name: Check if version has been updated
id: check
uses: EndBug/version-check@095362f3cd50f690c8fa0e6afeea81834bd8d320
with:
file-name: ts/package.json
- run: just -v assert-git-is-clean
outputs:
publish: ${{ steps.check.outputs.changed }}
release:
name: Release
needs: release-check
if: ${{ needs.release-check.outputs.publish == 'true' }}
runs-on: ubuntu-latest
defaults:
run:
working-directory: ts
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- uses: ./.github/actions/mlt-setup-node
- name: Get version
run: |
version="$(node -p "require('./package.json').version")"
echo version="$version" >> "$GITHUB_ENV"
if [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
echo prerelease=false >> "$GITHUB_ENV"
else
echo prerelease=true >> "$GITHUB_ENV"
fi
- name: Install
run: npm ci
- name: Build
run: npm run build
- name: Merge license files into LICENSE.txt
run: |
{
echo "===== MIT License ====="
cat ../LICENSE-MIT
echo
echo "===== Apache License 2.0 ====="
cat ../LICENSE-APACHE
} > LICENSE.txt
- name: Release (GitHub) - Create Draft
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
name: js-v${{ env.version }}
tag_name: js-v${{ env.version }}
prerelease: ${{ env.prerelease }}
draft: true
- if: github.repository_owner == 'maplibre'
name: Publish npm package
run: npm publish --access=public
- name: Publish GitHub release (remove draft)
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
tag_name: js-v${{ env.version }}
name: js-v${{ env.version }}
draft: false
- run: just -v assert-git-is-clean
================================================
FILE: .github/workflows/ts.yml
================================================
name: TypeScript CI
on:
workflow_call:
workflow_dispatch:
defaults:
run:
shell: bash
jobs:
test-js:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- uses: ./.github/actions/mlt-setup-node
- name: Lint JS code. If fails, run `just ts::fmt` to reformat, and `just ts::lint` to see issues locally
run: just -v ts::lint
- run: just -v ts::test
- run: just -v ts::build
- name: Codecov upload
if: "github.repository_owner == 'maplibre' && !cancelled()"
uses: codecov/codecov-action@v6
with:
files: ts/coverage/coverage-final.json
- run: just -v assert-git-is-clean
================================================
FILE: .gitignore
================================================
*.class
*.diff.geojson
*.gcov
*.log
*.new.geojson
*.actual.json
.DS_Store
.cache/
.idea/
.kotlin
.venv
.vscode/
MODULE.bazel.lock
bazel-*
bin/
codecov*
coverage/
dist/
site/
tmp/
node_modules
================================================
FILE: .gitmodules
================================================
[submodule "cpp/vendor/googletest"]
path = cpp/vendor/googletest
url = https://github.com/google/googletest.git
[submodule "cpp/vendor/simde"]
path = cpp/vendor/simde
url = https://github.com/simd-everywhere/simde.git
[submodule "cpp/vendor/fastpfor"]
path = cpp/vendor/fastpfor
url = https://github.com/fast-pack/FastPFor.git
[submodule "cpp/vendor/json"]
path = cpp/vendor/json
url = https://github.com/nlohmann/json.git
================================================
FILE: .pre-commit-config.yaml
================================================
# See https://pre-commit.com for more information
# See https://pre-commit.com/hooks.html for more hooks
# exclusions should be separated with a pipe (|) character and a newline
exclude: |
(?x)^(
test/expected/.*
|java/gradlew(\.bat)?
|\.cursor/rules/.*
)$
ci:
autoupdate_schedule: monthly
# sometimes fails https://github.com/keith/pre-commit-buildifier/issues/13
skip: [ buildifier ]
repos:
- repo: https://github.com/pre-commit/pre-commit-hooks
rev: v6.0.0
hooks:
- id: check-added-large-files
args: ['--maxkb=553']
- id: check-executables-have-shebangs
- id: check-json
exclude: '.+/tsconfig.json'
- id: check-shebang-scripts-are-executable
exclude: '.+\.rs' # would be triggered by #![some_attribute]
- id: check-symlinks
- id: check-toml
- id: check-yaml
args: [ --allow-multiple-documents ]
exclude: mkdocs.yml
- id: destroyed-symlinks
- id: end-of-file-fixer
- id: mixed-line-ending
args: [ --fix=lf ]
- id: trailing-whitespace
- repo: https://github.com/pre-commit/mirrors-clang-format
rev: v22.1.2
hooks:
- id: clang-format
types: [ c++ ]
args: ["-style=file:.clang-format"]
- repo: https://github.com/Mateusz-Grzelinski/actionlint-py
rev: v1.7.12.24
hooks:
- id: actionlint
additional_dependencies: [ shellcheck-py ]
exclude: '\.github/workflows/rust(-legacy)?\.yml'
- repo: local
hooks:
- id: cargo-fmt
name: Rust Format
description: "Automatically format Rust code with cargo fmt"
entry: sh -c "cd rust && cargo fmt --all"
language: rust
pass_filenames: false
- repo: https://github.com/keith/pre-commit-buildifier
rev: 8.5.1.1
hooks:
- id: buildifier
- repo: https://github.com/biomejs/pre-commit
rev: v2.4.10
hooks:
- id: biome-check
args: [--unsafe]
exclude: '.*\.json$'
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Code of conduct
[](https://github.com/maplibre/maplibre/blob/main/CODE_OF_CONDUCT.md)
================================================
FILE: LICENSE-APACHE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2024 MapLibre contributors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: LICENSE-CC0
================================================
Creative Commons Legal Code
CC0 1.0 Universal
CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
HEREUNDER.
Statement of Purpose
The laws of most jurisdictions throughout the world automatically confer
exclusive Copyright and Related Rights (defined below) upon the creator
and subsequent owner(s) (each and all, an "owner") of an original work of
authorship and/or a database (each, a "Work").
Certain owners wish to permanently relinquish those rights to a Work for
the purpose of contributing to a commons of creative, cultural and
scientific works ("Commons") that the public can reliably and without fear
of later claims of infringement build upon, modify, incorporate in other
works, reuse and redistribute as freely as possible in any form whatsoever
and for any purposes, including without limitation commercial purposes.
These owners may contribute to the Commons to promote the ideal of a free
culture and the further production of creative, cultural and scientific
works, or to gain reputation or greater distribution for their Work in
part through the use and efforts of others.
For these and/or other purposes and motivations, and without any
expectation of additional consideration or compensation, the person
associating CC0 with a Work (the "Affirmer"), to the extent that he or she
is an owner of Copyright and Related Rights in the Work, voluntarily
elects to apply CC0 to the Work and publicly distribute the Work under its
terms, with knowledge of his or her Copyright and Related Rights in the
Work and the meaning and intended legal effect of CC0 on those rights.
1. Copyright and Related Rights. A Work made available under CC0 may be
protected by copyright and related or neighboring rights ("Copyright and
Related Rights"). Copyright and Related Rights include, but are not
limited to, the following:
i. the right to reproduce, adapt, distribute, perform, display,
communicate, and translate a Work;
ii. moral rights retained by the original author(s) and/or performer(s);
iii. publicity and privacy rights pertaining to a person's image or
likeness depicted in a Work;
iv. rights protecting against unfair competition in regards to a Work,
subject to the limitations in paragraph 4(a), below;
v. rights protecting the extraction, dissemination, use and reuse of data
in a Work;
vi. database rights (such as those arising under Directive 96/9/EC of the
European Parliament and of the Council of 11 March 1996 on the legal
protection of databases, and under any national implementation
thereof, including any amended or successor version of such
directive); and
vii. other similar, equivalent or corresponding rights throughout the
world based on applicable law or treaty, and any national
implementations thereof.
2. Waiver. To the greatest extent permitted by, but not in contravention
of, applicable law, Affirmer hereby overtly, fully, permanently,
irrevocably and unconditionally waives, abandons, and surrenders all of
Affirmer's Copyright and Related Rights and associated claims and causes
of action, whether now known or unknown (including existing as well as
future claims and causes of action), in the Work (i) in all territories
worldwide, (ii) for the maximum duration provided by applicable law or
treaty (including future time extensions), (iii) in any current or future
medium and for any number of copies, and (iv) for any purpose whatsoever,
including without limitation commercial, advertising or promotional
purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
member of the public at large and to the detriment of Affirmer's heirs and
successors, fully intending that such Waiver shall not be subject to
revocation, rescission, cancellation, termination, or any other legal or
equitable action to disrupt the quiet enjoyment of the Work by the public
as contemplated by Affirmer's express Statement of Purpose.
3. Public License Fallback. Should any part of the Waiver for any reason
be judged legally invalid or ineffective under applicable law, then the
Waiver shall be preserved to the maximum extent permitted taking into
account Affirmer's express Statement of Purpose. In addition, to the
extent the Waiver is so judged Affirmer hereby grants to each affected
person a royalty-free, non transferable, non sublicensable, non exclusive,
irrevocable and unconditional license to exercise Affirmer's Copyright and
Related Rights in the Work (i) in all territories worldwide, (ii) for the
maximum duration provided by applicable law or treaty (including future
time extensions), (iii) in any current or future medium and for any number
of copies, and (iv) for any purpose whatsoever, including without
limitation commercial, advertising or promotional purposes (the
"License"). The License shall be deemed effective as of the date CC0 was
applied by Affirmer to the Work. Should any part of the License for any
reason be judged legally invalid or ineffective under applicable law, such
partial invalidity or ineffectiveness shall not invalidate the remainder
of the License, and in such case Affirmer hereby affirms that he or she
will not (i) exercise any of his or her remaining Copyright and Related
Rights in the Work or (ii) assert any associated claims and causes of
action with respect to the Work, in either case contrary to Affirmer's
express Statement of Purpose.
4. Limitations and Disclaimers.
a. No trademark or patent rights held by Affirmer are waived, abandoned,
surrendered, licensed or otherwise affected by this document.
b. Affirmer offers the Work as-is and makes no representations or
warranties of any kind concerning the Work, express, implied,
statutory or otherwise, including without limitation warranties of
title, merchantability, fitness for a particular purpose, non
infringement, or the absence of latent or other defects, accuracy, or
the present or absence of errors, whether or not discoverable, all to
the greatest extent permissible under applicable law.
c. Affirmer disclaims responsibility for clearing rights of other persons
that may apply to the Work or any use thereof, including without
limitation any person's Copyright and Related Rights in the Work.
Further, Affirmer disclaims responsibility for obtaining any necessary
consents, permissions or other rights required for any use of the
Work.
d. Affirmer understands and acknowledges that Creative Commons is not a
party to this document and has no duty or obligation with respect to
this CC0 or use of the Work.
================================================
FILE: LICENSE-MIT
================================================
MIT License
Copyright (c) 2024 MapLibre contributors
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
================================================
FILE: MODULE.bazel
================================================
module(name = "maplibre-tile-spec")
bazel_dep(name = "platforms", version = "1.0.0")
bazel_dep(name = "rules_cc", version = "0.2.8")
================================================
FILE: README.md
================================================
# MapLibre Tile (MLT)
> [!NOTE]
> [The specification](https://maplibre.org/maplibre-tile-spec/specification/) is deemed stable as of October 2025. However, as a living standard, experimental features may continue to evolve. Implementations and integrations are being developed, refer to the [implementation status](https://maplibre.org/maplibre-tile-spec/implementation-status/) page for the current status.
The MapLibre Tile specification is mainly inspired by the [Mapbox Vector Tile (MVT)](https://github.com/mapbox/vector-tile-spec) specification,
but has been redesigned from the ground up to address the challenges of rapidly growing geospatial data volumes
and complex next-generation geospatial source formats as well as to leverage the capabilities of modern hardware and APIs.
MLT is specifically designed for modern and next generation graphics APIs to enable high-performance processing and rendering of
large (planet-scale) 2D and 2.5 basemaps. In particular, MLT offers the following features:
- **Improved compression ratio**: up to 6x on large encoded tiles, based on a column oriented layout with recursively applied (custom)
lightweight encodings. This leads to reduced latency, storage, and egress costs and, in particular, improved cache utilization
- **Better decoding performance**: fast lightweight encodings which can be used in combination with SIMD/vectorization instructions
- **Support for linear referencing and m-values** to efficiently support the upcoming next generation source formats such as Overture Maps (GeoParquet)
- **Support 3D coordinates**, i.e. elevation
- **Support complex types**, including nested properties, lists and maps
- **Improved processing performance**, based on storage and in-memory formats that are specifically designed for modern GL APIs,
allowing for efficient processing on both CPU and GPU. The formats are designed to be loaded into
GPU buffers with little or no additional processing
📝 For a more in-depth exploration of MLT have a look at the [following slides](https://github.com/mactrem/presentations/blob/main/FOSS4G_2024_Europe/FOSS4G_2024_Europe.pdf), watch
[this talk](https://www.youtube.com/watch?v=YHcoAFcsES0) or read [this paper](https://dl.acm.org/doi/10.1145/3748636.3763208) by MLT inventor Markus Tremmel.
## Directory Structure
- `/spec` MLT specification and related documentation
- `/test` Test MVT tiles and the expected MLT conversion results
- `/java` Java encoder for converting MVT to MLT, as well as a decoder parsing MLT to an in-memory representation.
- `/js` Javascript decoder
- `/rust` Rust decoder
## Getting Involved
Join the `#maplibre-tile-format` Slack channel at OSM US: get an invite at https://slack.openstreetmap.us/
### Development
* This project is easier to develop with [just](https://just.systems/man/en/), a modern alternative to `make`.
* To get a list of available commands, run `just`.
* To run tests, use `just test`.
## License
* All project documentation and specification content is licensed under [CC0 1.0 Universal](https://creativecommons.org/publicdomain/zero/1.0/) - Public Domain Dedication.
* All code is dual licensed under [Apache License v2.0](http://www.apache.org/licenses/LICENSE-2.0) and [MIT license](http://opensource.org/licenses/MIT), at your option.
* Tile test data in the `/test` directory has different licenses depending on the source of that data.
### Contribution
Unless you explicitly state otherwise, any code contribution intentionally
submitted for inclusion in the work by you, as defined in the
Apache-2.0 license, shall be dual licensed as above, without any
additional terms or conditions. Similarly, any documentation or specification
contributions shall be licensed under CC0 1.0 Universal.
## Citing
If you use MapLibre Tile in your research, please cite our paper:
```bibtex
@inproceedings{tremmel2025maplibretile,
title = {MapLibre Tile: A Next Generation Vector Tile Format},
author = {Tremmel, Markus and Zink, Roland},
booktitle = {Proceedings of the 33rd ACM International Conference on Advances in Geographic Information Systems},
series = {SIGSPATIAL '25},
year = {2025},
pages = {1118--1121},
doi = {10.1145/3748636.3763208},
url = {https://doi.org/10.1145/3748636.3763208}
}
```
================================================
FILE: SECURITY_POLICY.txt
================================================
For an up-to-date policy refer to
https://github.com/maplibre/maplibre/blob/main/SECURITY_POLICY.txt
================================================
FILE: biome.json
================================================
{
"$schema": "https://biomejs.dev/schemas/2.0.5/schema.json",
"css": {
"formatter": {
"indentWidth": 2,
"indentStyle": "space"
}
},
"javascript": {
"formatter": {
"indentWidth": 2,
"indentStyle": "space"
}
}
}
================================================
FILE: cpp/.clang-tidy
================================================
---
Checks: [
android-*,
boost-*,
bugprone-*,
clang-analyzer-core*,
clang-analyzer-cplusplus*,
clang-analyzer-deadcode*,
clang-analyzer-optin.cplusplus*,
clang-analyzer-optin.performance.Padding,
clang-analyzer-security*,
clang-diagnostic-*,
cppcoreguidelines-avoid-goto,
cppcoreguidelines-no-malloc,
google-*,
llvm-*,
misc-*,
modernize-*,
performance-*,
portability-*,
readability-*,
-bugprone-branch-clone,
-bugprone-easily-swappable-parameters,
-bugprone-exception-escape,
-bugprone-forward-declaration-namespace,
-bugprone-forwarding-reference-overload,
-bugprone-implicit-widening-of-multiplication-result,
-bugprone-macro-parentheses,
-bugprone-narrowing-conversions,
-bugprone-reserved-identifier,
-bugprone-signed-char-misuse,
-bugprone-sizeof-expression,
-bugprone-unchecked-optional-access,
-bugprone-unhandled-exception-at-new,
-bugprone-unhandled-self-assignment,
-clang-analyzer-optin.cplusplus.UninitializedObject,
-clang-analyzer-core.NonNullParamChecker,
-clang-analyzer-core.NullDereference,
-clang-analyzer-core.uninitialized.Assign,
-clang-analyzer-core.UndefinedBinaryOperatorResult,
-clang-analyzer-security.FloatLoopCounter,
-google-build-explicit-make-pair,
-google-build-namespaces,
-google-build-using-namespace,
-google-default-arguments,
-google-explicit-constructor,
-google-objc-global-variable-declaration,
-google-readability-braces-around-statements,
-google-readability-casting,
-google-readability-function-size,
-google-readability-function,
-google-readability-namespace-comments,
-google-readability-todo,
-google-runtime-int,
-google-runtime-references,
-llvm-else-after-return,
-llvm-header-guard,
-llvm-include-order,
-llvm-namespace-comment,
-llvm-qualified-auto,
-llvm-twine-local,
-misc-confusable-identifiers,
-misc-const-correctness,
-misc-no-recursion,
-misc-non-private-member-variables-in-classes,
-misc-static-assert,
-modernize-avoid-bind,
-modernize-avoid-c-arrays,
-modernize-concat-nested-namespaces,
-modernize-macro-to-enum,
-modernize-pass-by-value,
-modernize-return-braced-init-list,
-modernize-use-auto,
-modernize-use-default-member-init,
-modernize-use-emplace,
-modernize-use-equals-default,
-modernize-use-nodiscard,
-modernize-use-nullptr,
-modernize-use-trailing-return-type,
-performance-move-const-arg,
-performance-noexcept-move-constructor,
-performance-no-int-to-ptr,
-performance-unnecessary-value-param,
-readability-avoid-const-params-in-decls,
-readability-braces-around-statements,
-readability-const-return-type,
-readability-container-size-empty,
-readability-convert-member-functions-to-static,
-readability-else-after-return,
-readability-function-cognitive-complexity,
-readability-function-size,
-readability-identifier-length,
-readability-identifier-naming,
-readability-implicit-bool-conversion,
-readability-inconsistent-declaration-parameter-name,
-readability-isolate-declaration,
-readability-magic-numbers,
-readability-make-member-function-const,
-readability-named-parameter,
-readability-non-const-parameter,
-readability-qualified-auto,
-readability-redundant-access-specifiers,
-readability-redundant-declaration,
-readability-redundant-member-init,
-readability-redundant-string-init,
-readability-simplify-boolean-expr,
-readability-static-accessed-through-instance
-readability-static-definition-in-anonymous-namespace,
-readability-suspicious-call-argument,
-readability-uppercase-literal-suffix,
-readability-use-anyofallof,
-modernize-loop-convert, # since C++20 this complains about reverse loops with iterators, but good ranges support only landed in clang 15
-performance-enum-size,
-misc-include-cleaner,
-readability-redundant-inline-specifier,
-readability-avoid-nested-conditional-operator,
-cppcoreguidelines-pro-type-static-cast-downcast, # no RTTI
]
WarningsAsErrors: '*'
HeaderFilterRegex: '.*'
CheckOptions:
- key: performance-unnecessary-value-param.AllowedTypes
value: 'exception_ptr'
================================================
FILE: cpp/.gitignore
================================================
/build
/.cache
compile_commands.json
cmake_test_discovery*
================================================
FILE: cpp/.nvmrc
================================================
24.13
================================================
FILE: cpp/BUILD.bazel
================================================
load("@rules_cc//cc:cc_library.bzl", "cc_library")
cc_library(
name = "mlt_internal_headers",
hdrs = glob(["src/mlt/**/*.hpp"]),
include_prefix = "",
strip_include_prefix = "src",
visibility = ["//visibility:private"],
)
cc_library(
name = "mlt_cpp",
srcs = glob([
"src/mlt/**/*.cpp",
]),
hdrs = glob([
"include/mlt/**/*.hpp",
]),
copts = select({
"@platforms//os:windows": [
"/std:c++20",
],
"//conditions:default": [
"-std=c++20",
"-Wall",
"-Wextra",
],
}),
defines = [
"MLT_WITH_JSON=0",
"MLT_WITH_FASTPFOR=0",
],
implementation_deps = [":mlt_internal_headers"],
include_prefix = "",
strip_include_prefix = "include",
visibility = ["//visibility:public"],
)
================================================
FILE: cpp/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.25)
project(mlt-cpp LANGUAGES CXX)
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/cmake)
include(AddCXXCompilerFlag)
# generate compile_commands.json https://cmake.org/cmake/help/latest/variable/CMAKE_EXPORT_COMPILE_COMMANDS.html
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(CMAKE_CXX_STANDARD 20)
if(PROJECT_IS_TOP_LEVEL AND CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
set(CMAKE_CXX_FLAGS_COVERAGE "-g -O0 --coverage")
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
string(APPEND CMAKE_CXX_FLAGS_COVERAGE " -fprofile-abs-path")
endif()
set(CMAKE_EXE_LINKER_FLAGS_COVERAGE "--coverage")
set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE "--coverage")
set(CMAKE_MODULE_LINKER_FLAGS_COVERAGE "--coverage")
endif()
add_library(mlt-cpp STATIC)
option(MLT_WITH_JSON "Include JSON support" ON)
option(MLT_WITH_FASTPFOR "Include FastPFor support" ON)
option(MLT_WITH_FASTPFOR_SIMD "Include SIMD/NEON support in FastPFor decoding" ON)
option(MLT_WITH_TESTS "Include Tests" ON)
option(MLT_WITH_TOOLS "Include CLI tools" ON)
set_target_properties(
mlt-cpp
PROPERTIES
INTERFACE_MAPLIBRE_NAME "MapLibre Tile Format"
INTERFACE_MAPLIBRE_URL "https://github.com/maplibre/maplibre-tile-spec"
INTERFACE_MAPLIBRE_AUTHOR "MapLibre"
INTERFACE_MAPLIBRE_LICENSE "${PROJECT_SOURCE_DIR}/../LICENSE-APACHE"
)
add_cxx_compiler_flag(-Wall)
add_cxx_compiler_flag(-Werror)
add_cxx_compiler_flag(-Wextra)
add_cxx_compiler_flag(-Wdeprecated-declarations)
add_cxx_compiler_flag(-Winvalid-offsetof)
add_cxx_compiler_flag(-Wno-block-capture-autoreleasing)
add_cxx_compiler_flag(-Wno-bool-conversion)
add_cxx_compiler_flag(-Wno-c++11-extensions)
add_cxx_compiler_flag(-Wno-comma)
add_cxx_compiler_flag(-Wno-constant-conversion)
add_cxx_compiler_flag(-Wno-conversion)
add_cxx_compiler_flag(-Wno-empty-body)
add_cxx_compiler_flag(-Wno-enum-conversion)
add_cxx_compiler_flag(-Wno-exit-time-destructors)
add_cxx_compiler_flag(-Wno-float-conversion)
add_cxx_compiler_flag(-Wno-four-char-constants)
add_cxx_compiler_flag(-Wno-implicit-fallthrough)
add_cxx_compiler_flag(-Wno-infinite-recursion)
add_cxx_compiler_flag(-Wno-missing-braces)
add_cxx_compiler_flag(-Wno-missing-field-initializers)
add_cxx_compiler_flag(-Wno-move)
add_cxx_compiler_flag(-Wno-newline-eof)
add_cxx_compiler_flag(-Wno-non-literal-null-conversion)
add_cxx_compiler_flag(-Wno-non-virtual-dtor)
add_cxx_compiler_flag(-Wno-objc-literal-conversion)
add_cxx_compiler_flag(-Wno-overloaded-virtual)
add_cxx_compiler_flag(-Wno-range-loop-analysis)
add_cxx_compiler_flag(-Wno-return-type)
add_cxx_compiler_flag(-Wno-semicolon-before-method-body)
add_cxx_compiler_flag(-Wno-shadow)
add_cxx_compiler_flag(-Wno-sign-conversion)
add_cxx_compiler_flag(-Wno-trigraphs)
add_cxx_compiler_flag(-Wno-uninitialized)
add_cxx_compiler_flag(-Wno-unknown-pragmas)
add_cxx_compiler_flag(-Wno-unused-function)
add_cxx_compiler_flag(-Wno-unused-label)
add_cxx_compiler_flag(-Wno-unused-parameter)
add_cxx_compiler_flag(-Wno-unused-variable)
add_cxx_compiler_flag(-Wparentheses)
add_cxx_compiler_flag(-Wshorten-64-to-32)
add_cxx_compiler_flag(-Wswitch)
add_cxx_compiler_flag(-Wunused-value)
add_cxx_compiler_flag(-fstrict-aliasing)
add_cxx_compiler_flag(-wd4061) # MSVC: enum member not handled in switch
add_cxx_compiler_flag(-wd4514) # MSVC: unreferenced inline function has been removed
add_cxx_compiler_flag(-wd4710) # MSVC: function not inlined
add_cxx_compiler_flag(-wd4820) # MSVC: padding added after data member
target_include_directories(mlt-cpp
PUBLIC ${PROJECT_SOURCE_DIR}/include
PRIVATE ${PROJECT_SOURCE_DIR}/src
)
list(APPEND MLT_INCLUDE_FILES
${PROJECT_SOURCE_DIR}/include/mlt/common.hpp
${PROJECT_SOURCE_DIR}/include/mlt/decoder.hpp
${PROJECT_SOURCE_DIR}/include/mlt/feature.hpp
${PROJECT_SOURCE_DIR}/include/mlt/geometry.hpp
${PROJECT_SOURCE_DIR}/include/mlt/geometry_vector.hpp
${PROJECT_SOURCE_DIR}/include/mlt/layer.hpp
${PROJECT_SOURCE_DIR}/include/mlt/polyfill.hpp
${PROJECT_SOURCE_DIR}/include/mlt/projection.hpp
${PROJECT_SOURCE_DIR}/include/mlt/properties.hpp
${PROJECT_SOURCE_DIR}/include/mlt/tile.hpp
${PROJECT_SOURCE_DIR}/include/mlt/metadata/stream.hpp
${PROJECT_SOURCE_DIR}/include/mlt/metadata/tileset.hpp
${PROJECT_SOURCE_DIR}/include/mlt/util/buffer_stream.hpp
${PROJECT_SOURCE_DIR}/include/mlt/util/packed_bitset.hpp
${PROJECT_SOURCE_DIR}/include/mlt/util/noncopyable.hpp
${PROJECT_SOURCE_DIR}/include/mlt/util/stl.hpp
${PROJECT_SOURCE_DIR}/include/mlt/util/varint.hpp
)
list(APPEND MLT_SRC_FILES
${PROJECT_SOURCE_DIR}/src/mlt/decoder.cpp
${PROJECT_SOURCE_DIR}/src/mlt/decode/geometry.hpp
${PROJECT_SOURCE_DIR}/src/mlt/decode/int.cpp
${PROJECT_SOURCE_DIR}/src/mlt/decode/int.hpp
${PROJECT_SOURCE_DIR}/src/mlt/decode/property.hpp
${PROJECT_SOURCE_DIR}/src/mlt/decode/string.hpp
${PROJECT_SOURCE_DIR}/src/mlt/feature.cpp
${PROJECT_SOURCE_DIR}/src/mlt/geometry_vector.cpp
${PROJECT_SOURCE_DIR}/src/mlt/layer.cpp
${PROJECT_SOURCE_DIR}/src/mlt/metadata/stream.cpp
${PROJECT_SOURCE_DIR}/src/mlt/metadata/tileset.cpp
${PROJECT_SOURCE_DIR}/src/mlt/properties.cpp
${PROJECT_SOURCE_DIR}/src/mlt/util/morton_curve.hpp
${PROJECT_SOURCE_DIR}/src/mlt/util/raw.hpp
${PROJECT_SOURCE_DIR}/src/mlt/util/rle.cpp
${PROJECT_SOURCE_DIR}/src/mlt/util/rle.hpp
${PROJECT_SOURCE_DIR}/src/mlt/util/space_filling_curve.hpp
${PROJECT_SOURCE_DIR}/src/mlt/util/vectorized.hpp
${PROJECT_SOURCE_DIR}/src/mlt/util/zigzag.hpp
)
if(MLT_WITH_JSON)
list(APPEND MLT_INCLUDE_FILES ${PROJECT_SOURCE_DIR}/include/mlt/json.hpp)
endif(MLT_WITH_JSON)
target_sources(mlt-cpp PRIVATE
${MLT_INCLUDE_FILES}
${MLT_SRC_FILES}
)
include("${PROJECT_SOURCE_DIR}/vendor/fastpfor.cmake")
# json
if(MLT_WITH_JSON)
message(STATUS "[MLT] Including JSON support")
add_subdirectory("${PROJECT_SOURCE_DIR}/vendor/json" "${CMAKE_CURRENT_BINARY_DIR}/json" EXCLUDE_FROM_ALL SYSTEM)
set(json_SOURCE_DIR "${PROJECT_SOURCE_DIR}/vendor/json")
target_include_directories(mlt-cpp PUBLIC "${json_SOURCE_DIR}/include")
target_compile_definitions(mlt-cpp PUBLIC MLT_WITH_JSON=1)
else()
message(STATUS "[MLT] No JSON support")
endif(MLT_WITH_JSON)
if(MLT_WITH_TESTS)
include(CTest)
add_subdirectory(${PROJECT_SOURCE_DIR}/test EXCLUDE_FROM_ALL)
endif(MLT_WITH_TESTS)
if(MLT_WITH_TOOLS)
add_subdirectory(${PROJECT_SOURCE_DIR}/tool EXCLUDE_FROM_ALL)
endif(MLT_WITH_TOOLS)
export(TARGETS ${MLT_EXPORT_TARGETS} FILE MLTTargets.cmake)
================================================
FILE: cpp/CTestCustom.cmake
================================================
# Exclude vendor/third-party code from coverage reports
set(CTEST_CUSTOM_COVERAGE_EXCLUDE
${CTEST_CUSTOM_COVERAGE_EXCLUDE}
".*/vendor/.*"
".*/build/.*/_deps/.*"
".*/test/.*"
)
================================================
FILE: cpp/README.md
================================================
# maplibre-tile-spec/cpp
A C++ implementation of the MapLibre Tile (MLT) vector tile format.
## Status
Decoder only, partial support for encodings.
CMake and Bazel build support.
## Build
```bash
git submodule update --init --recursive
cmake -GNinja -Bbuild -S.
cmake --build build --target mlt-cpp-test mlt-cpp-json
```
## Test
```
build/test/mlt-cpp-test
```
## Use
To decode a tile:
- Deserialize the tileset metadata
- Create a `Decoder`
- Call `decode` with the metadata and a view on the raw tile data
To use the standard packing of metadata and data within a tile, use `decodeTile`.
```cpp
#include
#include
...
auto metadata = mlt::metadata::tileset::read({metadataBuffer.data(), metadataBuffer.size()});
mlt::Decoder decoder;
const auto tile = decoder.decode({mltBuffer.data(), mltBuffer.size()}, metadata);
const auto tile2 = decoder.decodeTile({tileData.data(), tileData.size()});
```
## Tools
A simple application which dumps a tile/metadata file pair to JSON format.
```bash
build/tool/mlt-cpp-json ../test/expected/tag0x01/bing/4-12-6.mlt
```
================================================
FILE: cpp/bazel/check/BUILD.bazel
================================================
load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
cc_binary(
name = "sse42",
srcs = ["sse42.c"],
copts = select({
"@platforms//os:windows": [
"/EHsc",
"/arch:SSE2",
],
"//conditions:default": [
"-march=native",
"-msse4.2",
],
}),
)
cc_binary(
name = "avx",
srcs = ["avx.c"],
copts = select({
"@platforms//os:windows": [
"/EHsc",
"/arch:AVX",
],
"//conditions:default": [
"-march=native",
"-mavx",
],
}),
)
cc_binary(
name = "avx2",
srcs = ["avx2.c"],
copts = select({
"@platforms//os:windows": [
"/EHsc",
"/arch:AVX2",
],
"//conditions:default": [
"-march=native",
"-mavx2",
],
}),
)
================================================
FILE: cpp/bazel/check/avx.c
================================================
#include
int main(){
__m128 x=_mm_set1_ps(0.5);
x=_mm_permute_ps(x,1);
return _mm_movemask_ps(x);
}
================================================
FILE: cpp/bazel/check/avx2.c
================================================
#include
int main(){
__m256i x=_mm256_set1_epi32(5);
x=_mm256_add_epi32(x,x);
return _mm256_movemask_epi8(x);
}
================================================
FILE: cpp/bazel/check/sse42.c
================================================
#include
int main(){
__m128 x=_mm_set1_ps(0.5);
x=_mm_dp_ps(x,x,0x77);
return _mm_movemask_ps(x);
}")
================================================
FILE: cpp/cmake/AddCXXCompilerFlag.cmake
================================================
# - Adds a compiler flag if it is supported by the compiler
#
# This function checks that the supplied compiler flag is supported and then
# adds it to the corresponding compiler flags
#
# add_cxx_compiler_flag( [])
#
# - Example
#
# include(AddCXXCompilerFlag)
# add_cxx_compiler_flag(-Wall)
# add_cxx_compiler_flag(-no-strict-aliasing RELEASE)
# Requires CMake 2.6+
if(__add_cxx_compiler_flag)
return()
endif()
set(__add_cxx_compiler_flag INCLUDED)
include(CheckCXXCompilerFlag)
function(mangle_compiler_flag FLAG OUTPUT)
string(TOUPPER "HAVE_CXX_FLAG_${FLAG}" SANITIZED_FLAG)
string(REPLACE "+" "X" SANITIZED_FLAG ${SANITIZED_FLAG})
string(REGEX REPLACE "[^A-Za-z_0-9]" "_" SANITIZED_FLAG ${SANITIZED_FLAG})
string(REGEX REPLACE "_+" "_" SANITIZED_FLAG ${SANITIZED_FLAG})
set(${OUTPUT} "${SANITIZED_FLAG}" PARENT_SCOPE)
endfunction(mangle_compiler_flag)
function(add_cxx_compiler_flag FLAG)
mangle_compiler_flag("${FLAG}" MANGLED_FLAG)
set(OLD_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${FLAG}")
check_cxx_compiler_flag("${FLAG}" ${MANGLED_FLAG})
set(CMAKE_REQUIRED_FLAGS "${OLD_CMAKE_REQUIRED_FLAGS}")
if(${MANGLED_FLAG})
set(VARIANT ${ARGV1})
if(ARGV1)
string(TOUPPER "_${VARIANT}" VARIANT)
endif()
set(CMAKE_CXX_FLAGS${VARIANT} "${CMAKE_CXX_FLAGS${VARIANT}} ${BENCHMARK_CXX_FLAGS${VARIANT}} ${FLAG}" PARENT_SCOPE)
endif()
endfunction()
function(add_required_cxx_compiler_flag FLAG)
mangle_compiler_flag("${FLAG}" MANGLED_FLAG)
set(OLD_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${FLAG}")
check_cxx_compiler_flag("${FLAG}" ${MANGLED_FLAG})
set(CMAKE_REQUIRED_FLAGS "${OLD_CMAKE_REQUIRED_FLAGS}")
if(${MANGLED_FLAG})
set(VARIANT ${ARGV1})
if(ARGV1)
string(TOUPPER "_${VARIANT}" VARIANT)
endif()
set(CMAKE_CXX_FLAGS${VARIANT} "${CMAKE_CXX_FLAGS${VARIANT}} ${FLAG}" PARENT_SCOPE)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${FLAG}" PARENT_SCOPE)
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${FLAG}" PARENT_SCOPE)
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${FLAG}" PARENT_SCOPE)
set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${FLAG}" PARENT_SCOPE)
else()
message(FATAL_ERROR "Required flag '${FLAG}' is not supported by the compiler")
endif()
endfunction()
function(check_cxx_warning_flag FLAG)
mangle_compiler_flag("${FLAG}" MANGLED_FLAG)
set(OLD_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
# Add -Werror to ensure the compiler generates an error if the warning flag
# doesn't exist.
set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror ${FLAG}")
check_cxx_compiler_flag("${FLAG}" ${MANGLED_FLAG})
set(CMAKE_REQUIRED_FLAGS "${OLD_CMAKE_REQUIRED_FLAGS}")
endfunction()
================================================
FILE: cpp/include/mlt/common.hpp
================================================
#pragma once
#include
#include
#include
namespace mlt {
using DataView = std::string_view;
template
constexpr std::size_t countof(T (&)[N]) {
return N;
}
/// `std::underlying_type` that doesn't fail when given a simple type
template >
struct underlying_type {
using type = T;
};
template
struct underlying_type : ::std::underlying_type {};
template
using underlying_type_t = typename underlying_type::type;
} // namespace mlt
================================================
FILE: cpp/include/mlt/coordinate.hpp
================================================
#pragma once
#include
#include
namespace mlt {
struct Coordinate {
float x;
float y;
Coordinate(float x_, float y_) noexcept
: x(x_),
y(y_) {}
bool operator==(const Coordinate& other) const noexcept { return x == other.x && y == other.y; }
bool operator!=(const Coordinate& other) const noexcept { return !(*this == other); }
};
using CoordVec = std::vector;
struct TileCoordinate {
std::uint32_t x;
std::uint32_t y;
std::uint32_t z;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/decoder.hpp
================================================
#pragma once
#include
#include
#include
#include
#include
namespace mlt {
class Decoder : public util::noncopyable {
public:
using Geometry = geometry::Geometry;
using GeometryFactory = geometry::GeometryFactory;
Decoder(bool supportFastPFOR);
Decoder(std::unique_ptr&&, bool supportFastPFOR);
~Decoder() noexcept;
Decoder(Decoder&&) = delete;
Decoder& operator=(Decoder&&) = delete;
/// Decode a tile
MapLibreTile decode(DataView);
MapLibreTile decode(BufferStream);
private:
struct Impl;
std::unique_ptr impl;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/feature.hpp
================================================
#pragma once
#include
#include
#include
#include
namespace mlt {
namespace geometry {
class Geometry;
}
class Layer;
class Feature : public util::noncopyable {
public:
using id_t = std::uint64_t;
using extent_t = std::uint32_t;
using Geometry = geometry::Geometry;
Feature() = delete;
Feature(Feature&&) noexcept = default;
Feature& operator=(Feature&&) = delete;
/// Construct a feature
/// @param id Feature identifier, or nullopt if the feature has no ID
/// @param geometry Feature geometry, required
/// @param index Index of the property in the layer
Feature(std::optional id, std::unique_ptr&&, std::uint32_t index);
~Feature() noexcept;
std::optional getID() const noexcept { return ident; }
std::uint32_t getIndex() const noexcept { return index; }
const Geometry& getGeometry() const noexcept { return *geometry; }
std::optional getProperty(const std::string& key, const Layer&) const;
private:
std::optional ident;
std::uint32_t index; // index of the property in the layer
std::unique_ptr geometry;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/geometry.hpp
================================================
#pragma once
#include
#include
#include
#include
#include
#include
namespace mlt::geometry {
class Geometry : public util::noncopyable {
public:
using GeometryType = metadata::tileset::GeometryType;
protected:
Geometry(GeometryType type_) noexcept
: type(type_) {}
public:
virtual ~Geometry() noexcept = default;
const auto& getTriangles() const { return triangles; }
void setTriangles(std::span triangles_) noexcept { triangles = triangles_; }
const metadata::tileset::GeometryType type;
private:
std::span triangles;
};
class Point : public Geometry {
public:
Point(const Coordinate& coord) noexcept
: Geometry(GeometryType::POINT),
coordinate(coord) {}
const Coordinate& getCoordinate() const noexcept { return coordinate; }
private:
const Coordinate coordinate;
};
class MultiPoint : public Geometry {
public:
MultiPoint(CoordVec coords) noexcept
: Geometry(GeometryType::MULTIPOINT),
coordinates(std::move(coords)) {}
const CoordVec& getCoordinates() const noexcept { return coordinates; }
protected:
MultiPoint(CoordVec coords, GeometryType type_) noexcept
: Geometry(type_),
coordinates(std::move(coords)) {}
private:
CoordVec coordinates;
};
class LineString : public MultiPoint {
public:
LineString(CoordVec coords) noexcept
: MultiPoint(std::move(coords), GeometryType::LINESTRING) {}
private:
};
class LinearRing : public MultiPoint {
public:
LinearRing(CoordVec coords) noexcept
: MultiPoint(std::move(coords)) {}
private:
};
class MultiLineString : public Geometry {
public:
MultiLineString(std::vector lineStrings_) noexcept
: Geometry(GeometryType::MULTILINESTRING),
lineStrings(std::move(lineStrings_)) {}
const std::vector& getLineStrings() const noexcept { return lineStrings; }
private:
std::vector lineStrings;
};
class Polygon : public Geometry {
public:
using Ring = CoordVec;
using RingVec = std::vector;
Polygon(RingVec rings_) noexcept
: Geometry(GeometryType::POLYGON),
rings(std::move(rings_)) {}
const RingVec& getRings() const noexcept { return rings; }
private:
RingVec rings;
};
class MultiPolygon : public Geometry {
public:
using Ring = CoordVec;
using RingVec = std::vector;
MultiPolygon(std::vector polygons_) noexcept
: Geometry(GeometryType::MULTIPOLYGON),
polygons(std::move(polygons_)) {}
const std::vector& getPolygons() const noexcept { return polygons; }
private:
std::vector polygons;
};
class GeometryFactory {
public:
GeometryFactory() = default;
virtual ~GeometryFactory() = default;
virtual std::unique_ptr createPoint(const Coordinate& coord) const {
return std::make_unique(coord);
}
virtual std::unique_ptr createMultiPoint(CoordVec&& coords) const {
return std::make_unique(std::move(coords));
}
virtual std::unique_ptr createLineString(CoordVec&& coords) const {
return std::make_unique(std::move(coords));
}
virtual std::unique_ptr createLinearRing(CoordVec&& coords) const {
return std::make_unique(std::move(coords));
}
virtual std::unique_ptr createPolygon(std::vector&& rings) const {
return std::make_unique(std::move(rings));
}
virtual std::unique_ptr createMultiLineString(std::vector&& lineStrings) const {
return std::make_unique(std::move(lineStrings));
}
virtual std::unique_ptr createMultiPolygon(std::vector&& polys) const {
return std::make_unique(std::move(polys));
}
};
} // namespace mlt::geometry
================================================
FILE: cpp/include/mlt/geometry_vector.hpp
================================================
#pragma once
#include
#include
#include
#include
namespace mlt::geometry {
struct MortonSettings {
unsigned numBits;
unsigned coordinateShift;
};
enum class VertexBufferType : std::uint32_t {
MORTON,
VEC_2,
VEC_3
};
struct TopologyVector : public util::noncopyable {
TopologyVector(std::vector&& geometryOffsets_,
std::vector&& partOffsets_,
std::vector&& ringOffsets_) noexcept
: geometryOffsets(geometryOffsets_),
partOffsets(partOffsets_),
ringOffsets(ringOffsets_) {}
const std::vector& getGeometryOffsets() const noexcept { return geometryOffsets; }
const std::vector& getPartOffsets() const noexcept { return partOffsets; }
const std::vector& getRingOffsets() const noexcept { return ringOffsets; }
private:
std::vector geometryOffsets;
std::vector partOffsets;
std::vector ringOffsets;
};
struct GeometryVector : public util::noncopyable {
using GeometryType = metadata::tileset::GeometryType;
virtual ~GeometryVector() = default;
std::uint32_t getNumGeometries() const noexcept { return numGeometries; }
bool isSingleGeometryType() const noexcept { return singleType; }
virtual GeometryType getGeometryType(std::size_t index) const noexcept = 0;
virtual bool containsPolygonGeometry() const noexcept = 0;
std::vector> getGeometries(const GeometryFactory&) const;
protected:
GeometryVector(std::uint32_t numGeometries_,
bool singleType_,
std::vector&& indexBuffer_,
std::vector&& vertexBuffer_,
VertexBufferType vertexBufferType_,
std::vector&& vertexOffsets_,
std::vector&& triangleCounts_,
std::optional&& topologyVector_,
std::optional mortonSettings_ = {}) noexcept
: numGeometries(numGeometries_),
scale(1.0f),
singleType(singleType_),
indexBuffer(std::move(indexBuffer_)),
vertexBuffer(std::move(vertexBuffer_)),
vertexBufferType(vertexBufferType_),
vertexOffsets(std::move(vertexOffsets_)),
triangleCounts(std::move(triangleCounts_)),
topologyVector(std::move(topologyVector_)),
mortonSettings(mortonSettings_) {}
void applyTriangles(Geometry&,
std::uint32_t& triangleOffset,
std::uint32_t& indexBufferOffset,
std::uint32_t totalVertices,
bool multiPolygon) const;
protected:
std::uint32_t numGeometries;
float scale;
bool singleType;
std::vector indexBuffer;
std::vector vertexBuffer;
VertexBufferType vertexBufferType;
std::vector vertexOffsets;
std::vector triangleCounts;
std::optional topologyVector;
std::optional mortonSettings;
};
struct GpuVector : public GeometryVector {
GpuVector(std::uint32_t numGeometries_,
bool singleType_,
std::vector&& triangleCounts_,
std::vector&& indexBuffer_,
std::vector&& vertexBuffer_,
VertexBufferType vertexBufferType_,
std::optional&& topologyVector_) noexcept
: GeometryVector(numGeometries_,
singleType_,
std::move(indexBuffer_),
std::move(vertexBuffer_),
vertexBufferType_,
{},
std::move(triangleCounts_),
std::move(topologyVector_)) {}
private:
};
struct ConstGpuVector : public GpuVector {
ConstGpuVector(std::uint32_t numGeometries_,
GeometryType geometryType_,
std::vector&& triangleCounts_,
std::vector&& indexBuffer_,
std::vector&& vertexBuffer_,
VertexBufferType vertexBufferType_,
std::optional&& topologyVector_) noexcept
: GpuVector(numGeometries_,
/*singleType=*/true,
std::move(triangleCounts_),
std::move(indexBuffer_),
std::move(vertexBuffer_),
vertexBufferType_,
std::move(topologyVector_)),
geometryType(geometryType_) {}
GeometryType getGeometryType(std::size_t) const noexcept override { return geometryType; }
bool containsPolygonGeometry() const noexcept override {
return geometryType == GeometryType::POLYGON || geometryType == GeometryType::MULTIPOLYGON;
}
private:
GeometryType geometryType;
};
struct FlatGpuVector : public GpuVector {
FlatGpuVector(std::vector&& geometryTypes_,
std::vector&& triangleCounts_,
std::vector&& indexBuffer_,
std::vector&& vertexBuffer_,
std::optional&& topologyVector_ = {}) noexcept
: GpuVector(static_cast(geometryTypes_.size()),
/*singleType=*/false,
std::move(triangleCounts_),
std::move(indexBuffer_),
std::move(vertexBuffer_),
VertexBufferType::VEC_2,
std::move(topologyVector_)),
geometryTypes(std::move(geometryTypes_)) {}
GeometryType getGeometryType(std::size_t index) const noexcept override {
assert(index < geometryTypes.size());
return geometryTypes[index];
}
bool containsPolygonGeometry() const noexcept override {
// TODO: cache? types can't change
return std::ranges::any_of(geometryTypes, [](const auto type) {
return type == GeometryType::POLYGON || type == GeometryType::MULTIPOLYGON;
});
}
private:
std::vector geometryTypes;
};
struct CpuVector : public GeometryVector {
CpuVector(std::uint32_t numGeometries_,
bool singleType_,
TopologyVector&& topologyVector_,
std::vector&& vertexOffsets_,
std::vector&& vertexBuffer_,
VertexBufferType vertexBufferType_,
std::optional mortonSettings_) noexcept
: GeometryVector(numGeometries_,
singleType_,
/*indexBuffer=*/{},
std::move(vertexBuffer_),
vertexBufferType_,
std::move(vertexOffsets_),
{},
std::move(topologyVector_),
mortonSettings_) {}
Coordinate getVertex(std::size_t index) const {
if (!vertexOffsets.empty() && !mortonSettings) {
const auto vertexOffset = vertexOffsets[index] * 2;
return {static_cast(vertexBuffer[vertexOffset]), static_cast(vertexBuffer[vertexOffset + 1])};
}
if (!vertexOffsets.empty() && mortonSettings) {
// TODO: move decoding of the morton codes on the GPU in the vertex shader
const auto vertexOffset = vertexOffsets[index];
const auto mortonEncodedVertex = vertexBuffer[vertexOffset];
// TODO: improve performance -> inline calculation and move to decoding of VertexBuffer
return util::MortonCurve::decode(
mortonEncodedVertex, mortonSettings->numBits, mortonSettings->coordinateShift);
}
return {static_cast(vertexBuffer[2 * index]), static_cast(vertexBuffer[(2 * index) + 1])};
}
};
struct ConstGeometryVector : public CpuVector {
ConstGeometryVector(std::uint32_t numGeometries_,
GeometryType geometryType_,
VertexBufferType vertexBufferType_,
TopologyVector&& topologyVector_,
std::vector&& vertexOffsets_,
std::vector&& vertexBuffer_,
std::optional mortonSettings_) noexcept
: CpuVector(numGeometries_,
/*singleType=*/true,
std::move(topologyVector_),
std::move(vertexOffsets_),
std::move(vertexBuffer_),
vertexBufferType_,
mortonSettings_),
geometryType(geometryType_) {}
GeometryType getGeometryType(std::size_t) const noexcept override { return geometryType; }
bool containsPolygonGeometry() const noexcept override {
return geometryType == GeometryType::POLYGON || geometryType == GeometryType::MULTIPOLYGON;
}
private:
GeometryType geometryType;
};
struct FlatGeometryVector : public CpuVector {
FlatGeometryVector(std::vector&& geometryTypes_,
TopologyVector&& topologyVector_,
std::vector&& vertexOffsets_,
std::vector&& vertexBuffer_,
VertexBufferType vertexBufferType_,
std::optional mortonSettings_) noexcept
: CpuVector(static_cast(geometryTypes_.size()),
/*singleType=*/false,
std::move(topologyVector_),
std::move(vertexOffsets_),
std::move(vertexBuffer_),
vertexBufferType_,
mortonSettings_),
geometryTypes(geometryTypes_) {}
GeometryType getGeometryType(std::size_t index) const noexcept override {
assert(index < geometryTypes.size());
return geometryTypes[index];
}
bool containsPolygonGeometry() const noexcept override {
// TODO: cache? types can't change
return std::ranges::any_of(geometryTypes, [](const auto type) {
return type == GeometryType::POLYGON || type == GeometryType::MULTIPOLYGON;
});
}
private:
std::vector geometryTypes;
};
} // namespace mlt::geometry
================================================
FILE: cpp/include/mlt/json.hpp
================================================
#pragma once
#include
#if MLT_WITH_JSON
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace mlt {
namespace json {
using json = nlohmann::json;
namespace detail {
#pragma region JSON utils
/// Create a json array object with pre-allocated space
inline json buildArray(std::size_t reservedSize) {
json array = json::array();
assert(array.is_array());
array.get_ref().reserve(reservedSize);
return array;
}
/// Add to a json array the result of a function applied to each element in a range
template
requires requires(TFunc f, typename std::ranges::range_rvalue_reference_t v) {
{ f(v) } -> std::same_as;
}
inline json append(TRange sourceRange, json&& array, TFunc transform) {
assert(array.is_array());
std::ranges::transform(
std::forward(sourceRange), std::back_inserter(array), std::forward(transform));
return std::move(array);
}
/// Convert a collection range into a json array by applying the given function to each element
template
requires requires(TFunc f, typename std::ranges::range_rvalue_reference_t v) {
{ f(v) } -> std::same_as;
}
inline json buildArray(TRange sourceRange, TFunc transform) {
return append(sourceRange, buildArray(std::ranges::size(sourceRange)), std::forward(transform));
}
#pragma endregion JSON utils
#pragma region Geometry
/// Build the coordinate representation for a single coordinate that has already been projected
inline json buildProjectedCoordinateArray(const Coordinate& coord) {
return json::array({coord.x, coord.y});
}
/// Build the coordinate representation for a single coordinate
inline json buildCoordinateArray(const Coordinate& coord, const Projection& projection) {
return buildProjectedCoordinateArray(projection.project(coord));
}
/// Build the coordinate representation for a collection of coordinates
inline json buildCoordinatesArray(const CoordVec& coords, const Projection& projection) {
return buildArray(coords, [&](const auto& coord) { return buildCoordinateArray(coord, projection); });
}
/// Build the coordinate representation for a polygon, consisting of the rings concatenated to the shell
inline json buildPolygonCoords(const std::vector& polyRings, const Projection& projection) {
auto result = buildArray(polyRings.size());
return append(polyRings, std::move(result), [&](const auto& lineString) {
return buildCoordinatesArray(lineString, projection);
});
}
/// Create the value type for the "geometry" entry in a GeoJSON feature with the given coordinate representation
inline json buildGeometryElement(std::string_view type, json&& coords) {
return {
{"type", type},
{"coordinates", std::move(coords)},
};
}
inline json buildGeometryElement(const geometry::Point& point, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return {
{"type", "Point"},
{"coordinates", buildCoordinateArray(point.getCoordinate(), projection)},
};
} else {
std::ostringstream ss;
ss << "POINT (" << point.getCoordinate().x << " " << point.getCoordinate().y << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::LineString& line, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("LineString", buildCoordinatesArray(line.getCoordinates(), projection));
} else {
std::ostringstream ss;
ss << "LINESTRING (";
const auto& coords = line.getCoordinates();
for (std::size_t i = 0, n = coords.size(); i < n; ++i) {
ss << (i == 0 ? "" : ", ") << coords[i].x << " " << coords[i].y;
}
ss << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::LinearRing& line, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("LineString", buildCoordinatesArray(line.getCoordinates(), projection));
} else {
std::ostringstream ss;
ss << "LINESTRING (";
const auto& coords = line.getCoordinates();
for (std::size_t i = 0; i < coords.size(); ++i) {
ss << (i == 0 ? "" : ", ") << coords[i].x << " " << coords[i].y;
}
ss << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::MultiPoint& points, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("MultiPoint", buildCoordinatesArray(points.getCoordinates(), projection));
} else {
std::ostringstream ss;
ss << "MULTIPOINT (";
const auto& coords = points.getCoordinates();
for (std::size_t i = 0; i < coords.size(); ++i) {
ss << (i == 0 ? "" : ", ") << "(" << coords[i].x << " " << coords[i].y << ")";
}
ss << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::MultiLineString& mls, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("MultiLineString", buildArray(mls.getLineStrings(), [&](const auto& lineString) {
return buildCoordinatesArray(lineString, projection);
}));
} else {
std::ostringstream ss;
ss << "MULTILINESTRING (";
const auto& lineStrings = mls.getLineStrings();
for (std::size_t i = 0, n = lineStrings.size(); i < n; ++i) {
if (i != 0) {
ss << ", ";
}
ss << "(";
const auto& coords = lineStrings[i];
for (std::size_t j = 0; j < coords.size(); ++j) {
ss << (j == 0 ? "" : ", ") << coords[j].x << " " << coords[j].y;
}
ss << ")";
}
ss << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::Polygon& poly, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("Polygon", buildPolygonCoords(poly.getRings(), projection));
} else {
std::ostringstream ss;
ss << "POLYGON (";
const auto& rings = poly.getRings();
for (std::size_t i = 0, n = rings.size(); i < n; ++i) {
if (i != 0) {
ss << ", ";
}
ss << "(";
const auto& coords = rings[i];
for (std::size_t j = 0; j <= coords.size(); ++j) {
// Wrap around to the first coordinate to close the ring.
// See `getLineStringCoords`
const auto& coord = coords[j % coords.size()];
ss << (j == 0 ? "" : ", ") << coord.x << " " << coord.y;
}
ss << ")";
}
ss << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::MultiPolygon& poly, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("MultiPolygon", buildArray(poly.getPolygons(), [&](const auto& poly) {
return buildPolygonCoords(poly, projection);
}));
} else {
std::ostringstream ss;
ss << "MULTIPOLYGON (";
const auto& polygons = poly.getPolygons();
for (std::size_t i = 0; i < polygons.size(); ++i) {
if (i != 0) {
ss << ", ";
}
ss << "(";
const auto& rings = polygons[i];
for (std::size_t j = 0; j < rings.size(); ++j) {
if (j != 0) {
ss << ", ";
}
ss << "(";
const auto& coords = rings[j];
for (std::size_t k = 0; k <= coords.size(); ++k) {
const auto& coord = coords[k % coords.size()];
ss << (k == 0 ? "" : ", ") << coord.x << " " << coord.y;
}
ss << ")";
}
ss << ")";
}
ss << ")";
return ss.str();
}
}
inline json buildAnyGeometryElement(const geometry::Geometry& geometry, const Projection& projection, bool geoJSON) {
switch (geometry.type) {
case metadata::tileset::GeometryType::POINT:
return buildGeometryElement(static_cast(geometry), projection, geoJSON);
case metadata::tileset::GeometryType::LINESTRING:
return buildGeometryElement(static_cast(geometry), projection, geoJSON);
case metadata::tileset::GeometryType::POLYGON:
return buildGeometryElement(static_cast(geometry), projection, geoJSON);
case metadata::tileset::GeometryType::MULTIPOINT:
return buildGeometryElement(static_cast(geometry), projection, geoJSON);
case metadata::tileset::GeometryType::MULTILINESTRING:
return buildGeometryElement(static_cast(geometry), projection, geoJSON);
case metadata::tileset::GeometryType::MULTIPOLYGON:
return buildGeometryElement(static_cast(geometry), projection, geoJSON);
default:
throw std::runtime_error("Unsupported geometry type " + std::to_string(std::to_underlying(geometry.type)));
}
}
#pragma endregion Geometry
#pragma region Properties
struct PropertyVisitor {
template
std::optional encodeFloatingPoint(T value, std::string_view prefix) const {
if (std::isfinite(value)) {
return json(value);
}
if (std::isnan(value)) {
return json(std::string(prefix) + "::NAN");
}
if (std::signbit(value)) {
return json(std::string(prefix) + "::NEG_INFINITY");
}
return json(std::string(prefix) + "::INFINITY");
}
std::optional operator()(float value) const { return encodeFloatingPoint(value, "f32"); }
std::optional operator()(double value) const { return encodeFloatingPoint(value, "f64"); }
template
std::optional operator()(const T& value) const {
return value;
}
};
inline json buildProperties(const Layer& layer, const Feature& feature) {
auto result = json::object();
for (const auto& [key, _] : layer.getProperties()) {
if (const auto property = feature.getProperty(key, layer); property) {
if (auto json = std::visit(PropertyVisitor(), *property); json) {
result[key] = std::move(*json);
}
}
}
return result;
}
#pragma endregion Properties
} // namespace detail
inline json toJSON(const Layer& layer, const Feature& feature, const Projection& projection, bool geoJSON) {
auto result = json{
{"geometry", detail::buildAnyGeometryElement(feature.getGeometry(), projection, geoJSON)},
};
if (const auto id = feature.getID(); id.has_value()) {
result["id"] = *id;
}
if (geoJSON) {
result["type"] = "Feature";
}
if (!layer.getProperties().empty()) {
result["properties"] = detail::buildProperties(layer, feature);
}
return result;
}
inline json toJSON(const Layer& layer, const TileCoordinate& tileCoord, bool geoJSON) {
const auto projection = Projection{layer.getExtent(), tileCoord};
const auto features = std::ranges::views::all(layer.getFeatures());
return {{"name", layer.getName()},
{"extent", layer.getExtent()},
{"features", detail::buildArray(features, [&](const auto& feature) {
return toJSON(layer, feature, projection, geoJSON);
})}};
}
inline json toJSON(const MapLibreTile& tile, const TileCoordinate& tileCoord, bool geoJSON) {
const auto layers = std::ranges::views::all(tile.getLayers());
return {
{"layers", detail::buildArray(layers, [&](const auto& layer) { return toJSON(layer, tileCoord, geoJSON); })},
};
}
} // namespace json
} // namespace mlt
#endif
================================================
FILE: cpp/include/mlt/layer.hpp
================================================
#pragma once
#include
#include
#include
#include
namespace mlt {
namespace geometry {
struct GeometryVector;
}
class Layer : public util::noncopyable {
public:
using extent_t = std::uint32_t;
Layer() = delete;
Layer(std::string name_,
extent_t extent_,
std::unique_ptr&& geometryVector_,
std::vector features_,
PropertyVecMap properties_) noexcept;
~Layer();
Layer(Layer&&) noexcept = default;
Layer& operator=(Layer&&) = default;
const std::string& getName() const noexcept { return name; }
extent_t getExtent() const noexcept { return extent; }
const std::vector& getFeatures() const noexcept { return features; }
const PropertyVecMap& getProperties() const { return properties; }
private:
std::string name;
extent_t extent;
// Retain the geometry vector because features may reference data from it rather than making copies
std::unique_ptr geometryVector;
std::vector features;
PropertyVecMap properties;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/metadata/stream.hpp
================================================
#pragma once
#include
#include
#include
#include
#include
#include
namespace mlt::metadata::stream {
enum class DictionaryType : std::uint32_t {
NONE = 0,
SINGLE = 1,
SHARED = 2,
VERTEX = 3,
MORTON = 4,
FSST = 5,
VALUE_COUNT = 6,
};
enum class LengthType : std::uint32_t {
VAR_BINARY = 0,
GEOMETRIES = 1,
PARTS = 2,
RINGS = 3,
TRIANGLES = 4,
SYMBOL = 5,
DICTIONARY = 6,
VALUE_COUNT = 7,
};
enum class PhysicalLevelTechnique : std::uint32_t {
NONE = 0,
/// Preferred, tends to produce the best compression ratio and decoding performance.
/// But currently limited to 32-bit integer.
FAST_PFOR = 1,
/// Can produce better results in combination with a heavyweight compression scheme like Gzip.
/// Simple compression scheme where the decoder are easier to implement compared to FastPfor.
VARINT = 2,
VALUE_COUNT = 3,
};
enum class LogicalLevelTechnique : std::uint32_t {
NONE = 0,
DELTA = 1,
COMPONENTWISE_DELTA = 2,
RLE = 3,
MORTON = 4,
PSEUDODECIMAL = 5,
VALUE_COUNT = 6,
};
enum class OffsetType : std::uint32_t {
VERTEX = 0,
INDEX = 1,
STRING = 2,
KEY = 3,
VALUE_COUNT = 4,
};
enum class PhysicalStreamType : std::uint32_t {
PRESENT = 0,
DATA = 1,
OFFSET = 2,
LENGTH = 3,
VALUE_COUNT = 4,
};
class LogicalStreamType : public util::noncopyable {
public:
LogicalStreamType(DictionaryType type) noexcept
: dictionaryType(type) {}
LogicalStreamType(OffsetType type) noexcept
: offsetType(type) {}
LogicalStreamType(LengthType type) noexcept
: lengthType(type) {}
LogicalStreamType() = delete;
LogicalStreamType(LogicalStreamType&&) noexcept = default;
LogicalStreamType& operator=(LogicalStreamType&&) noexcept = default;
const std::optional& getDictionaryType() const noexcept { return dictionaryType; }
const std::optional& getOffsetType() const noexcept { return offsetType; }
const std::optional& getLengthType() const noexcept { return lengthType; }
private:
std::optional dictionaryType;
std::optional offsetType;
std::optional lengthType;
};
class StreamMetadata : public util::noncopyable {
public:
StreamMetadata() = delete;
StreamMetadata(PhysicalStreamType physicalStreamType_,
std::optional logicalStreamType_,
LogicalLevelTechnique logicalLevelTechnique1_,
LogicalLevelTechnique logicalLevelTechnique2_,
PhysicalLevelTechnique physicalLevelTechnique_,
std::uint32_t numValues_,
std::uint32_t byteLength_) noexcept
: physicalStreamType(physicalStreamType_),
logicalStreamType(std::move(logicalStreamType_)),
logicalLevelTechnique1(logicalLevelTechnique1_),
logicalLevelTechnique2(logicalLevelTechnique2_),
physicalLevelTechnique(physicalLevelTechnique_),
numValues(numValues_),
byteLength(byteLength_) {}
virtual ~StreamMetadata() noexcept = default;
StreamMetadata(StreamMetadata&&) noexcept = default;
StreamMetadata& operator=(StreamMetadata&&) noexcept = default;
virtual LogicalLevelTechnique getMetadataType() const noexcept { return LogicalLevelTechnique::NONE; }
static std::unique_ptr decode(BufferStream&);
PhysicalStreamType getPhysicalStreamType() const { return physicalStreamType; }
const std::optional& getLogicalStreamType() const { return logicalStreamType; }
LogicalLevelTechnique getLogicalLevelTechnique1() const { return logicalLevelTechnique1; }
LogicalLevelTechnique getLogicalLevelTechnique2() const { return logicalLevelTechnique2; }
PhysicalLevelTechnique getPhysicalLevelTechnique() const { return physicalLevelTechnique; }
std::uint32_t getNumValues() const noexcept { return numValues; }
std::uint32_t getByteLength() const noexcept { return byteLength; }
private:
int getLogicalType() const noexcept;
friend class RleEncodedStreamMetadata;
friend class MortonEncodedStreamMetadata;
friend std::unique_ptr decode(BufferStream&);
static StreamMetadata decodeInternal(BufferStream&);
PhysicalStreamType physicalStreamType;
std::optional logicalStreamType;
LogicalLevelTechnique logicalLevelTechnique1;
LogicalLevelTechnique logicalLevelTechnique2;
PhysicalLevelTechnique physicalLevelTechnique;
// After logical Level technique was applied -> when rle is used it is the length of the runs and values array
std::uint32_t numValues;
std::uint32_t byteLength;
};
class RleEncodedStreamMetadata : public StreamMetadata {
public:
/**
* Only used for RLE encoded integer values, not boolean and byte values.
*
* @param numValues After LogicalLevelTechnique was applied -> numRuns + numValues
* @param runs Length of the runs array
* @param numRleValues Used for pre-allocating the arrays on the client for faster decoding
*/
RleEncodedStreamMetadata(PhysicalStreamType physicalStreamType_,
std::optional logicalStreamType_,
LogicalLevelTechnique logicalLevelTechnique1_,
LogicalLevelTechnique logicalLevelTechnique2_,
PhysicalLevelTechnique physicalLevelTechnique_,
unsigned numValues_,
unsigned byteLength_,
unsigned runs_,
unsigned numRleValues_) noexcept
: StreamMetadata(physicalStreamType_,
std::move(logicalStreamType_),
logicalLevelTechnique1_,
logicalLevelTechnique2_,
physicalLevelTechnique_,
numValues_,
byteLength_),
runs(runs_),
numRleValues(numRleValues_) {}
RleEncodedStreamMetadata(StreamMetadata&& streamMetadata, unsigned runs_, unsigned numRleValues_) noexcept
: StreamMetadata(std::move(streamMetadata)),
runs(runs_),
numRleValues(numRleValues_) {}
RleEncodedStreamMetadata() = delete;
LogicalLevelTechnique getMetadataType() const noexcept override { return LogicalLevelTechnique::RLE; }
static RleEncodedStreamMetadata decodePartial(StreamMetadata&& streamMetadata, BufferStream& tileData) {
const auto [runs, numValues] = util::decoding::decodeVarints(tileData);
return RleEncodedStreamMetadata(std::move(streamMetadata), runs, numValues);
}
static RleEncodedStreamMetadata decode(BufferStream& tileData) {
return decodePartial(decodeInternal(tileData), tileData);
}
unsigned getRuns() const noexcept { return runs; }
unsigned getNumRleValues() const noexcept { return numRleValues; }
private:
unsigned runs;
unsigned numRleValues;
};
class MortonEncodedStreamMetadata : public StreamMetadata {
public:
MortonEncodedStreamMetadata(PhysicalStreamType physicalStreamType_,
LogicalStreamType logicalStreamType_,
LogicalLevelTechnique logicalLevelTechnique1_,
LogicalLevelTechnique logicalLevelTechnique2_,
PhysicalLevelTechnique physicalLevelTechnique_,
unsigned numValues_,
unsigned byteLength_,
unsigned numBits_,
unsigned coordinateShift_) noexcept
: StreamMetadata(physicalStreamType_,
std::move(logicalStreamType_),
logicalLevelTechnique1_,
logicalLevelTechnique2_,
physicalLevelTechnique_,
numValues_,
byteLength_),
numBits(numBits_),
coordinateShift(coordinateShift_) {}
MortonEncodedStreamMetadata(StreamMetadata&& streamMetadata, int numBits_, int coordinateShift_) noexcept
: StreamMetadata(std::move(streamMetadata)),
numBits(numBits_),
coordinateShift(coordinateShift_) {}
LogicalLevelTechnique getMetadataType() const noexcept override { return LogicalLevelTechnique::MORTON; }
static MortonEncodedStreamMetadata decodePartial(StreamMetadata&& streamMetadata, BufferStream& tileData) {
const auto [numBits, coordShift] = util::decoding::decodeVarints(tileData);
return MortonEncodedStreamMetadata(std::move(streamMetadata), numBits, coordShift);
}
static MortonEncodedStreamMetadata decode(BufferStream& tileData) {
return decodePartial(decodeInternal(tileData), tileData);
}
unsigned getNumBits() const noexcept { return numBits; }
unsigned getCoordinateShift() const noexcept { return coordinateShift; }
private:
unsigned numBits;
unsigned coordinateShift;
};
class PdeEncodedMetadata {};
} // namespace mlt::metadata::stream
================================================
FILE: cpp/include/mlt/metadata/tileset.hpp
================================================
#pragma once
#include
#include
#include
#include
#include
namespace mlt {
struct BufferStream;
}
namespace mlt::metadata::tileset {
// See https://maplibre.org/maplibre-tile-spec/specification/
namespace schema {
enum class ColumnScope {
// 1:1 Mapping of property and feature -> id and geometry
FEATURE = 0,
// For M-Values -> 1:1 Mapping for property and vertex
VERTEX = 1,
};
enum class ScalarType {
BOOLEAN = 0,
INT_8 = 1,
UINT_8 = 2,
INT_32 = 3,
UINT_32 = 4,
INT_64 = 5,
UINT_64 = 6,
FLOAT = 7,
DOUBLE = 8,
STRING = 9,
};
enum class ComplexType {
// vec2 for the VertexBuffer stream with additional information
// (streams) about the topology
GEOMETRY = 0,
// vec3 for the VertexBuffer stream with additional information
// (streams) about the topology
STRUCT = 1,
};
enum class LogicalScalarType {
// uin32 or 64_t depending on hasLongID
ID = 0,
};
enum class LogicalComplexType {
};
} // namespace schema
using schema::ColumnScope;
using schema::ComplexType;
using schema::LogicalComplexType;
using schema::LogicalScalarType;
using schema::ScalarType;
enum class GeometryType {
POINT = 0,
LINESTRING = 1,
POLYGON = 2,
MULTIPOINT = 3,
MULTILINESTRING = 4,
MULTIPOLYGON = 5,
};
struct ScalarColumn {
std::variant type;
bool hasLongID = false;
bool hasPhysicalType() const { return std::holds_alternative(type); }
bool hasLogicalType() const { return std::holds_alternative(type); }
auto& getPhysicalType() { return std::get(type); }
auto& getPhysicalType() const { return std::get(type); }
auto& getLogicalType() { return std::get(type); }
auto& getLogicalType() const { return std::get(type); }
bool isID() const { return hasLogicalType() && getLogicalType() == LogicalScalarType::ID; }
};
// The type tree is flattened in to a list via a pre-order traversal.
// Represents a column if it is a root (top-level) type or a child of a nested type.
struct Column;
struct ComplexColumn {
std::variant type;
// The complex type Geometry and the logical type BINARY have no children
// since there layout is implicit known. RangeMap has only one child
// specifying the type of the value since the key is always a vec2.
std::vector children;
bool hasChildren() const { return !children.empty(); }
bool hasPhysicalType() const { return std::holds_alternative(type); }
bool hasLogicalType() const { return std::holds_alternative(type); }
auto& getPhysicalType() { return std::get(type); }
auto& getPhysicalType() const { return std::get(type); }
auto& getLogicalType() { return std::get(type); }
auto& getLogicalType() const { return std::get(type); }
bool isGeometry() const { return hasPhysicalType() && getPhysicalType() == ComplexType::GEOMETRY; }
bool isStruct() const { return hasPhysicalType() && getPhysicalType() == ComplexType::STRUCT; }
};
// Column are top-level types in the schema
struct Column {
std::string name;
bool nullable = false;
ColumnScope columnScope = ColumnScope::FEATURE;
std::variant type;
bool hasScalarType() const { return std::holds_alternative(type); }
bool hasComplexType() const { return std::holds_alternative(type); }
auto& getScalarType() { return std::get(type); }
auto& getScalarType() const { return std::get(type); }
auto& getComplexType() { return std::get(type); }
auto& getComplexType() const { return std::get(type); }
bool isID() const { return hasScalarType() && getScalarType().isID(); }
bool isGeometry() const { return hasComplexType() && getComplexType().isGeometry(); }
bool isStruct() const { return hasComplexType() && getComplexType().isStruct(); }
};
struct FeatureTable {
std::string name;
std::uint32_t extent;
std::vector columns;
};
FeatureTable decodeFeatureTable(BufferStream&);
} // namespace mlt::metadata::tileset
================================================
FILE: cpp/include/mlt/metadata/type_map.hpp
================================================
#include
#include
#include
#include
namespace mlt::metadata::type_map {
struct Tag0x01 {
using Column = metadata::tileset::Column;
using ScalarColumn = metadata::tileset::ScalarColumn;
using ComplexColumn = metadata::tileset::ComplexColumn;
using ScalarType = metadata::tileset::ScalarType;
using ComplexType = metadata::tileset::ComplexType;
using LogicalScalarType = metadata::tileset::LogicalScalarType;
using LogicalComplexType = metadata::tileset::LogicalComplexType;
/// Produces the unique type encoding for a `Column` or `Field`
static std::optional encodeColumnType(std::optional physicalScalarType,
std::optional logicalScalarType,
std::optional physicalComplexType,
std::optional,
bool isNullable,
bool hasChildren,
bool hasLongIDs) {
if (physicalScalarType) {
if (!hasChildren) {
return mapScalarType(*physicalScalarType, isNullable);
}
} else if (logicalScalarType) {
if (logicalScalarType == LogicalScalarType::ID) {
return isNullable ? (hasLongIDs ? 3 : 2) : (hasLongIDs ? 1 : 0);
}
} else if (physicalComplexType) {
if (physicalComplexType == ComplexType::GEOMETRY) {
if (!isNullable && !hasChildren) {
return 4;
}
} else if (physicalComplexType == ComplexType::STRUCT) {
if (!isNullable && hasChildren) {
return 30;
}
}
}
return std::nullopt;
}
/// Re-create a `Column` from the unique type code.
/// The inverse of `encodeColumnType`
static std::optional decodeColumnType(std::uint32_t typeCode) {
using ColumnScope = metadata::tileset::ColumnScope;
switch (typeCode) {
case 0:
case 1:
case 2:
case 3:
return Column{.name = {},
.nullable = (typeCode & 1) != 0,
.columnScope = ColumnScope::FEATURE,
.type = ScalarColumn{.type = LogicalScalarType::ID, .hasLongID = typeCode > 1}};
case 4:
return Column{.name = {},
.nullable = false,
.columnScope = ColumnScope::FEATURE,
.type = ComplexColumn{.type = ComplexType::GEOMETRY, .children = {}}};
case 30:
return Column{.name = {},
.nullable = false,
.columnScope = ColumnScope::FEATURE,
.type = ComplexColumn{.type = ComplexType::STRUCT, .children = {}}};
default:
if (const auto type = mapScalarType(typeCode); type) {
return Column{.name = {},
.nullable = (typeCode & 1) != 0,
.columnScope = ColumnScope::FEATURE,
.type = ScalarColumn{.type = *type}};
}
return std::nullopt;
}
}
static bool columnTypeHasName(std::uint32_t typeCode) { return (10 <= typeCode); }
static bool columnTypeHasChildren(std::uint32_t typeCode) { return (typeCode == 30); }
static bool hasStreamCount(const Column& column) {
if (column.hasScalarType()) {
if (column.getScalarType().hasPhysicalType()) {
switch (column.getScalarType().getPhysicalType()) {
default:
case ScalarType::BOOLEAN:
case ScalarType::INT_8:
case ScalarType::UINT_8:
case ScalarType::INT_32:
case ScalarType::UINT_32:
case ScalarType::INT_64:
case ScalarType::UINT_64:
case ScalarType::FLOAT:
case ScalarType::DOUBLE:
return false;
case ScalarType::STRING:
return true;
};
} else if (column.getScalarType().hasLogicalType()) {
if (column.getScalarType().getLogicalType() == LogicalScalarType::ID) {
return false;
}
}
} else if (column.hasComplexType()) {
if (column.getComplexType().hasPhysicalType()) {
switch (column.getComplexType().getPhysicalType()) {
case ComplexType::GEOMETRY:
case ComplexType::STRUCT:
return true;
default:
break;
}
}
}
// other cases should be impossible
assert(false);
return false;
}
private:
constexpr static std::optional mapScalarType(std::uint32_t typeCode) {
switch (typeCode) {
case 10:
case 11:
return ScalarType::BOOLEAN;
case 12:
case 13:
return ScalarType::INT_8;
case 14:
case 15:
return ScalarType::UINT_8;
case 16:
case 17:
return ScalarType::INT_32;
case 18:
case 19:
return ScalarType::UINT_32;
case 20:
case 21:
return ScalarType::INT_64;
case 22:
case 23:
return ScalarType::UINT_64;
case 24:
case 25:
return ScalarType::FLOAT;
case 26:
case 27:
return ScalarType::DOUBLE;
case 28:
case 29:
return ScalarType::STRING;
default:
return std::nullopt;
}
}
constexpr static std::optional mapScalarType(ScalarType typeCode, bool isNullable) {
switch (typeCode) {
case ScalarType::BOOLEAN:
return isNullable ? 11 : 10;
case ScalarType::INT_8:
return isNullable ? 13 : 12;
case ScalarType::UINT_8:
return isNullable ? 15 : 14;
case ScalarType::INT_32:
return isNullable ? 17 : 16;
case ScalarType::UINT_32:
return isNullable ? 19 : 18;
case ScalarType::INT_64:
return isNullable ? 21 : 20;
case ScalarType::UINT_64:
return isNullable ? 23 : 22;
case ScalarType::FLOAT:
return isNullable ? 25 : 24;
case ScalarType::DOUBLE:
return isNullable ? 27 : 26;
case ScalarType::STRING:
return isNullable ? 29 : 28;
default:
assert(false);
return std::nullopt;
}
}
};
} // namespace mlt::metadata::type_map
================================================
FILE: cpp/include/mlt/polyfill.hpp
================================================
#pragma once
#include
#include
#include // IWYU pragma: keep - Needed by MSVC
#include
namespace std {
#if !__has_cpp_attribute(__cpp_lib_to_underlying)
template
constexpr auto to_underlying(E e) noexcept {
return static_cast>(e);
}
#endif
#if !__has_cpp_attribute(__cpp_lib_byteswap)
template
constexpr T byteswap(T value) noexcept {
static_assert(std::has_unique_object_representations_v, "T may not have padding bits");
auto value_representation = std::bit_cast>(value);
std::ranges::reverse(value_representation);
return std::bit_cast(value_representation);
}
#endif
} // namespace std
================================================
FILE: cpp/include/mlt/projection.hpp
================================================
#pragma once
#include
#include
#include
#include
#include
#include
namespace mlt {
// Intended to match the results of
// https://github.com/mapbox/vector-tile-js/blob/77851380b63b07fd0af3d5a3f144cc86fb39fdd1/lib/vectortilefeature.js#L129
class Projection {
public:
Projection() = delete;
Projection(const Projection&) noexcept = default;
Projection(Projection&&) noexcept = default;
Projection(Layer::extent_t extent, const TileCoordinate& tile)
: size(extent * (1 << tile.z)),
x0(extent * tile.x),
y0(extent * tile.y),
s1(360.0 / size) {
if (extent == 0) {
throw std::runtime_error("Invalid tile extent");
}
}
Coordinate project(const Coordinate& coord) const noexcept { return {projectX(coord.x), projectY(coord.y)}; }
private:
float projectX(float x) const noexcept { return ((x + x0) * s1) - 180.0f; }
float projectY(float y) const noexcept {
return (2.0f * radToDeg(std::atan(std::exp(degToRad(180.0f - ((y + y0) * s1)))))) - 90.0f;
}
static float degToRad(float deg) noexcept { return deg * std::numbers::pi / 180.0; }
static float radToDeg(float rad) noexcept { return rad * 180 / std::numbers::pi; }
std::uint64_t size;
std::uint64_t x0;
std::uint64_t y0;
double s1;
constexpr static double s2 = 360.0 / std::numbers::pi;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/properties.hpp
================================================
#pragma once
#include