Assignment 3: Path Planning Basics
We will not be using Roombas in this first part; rather, we will simulate a point robot. You will write a program to calculate a path through an occupancy map using the Wavefront algorithm, a breadth first search. Once the path has been planned, this turns into a dead reckoning problem, which we have already seen, and since we know how temperamental dead reckoning is, this will introduce a wrinkle. We know with dead reckoning the path your robot takes is not exactly the path you specify, and over the course of the path your robot's error grows. If your robot hits an obstacle, this will throw off the path that you had told your robot to execute and your robot may not finish the course. Before creating the path, your program must first adapt the map so that your robot will not come close to any obstacle or any wall except for the start and end positions. Then you should calculate the possible paths in the map using the Wavefront algorithm, and finally calculate a best path for your robot given the Wavefront map.
- 2007-11-09: Here is the original map before it was scaled up File:InitialMap.txt
- rows and columns were written backwards, the first number is columns, the second number is rows
- All parts of the assignment should be done in your code, your code can be whatever language you like
- The number of rows and columns start from 1, so if rows = 9, then there are 9 rows
- For lettering your path, rather than A-Z,AA-AZ you can just start over at A again.
Your program should take in a text file called path_input.txt which will look like:
Note that this is an example input, which will be followed in the assignment. The actual input file will be provided below.
The first line tells how many columns (9), the second line tells how many rows (8) the map has. The starting point for the path will have an S, and the ending point will have an E. All obstacles will have a 1, and open cells will have a 0.
We will assume that your robot can move one square at a time in any direction (up, down, left, right, all four diagonals), as long as it does not go off the map or into an occupied cell. We also assume that your robot takes up 1 cell. To provide your robot with a buffer so that it does not run into an obstacle or a wall given the error in its path, you will add extra occupied cells to the map. You should first increase the size of all obstacles by the size of your robot in all directions by adding a 1 in all directions around all obstacles.
You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the obstacles:
Next you will expand all walls by adding a 1 above the lower wall, to the right of the left wall, below the upper wall, and to the left of the right wall, do this for all cells that are not currently occupied and are not the start and end positions (i.e. for any cell that has a 0).
You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the walls:
Now we perform the Wavefront algorithm. This is a breadth first search that starts at the end position, and expands out from there, noting how far every other cell is from the end position. You should replace the E (end position) with a 2, then until your algorithm encounters the S (but will not replace the S), you will expand out in a wave from the end position, setting all adjacent cells to 3, then the adjacent cells of the 3's to 4, etc.
You will turn this step in, so your program should output a file named wavefront_path_map.txt that looks like the following:
Finally you will calculate the shortest path from the S to the 2. Note that this minimal distance path may not be unique. Your path will replace the S with an A, then increment through alphabet (B..Z, then AA, AB, AC..AZ if needed) with one letter per cell to indicate your path. Since some environments don't allow more than one character in a position, you may start your path over at A, i.e. A-Z, then A-Z again.
You will turn this step in, so your program should output a file named wavefront_path_plan.txt that looks like the following:
Note that there is an alternative path with F the cell below the displayed F, and then another choice for G, as all of these paths will have the same length.
You will be given the File:Hallway path input.txt file (and change the name to path_input.txt), and your code should execute on that input file, producing the two output files.
NOTE Each character in the input file represents a 3x3 inch square, so a 16 character square represents 1 tile in the floor.
You should turn in:
- your code
Assignment 3 Part B: Path Planning Execution
While you used simulated robots in the first part, you will use real robots in this section. In this section, you will be provided with an initial text file that represents part of the hallway on which you will perform path planning techniques you learned in the first section, but taking into account the challenges of executing the path with a real robot.
- Perform path planning techniques from section A onto the provided text document of the hallway (below). Each character represents a forth of a foot.
- Take in account the diameter of the robot in the path planning. The path planning algorithms in part 1 may return paths that a point robot may travers, but not a real robot. For example, some paths might bring your robot through a 1 foot passage, but your robot's diameter is more than 1 foot. You might want iterate through potential paths returned by your path planning algorithm and discard ones that would not work for a real robot.
- Write code that would allow your robot to follow the calculated path. The robot will start facing any direction you please.
- The initial map (not expanded) can be found here: File:InitialMap.txt
- This assignment should be included all in one program (ie your program should calculate a path, perform corrections on the path, and then move the robot without user assistance between stages).
- your code