Struct geogrid::GeoGrid

pub struct GeoGrid { /* fields omitted */ }

GeoGrid represents some portion of a geographic map as a grid. The grid computes step size from the center of the bounds. Because earth is not flat there will be some distance distortion farther from the central latitude if the grid is spread over a large area.

Methods

impl GeoGrid

fn from_roads<NMatrix: AsRef<[NRow]> + Sync, NRow: AsRef<[Node]> + Sync>(roads: NMatrix,
                                                                         resolution: (usize, usize),
                                                                         scale: bool)
                                                                         -> GeoGrid

Construct a GeoGrid from a slice of roads, where each road is a slice of nodes. This constructor will interpolate linearly between nodes within each row to set to 1. The grid's bounds will be exactly large enough to contain every given map node. Resolution is given as pair of (height, width) of the grid in pixels. If scale is true, then the aspect ratio of the original map will be maintained, potentially reducing one of the resolution dimensions. Otherwise, with scale false, the grid will stretch to the provided resolution.

fn from_nodes(nodes: &[Node], resolution: (f32, f32)) -> GeoGrid

Construct a GeoGrid from provided slice of nodes using given resolution, expressed in units of (meters latitude per grid unit, meters longitude per grid unit).

fn resolution(&self) -> (f32, f32)

Grid resolution, in meters per row and meters per column.

fn degree_resolution(&self) -> (f32, f32)

Grid resolution, in degrees latitude per row and degrees longitude per column.

fn bbox(&self) -> Bounds

Return the lat/lon boundaries of the grid.

fn size(&self) -> (usize, usize)

Grid dimensions.

fn len(&self) -> usize

Grid length, product of width and height.

fn is_empty(&self) -> bool

Grid is 0x0.

fn clear_grid(&mut self)

Clears the grid, but leaves all other fields intact. Maybe useful to save memory if you only need the distance transform and not the original grid.

fn real_size(&self) -> (f32, f32)

Latitude and longitude covered, in meters. resolution * size.

fn grid(&self) -> &[u8]

Immutable access to the underlying grid.

fn grid_mut(&mut self) -> &mut [u8]

Mutable access to the underlying grid.

fn trace_shape<BMatrix: AsRef<[BRow]>, BRow: AsRef<[bool]>>(&self,
                                                            shape: BMatrix,
                                                            topleft: usize)
                                                            -> Vec<usize>

Trace provided shape from given top left index, returning locations of all the true cells.

fn to_lat_lon(&self, idx: usize) -> (f32, f32)

Return lat, lon coordinates of given index in the grid.

fn near_lat_lon(&self, lat: f32, lon: f32) -> usize

Return closest index in grid to given latitude, longitude.

fn bounded_subgrid(&self,
                   north: f32,
                   south: f32,
                   east: f32,
                   west: f32)
                   -> (usize, (usize, usize))

Return start index and a new size of a bounded subgrid specified by given rectangle in degrees.

fn l1dist_transform(&self) -> Vec<i32>

Compute L1 distance transform of t matrix. Output is linearized matrix of same size as grid.

Trait Implementations

impl Clone for GeoGrid

fn clone(&self) -> GeoGrid

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.