🥮 mooncakes.io

    moonbitstack/moonmcl/planning does not have a README file

    Dubins

    source
    pub(all) struct Dubins {
      turning_radius : Double
      extent : Double
    } derive(
    Debug    )

    A Dubins car.
    impl Space for Dubins

    Dubins::distance

    source

    Dubins::interpolate

    source

    Dubins::new

    source
    fn Dubins::new(turning_radius~ : Double, extent? : Double) -> Dubins raise 
    Refused

    A Dubins car with the given radius. extent is the half width of the box the space samples from.

    Dubins::path

    source

    The shortest Dubins path between two (x, y, heading) poses.

    Dubins::paths

    source

    Every word that joins the two poses, in word order.

    A car whose words are all drawn is a car the reader can compare; the callers that only want to drive one take path.

    Dubins::sample

    source

    Dubins::to_repr

    source

    DubinsPath

    source
    pub(all) struct DubinsPath {
      word : DubinsWord
      lengths : (Double, Double, Double)
      length : Double
      origin : 
    Vec
      radius : Double
    } derive(
    Debug    )

    The Dubins path between two poses: the word and the length of each of its three pieces.

    DubinsPath::at

    source
    fn DubinsPath::at(self : DubinsPath, distance : Double) -> 
    Vec

    The pose at distance travelled along the path.

    DubinsPath::to_repr

    source

    DubinsWord

    source
    pub(all) enum DubinsWord {
      Lsl
      Lsr
      Rsl
      Rsr
      Rlr
      Lrl
    } derive(
    Debug    )

    One of the six Dubins words: three pieces, each a left arc, a right arc or a straight line.

    DubinsWord::to_repr

    source

    DynamicWindow

    source
    pub(all) struct DynamicWindow {
      max_velocity : Double
      min_velocity : Double
      max_rotation : Double
      max_acceleration : Double
      max_rotation_acceleration : Double
      resolution_velocity : Double
      resolution_rotation : Double
      predict : Double
      clearance : Double
      margin : Double
      heading_weight : Double
      clearance_weight : Double
      velocity_weight : Double
    } derive(
    Debug    )

    The dynamic window approach: sample the velocities the drives can reach in one period, roll each one forward, and keep the best by heading, clearance and speed.

    DynamicWindow::command

    source

    The best velocity pair for the current pose towards goal, avoiding obstacles, which are points.

    DynamicWindow::to_repr

    source

    GridSearch

    source
    pub(all) enum GridSearch {
      Dijkstra
      AStar
      Jps
      ThetaStar
    } derive(
    Debug    )

    Which search a grid query runs.

    GridSearch::to_repr

    source

    GridSpace

    source
    pub(all) struct GridSpace {
      grid : 
    Grid
      resolution : Double
    }

    A grid used as a planning space, so a sampling planner can search a lattice.
    impl Space for GridSpace

    GridSpace::distance

    source

    GridSpace::interpolate

    source

    GridSpace::motion

    source

    GridSpace::new

    source

    A space whose states are grid cells scaled by resolution.

    GridSpace::sample

    source

    GridSpace::valid

    source

    InformedRrtStar

    source
    pub(all) struct InformedRrtStar {
      space : &
    Space
      validity : &
    Validity
      step : Double
      goal_bias : Double
      neighbourhood : Double
      rng : &
    Rng
    }

    An RRT* that only samples where a path shorter than the best one could still run: the ellipse whose foci are the start and the goal.

    InformedRrtStar::new

    source
    fn InformedRrtStar::new(space~ : &
    Space    , validity~ : &
    Validity    , step? : Double, goal_bias? : Double, neighbourhood? : Double, seed? : Int) -> InformedRrtStar raise 
    Refused

    An informed RRT* seeded from the best path found so far.

    InformedRrtStar::plan

    source

    PotentialField

    source
    pub(all) struct PotentialField {
      attraction : Double
      repulsion : Double
      influence : Double
      step : Double
    } derive(
    Debug    )

    An artificial potential field: attraction to the goal, repulsion from the obstacles.

    PotentialField::command

    source

    The velocity command for this step, as a two-dimensional motion.

    PotentialField::to_repr

    source

    Prm

    source
    pub(all) struct Prm {
      space : &
    Space
      validity : &
    Validity
      samples : Int
      neighbours : Int
      connection : Double
      rng : &
    Rng
    }

    A probabilistic roadmap.
    impl Planner for Prm

    Prm::new

    source
    fn Prm::new(space~ : &
    Space    , validity~ : &
    Validity    , samples? : Int, neighbours? : Int, connection? : Double, seed? : Int) -> Prm raise 
    Refused

    A roadmap with the given sample count and connection radius.

    Prm::plan

    source

    ReedsShepp

    source
    pub(all) struct ReedsShepp {
      turning_radius : Double
      extent : Double
    } derive(
    Debug    )

    A Reeds-Shepp car.
    impl Space for ReedsShepp

    ReedsShepp::candidates

    source

    Every word that joins the two poses, shortest first.

    A word that cannot reach the goal returns no parameters at all, so the list holds only the ones that do; the shortest of them shares its length with any other candidate of the same total.

    ReedsShepp::distance

    source

    ReedsShepp::interpolate

    source

    ReedsShepp::new

    source
    fn ReedsShepp::new(turning_radius~ : Double, extent? : Double) -> ReedsShepp raise 
    Refused

    A Reeds-Shepp car with the given radius. extent is the half width of the box the space samples from.

    ReedsShepp::path

    source

    The shortest path between two (x, y, heading) poses, reversing as needed.

    ReedsShepp::sample

    source

    ReedsShepp::to_repr

    source

    ReedsSheppPath

    source
    pub(all) struct ReedsSheppPath {
      word : ReedsSheppWord
      segments : Array[ReedsSheppSegment]
      length : Double
      origin : 
    Vec
      radius : Double
    } derive(
    Debug    )

    A Reeds-Shepp path: the word it spells, its pieces, and the pose it starts from.

    ReedsSheppPath::at

    source

    The pose at distance travelled along the path: an arc turns around its own centre, a straight runs along the heading, and backing up moves the car the other way without changing which way it faces.

    ReedsSheppPath::cusps

    source
    fn ReedsSheppPath::cusps(self : ReedsSheppPath) -> Int

    How many times the path changes direction.

    ReedsSheppPath::to_repr

    source

    ReedsSheppSegment

    source
    pub(all) struct ReedsSheppSegment {
      turn : Double
      forward : Double
      length : Double
    } derive(
    Debug    )

    One straight or curved piece of a Reeds-Shepp path.

    ReedsSheppSegment::to_repr

    source

    ReedsSheppWord

    source
    pub(all) enum ReedsSheppWord {
      LpSpLp
      RpSpRp
      LmSmLm
      RmSmRm
      LpSpRp
      RpSpLp
      LmSmRm
      RmSmLm
      LpRmLp
      RpLmRp
      LmRpLm
      RmLpRm
      LpRmLm
      RpLmRm
      LmRpLp
      RmLpRp
      LpRpLm
      RpLpRm
      LmRmLp
      RmRmLp
      LpRpLmRm
      RpLpRmLm
      LmRmLpRp
      RmRmLpLp
      LpRmLmRp
      RpLmRmLp
      LmRpLpRm
      RmLpRpLm
      LpRmSmLm
      RpLmSmRm
      LmRpSpLp
      RmLpSpRp
      LpRmSmRm
      RpLmSmLm
      LmRpSpRp
      RmLpSpLp
      LpSpRmLm
      RpSpLmRm
      LmSmRpLp
      RmSmLpRp
      LpSpLpRm
      RpSpRpLm
      LmSmLmRp
      RmSmRmLp
      LpRmSmLmRp
      RpLmSmRmLp
      LmRpSpLpRm
      RmLpSpRpLm
    } derive(
    Debug    )

    One of the forty-eight reversable-car path words.

    ReedsSheppWord::code

    source
    fn ReedsSheppWord::code(self : ReedsSheppWord) -> Int

    The position of a word in the enumeration: family times four plus variant.

    A family is one set of segment formulas and a variant is one of the four frames it is applied in, so the pair is all the table a word needs.

    ReedsSheppWord::of_code

    source
    fn ReedsSheppWord::of_code(code : Int) -> ReedsSheppWord?

    The word a code names, or None outside the forty-eight.

    ReedsSheppWord::to_repr

    source

    Rrt

    source
    pub(all) struct Rrt {
      space : &
    Space
      validity : &
    Validity
      step : Double
      goal_bias : Double
      rng : &
    Rng
    }

    A rapidly-exploring random tree.

    step is the length of the edge a new sample is allowed to reach, and goal_bias the chance that a sample is the goal itself rather than a random state. The generator is seeded from the planner, so a run replays exactly.
    impl Planner for Rrt

    Rrt::new

    source
    fn Rrt::new(space~ : &
    Space    , validity~ : &
    Validity    , step? : Double, goal_bias? : Double, seed? : Int) -> Rrt raise 
    Refused

    An RRT that extends by step and steers to the goal once every 1 / goal_bias samples.

    Rrt::plan

    source

    RrtConnect

    source

    An RRT grown from both ends at once: the two trees take turns reaching for each other, which closes a narrow passage far faster than one tree alone.

    RrtConnect::new

    source

    A bidirectional RRT.

    RrtConnect::plan

    source

    RrtStar

    source
    pub(all) struct RrtStar {
      space : &
    Space
      validity : &
    Validity
      step : Double
      goal_bias : Double
      neighbourhood : Double
      rng : &
    Rng
    }

    An RRT that rewires the tree as it grows, so the path converges on the shortest one inside the budget.
    impl Planner for RrtStar

    RrtStar::new

    source
    fn RrtStar::new(space~ : &
    Space    , validity~ : &
    Validity    , step? : Double, goal_bias? : Double, neighbourhood? : Double, seed? : Int) -> RrtStar raise 
    Refused

    An RRT* with a rewiring radius.

    RrtStar::plan

    source

    dynamic_window

    source
    let dynamic_window : DynamicWindow

    The preset dynamic window: a metre per second, two radians per second, and a prediction of a second and a half.

    family_words

    source
    fn family_words(family : Int) -> Array[ReedsSheppWord]

    The words of the family family, in variant order.

    grid_path

    source
    fn grid_path(grid : 
    Grid    , start~ : Int, goal~ : Int, search? : GridSearch) -> Array[Int] raise 
    Refused

    The shortest path between two grid cells, as node indices, from the grid package's own search.

    potential_field

    source
    let potential_field : PotentialField

    The preset potential field.

    Source Files