Struct cell_map::cell_map_file::CellMapFile

pub struct CellMapFile<L, T> where
    L: Layer,  {
    pub num_layers: usize,
    pub layers: Vec<L>,
    pub cell_bounds: Bounds,
    pub cell_size: Vector2<f64>,
    pub cell_boundary_precision: f64,
    pub from_parent_angle_rad: f64,
    pub from_parent_translation: Vector2<f64>,
    pub from_parent_matrix: Affine2<f64>,
    pub data: Vec<Array2<T>>,
}

Represents a file that can be serialised and deserialised using serde.

Fields

num_layers: usize

Number of layers stored in the map

layers: Vec<L>

The order of layers in the map.

The index of a layer name in this vector matches the index of that layer in the data member.

cell_bounds: Bounds

The bounds of the map

cell_size: Vector2<f64>

The size of each cell in the map, in parent-frame units.

cell_boundary_precision: f64

The precision used when calculating cell boundaries, relative to cell_size.

from_parent_angle_rad: f64

The angle which rotates the parent frame into the map frame, in radians.

from_parent_translation: Vector2<f64>

The translation that goes from the parent frame to the map frame, in parent frame units.

from_parent_matrix: Affine2<f64>

The affine transformation matrix that converts from points in the parent frame to the map frame.

data: Vec<Array2<T>>

Stores each layer of the map as an ndarray::Array2<T>.

Implementations

impl<L, T> CellMapFile<L, T> where
    L: Layer, 

pub fn into_cell_map(self) -> Result<CellMap<L, T>, Error>

Converts this file into a CellMap.

impl<L, T> CellMapFile<L, T> where
    L: Layer + Serialize,
    T: Serialize, 

pub fn write_json<P: AsRef<Path>>(&self, path: P) -> Result<(), Error>

Writes the CellMapFile to the given path, overwriting any existing file. The format of the written file is JSON.

impl<L, T> CellMapFile<L, T> where
    L: Layer + DeserializeOwned,
    T: DeserializeOwned, 

pub fn from_json<P: AsRef<Path>>(path: P) -> Result<Self, Error>

Loads a CellMapFile from the given path, which points to a JSON file.

Trait Implementations

impl<L: Clone, T: Clone> Clone for CellMapFile<L, T> where
    L: Layer, 

fn clone(&self) -> CellMapFile<L, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Debug, T: Debug> Debug for CellMapFile<L, T> where
    L: Layer, 

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

Formats the value using the given formatter.

impl<'de, L, T> Deserialize<'de> for CellMapFile<L, T> where
    L: Layer,
    L: Deserialize<'de>,
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<L, T> From<CellMap<L, T>> for CellMapFile<L, T> where
    L: Layer + Serialize,
    T: Clone + Serialize, 

fn from(map: CellMap<L, T>) -> Self

Performs the conversion.

impl<L, T> Serialize for CellMapFile<L, T> where
    L: Layer,
    L: Serialize,
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<L, T> TryFrom<CellMapFile<L, T>> for CellMap<L, T> where
    L: Layer, 

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: CellMapFile<L, T>) -> Result<Self, Self::Error>

Performs the conversion.