Struct map_model::pathfind::v1::Path

pub struct Path {
    steps: VecDeque<PathStep>,
    orig_req: PathRequest,
    total_length: Distance,
    crossed_so_far: Distance,
    uber_turns: VecDeque<UberTurn>,
    currently_inside_ut: Option<UberTurn>,
    blocked_starts: Vec<LaneID>,
}

Fields

steps: VecDeque<PathStep>

orig_req: PathRequest

total_length: Distance

crossed_so_far: Distance

uber_turns: VecDeque<UberTurn>

currently_inside_ut: Option<UberTurn>

blocked_starts: Vec<LaneID>

Implementations

impl Path

pub(crate) fn new( map: &Map, steps: Vec<PathStep>, orig_req: PathRequest, uber_turns: Vec<UberTurn>, blocked_starts: Vec<LaneID> ) -> Path

pub fn dist_crossed_from_step(&self, map: &Map, step: &PathStep) -> Distance

Once we finish this PathStep, how much distance will be crossed? If the step is at the beginning or end of our path, then the full length may not be used.

pub fn get_req(&self) -> &PathRequest

The original PathRequest used to produce this path. If the path has been modified since creation, the start and end of the request won’t match up with the current path steps.

pub fn crossed_so_far(&self) -> Distance

pub fn total_length(&self) -> Distance

pub fn percent_dist_crossed(&self) -> f64

pub fn is_empty(&self) -> bool

pub fn is_last_step(&self) -> bool

pub fn isnt_last_step(&self) -> bool

pub fn currently_inside_ut(&self) -> &Option<UberTurn>

pub fn about_to_start_ut(&self) -> Option<&UberTurn>

pub fn shift(&mut self, map: &Map) -> PathStep

pub fn add(&mut self, step: PathStep, map: &Map)

pub fn is_upcoming_uber_turn_component(&self, t: TurnID) -> bool

pub fn modify_step(&mut self, idx: usize, step: PathStep, map: &Map)

Trusting the caller to do this in valid ways.

pub fn current_step(&self) -> PathStep

pub fn next_step(&self) -> PathStep

pub fn maybe_next_step(&self) -> Option<PathStep>

pub fn last_step(&self) -> PathStep

pub fn trace(&self, map: &Map) -> Option<PolyLine>

Traces along the path from its originally requested start. This is only valid to call for an umodified path.

It mostly seems the PolyLine’s length will match total_length, but callers beware if you’re relying on this – check walking paths with the buggy sharp angles particularly.

pub fn trace_from_start( &self, map: &Map, start_dist: Distance ) -> Option<PolyLine>

Traces along the path from a specified distance along the first step until the end.

pub fn trace_v2(&self, map: &Map) -> Result<Polygon>

Draws the thickened path, matching entire roads. Ignores the path’s exact starting and ending distance.

pub fn get_steps(&self) -> &VecDeque<PathStep>

pub fn estimate_duration(&self, map: &Map, max_speed: Option<Speed>) -> Duration

Estimate how long following the path will take in the best case, assuming no traffic or delay at intersections. To determine the speed along each step, the agent’s optional max_speed must be known.

pub fn get_blocked_starts(&self) -> Vec<LaneID>

If the agent following this path will initially block some intermediate lanes as they move between a driveway and get_req().start, then record them here.

pub fn get_total_elevation_change(&self, map: &Map) -> (Distance, Distance)

Returns the total elevation (gain, loss) experienced over the path.

pub fn get_step_at_dist_along( &self, map: &Map, dist_along: Distance ) -> Result<PathStep>

pub fn crosses_road(&self, r: RoadID) -> bool

Trait Implementations

impl Clone for Path

fn clone(&self) -> Path

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Path

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Path

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Path

fn eq(&self, other: &Path) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Path

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Path