### 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 -> U) -> Option ``` -------------------------------- ### 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 = env::args().collect(); if args.len() != 2 { eprintln!("Usage: {} ", 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 = env::args().collect(); if args.len() != 2 { eprintln!("Usage: {} ", 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 = env::args().collect(); if args.len() != 2 { eprintln!("Usage: {} ", 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 = env::args().collect(); 12 if args.len() != 2 { 13 eprintln!("Usage: {} ", 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 = env::args().collect(); if args.len() != 2 { eprintln!("Usage: {} ", 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 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 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 { match value { ``` -------------------------------- ### Get int_value Source: https://docs.rs/tinymvt/0.3.0/tinymvt/vector_tile/tile/struct.Value.html?search=u32+-%3E+bool Returns the integer value of the `int_value` field. If the field is unset, it returns the default value for i64, which is 0. ```rust pub fn int_value(&self) -> i64 ```