Struct Map 

pub struct Map { /* private fields */ }

represents a map assembled from map tiles

Implementations

impl Map

pub async fn new( map_tile_cache: &mut MapTileCache, x: u32, y: u32, grid_rectangle: GridRectangle, fill_missing_map_tiles: Option<Rgba<u8>>, fill_missing_regions: Option<Rgba<u8>>, ) -> Result<Self, MapError>

creates a new Map

if we choose not to fill the missing map tiles they appear as black

if we choose not to fill the missing regions they appear in a color similar to water but filling them in has some performance impact since we need to check if the region exists by fetching higher resolution map tiles for it.

Errors

returns an error if fetching the map tiles fails

Arguments

• map_tile_cache - the map tile cache to use to fetch the map tiles
• x - the width of the map in pixels
• y - the height of the map in pixels
• grid_rectangle - the grid rectangle of regions represented by this map

pub async fn draw_route( &mut self, region_name_to_grid_coordinates_cache: &mut RegionNameToGridCoordinatesCache, usb_notecard: &USBNotecard, color: Rgba<u8>, ) -> Result<(), MapError>

draws a route from a USBNotecard onto the map

Errors

fails if the region name to grid coordinate conversion fails or the conversion of those into pixel coordinates

pub fn save(&self, path: &Path) -> Result<(), ImageError>

saves the map to the specified path

Errors

returns an error when the image libraries returns an error when saving the image

Trait Implementations

impl Clone for Map

fn clone(&self) -> Map

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Map

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl GenericImage for Map

fn get_pixel_mut(&mut self, x: u32, y: u32) -> &mut Self::Pixel

👎Deprecated since 0.24.0:

Use get_pixel and put_pixel instead.

Gets a reference to the mutable pixel at location (x, y). Indexed from top left.

fn put_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel)

Put a pixel at location (x, y). Indexed from top left.

fn blend_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel)

👎Deprecated since 0.24.0:

Use iterator pixels_mut to blend the pixels directly

Put a pixel at location (x, y), taking into account alpha channels

unsafe fn unsafe_put_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel)

Puts a pixel at location (x, y). Indexed from top left.

fn copy_from<O>(&mut self, other: &O, x: u32, y: u32) -> Result<(), ImageError>

where O: GenericImageView<Pixel = Self::Pixel>,

Copies all of the pixels from another image into this image.

fn copy_from_samples( &mut self, samples: View<&[<Self::Pixel as Pixel>::Subpixel], Self::Pixel>, x: u32, y: u32, ) -> Result<(), ImageError>

Copy pixels from a regular strided matrix of pixels.

fn copy_within(&mut self, source: Rect, x: u32, y: u32) -> bool

Copies all of the pixels from one part of this image to another part of this image.

fn sub_image( &mut self, x: u32, y: u32, width: u32, height: u32, ) -> SubImage<&mut Self>

where Self: Sized,

Returns a mutable subimage that is a view into this image. If you want an immutable subimage instead, use GenericImageView::view The coordinates set the position of the top left corner of the SubImage.

impl GenericImageView for Map

type Pixel = <DynamicImage as GenericImageView>::Pixel

The type of pixel.

fn dimensions(&self) -> (u32, u32)

The width and height of this image.

fn get_pixel(&self, x: u32, y: u32) -> Self::Pixel

Returns the pixel located at (x, y). Indexed from top left.

fn width(&self) -> u32

The width of this image.

fn height(&self) -> u32

The height of this image.

fn in_bounds(&self, x: u32, y: u32) -> bool

Returns true if this x, y coordinate is contained inside the image.

unsafe fn unsafe_get_pixel(&self, x: u32, y: u32) -> Self::Pixel

Returns the pixel located at (x, y). Indexed from top left.

fn pixels(&self) -> Pixels<'_, Self>

where Self: Sized,

Returns an Iterator over the pixels of this image. The iterator yields the coordinates of each pixel along with their value

fn view(&self, x: u32, y: u32, width: u32, height: u32) -> SubImage<&Self>

where Self: Sized,

Returns a subimage that is an immutable view into this image. You can use GenericImage::sub_image if you need a mutable view instead. The coordinates set the position of the top left corner of the view.

fn try_view( &self, x: u32, y: u32, width: u32, height: u32, ) -> Result<SubImage<&Self>, ImageError>

where Self: Sized,

Returns a subimage that is an immutable view into this image so long as the provided coordinates and dimensions are within the bounds of this Image.

fn buffer_like( &self, ) -> ImageBuffer<Self::Pixel, Vec<<Self::Pixel as Pixel>::Subpixel>>

Create an empty ImageBuffer with the same pixel type as this image.

fn buffer_with_dimensions( &self, width: u32, height: u32, ) -> ImageBuffer<Self::Pixel, Vec<<Self::Pixel as Pixel>::Subpixel>>

Create an empty ImageBuffer with different dimensions.

fn to_pixel_view( &self, ) -> Option<View<&[<Self::Pixel as Pixel>::Subpixel], Self::Pixel>>

If the buffer has a fitting layout, return a canonical view of the samples.

impl GridRectangleLike for Map

fn grid_rectangle(&self) -> GridRectangle

the GridRectangle represented by this map like image

fn lower_left_corner(&self) -> GridCoordinates

returns the lower left corner of the rectangle

fn lower_right_corner(&self) -> GridCoordinates

returns the lower right corner of the rectangle

fn upper_left_corner(&self) -> GridCoordinates

returns the upper left corner of the rectangle

fn upper_right_corner(&self) -> GridCoordinates

returns the upper right corner of the rectangle

fn size_x(&self) -> u16

the size of the map like image in regions in the x direction (width)

fn size_y(&self) -> u16

the size of the map like image in regions in the y direction (width)

fn x_range(&self) -> RangeInclusive<u16>

returns a range for the region x coordinates of this rectangle

fn y_range(&self) -> RangeInclusive<u16>

returns a range for the region y coordinates of this rectangle

fn contains(&self, grid_coordinates: &GridCoordinates) -> bool

checks if a given set of GridCoordinates is within this GridRectangle

fn intersect<O>(&self, other: &O) -> Option<GridRectangle>

where O: GridRectangleLike,

returns a new GridRectangle which is the area where this GridRectangle and another intersect each other or None if there is no intersection

fn pps_hud_config(&self) -> String

returns a PPS HUD description string for this GridRectangle

impl MapLike for Map

fn zoom_level(&self) -> ZoomLevel

the zoom level of the map

fn image(&self) -> &DynamicImage

the image of the map

fn image_mut(&mut self) -> &mut DynamicImage

the mutable image of the map

fn pixels_per_meter(&self) -> f32

pixels per meter

fn pixels_per_region(&self) -> f32

pixels per region

fn pixel_coordinates_for_coordinates( &self, grid_coordinates: &GridCoordinates, region_coordinates: &RegionCoordinates, ) -> Option<(u32, u32)>

the pixel coordinates in the map that represent the given GridCoordinates and RegionCoordinates

fn coordinates_for_pixel_coordinates( &self, x: u32, y: u32, ) -> Option<(GridCoordinates, RegionCoordinates)>

the GridCoordinates and RegionCoordinates at the given pixel coordinates

fn crop_imm_grid_rectangle( &self, grid_rectangle: &GridRectangle, ) -> Option<SubImage<&Self>>

where Self: Sized,

a crop of the map like image by coordinates and size

fn draw_waypoint(&mut self, x: u32, y: u32, color: Rgba<u8>)

draw a waypoint at the given coordinates

fn draw_line( &mut self, from_x: u32, from_y: u32, to_x: u32, to_y: u32, color: Rgba<u8>, )

draw a line from the given coordinates to the given coordinates

fn draw_arrow(&mut self, from: (f32, f32), tip: (f32, f32), color: Rgba<u8>)

draw an arrow from the direction of the first point with the tip at the second point