Struct map_model::objects::block::Perimeter

source · [−]

pub struct Perimeter {
    pub roads: Vec<RoadSideID>,
    pub interior: BTreeSet<RoadID>,
}

Expand description

A sequence of roads in order, beginning and ending at the same place. No “crossings” – tracing along this sequence should geometrically yield a simple polygon.

Fields

roads: Vec<RoadSideID>interior: BTreeSet<RoadID>

These roads exist entirely within the perimeter

Implementations

source

impl Perimeter

source

pub fn single_block(
 map: &Map,
 start: LaneID,
 skip: &HashSet<RoadID>
) -> Result<Perimeter>

Starting at any lane, snap to the nearest side of that road, then begin tracing a single block, with no interior roads. This will fail if a map boundary is reached. The results are unusual when crossing the entrance to a tunnel or bridge, and so skip is used to avoid tracing there.

source

pub fn find_all_single_blocks(map: &Map) -> Vec<Perimeter>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where A: Allocator,`

This calculates all single block perimeters for the entire map. The resulting list does not cover roads near the map boundary.

source

pub fn find_roads_to_skip_tracing(map: &Map) -> HashSet<RoadID>

Trying to form blocks near railways or cycleways that involve bridges/tunnels often causes overlapping geometry or blocks that’re way too large. These are extremely imperfect heuristics to avoid the worst problems.

source

fn undo_invariant(&mut self)

A perimeter has the first and last road matching up, but that’s confusing to work with. Temporarily undo that.

source

fn restore_invariant(&mut self)

Restore the first=last invariant. Methods may temporarily break this, but must restore it before returning.

source

fn try_to_merge(
    &mut self,
    map: &Map,
    other: &mut Perimeter,
    debug_failures: bool,
    use_expensive_blockfinding: bool
) -> bool

Try to merge two blocks. Returns true if this is successful, which will only be when the blocks are adjacent, but the merge wouldn’t create an interior “hole”.

Note this may modify both perimeters and still return false. The modification is just to rotate the order of the road loop; this doesn’t logically change the perimeter.

TODO Due to https://github.com/a-b-street/abstreet/issues/841, it seems like rotation sometimes breaks to_block, so for now, always revert to the original upon failure.

source

fn check_continuity(&self, map: &Map) -> Result<()>

source

fn reverse_to_fix_winding_order(&self, map: &Map, other: &Perimeter) -> bool

Should we reverse one perimeter to match the winding order?

This is only meant to be called in the middle of try_to_merge. It assumes both perimeters have already been rotated so the common roads are at the end. The invariant of first=last is not true.

source

pub fn merge_all(
 map: &Map,
 input: Vec<Perimeter>,
 stepwise_debug: bool,
 use_expensive_blockfinding: bool
) -> Vec<Perimeter>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where A: Allocator,`

Try to merge all given perimeters. If successful, only one perimeter will be returned. Perimeters are never “destroyed” – if not merged, they’ll appear in the results. If stepwise_debug is true, returns after performing just one merge.

source

pub fn collapse_deadends(&mut self)

If the perimeter follows any dead-end roads, “collapse” them and instead make the perimeter contain the dead-end.

source

pub fn partition_by_predicate<F: Fn(RoadID) -> bool>(
 input: Vec<Perimeter>,
 predicate: F
) -> Vec<Vec<Perimeter>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where A: Allocator,`

Consider the perimeters as a graph, with adjacency determined by sharing any road in common. Partition adjacent perimeters, subject to the predicate. Each partition should produce a single result with merge_all.

source

pub fn calculate_coloring(
input: &[Perimeter ],
num_colors: usize
) -> Option<Vec<usize>>

Assign each perimeter one of num_colors, such that no two adjacent perimeters share the same color. May fail. The resulting colors are expressed as [0, num_colors).

source