Struct ColorSet 

pub struct ColorSet(pub Vec<Color>);

An ordered set of map colors.

The order of the Color values in the Vec determines their priority. Move colors to change priority, for example with color_set.0.swap(2, 5).

Deleting a color drops its allocation if there are no outstanding Rc references. Symbols and ColorComponent values only hold std::rc::Weak references. A dangling weak reference contributes no color when the map is written.

Tuple Fields

0: Vec<Color>

Implementations

impl ColorSet

pub fn len(&self) -> usize

Get the number of colors in the set.

pub fn is_empty(&self) -> bool

Returns true if the color set contains no colors.

pub fn push(&mut self, color: impl Into<Color>)

Append a new color with the lowest priority.

pub fn remove(&mut self, index: usize) -> Option<Color>

Remove a color by its priority index.

pub fn insert( &mut self, index: usize, color: impl Into<Color>, ) -> Result<(), Error>

Insert a new color into the ColorSet with priority index, fails if index > self.len()

Errors

Returns Error::ColorError if index is greater than the number of colors.

pub fn get_color_by_priority(&self, priority: usize) -> Option<&Color>

Get a color by its priority index.

pub fn get_weak_color_by_priority(&self, priority: usize) -> Option<WeakColor>

Get a weak reference to a color by its priority index.

pub fn get_color_by_name(&self, name: &str) -> Option<&Color>

Get the first color with an exact name match

pub fn get_id_of_color(&self, color: &Color) -> Option<usize>

Get the priority index of a specific color in the set (by pointer identity).

pub fn iter(&self) -> impl Iterator<Item = &Color>

Access the colors through an iterator

Examples found in repository

examples/default_write.rs (line 38)

fn main() -> Result<(), Error> {
    #[cfg(feature = "geo_ref")]
    let mut map = {
        let proj_center = Coord {
            x: 463_575.5,
            y: 6_833_849.6,
        };
        let map_center_elevation_meters = 2_469.;
        let crs_epsg_code = 25832;
        Omap::default_15_000_geo_referenced(
            proj_center,
            CrsType::Epsg(crs_epsg_code),
            map_center_elevation_meters,
        )?
    };
    #[cfg(not(feature = "geo_ref"))]
    let mut map = Omap::default_15_000()?;

    for color in map.colors.iter() {
        match color {
            Color::SpotColor(ref_cell) => {
                let b = ref_cell.try_borrow().unwrap();
                println!("{} with spot name {}", b.color_name, b.spotcolor_name);
            }
            Color::MixedColor(ref_cell) => {
                println!("{}", ref_cell.try_borrow().unwrap().color_name);
            }
        }
    }

    let erosion_gully = map
        .symbols
        .get_symbol_by_code(Code::new(107, 0, 0))
        .unwrap()
        .downgrade();

    let mut ls = LineObject::new(
        WeakLinePathSymbol::try_from(erosion_gully).unwrap(),
        // geometry coordinates are always in mm of paper
        LineString::new(vec![Coord { x: 0., y: 0. }, Coord { x: 200., y: 100. }]),
    );
    ls.tags.insert("Some Key".to_owned(), "My value".to_owned());

    map.parts.0[0].add_object(ls);

    println!("\nCombined Line symbols:");
    for symbol in map.symbols.iter() {
        if let Symbol::CombinedLine(s) = symbol {
            println!("{}", s.borrow().common.name);
        }
    }
    if let Some(s) = map.symbols.get_symbol_by_name("Railway, Olive background") {
        println!("{s:?}");
    }

    let mut num = 0;
    for symbol in map.symbols.iter() {
        if let Symbol::Line(s) = symbol {
            let borrowed = s.borrow();

            if let Some(_ss_) = &borrowed.start_symbol {
                num += 1;
            }
            if let Some(_ms_) = &borrowed.mid_symbol {
                num += 1;
            }
            if let Some(_ds_) = &borrowed.dash_symbol {
                num += 1;
            }
            if let Some(_es_) = &borrowed.end_symbol {
                num += 1;
            }
        }
        if let Symbol::CombinedLine(s) = symbol {
            let borrowed = s.borrow();

            for part in borrowed.components() {
                if let PublicOrPrivateSymbol::Private(s) = part {
                    if let Some(_ss_) = &s.start_symbol {
                        num += 1;
                    }
                    if let Some(_ms_) = &s.mid_symbol {
                        num += 1;
                    }
                    if let Some(_ds_) = &s.dash_symbol {
                        num += 1;
                    }
                    if let Some(_es_) = &s.end_symbol {
                        num += 1;
                    }
                }
            }
        }
    }
    println!("\nNumber of sub symbols in line symbols: {num}");

    map.write_to_file("./test_write.omap")
}

examples/from_path.rs (line 101)

fn main() -> Result<(), Error> {
    let mut map = Omap::from_path("./example_data/from_path.omap")?;

    #[cfg(feature = "geo_ref")]
    {
        // we want to move the map center to the average position of all objects
        let old_transform = map.geo_referencing.get_transform();

        let mut mean_pos = Coord::zero();
        let mut num_coords = 0;
        for obj in map.parts.iter().flat_map(|part| part.iter_all_objects()) {
            match obj {
                MapObject::Point(object) => {
                    mean_pos = mean_pos + object.get_geometry().0;
                    num_coords += 1;
                }
                MapObject::Line(object) => {
                    let geometry = object.get_geometry(0.1)?;
                    mean_pos =
                        mean_pos + geometry.0.iter().copied().reduce(|sum, c| sum + c).unwrap();
                    num_coords += geometry.0.len();
                }
                MapObject::Area(object) => {
                    let geometry = object.get_geometry(0.1)?;
                    mean_pos = mean_pos
                        + geometry
                            .exterior()
                            .0
                            .iter()
                            .copied()
                            .reduce(|sum, c| sum + c)
                            .unwrap();
                    num_coords += geometry.exterior().0.len();
                }
                MapObject::Text(object) => {
                    match object.get_geometry() {
                        TextGeometry::SingleAnchor(coord) => mean_pos = mean_pos + *coord,
                        TextGeometry::WrapBox(wrap_box) => mean_pos = mean_pos + wrap_box.anchor,
                    }
                    num_coords += 1;
                }
            }
        }
        mean_pos = mean_pos / num_coords as f64;

        // now transform that into projected coords
        let mean_proj_pos = old_transform.to_projected(mean_pos);

        // get the new georef info for that position
        let new_gr = GeoRef::initialize(
            mean_proj_pos,
            map.geo_referencing.crs_type,
            2_469.,
            map.geo_referencing.scale_denominator,
        )
        .unwrap();

        // assign the new info
        map.geo_referencing = new_gr;

        // get the new map transform
        let new_transform = map.geo_referencing.get_transform();

        // transfrom every object out of the old map space to projected coords
        // and from projected coord to the new map space
        // NB! If the new projection were different than the old,
        // a transfrom between projections using a proj library like proj-core would be needed
        // and this function would return Err
        map.apply_affine_between(&old_transform, &new_transform)
            .unwrap();
    };

    println!("Map colors in order:");
    for color in map.colors.iter() {
        match color {
            Color::SpotColor(ref_cell) => {
                let b = ref_cell.try_borrow().unwrap();
                println!("{} with spot name {}", b.color_name, b.spotcolor_name);
            }
            Color::MixedColor(ref_cell) => {
                println!("{}", ref_cell.try_borrow().unwrap().color_name);
            }
        }
    }

    let erosion_gully = map
        .symbols
        .get_symbol_by_code(Code::new(107, 0, 0))
        .unwrap()
        .downgrade();

    let mut ls = LineObject::new(
        WeakLinePathSymbol::try_from(erosion_gully).unwrap(),
        // geometry coordinates are always in mm of paper
        LineString::new(vec![Coord { x: -60., y: -50. }, Coord { x: 60., y: -50. }]),
    );
    ls.tags.insert("Some Key".to_owned(), "My value".to_owned());

    map.parts.0[0].add_object(ls);

    let weak_symbol = map
        .symbols
        .get_symbol_by_name("Contour value")
        .unwrap()
        .downgrade();

    let ts = TextObject::new(
        Weak::<RefCell<TextSymbol>>::try_from(weak_symbol)
            .expect("The symbol type of Contour value is not Text"),
        TextGeometry::SingleAnchor(Coord { x: 0., y: 0. }),
        "This is the middle of the map".to_owned(),
    );
    map.parts.0[0].add_object(ts);

    map.write_to_file("./from_path_out.omap")
}

pub fn iter_weak(&self) -> impl Iterator<Item = WeakColor>

Iterate over weak references to the colors.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Color>

Access the mutable colors through an iterator

Trait Implementations

impl Clone for ColorSet

fn clone(&self) -> ColorSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColorSet

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

Formats the value using the given formatter.

impl Default for ColorSet

fn default() -> ColorSet

Returns the “default value” for a type.