Tinymvt

https://docs.rs/tinymvt/0.3.0
Admin
Tinymvt is a Rust crate providing utilities for encoding and decoding Mapbox Vector Tiles (MVT),...
Tokens:103,078
Snippets:774
Trust Score:9.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example Searches

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/tileid/hilbert/fn.hilbert_to_zxy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

These are example search queries that demonstrate common Rust patterns and types, useful for finding related documentation or code.

```rust
std::vec
```

```rust
u32 -> bool
```

```rust
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### MVT Tile Decoding Example

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/geometry/struct.GeometryDecoder.html?search=std%3A%3Avec

A complete example demonstrating how to read a Mapbox Vector Tile (MVT) file, decode its layers and features, and then use GeometryDecoder to extract geometric data. This serves as a practical guide for processing MVT data.

```rust
use std::env;
use std::fs;

// Assuming Tile, GeomType, TagsDecoder, GeometryDecoder are defined elsewhere
// use tinymvt::Tile;
// use tinymvt::geom_type::GeomType;
// use tinymvt::tags_decoder::TagsDecoder;
// use tinymvt::geometry::GeometryDecoder;

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() != 2 {
        eprintln!("Usage: {} <path-to-mvt-file>", args[0]);
        std::process::exit(1);
    }

    let path = &args[1];
    let data = fs::read(path).expect("Failed to read MVT file");

    let tile = Tile::decode(&data[..]).expect("Failed to decode MVT protobuf");

    println!("layers={}", tile.layers.len());

    for layer in tile.layers.iter() {
        println!("layer.name={}", layer.name);
        println!("layer.version={}", layer.version);
        println!("layer.extent={}", layer.extent.unwrap_or(4096));
        println!("layer.features={}", layer.features.len());
        println!("layer.keys={}", layer.keys.len());
        println!("layer.values={}", layer.values.len());

        let tags_decoder = TagsDecoder::new(&layer.keys, &layer.values);

        for feature in layer.features.iter() {
            if let Some(id) = feature.id {
                println!("feature.id={}", id);
            }

            let geom_type = feature.r#type.and_then(|t| GeomType::try_from(t).ok());
            println!("feature.type={:?}", geom_type.unwrap_or(GeomType::Unknown));

            if !feature.tags.is_empty() {
                match tags_decoder.decode(&feature.tags) {
                    Ok(tags) => {
                        for (key, value) in tags {
                            println!("feature.tag.{}={}", key, format_value(&value));
                        }
                    }
                    Err(e) => {
                        println!("feature.tags.error={}", e);
                    }
                }
            }

            if !feature.geometry.is_empty() {
                match geom_type {
                    Some(GeomType::Point) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_points() {
                            Ok(points) => {
                                for point in points.iter() {
                                    println!("feature.point={},{}", point[0], point[1]);
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    Some(GeomType::Linestring) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_linestrings() {
                            Ok(linestrings) => {
                                for ls in linestrings.iter() {
                                    for vertex in ls.iter() {
                                        println!(
                                            "feature.linestring.vertex={},{}",
                                            vertex[0],
                                            vertex[1]
                                        );
                                    }
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    Some(GeomType::Polygon) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_polygons() {
                            Ok(polygons) => {
                                for polygon in polygons.iter() {
                                    for (ring_idx, ring) in polygon.iter().enumerate() {
                                        let ring_type = if ring_idx == 0 {
                                            "exterior"
                                        } else {
                                            "interior"
                                        };
                                        for vertex in ring.iter() {
                                            println!(
                                                "feature.polygon.{}.vertex={},{}",
                                                ring_type,
                                                vertex[0],
                                                vertex[1]
                                            );
                                        }
                                    }
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    _ => {
                        println!("feature.geometry.raw={}", feature.geometry.len());
                    }
                }
            }
        }
    }
}

```

--------------------------------

### MVT Tile Decoding Example

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/geometry/struct.GeometryDecoder.html?search=

A complete example demonstrating how to read an MVT file, decode its layers and features, and process geometry data using GeometryDecoder. Requires command-line arguments for the MVT file path.

```rust
use std::env;
use std::fs;

// Assuming Tile, TagsDecoder, GeometryDecoder, GeomType, and format_value are defined elsewhere
// For example:
// use tinymvt::Tile;
// use tinymvt::geometry::GeometryDecoder;
// use tinymvt::tags::TagsDecoder;
// use tinymvt::geom_type::GeomType;

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() != 2 {
        eprintln!("Usage: {} <path-to-mvt-file>", args[0]);
        std::process::exit(1);
    }

    let path = &args[1];
    let data = fs::read(path).expect("Failed to read MVT file");

    let tile = Tile::decode(&data[..]).expect("Failed to decode MVT protobuf");

    println!("layers={}", tile.layers.len());

    for layer in tile.layers.iter() {
        println!("layer.name={}", layer.name);
        println!("layer.version={}", layer.version);
        println!("layer.extent={}", layer.extent.unwrap_or(4096));
        println!("layer.features={}", layer.features.len());
        println!("layer.keys={}", layer.keys.len());
        println!("layer.values={}", layer.values.len());

        let tags_decoder = TagsDecoder::new(&layer.keys, &layer.values);

        for feature in layer.features.iter() {
            if let Some(id) = feature.id {
                println!("feature.id={}", id);
            }

            let geom_type = feature.r#type.and_then(|t| GeomType::try_from(t).ok());
            println!("feature.type={:?}", geom_type.unwrap_or(GeomType::Unknown));

            if !feature.tags.is_empty() {
                match tags_decoder.decode(&feature.tags) {
                    Ok(tags) => {
                        for (key, value) in tags {
                            println!("feature.tag.{}={}", key, format_value(&value));
                        }
                    }
                    Err(e) => {
                        println!("feature.tags.error={}", e);
                    }
                }
            }

            if !feature.geometry.is_empty() {
                match geom_type {
                    Some(GeomType::Point) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_points() {
                            Ok(points) => {
                                for point in points.iter() {
                                    println!("feature.point={},{}", point[0], point[1]);
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    Some(GeomType::Linestring) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_linestrings() {
                            Ok(linestrings) => {
                                for ls in linestrings.iter() {
                                    for vertex in ls.iter() {
                                        println!(
                                            "feature.linestring.vertex={},{}",
                                            vertex[0],
                                            vertex[1]
                                        );
                                    }
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    Some(GeomType::Polygon) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_polygons() {
                            Ok(polygons) => {
                                for polygon in polygons.iter() {
                                    for (ring_idx, ring) in polygon.iter().enumerate() {
                                        let ring_type = if ring_idx == 0 {
                                            "exterior"
                                        } else {
                                            "interior"
                                        };
                                        for vertex in ring.iter() {
                                            println!(
                                                "feature.polygon.{}.vertex={},{}",
                                                ring_type,
                                                vertex[0],
                                                vertex[1]
                                            );
                                        }
                                    }
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    _ => {
                        println!("feature.geometry.raw={}", feature.geometry.len());
                    }
                }
            }
        }
    }
}

```

--------------------------------

### Example Calling a Documented Function

Source: https://docs.rs/tinymvt/0.3.0/scrape-examples-help.html

An example demonstrating how to call a documented function from another file. This code would be scraped and included in the documentation of `a_func`.

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

--------------------------------

### Main Function for MVT File Processing

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/geometry/struct.GeometryDecoder.html?search=u32+-%3E+bool

Parses command-line arguments to get an MVT file path, reads the file, decodes it into a Tile object, and then iterates through layers and features to print information. This serves as a comprehensive example of using the MVT decoding and feature processing logic.

```rust
fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() != 2 {
        eprintln!("Usage: {} <path-to-mvt-file>", args[0]);
        std::process::exit(1);
    }

    let path = &args[1];
    let data = fs::read(path).expect("Failed to read MVT file");

    let tile = Tile::decode(&data[..]).expect("Failed to decode MVT protobuf");

    println!("layers={}", tile.layers.len());

    for layer in tile.layers.iter() {
        println!("layer.name={}", layer.name);
        println!("layer.version={}", layer.version);
        println!("layer.extent={}", layer.extent.unwrap_or(4096));
        println!("layer.features={}", layer.features.len());
        println!("layer.keys={}", layer.keys.len());
        println!("layer.values={}", layer.values.len());

        let tags_decoder = TagsDecoder::new(&layer.keys, &layer.values);

        for feature in layer.features.iter() {
            if let Some(id) = feature.id {
                println!("feature.id={}", id);
            }

            let geom_type = feature.r#type.and_then(|t| GeomType::try_from(t).ok());
            println!("feature.type={:?}", geom_type.unwrap_or(GeomType::Unknown));

            if !feature.tags.is_empty() {
                match tags_decoder.decode(&feature.tags) {
                    Ok(tags) => {
                        for (key, value) in tags {
                            println!("feature.tag.{}={}", key, format_value(&value));
                        }
                    }
                    Err(e) => {
                        println!("feature.tags.error={}", e);
                    }
                }
            }

            if !feature.geometry.is_empty() {
                match geom_type {
                    Some(GeomType::Point) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_points() {
                            Ok(points) => {
                                for point in points.iter() {
                                    println!("feature.point={},{}", point[0], point[1]);
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    Some(GeomType::Linestring) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_linestrings() {
                            Ok(linestrings) => {
                                for ls in linestrings.iter() {
                                    for vertex in ls.iter() {
                                        println!(
                                            "feature.linestring.vertex={},{}",
                                            vertex[0],
                                            vertex[1]
                                        );
                                    }
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    Some(GeomType::Polygon) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_polygons() {
                            Ok(polygons) => {
                                for polygon in polygons.iter() {
                                    for (ring_idx, ring) in polygon.iter().enumerate() {
                                        let ring_type = if ring_idx == 0 {
                                            "exterior"
                                        } else {
                                            "interior"
                                        };
                                        for vertex in ring.iter() {
                                            println!(
                                                "feature.polygon.{}.vertex={},{}",
                                                ring_type,
                                                vertex[0],
                                                vertex[1]
                                            );
                                        }
                                    }
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    _ => {
                        println!("feature.geometry.raw={}", feature.geometry.len());
                    }
                }
            }
        }
    }
}
```

--------------------------------

### Full Example: Encoding MVT Geometries

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/geometry/struct.GeometryEncoder.html?search=u32+-%3E+bool

Demonstrates the complete process of creating MVT geometries for points, linestrings, and polygons, including tag encoding and layer creation.

```rust
fn main() {
    let extent = 4096;

    let layer = {
        let mut tags_enc = TagsEncoder::new();

        let points_feature = {
            let mut geom_enc = GeometryEncoder::new();
            geom_enc.add_points([
                [300, 300],
                [300, extent - 300],
                [extent - 300, extent - 300],
                [extent - 300, 300],
                [900, 900],
                [900, extent - 900],
                [extent - 900, extent - 900],
                [extent - 900, 900],
            ]);

            tags_enc.add("foo", 10);
            tags_enc.add("bar", 20.5);

            Feature {
                id: Some(1),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Point as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let line_strings_feature = {
            let mut geom_enc = GeometryEncoder::new();
            geom_enc.add_linestring([[0, 0], [0, extent], [extent, extent], [extent, 0]]);
            geom_enc.add_linestring([
                [500, 500],
                [500, extent - 500],
                [extent - 500, extent - 500],
                [extent - 500, 500],
            ]);
            geom_enc.add_linestring([
                [700, 700],
                [700, extent - 700],
                [extent - 700, extent - 700],
                [extent - 700, 700],
            ]);

            tags_enc.add("uint", Value::Uint(10));
            tags_enc.add("sint", Value::SInt(-10));
            tags_enc.add("int", Value::Int(10));
            tags_enc.add("string", Value::String("string".to_string()));
            tags_enc.add("float", 10.5f32);
            tags_enc.add("double", 10.5f64);
            tags_enc.add("bool", Value::Bool(true));

            Feature {
                id: Some(2),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Linestring as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let polygon_feature = {
            let mut geom_enc = GeometryEncoder::new();
            geom_enc.add_ring([[1000, 1000], [1000, 1500], [1500, 1500], [1500, 1000]]);
            geom_enc.add_ring([[1100, 1100], [1200, 1100], [1200, 1200], [1100, 1200]]);
            geom_enc.add_ring([[1200, 1200], [1300, 1200], [1300, 1300], [1200, 1300]]);

            geom_enc.add_ring([[2000, 2000], [2000, 2500], [2500, 2500], [2500, 2000]]);
            geom_enc.add_ring([[2100, 2100], [2200, 2100], [2200, 2200], [2100, 2200]]);
            geom_enc.add_ring([[2200, 2200], [2300, 2200], [2300, 2300], [2200, 2300]]);
            geom_enc.add_ring([[2300, 2300], [2400, 2300], [2400, 2400], [2300, 2400]]);

            tags_enc.add("fizz", 10);
            tags_enc.add("buzz", 20.5);

            Feature {
                id: Some(3),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Polygon as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let (keys, values) = tags_enc.into_keys_and_values();

        Layer {
            version: 2,
            name: "road".to_string(),
            features: vec![points_feature, line_strings_feature, polygon_feature],
            keys,
            values,
            extent: Some(4096),
        }
    };

    let buf = Tile {
        layers: vec![layer],
    }
    .encode_to_vec();

    fs::write("tile.pbf", buf).unwrap();
}
```

--------------------------------

### Initialize GeometryEncoder

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/geometry/struct.GeometryEncoder.html?search=

Creates a new instance of GeometryEncoder. This is the starting point for encoding geometries.

```rust
pub struct GeometryEncoder { /* private fields */ }
```

--------------------------------

### Decode MVT File and Print Layer/Feature Data

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/geometry/struct.GeometryDecoder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to read a Mapbox Vector Tile (MVT) file, decode its contents, and print information about layers and features. It utilizes `Tile::decode` for MVT parsing and `GeometryDecoder` for processing feature geometries.

```rust
10fn main() {
11    let args: Vec<String> = env::args().collect();
12    if args.len() != 2 {
13        eprintln!("Usage: {} <path-to-mvt-file>", args[0]);
14        std::process::exit(1);
15    }
16
17    let path = &args[1];
18    let data = fs::read(path).expect("Failed to read MVT file");
19
20    let tile = Tile::decode(&data[..]).expect("Failed to decode MVT protobuf");
21
22    println!("layers={}", tile.layers.len());
23
24    for layer in tile.layers.iter() {
25        println!("layer.name={}", layer.name);
26        println!("layer.version={}", layer.version);
27        println!("layer.extent={}", layer.extent.unwrap_or(4096));
28        println!("layer.features={}", layer.features.len());
29        println!("layer.keys={}", layer.keys.len());
30        println!("layer.values={}", layer.values.len());
31
32        let tags_decoder = TagsDecoder::new(&layer.keys, &layer.values);
33
34        for feature in layer.features.iter() {
35            if let Some(id) = feature.id {
36                println!("feature.id={}", id);
37            }
38
39            let geom_type = feature.r#type.and_then(|t| GeomType::try_from(t).ok());
40            println!("feature.type={:?}", geom_type.unwrap_or(GeomType::Unknown));
41
42            if !feature.tags.is_empty() {
43                match tags_decoder.decode(&feature.tags) {
44                    Ok(tags) => {
45                        for (key, value) in tags {
46                            println!("feature.tag.{}={}", key, format_value(&value));
47                        }
48                    }
49                    Err(e) => {
50                        println!("feature.tags.error={}", e);
51                    }
52                }
53            }
54
55            if !feature.geometry.is_empty() {
56                match geom_type {
57                    Some(GeomType::Point) => {
58                        let mut decoder = GeometryDecoder::new(&feature.geometry);
59                        match decoder.decode_points() {
60                            Ok(points) => {
61                                for point in points.iter() {
62                                    println!("feature.point={},{}", point[0], point[1]);
63                                }
64                            }
65                            Err(e) => println!("feature.geometry.error={}", e),
66                        }
67                    }
68                    Some(GeomType::Linestring) => {
69                        let mut decoder = GeometryDecoder::new(&feature.geometry);
70                        match decoder.decode_linestrings() {
71                            Ok(linestrings) => {
72                                for ls in linestrings.iter() {
73                                    for vertex in ls.iter() {
74                                        println!(
75                                            "feature.linestring.vertex={},{}",
76                                            vertex[0],
77                                            vertex[1]
78                                        );
79                                    }
80                                }
81                            }
82                            Err(e) => println!("feature.geometry.error={}", e),
83                        }
84                    }
85                    Some(GeomType::Polygon) => {
86                        let mut decoder = GeometryDecoder::new(&feature.geometry);
87                        match decoder.decode_polygons() {
88                            Ok(polygons) => {
89                                for polygon in polygons.iter() {
90                                    for (ring_idx, ring) in polygon.iter().enumerate() {
91                                        let ring_type = if ring_idx == 0 {
92                                            "exterior"
93                                        } else {
94                                            "interior"
95                                        };
96                                        for vertex in ring.iter() {
97                                            println!(
98                                                "feature.polygon.{}.vertex={},{}",
99                                                ring_type,
100                                                vertex[0],
101                                                vertex[1]
102                                            );
103                                        }
104                                    }
105                                }
106                            }
107                            Err(e) => println!("feature.geometry.error={}", e),
108                        }
109                    }
110                    _ => {
111                        println!("feature.geometry.raw={}", feature.geometry.len());
112                    }
113                }
114            }
115        }
116    }
117}
```

--------------------------------

### Create a new GeometryEncoder

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/geometry/struct.GeometryEncoder.html?search=u32+-%3E+bool

Instantiates a new GeometryEncoder. This is the starting point for adding geometric data.

```rust
let mut geom_enc = GeometryEncoder::new();
```

--------------------------------

### Encoding Geometry Data

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/geometry/struct.GeometryEncoder.html?search=

This example demonstrates how to use GeometryEncoder to add various geometric types like points, linestrings, and polygons. It also shows how to associate tags with features and encode the entire layer into a Tile object.

```rust
fn main() {
    let extent = 4096;

    let layer = {
        let mut tags_enc = TagsEncoder::new();

        let points_feature = {
            let mut geom_enc = GeometryEncoder::new();
            geom_enc.add_points([
                [300, 300],
                [300, extent - 300],
                [extent - 300, extent - 300],
                [extent - 300, 300],
                [900, 900],
                [900, extent - 900],
                [extent - 900, extent - 900],
                [extent - 900, 900],
            ]);

            tags_enc.add("foo", 10);
            tags_enc.add("bar", 20.5);

            Feature {
                id: Some(1),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Point as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let line_strings_feature = {
            let mut geom_enc = GeometryEncoder::new();
            geom_enc.add_linestring([[0, 0], [0, extent], [extent, extent], [extent, 0]]);
            geom_enc.add_linestring([
                [500, 500],
                [500, extent - 500],
                [extent - 500, extent - 500],
                [extent - 500, 500],
            ]);
            geom_enc.add_linestring([
                [700, 700],
                [700, extent - 700],
                [extent - 700, extent - 700],
                [extent - 700, 700],
            ]);

            tags_enc.add("uint", Value::Uint(10));
            tags_enc.add("sint", Value::SInt(-10));
            tags_enc.add("int", Value::Int(10));
            tags_enc.add("string", Value::String("string".to_string()));
            tags_enc.add("float", 10.5f32);
            tags_enc.add("double", 10.5f64);
            tags_enc.add("bool", Value::Bool(true));

            Feature {
                id: Some(2),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Linestring as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let polygon_feature = {
            let mut geom_enc = GeometryEncoder::new();
            geom_enc.add_ring([[1000, 1000], [1000, 1500], [1500, 1500], [1500, 1000]]);
            geom_enc.add_ring([[1100, 1100], [1200, 1100], [1200, 1200], [1100, 1200]]);
            geom_enc.add_ring([[1200, 1200], [1300, 1200], [1300, 1300], [1200, 1300]]);

            geom_enc.add_ring([[2000, 2000], [2000, 2500], [2500, 2500], [2500, 2000]]);
            geom_enc.add_ring([[2100, 2100], [2200, 2100], [2200, 2200], [2100, 2200]]);
            geom_enc.add_ring([[2200, 2200], [2300, 2200], [2300, 2300], [2200, 2300]]);
            geom_enc.add_ring([[2300, 2300], [2400, 2300], [2400, 2400], [2300, 2400]]);

            tags_enc.add("fizz", 10);
            tags_enc.add("buzz", 20.5);

            Feature {
                id: Some(3),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Polygon as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let (keys, values) = tags_enc.into_keys_and_values();

        Layer {
            version: 2,
            name: "road".to_string(),
            features: vec![points_feature, line_strings_feature, polygon_feature],
            keys,
            values,
            extent: Some(4096),
        }
    };

    let buf = Tile {
        layers: vec![layer],
    }
    .encode_to_vec();

    fs::write("tile.pbf", buf).unwrap();
}

```

--------------------------------

### Initialize TagsEncoder

Source: https://docs.rs/tinymvt/0.3.0/src/tinymvt/tag.rs.html

Creates a new instance of `TagsEncoder`. This is the starting point for encoding attributes for MVT features.

```rust
pub fn new() -> Self {
    Default::default()
}
```

--------------------------------

### Encoding Geometry with GeometryEncoder

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/geometry/struct.GeometryEncoder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to use `GeometryEncoder` to add points, linestrings, and polygons, and then convert the encoded geometry into a vector of u32 using `into_vec`. It also shows the integration with `TagsEncoder` and the creation of `Feature` and `Layer` objects for tile encoding.

```rust
11fn main() {
12    let extent = 4096;
13
14    let layer = {
15        let mut tags_enc = TagsEncoder::new();
16
17        let points_feature = {
18            let mut geom_enc = GeometryEncoder::new();
19            geom_enc.add_points([
20                [300, 300],
21                [300, extent - 300],
22                [extent - 300, extent - 300],
23                [extent - 300, 300],
24                [900, 900],
25                [900, extent - 900],
26                [extent - 900, extent - 900],
27                [extent - 900, 900],
28            ]);
29
30            tags_enc.add("foo", 10);
31            tags_enc.add("bar", 20.5);
32
33            Feature {
34                id: Some(1),
35                tags: tags_enc.take_tags(),
36                r#type: Some(GeomType::Point as i32),
37                geometry: geom_enc.into_vec(),
38            }
39        };
40
41        let line_strings_feature = {
42            let mut geom_enc = GeometryEncoder::new();
43            geom_enc.add_linestring([[0, 0], [0, extent], [extent, extent], [extent, 0]]);
44            geom_enc.add_linestring([
45                [500, 500],
46                [500, extent - 500],
47                [extent - 500, extent - 500],
48                [extent - 500, 500],
49            ]);
50            geom_enc.add_linestring([
51                [700, 700],
52                [700, extent - 700],
53                [extent - 700, extent - 700],
54                [extent - 700, 700],
55            ]);
56
57            tags_enc.add("uint", Value::Uint(10));
58            tags_enc.add("sint", Value::SInt(-10));
59            tags_enc.add("int", Value::Int(10));
60            tags_enc.add("string", Value::String("string".to_string()));
61            tags_enc.add("float", 10.5f32);
62            tags_enc.add("double", 10.5f64);
63            tags_enc.add("bool", Value::Bool(true));
64
65            Feature {
66                id: Some(2),
67                tags: tags_enc.take_tags(),
68                r#type: Some(GeomType::Linestring as i32),
69                geometry: geom_enc.into_vec(),
70            }
71        };
72
73        let polygon_feature = {
74            let mut geom_enc = GeometryEncoder::new();
75            geom_enc.add_ring([[1000, 1000], [1000, 1500], [1500, 1500], [1500, 1000]]);
76            geom_enc.add_ring([[1100, 1100], [1200, 1100], [1200, 1200], [1100, 1200]]);
77            geom_enc.add_ring([[1200, 1200], [1300, 1200], [1300, 1300], [1200, 1300]]);
78
79            geom_enc.add_ring([[2000, 2000], [2000, 2500], [2500, 2500], [2500, 2000]]);
80            geom_enc.add_ring([[2100, 2100], [2200, 2100], [2200, 2200], [2100, 2200]]);
81            geom_enc.add_ring([[2200, 2200], [2300, 2200], [2300, 2300], [2200, 2300]]);
82            geom_enc.add_ring([[2300, 2300], [2400, 2300], [2400, 2400], [2300, 2400]]);
83
84            tags_enc.add("fizz", 10);
85            tags_enc.add("buzz", 20.5);
86
87            Feature {
88                id: Some(3),
89                tags: tags_enc.take_tags(),
90                r#type: Some(GeomType::Polygon as i32),
91                geometry: geom_enc.into_vec(),
92            }
93        };
94
95        let (keys, values) = tags_enc.into_keys_and_values();
96
97        Layer {
98            version: 2,
99            name: "road".to_string(),
100            features: vec![points_feature, line_strings_feature, polygon_feature],
101            keys,
102            values,
103            extent: Some(4096),
104        }
105    };
106
107    let buf = Tile {
108        layers: vec![layer],
109    }
110    .encode_to_vec();
111
112    fs::write("tile.pbf", buf).unwrap();
113}
```

--------------------------------

### Add Various Data Types to TagsEncoder

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/tag/struct.TagsEncoder.html?search=std%3A%3Avec

Shows how to add different data types (Uint, SInt, Int, String, Float, Double, Bool) as tags using the TagsEncoder. This example illustrates the flexibility of the `add` method.

```rust
tags_enc.add("uint", Value::Uint(10));
tags_enc.add("sint", Value::SInt(-10));
tags_enc.add("int", Value::Int(10));
tags_enc.add("string", Value::String("string".to_string()));
tags_enc.add("float", 10.5f32);
tags_enc.add("double", 10.5f64);
tags_enc.add("bool", Value::Bool(true));
```

--------------------------------

### Decode and Print MVT File Contents

Source: https://docs.rs/tinymvt/0.3.0/src/dump_mvt/dump_mvt.rs.html?search=u32+-%3E+bool

This is the main function of the `dump_mvt` utility. It parses command-line arguments to get the MVT file path, reads the file, decodes the MVT data using `prost::Message::decode`, and then iterates through layers and features to print their properties. It handles point, linestring, and polygon geometries, as well as feature tags.

```rust
use std::env;
use std::fs;

use prost::Message;
use std::convert::TryFrom;
use tinymvt::geometry::GeometryDecoder;
use tinymvt::tag::TagsDecoder;
use tinymvt::vector_tile::{tile::GeomType, Tile};

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() != 2 {
        eprintln!("Usage: {} <path-to-mvt-file>", args[0]);
        std::process::exit(1);
    }

    let path = &args[1];
    let data = fs::read(path).expect("Failed to read MVT file");

    let tile = Tile::decode(&data[..]).expect("Failed to decode MVT protobuf");

    println!("layers={}", tile.layers.len());

    for layer in tile.layers.iter() {
        println!("layer.name={}", layer.name);
        println!("layer.version={}", layer.version);
        println!("layer.extent={}", layer.extent.unwrap_or(4096));
        println!("layer.features={}", layer.features.len());
        println!("layer.keys={}", layer.keys.len());
        println!("layer.values={}", layer.values.len());

        let tags_decoder = TagsDecoder::new(&layer.keys, &layer.values);

        for feature in layer.features.iter() {
            if let Some(id) = feature.id {
                println!("feature.id={}", id);
            }

            let geom_type = feature.r#type.and_then(|t| GeomType::try_from(t).ok());
            println!("feature.type={:?}", geom_type.unwrap_or(GeomType::Unknown));

            if !feature.tags.is_empty() {
                match tags_decoder.decode(&feature.tags) {
                    Ok(tags) => {
                        for (key, value) in tags {
                            println!("feature.tag.{}={}", key, format_value(&value));
                        }
                    }
                    Err(e) => {
                        println!("feature.tags.error={}", e);
                    }
                }
            }

            if !feature.geometry.is_empty() {
                match geom_type {
                    Some(GeomType::Point) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_points() {
                            Ok(points) => {
                                for point in points.iter() {
                                    println!("feature.point={},{}", point[0], point[1]);
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    Some(GeomType::Linestring) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_linestrings() {
                            Ok(linestrings) => {
                                for ls in linestrings.iter() {
                                    for vertex in ls.iter() {
                                        println!(
                                            "feature.linestring.vertex={},{}",
                                            vertex[0],
                                            vertex[1]
                                        );
                                    }
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    Some(GeomType::Polygon) => {
                        let mut decoder = GeometryDecoder::new(&feature.geometry);
                        match decoder.decode_polygons() {
                            Ok(polygons) => {
                                for polygon in polygons.iter() {
                                    for (ring_idx, ring) in polygon.iter().enumerate() {
                                        let ring_type = if ring_idx == 0 {
                                            "exterior"
                                        } else {
                                            "interior"
                                        };
                                        for vertex in ring.iter() {
                                            println!(
                                                "feature.polygon.{}.vertex={},{}",
                                                ring_type,
                                                vertex[0],
                                                vertex[1]
                                            );
                                        }
                                    }
                                }
                            }
                            Err(e) => println!("feature.geometry.error={}", e),
                        }
                    }
                    _ => {
                    }
                }
            }
        }
    }
}

fn format_value(value: &tinymvt::tag::Value) -> String {
    match value {
        tinymvt::tag::Value::String(s) => s.clone(),
        tinymvt::tag::Value::F32(f) => f.to_string(),
        tinymvt::tag::Value::F64(f) => f.to_string(),
        tinymvt::tag::Value::I64(i) => i.to_string(),
        tinymvt::tag::Value::Ui64(u) => u.to_string(),
        tinymvt::tag::Value::Bool(b) => b.to_string(),
        tinymvt::tag::Value::Json(j) => j.clone(),
    }
}

```

--------------------------------

### impl<T> Any for T

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/vector_tile/struct.Tile.html?search=u32+-%3E+bool

Provides the `type_id` method to get the `TypeId` of a type.

```APIDOC
## fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`.
```

--------------------------------

### impl Any for T

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/tag/enum.Value.html

Provides the `type_id` method to get the unique identifier of a type.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Parameters
None

### Response
- **TypeId**: The unique identifier of the type.
```

--------------------------------

### Create a Vector Tile with tinymvt

Source: https://docs.rs/tinymvt/0.3.0/src/demo/demo.rs.html?search=u32+-%3E+bool

This snippet shows how to construct a Vector Tile. It includes creating layers, adding features with different geometry types (Point, Linestring, Polygon), and encoding tags with various value types. The resulting tile is then serialized to a byte vector and written to a file.

```rust
use std::fs;

use prost::Message;
use tinymvt::geometry::GeometryEncoder;
use tinymvt::tag::{TagsEncoder, Value};
use tinymvt::vector_tile::{
    tile::{Feature, GeomType, Layer},
    Tile,
};

fn main() {
    let extent = 4096;

    let layer = {
        let mut tags_enc = TagsEncoder::new();

        let points_feature = {
            let mut geom_enc = GeometryEncoder::new();
            geom_enc.add_points([
                [300, 300],
                [300, extent - 300],
                [extent - 300, extent - 300],
                [extent - 300, 300],
                [900, 900],
                [900, extent - 900],
                [extent - 900, extent - 900],
                [extent - 900, 900],
            ]);

            tags_enc.add("foo", 10);
            tags_enc.add("bar", 20.5);

            Feature {
                id: Some(1),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Point as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let line_strings_feature = {
            let mut geom_enc = GeometryEncoder::new();
            geom_enc.add_linestring([[0, 0], [0, extent], [extent, extent], [extent, 0]]);
            geom_enc.add_linestring([
                [500, 500],
                [500, extent - 500],
                [extent - 500, extent - 500],
                [extent - 500, 500],
            ]);
            geom_enc.add_linestring([
                [700, 700],
                [700, extent - 700],
                [extent - 700, extent - 700],
                [extent - 700, 700],
            ]);

            tags_enc.add("uint", Value::Uint(10));
            tags_enc.add("sint", Value::SInt(-10));
            tags_enc.add("int", Value::Int(10));
            tags_enc.add("string", Value::String("string".to_string()));
            tags_enc.add("float", 10.5f32);
            tags_enc.add("double", 10.5f64);
            tags_enc.add("bool", Value::Bool(true));

            Feature {
                id: Some(2),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Linestring as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let polygon_feature = {
            let mut geom_enc = GeometryEncoder::new();
            geom_enc.add_ring([[1000, 1000], [1000, 1500], [1500, 1500], [1500, 1000]]);
            geom_enc.add_ring([[1100, 1100], [1200, 1100], [1200, 1200], [1100, 1200]]);
            geom_enc.add_ring([[1200, 1200], [1300, 1200], [1300, 1300], [1200, 1300]]);

            geom_enc.add_ring([[2000, 2000], [2000, 2500], [2500, 2500], [2500, 2000]]);
            geom_enc.add_ring([[2100, 2100], [2200, 2100], [2200, 2200], [2100, 2200]]);
            geom_enc.add_ring([[2200, 2200], [2300, 2200], [2300, 2300], [2200, 2300]]);
            geom_enc.add_ring([[2300, 2300], [2400, 2300], [2400, 2400], [2300, 2400]]);

            tags_enc.add("fizz", 10);
            tags_enc.add("buzz", 20.5);

            Feature {
                id: Some(3),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Polygon as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let (keys, values) = tags_enc.into_keys_and_values();

        Layer {
            version: 2,
            name: "road".to_string(),
            features: vec![points_feature, line_strings_feature, polygon_feature],
            keys,
            values,
            extent: Some(4096),
        }
    };

    let buf = Tile {
        layers: vec![layer],
    }
    .encode_to_vec();

    fs::write("tile.pbf", buf).unwrap();
}
```

--------------------------------

### impl CloneToUninit for T

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/tag/enum.Value.html

Provides the experimental `clone_to_uninit` method for cloning to uninitialized memory.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`.

### Parameters
- **dest** (*mut u8): A pointer to the destination memory location.

### Response
None
```

--------------------------------

### impl<T> CloneToUninit for T

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/vector_tile/tile/struct.Value.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides an unsafe, nightly-only experimental API for cloning data directly into an uninitialized memory location.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to the memory location pointed to by `dest`.

### Method
`clone_to_uninit`

### Parameters
- `&self` (T): A reference to the data to be cloned.
- `dest` (*mut u8): A raw pointer to the destination memory location.

### Safety
This function is unsafe because it operates on raw pointers and assumes the destination memory is valid and sufficiently large to hold the cloned data.
```

--------------------------------

### Initialize TagsEncoder and Add Tags

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/tag/struct.TagsEncoder.html

Demonstrates creating a new TagsEncoder instance and adding various types of tags to it. This is typically done before creating a feature.

```rust
    let mut tags_enc = TagsEncoder::new();

    tags_enc.add("foo", 10);
    tags_enc.add("bar", 20.5);

    tags_enc.add("uint", Value::Uint(10));
    tags_enc.add("sint", Value::SInt(-10));
    tags_enc.add("int", Value::Int(10));
    tags_enc.add("string", Value::String("string".to_string()));
    tags_enc.add("float", 10.5f32);
    tags_enc.add("double", 10.5f64);
    tags_enc.add("bool", Value::Bool(true));

```

--------------------------------

### Basic Function Definition

Source: https://docs.rs/tinymvt/0.3.0/scrape-examples-help.html

A simple public function definition in Rust. This serves as an item that can be documented and have examples scraped.

```rust
// src/lib.rs
pub fn a_func() {}
```

--------------------------------

### Test Boundary Conversion (Meters)

Source: https://docs.rs/tinymvt/0.3.0/src/tinymvt/webmercator.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Tests the conversion of extreme geographic coordinates (180, 85.05) to Web Mercator meters, verifying the boundary conditions.

```rust
let (lng, lat) = (180., 85.0511287798066);

```

--------------------------------

### Module Summary and Exports

Source: https://docs.rs/tinymvt/0.3.0/src/tinymvt/tileid/mod.rs.html

This snippet shows the main documentation comment for the tileid module and its re-export of the hilbert module.

```rust
1//! Conversion between Tile ID and XYZ tile coordinate.
2
3pub mod hilbert;
4
5pub use hilbert::*;

```

--------------------------------

### Get string_value

Source: https://docs.rs/tinymvt/0.3.0/tinymvt/vector_tile/tile/struct.Value.html?search=u32+-%3E+bool

Returns the string value of the `string_value` field. If the field is unset, it returns an empty string slice.

```rust
pub fn string_value(&self) -> &str
```

--------------------------------

### GeomType as String

Source: https://docs.rs/tinymvt/0.3.0/src/tinymvt/vector_tile.rs.html

Provides a method to get the string representation of a GeomType enum variant, useful for debugging or logging.

```rust
impl GeomType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unknown => "UNKNOWN",
            Self::Point => "POINT",
            Self::Linestring => "LINESTRING",
            Self::Polygon => "POLYGON",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {

```
Tokens:
Raw