Global planner (A*, Dijkstra) in ROS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the global planner node in ROS.

ROS

ros::init(argc, argv, [1]);

Drag options to blanks, or click blank then click option'

A"navigation_node"

B"local_planner_node"

C"global_planner_node"

D"sensor_node"

Attempts:

3 left

💡 Hint

Common Mistakes

Using a local planner or unrelated node name.

The global planner node must be initialized with its unique name, here "global_planner_node".

2fill in blank

medium

Complete the code to create a ROS publisher for the planned path.

ROS

ros::Publisher path_pub = nh.advertise<nav_msgs::Path>([1], 1);

Drag options to blanks, or click blank then click option'

A"/planned_path"

B"/cmd_vel"

C"/robot_path"

D"/scan"

Attempts:

3 left

💡 Hint

Common Mistakes

Using sensor or command topics instead of path topic.

The global planner publishes the planned path on the topic "/planned_path".

3fill in blank

hard

Fix the error in the A* heuristic function signature.

ROS

double heuristic([1] const Node& a, const Node& b) {

Drag options to blanks, or click blank then click option'

Ainline

Bstatic

Cvirtual

Dconst

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting const causes unnecessary copying or accidental modification.

The heuristic function parameters should be constant references to avoid copying and allow read-only access.

4fill in blank

hard

Fill both blanks to correctly update the cost in Dijkstra's algorithm.

ROS

if (distances[neighbor] > distances[current] [1] graph.getCost(current, neighbor)) {
  distances[neighbor] = distances[current] [2] graph.getCost(current, neighbor);
}

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication instead of addition.

In Dijkstra's algorithm, the new cost is the sum of the current cost and the edge cost.

5fill in blank

hard

Fill all three blanks to implement the main loop of the A* algorithm.

ROS

while (!open_set.empty()) {
  Node current = open_set.top();
  open_set.pop();
  if (current == [1]) {
    return reconstructPath(came_from, current);
  }
  for (auto& neighbor : graph.getNeighbors(current)) {
    double tentative_gScore = g_score[current] [2] graph.getCost(current, neighbor);
    if (tentative_gScore < g_score[neighbor]) {
      came_from[neighbor] = current;
      g_score[neighbor] = tentative_gScore;
      f_score[neighbor] = g_score[neighbor] [3] heuristic(neighbor, goal);
      open_set.push(neighbor);
    }
  }
}

Drag options to blanks, or click blank then click option'

Agoal

B+

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing start and goal nodes, or using wrong operators for score updates.

The loop checks if the current node is the goal, updates scores by adding costs and heuristic, and pushes neighbors to the open set.

Practice

1. What is the main difference between the A* algorithm and Dijkstra's algorithm in ROS global planners?

easy

A. Dijkstra uses a heuristic, while A* explores all paths evenly.

B. A* uses a heuristic to guide the search, while Dijkstra explores all paths evenly.

C. Both algorithms use heuristics but in different ways.

D. Neither algorithm considers obstacles in the map.

Solution

1. Step 1: Understand Dijkstra's algorithm behavior

   Dijkstra explores all possible paths evenly without using heuristics, ensuring the shortest path but potentially slower.

2. Step 2: Understand A* algorithm behavior

   A* uses a heuristic function to estimate the cost to the goal, guiding the search more efficiently and often faster.

3. Final Answer:

   A* uses a heuristic to guide the search, while Dijkstra explores all paths evenly. -> Option B

4. Quick Check:

   Heuristic guides A*; Dijkstra explores evenly [OK]

Hint: Remember: A* uses heuristics, Dijkstra does not [OK]

Common Mistakes:

• Confusing which algorithm uses heuristics
• Thinking both ignore obstacles
• Assuming both explore paths the same way

2. Which of the following is the correct way to initialize a Dijkstra planner in ROS using C++?

easy

A. auto planner = new DijkstraPlanner();

B. DijkstraPlanner planner = new DijkstraPlanner();

C. auto planner = DijkstraPlanner();

D. DijkstraPlanner planner();

Solution

1. Step 1: Understand object initialization in modern C++

   Using 'auto' with direct initialization calls the constructor properly and manages type automatically.

2. Step 2: Analyze each option

   auto planner = new DijkstraPlanner(); uses 'new' which returns a pointer, not an object. DijkstraPlanner planner = new DijkstraPlanner(); attempts to assign a pointer to an object, causing a type mismatch compile error. DijkstraPlanner planner(); is a function declaration, not an object. auto planner = DijkstraPlanner(); correctly initializes an object with automatic type deduction.

3. Final Answer:

   auto planner = DijkstraPlanner(); -> Option C

4. Quick Check:

   Use auto with constructor for clean initialization [OK]

Hint: Use 'auto planner = ClassName();' for simple object creation [OK]

Common Mistakes:

• Using parentheses that declare a function, not an object
• Using 'new' without managing pointers
• Not using auto for type deduction

3. Given the following ROS global planner code snippet using A*:

std::vector<Point> path = planner.makePlan(start, goal);
std::cout << path.size() << std::endl;

If the planner finds a path with 5 points, what will be printed?

medium

A. 0

B. 4

C. 6

D. 5

Solution

1. Step 1: Understand the return value of makePlan()

   The makePlan function returns a vector of points representing the path from start to goal, including both points.

2. Step 2: Analyze the output of path.size()

   If the planner finds a path with 5 points, the vector size is 5, so printing path.size() outputs 5.

3. Final Answer:

   5 -> Option D

4. Quick Check:

   Path points count equals vector size [OK]

Hint: Path size equals number of points including start and goal [OK]

Common Mistakes:

• Assuming path size excludes start or goal
• Confusing index with size
• Thinking path size counts edges, not points

4. You have this snippet in your ROS global planner node:

std::vector<Point> path = planner.makePlan(start, goal);
for (int i = 0; i <= path.size(); i++) {
  std::cout << path[i].x << "," << path[i].y << std::endl;
}

What is the error in this code?

medium

A. Using <= in the loop causes out-of-bounds access.

B. The loop variable should be a float, not int.

C. The path vector is not initialized.

D. The makePlan function does not return a vector.

Solution

1. Step 1: Analyze the loop condition

   The loop runs from i = 0 to i <= path.size(), which means it tries to access path[path.size()] on the last iteration.

2. Step 2: Understand vector indexing

   Vectors are zero-indexed, so valid indices are 0 to path.size() - 1. Accessing path[path.size()] causes out-of-bounds error.

3. Final Answer:

   Using <= in the loop causes out-of-bounds access. -> Option A

4. Quick Check:

   Loop index must be less than size, not less or equal [OK]

Hint: Use i < path.size() in loops to avoid out-of-bounds [OK]

Common Mistakes:

• Using <= instead of < in loops
• Confusing vector size with last index
• Assuming makePlan returns empty vector

5. In a ROS global planner using A*, you want to modify the heuristic to prefer paths farther from obstacles for safety. Which approach correctly applies this change?

hard

A. Add a penalty to the heuristic cost for points near obstacles.

B. Subtract a penalty from the heuristic cost for points near obstacles.

C. Add a penalty to the heuristic cost for points far from obstacles.

D. Ignore the heuristic and use Dijkstra instead.

Solution

1. Step 1: Understand heuristic modification goal

   To prefer paths farther from obstacles, the heuristic should favor those points by lowering their cost or penalizing points near obstacles.

2. Step 2: Analyze penalty application

   Adding a penalty to the heuristic cost for points near obstacles increases their cost, which discourages paths near obstacles, as desired for safety.

3. Step 3: Choose correct approach

   Add a penalty to the heuristic cost for points near obstacles. correctly adds a penalty to points near obstacles, increasing their heuristic cost and discouraging proximity for safer paths.

4. Final Answer:

   Add a penalty to the heuristic cost for points near obstacles. -> Option A

5. Quick Check:

   Modify heuristic cost to prefer points near obstacles [OK]

Hint: Adjust heuristic cost to favor desired path traits [OK]

Common Mistakes:

• Confusing penalty direction for heuristic
• Ignoring heuristic and switching algorithms unnecessarily
• Not understanding heuristic impact on path choice