Struct GridMap 

pub struct GridMap {
    pub resolution: f64,
    pub robot_radius: f64,
    pub min_x: f64,
    pub min_y: f64,
    pub max_x: f64,
    pub max_y: f64,
    pub x_width: i32,
    pub y_width: i32,
    pub obstacle_map: Vec<Vec<bool>>,
}

Occupancy grid map for path planning

Fields

resolution: f64

robot_radius: f64

min_x: f64

min_y: f64

max_x: f64

max_y: f64

x_width: i32

y_width: i32

obstacle_map: Vec<Vec<bool>>

Implementations

impl GridMap

pub fn new(ox: &[f64], oy: &[f64], resolution: f64, robot_radius: f64) -> Self

Create a new grid map from obstacle points

pub fn try_new( ox: &[f64], oy: &[f64], resolution: f64, robot_radius: f64, ) -> RoboticsResult<Self>

Create a validated grid map from obstacle points

pub fn from_obstacles( obstacles: &Obstacles, resolution: f64, robot_radius: f64, ) -> RoboticsResult<Self>

Create a validated grid map from obstacle points

pub fn calc_xy_index(&self, position: f64) -> i32

Convert world position to grid index (uses min_x as reference)

pub fn calc_x_index(&self, x: f64) -> i32

Convert world x position to grid index

pub fn calc_y_index(&self, y: f64) -> i32

Convert world y position to grid index

pub fn calc_grid_position(&self, index: i32) -> f64

Convert grid index to world position

pub fn calc_x_position(&self, ix: i32) -> f64

Convert grid x index to world x position

pub fn calc_y_position(&self, iy: i32) -> f64

Convert grid y index to world y position

pub fn calc_grid_index(&self, node: &Node) -> i32

Calculate unique grid index for a node

pub fn calc_index(&self, x: i32, y: i32) -> i32

Calculate unique grid index from grid coordinates

pub fn verify_node(&self, node: &Node) -> bool

Verify if a node is valid (within bounds and not in obstacle)

pub fn is_valid(&self, x: i32, y: i32) -> bool

Check if grid coordinates are valid

pub fn is_valid_step( &self, from_x: i32, from_y: i32, to_x: i32, to_y: i32, ) -> bool

Check whether a single adjacent step is valid.

Diagonal steps are rejected when either orthogonal side cell is blocked, matching no-corner-cutting grid semantics.

pub fn is_valid_offset(&self, x: i32, y: i32, dx: i32, dy: i32) -> bool

Check whether an adjacent (dx, dy) move is valid from the given cell.

Trait Implementations

impl Clone for GridMap

fn clone(&self) -> GridMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GridMap

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

Formats the value using the given formatter.