mlt 0.1.10

MapLibre Tile Tools
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use std::fs;
use std::path::PathBuf;

use anyhow::{Result as AnyResult, bail};
use clap::Args;
use mlt_core::geojson::FeatureCollection;
use mlt_core::{Decoder, MltResult, Parser};

use crate::OutputFormat;
use crate::ls::is_mlt_extension;

#[derive(Args)]
pub struct DumpArgs {
    /// Path to a tile file (.mlt, .mvt, .pbf)
    file: PathBuf,

    /// Output format
    #[arg(short, long, default_value_t, value_enum)]
    format: OutputFormat,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum AfterDump {
    KeepRaw,
    Decode,
}

pub fn dump(args: &DumpArgs, decode: AfterDump) -> AnyResult<()> {
    let buffer = fs::read(&args.file)?;

    if is_mlt_extension(&args.file) {
        dump_mlt(args, decode, &buffer)?;
    } else {
        dump_mvt(args, buffer)?;
    }
    Ok(())
}

fn dump_mlt(args: &DumpArgs, decode: AfterDump, buffer: &[u8]) -> AnyResult<()> {
    let layers = Parser::default().parse_layers(buffer)?;

    match args.format {
        OutputFormat::Text => match decode {
            AfterDump::KeepRaw => {
                for (i, layer) in layers.into_iter().enumerate() {
                    println!("=== Layer {i} ===");
                    println!("{layer:#?}");
                }
            }
            AfterDump::Decode => {
                let layers = Decoder::default().decode_all(layers)?;
                for (i, layer) in layers.into_iter().enumerate() {
                    println!("=== Layer {i} ===");
                    println!("{layer:#?}");
                }
            }
        },
        OutputFormat::GeoJson => {
            if decode == AfterDump::KeepRaw {
                bail!("GeoJSON output only works with `mlt decode`");
            }
            let fc = FeatureCollection::from_layers(Decoder::default().decode_all(layers)?)?;
            println!("{}", serde_json::to_string_pretty(&fc)?);
        }
    }
    Ok(())
}

fn dump_mvt(args: &DumpArgs, buffer: Vec<u8>) -> MltResult<()> {
    let fc = mlt_core::mvt::mvt_to_feature_collection(buffer)?;
    match args.format {
        OutputFormat::Text => {
            for (i, feature) in fc.features.iter().enumerate() {
                println!("=== Feature {i} ===");
                println!("{feature:#?}");
            }
        }
        OutputFormat::GeoJson => {
            println!("{}", serde_json::to_string_pretty(&fc)?);
        }
    }
    Ok(())
}