Struct AreaObject 

pub struct AreaObject {
    pub tags: HashMap<String, String>,
    pub pattern_rotation: PatternRotation,
    pub symbol: WeakAreaPathSymbol,
    pub bezier_write_error: Option<NonNegativeF64>,
    /* private fields */
}

An area (polygon) object on the map.

Fields

tags: HashMap<String, String>

The tags associated with the object

pattern_rotation: PatternRotation

The fill-pattern rotation and origin.

symbol: WeakAreaPathSymbol

The area or combined-area symbol used to render this object.

bezier_write_error: Option<NonNegativeF64>

The permitted error when fitting Bézier curves for writing.

Bézier fitting is enabled when this is Some.

Implementations

impl AreaObject

pub fn new(symbol: impl Into<WeakAreaPathSymbol>, geometry: Polygon) -> Self

Create a new area object with the given symbol and geometry.

pub fn into_geometry(self, allowed_error: f64) -> Result<Polygon, Error>

Consume this object and return its polygon geometry.

Errors

Returns an error if the object has no usable geometry or if uncached raw geometry cannot be flattened with the requested error tolerance.

pub fn get_geometry(&self, allowed_error: f64) -> Result<&Polygon, Error>

Get the polygon geometry, flattening and caching raw Bézier coordinates when needed.

allowed_error is used only when initializing the cache. Later calls return the previously cached geometry.

Errors

Returns an error if the object has no usable geometry or if its raw geometry cannot be flattened with the requested error tolerance.

Examples found in repository

examples/from_path.rs (line 51)

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 bezier_geometry(&self) -> Option<BezierPolygon>

Rebuild the original area geometry as mixed straight/cubic Bézier rings, including dash-point metadata for every vertex.

This is generated directly from the original file coordinates and therefore preserves the exact Bézier handles. Every returned ring is closed, matching Polygon’s invariant, and zero-segment rings are omitted. For a successfully parsed object, ring order and count match Self::get_geometry.

Returns None when the object was not read from raw file coordinates or after Self::get_geometry_mut has marked those coordinates as touched.

pub fn get_geometry_bezier(&self) -> Option<BezierPolygon>

👎Deprecated:

renamed to bezier_geometry

Rebuild the original area geometry as mixed straight/cubic Bézier rings.

Prefer Self::bezier_geometry, whose name makes the reconstruction cost explicit.

pub fn get_geometry_mut( &mut self, allowed_error: f64, ) -> Result<&mut Polygon, Error>

Get a mutable reference to the polygon geometry, flattening it first when needed, and mark the coordinates as touched.

allowed_error is used only when initializing the cache.

Errors

Returns an error if the object has no usable geometry or if its raw geometry cannot be flattened with the requested error tolerance.

pub fn raw_coords(&self) -> impl ExactSizeIterator<Item = (Coord, u8)> + '_

Iterate over the raw file coordinates in mm with their flags.

These are the original control points (including Bézier handles) as read from the file, converted from µm integers to mm floats. See the COORD_FLAG_* constants in this module for the flag assignments.

The iterator is empty for objects not read from file data.

pub fn get_raw_coords(&self) -> Vec<(Coord, u8)>

👎Deprecated:

use the allocation-free raw_coords iterator

Get the raw file coordinates in mm with their flags.

Prefer Self::raw_coords when a collected Vec is not needed.

pub fn apply_affine(&mut self, transform: &AffineMapTransform)

Apply an affine coordinate transform to both the geometry and the raw control points, preserving Bézier structure without re-approximation.

This does not mark the coordinates as touched, so the raw (affine transformed) control points (with Bézier flags) will still be used on write.

pub fn reverse_polygon(&mut self)

Reverse the winding order of all rings.

pub fn new_element(geometry: Polygon) -> Self

Create an AreaObject for use as a PointSymbol element (no map symbol needed)

Trait Implementations

impl Clone for AreaObject

fn clone(&self) -> AreaObject

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AreaObject

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

Formats the value using the given formatter.

impl From<AreaObject> for MapObject

fn from(value: AreaObject) -> Self

Converts to this type from the input type.