Struct mvt::Tile

pub struct Tile { /* private fields */ }

A tile represents a rectangular region of a map.

Each tile can contain any number of layers. When all layers have been added to the tile, it can be written out or converted to a Vec<u8>.

Example

use mvt::Tile;

let mut tile = Tile::new(4096);
let layer = tile.create_layer("First Layer");
// ...
// set up the layer
// ...
tile.add_layer(layer)?;
// ...
// add more layers
// ...
let data = tile.to_bytes()?;

Implementations

impl Tile

pub fn new(extent: u32) -> Self

Create a new tile.

• extent Height / width of tile bounds.

Examples found in repository

examples/simple.rs (line 4)

fn main() -> Result<(), Error> {
    let mut tile = Tile::new(4096);
    let layer = tile.create_layer("First Layer");
    // NOTE: normally, the Transform would come from MapGrid::tile_transform
    let b = GeomEncoder::new(GeomType::Linestring)
        .point(0.0, 0.0)?
        .point(1024.0, 0.0)?
        .point(1024.0, 2048.0)?
        .point(2048.0, 2048.0)?
        .point(2048.0, 4096.0)?
        .encode()?;
    let mut feature = layer.into_feature(b);
    feature.set_id(1);
    feature.add_tag_string("key", "value");
    let layer = feature.into_layer();
    tile.add_layer(layer)?;
    let data = tile.to_bytes()?;
    println!("encoded {} bytes: {:?}", data.len(), data);
    Ok(())
}

pub fn extent(&self) -> u32

Get extent, or height / width of tile bounds.

pub fn num_layers(&self) -> usize

Get the number of layers.

pub fn create_layer(&self, name: &str) -> Layer

Create a new layer.

• name Layer name.

Examples found in repository

examples/simple.rs (line 5)

fn main() -> Result<(), Error> {
    let mut tile = Tile::new(4096);
    let layer = tile.create_layer("First Layer");
    // NOTE: normally, the Transform would come from MapGrid::tile_transform
    let b = GeomEncoder::new(GeomType::Linestring)
        .point(0.0, 0.0)?
        .point(1024.0, 0.0)?
        .point(1024.0, 2048.0)?
        .point(2048.0, 2048.0)?
        .point(2048.0, 4096.0)?
        .encode()?;
    let mut feature = layer.into_feature(b);
    feature.set_id(1);
    feature.add_tag_string("key", "value");
    let layer = feature.into_layer();
    tile.add_layer(layer)?;
    let data = tile.to_bytes()?;
    println!("encoded {} bytes: {:?}", data.len(), data);
    Ok(())
}

pub fn add_layer(&mut self, layer: Layer) -> Result<(), Error>

Add a layer.

• layer The layer.

Returns an error if:

• a layer with the same name already exists
• the layer extent does not match the tile extent

Examples found in repository

examples/simple.rs (line 18)

fn main() -> Result<(), Error> {
    let mut tile = Tile::new(4096);
    let layer = tile.create_layer("First Layer");
    // NOTE: normally, the Transform would come from MapGrid::tile_transform
    let b = GeomEncoder::new(GeomType::Linestring)
        .point(0.0, 0.0)?
        .point(1024.0, 0.0)?
        .point(1024.0, 2048.0)?
        .point(2048.0, 2048.0)?
        .point(2048.0, 4096.0)?
        .encode()?;
    let mut feature = layer.into_feature(b);
    feature.set_id(1);
    feature.add_tag_string("key", "value");
    let layer = feature.into_layer();
    tile.add_layer(layer)?;
    let data = tile.to_bytes()?;
    println!("encoded {} bytes: {:?}", data.len(), data);
    Ok(())
}

pub fn write_to(&self, out: &mut dyn Write) -> Result<(), Error>

Write the tile.

• out Writer to output the tile.

pub fn to_bytes(&self) -> Result<Vec<u8>, Error>

Encode the tile and return the bytes.

Examples found in repository

examples/simple.rs (line 19)

fn main() -> Result<(), Error> {
    let mut tile = Tile::new(4096);
    let layer = tile.create_layer("First Layer");
    // NOTE: normally, the Transform would come from MapGrid::tile_transform
    let b = GeomEncoder::new(GeomType::Linestring)
        .point(0.0, 0.0)?
        .point(1024.0, 0.0)?
        .point(1024.0, 2048.0)?
        .point(2048.0, 2048.0)?
        .point(2048.0, 4096.0)?
        .encode()?;
    let mut feature = layer.into_feature(b);
    feature.set_id(1);
    feature.add_tag_string("key", "value");
    let layer = feature.into_layer();
    tile.add_layer(layer)?;
    let data = tile.to_bytes()?;
    println!("encoded {} bytes: {:?}", data.len(), data);
    Ok(())
}

pub fn compute_size(&self) -> usize

Compute the encoded size in bytes.