15 | 
16 | 
17 |
22 |
23 | 
24 | 
25 |
15 |
16 |
38 |
39 |
40 |
41 |
42 |
43 |
--------------------------------------------------------------------------------
/Python Simulator/Frontier Exploration/greedy/results/plot.py:
--------------------------------------------------------------------------------
1 | # The MIT License (MIT)
2 |
3 | # Copyright (c) 2014 INSPIRE Lab, BITS Pilani
4 |
5 | # Permission is hereby granted, free of charge, to any person obtaining a copy
6 | # of this software and associated documentation files (the "Software"), to deal
7 | # in the Software without restriction, including without limitation the rights
8 | # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | # copies of the Software, and to permit persons to whom the Software is
10 | # furnished to do so, subject to the following conditions:
11 |
12 | # The above copyright notice and this permission notice shall be included in all
13 | # copies or substantial portions of the Software.
14 |
15 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | # SOFTWARE.
22 |
23 |
24 | """
25 | Provides a script to plot results
26 | """
27 |
28 |
29 | import sys
30 |
31 | import matplotlib.pyplot as plt
32 |
33 |
34 | def main():
35 |
36 | try:
37 | inFile = open(sys.argv[1], 'r')
38 | except Exception, e:
39 | print 'A valid input file was not passed'
40 | sys.exit(-1)
41 |
42 | y = []
43 | x = []
44 |
45 | lines = inFile.readlines()
46 | count = 1
47 | noGain = 0
48 |
49 | for line in lines:
50 | currentLine = line.strip().split()
51 |
52 | try:
53 | if int(currentLine[0]) == 0:
54 | noGain += 1
55 | y.append(int(currentLine[0]))
56 | x.append(count)
57 | except:
58 | pass
59 |
60 | count += 1
61 |
62 | plt.bar(x, y)
63 | plt.show()
64 | print 'noGain:', noGain
65 |
66 |
67 | if __name__ == '__main__':
68 |
69 | main()
--------------------------------------------------------------------------------
/Python Simulator/Frontier Exploration/greedy/results/plot_old.py:
--------------------------------------------------------------------------------
1 | # The MIT License (MIT)
2 |
3 | # Copyright (c) 2014 INSPIRE Lab, BITS Pilani
4 |
5 | # Permission is hereby granted, free of charge, to any person obtaining a copy
6 | # of this software and associated documentation files (the "Software"), to deal
7 | # in the Software without restriction, including without limitation the rights
8 | # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | # copies of the Software, and to permit persons to whom the Software is
10 | # furnished to do so, subject to the following conditions:
11 |
12 | # The above copyright notice and this permission notice shall be included in all
13 | # copies or substantial portions of the Software.
14 |
15 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | # SOFTWARE.
22 |
23 |
24 | """
25 | Provides a script to plot results
26 | """
27 |
28 |
29 | import sys
30 |
31 | import matplotlib.pyplot as plt
32 |
33 |
34 | def main():
35 |
36 | try:
37 | inFile = open(sys.argv[1], 'r')
38 | except Exception, e:
39 | print 'A valid input file was not passed'
40 | sys.exit(-1)
41 |
42 | y = []
43 | x = []
44 |
45 | lines = inFile.readlines()
46 | count = 1
47 | noGain = 0
48 |
49 | for line in lines:
50 | currentLine = line.strip().split()
51 |
52 | try:
53 | if int(currentLine[0]) == 0:
54 | noGain += 1
55 | y.append(int(currentLine[0]))
56 | x.append(count)
57 | except:
58 | pass
59 |
60 | count += 1
61 |
62 | plt.bar(x, y)
63 | plt.show()
64 | print 'noGain:', noGain
65 |
66 |
67 | if __name__ == '__main__':
68 |
69 | main()
--------------------------------------------------------------------------------
/Python Simulator/Frontier Exploration/Datatypes.py:
--------------------------------------------------------------------------------
1 | import heapq
2 | class Queue:
3 | def __init__(self):
4 | self.items=[]
5 | def isEmpty(self):
6 | return len(self.items)==0
7 | def length(self):
8 | return len(self.items)
9 | def put(self,a):
10 | return self.items.insert(0,a)
11 | def get(self):
12 | return self.items.pop()
13 | def _print(self):
14 | print(self.items)
15 |
16 |
17 | class Stack:
18 | def __init__(self):
19 | self.items=[]
20 | def isEmpty(self):
21 | return len(self.items)==0
22 | def length(self):
23 | return len(self.items)
24 | def push(self,a):
25 | return self.items.append(a)
26 | def remove(self):
27 | return self.items.pop()
28 | def _print(self):
29 | print(self.items)
30 | def top(self):
31 | return self.items[len(self.items)-1]
32 |
33 |
34 | # class PriorityQueue:
35 | # def __init__(self):
36 | # self.elements = {}
37 |
38 | # def isEmpty(self):
39 | # return len(self.elements) == 0
40 |
41 | # def put(self, item, priority):
42 | # '''
43 | # if item in self.elements:
44 | # print("Reprioritizing", item, "from", self.elements[item], "to", priority)
45 | # else:
46 | # print("Inserting", item, "with priority", priority)
47 | # '''
48 | # self.elements[item] = priority
49 |
50 | # def get(self):
51 | # best_item, best_priority = None, None
52 | # for item, priority in self.elements.items():
53 | # if best_priority is None or priority < best_priority:
54 | # best_item, best_priority = item, priority
55 |
56 | # del self.elements[best_item]
57 | # return best_item
58 |
59 | class PriorityQueue:
60 | def __init__(self):
61 | self._queue = []
62 | self._index = 0
63 |
64 | def isEmpty(self):
65 | return len(self.elements) == 0
66 |
67 | def put(self, item, priority):
68 | heapq.heappush(self._queue, (-priority, self._index, item))
69 | self._index += 1
70 |
71 | def get(self):
72 | return heapq.heappop(self._queue)[-1]
--------------------------------------------------------------------------------
/Python Simulator/Frontier Exploration/livingRoom.config:
--------------------------------------------------------------------------------
1 | # Anything that begins with # is treated as a comment
2 |
3 | # Blank lines such as the one above are ignored
4 |
5 | # Configuration file for the living room scenario described in the following paper
6 | # "A Practical Framework for Cleaning Robots", 2011
7 | # Wen-Mau Chong, Chien-Le Goh, and Yoon-Teck Bau
8 | # In the Sixth International Conference of Bio-inspired Computing : Theories and Applications
9 |
10 |
11 |
12 |
13 | # Specifies the height of the grid
14 | height 15
15 | # Specifies the width of the grid
16 | width 15
17 |
18 | # Specifies the number of robots to be placed
19 | numRobots 10
20 |
21 | # Specifies the communication range (radius) of each robot
22 | R 50
23 |
24 | # Specifies the X and Y coordinates of the base station
25 | baseX 0
26 | baseY 0
27 |
28 | # Specifies the initial locations of each robot (Format: Path Planner Simulation
17 | 18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
37 |
33 |
35 |
36 | Press one of the buttons above to start!
34 |Simulator Usage:
2 |-
3 |
- Navigate to the folder and run the file named ConfigFileMaker.py 4 |
- Click on the opened GUI to make obstacles. Once done doing this, click on “Set” and then “Exit” button. 5 |
- By default the size of the map is given to be a grid of 20 x 20 cells. However this can be changed by changing the values of ROWS and COLUMNS in the above mentioned file. The name of the config file generated is “one.config” by default. You can change it by changing line 8 of the above mentioned file. 6 |
- Once done run the Simulator.py file via terminal. The syntax is to be:
7 | python Simulator.py
8 | Eg. python Simulator.py one.config 1,0 10,10
9 |
10 | Program Structure:
11 | 1. Datatypes.py - > Contains implementations of all the ADT’s such as queue, stack and priority queue.
12 |
13 | 2. Cell.py - > A class that is used to initialize the basic cell on the grid and its properties. The properties are:
14 | a. (x,y) – the coordinates of the cell
15 | b. Occupied – flag to see if the cell is occupied or not
16 | c. Obstacle – flag to determine if the cell is an obstacle or not
17 | d. Visited - flag to determine if the cell has been previously visited or not
18 | e. ispath – flag to determine if the cell lies in the path of the robot
19 | f. isprinted - flag to determine if the cell has been marked or not when visited
20 | g. start – is the cell the starting node
21 | h. goal – is the cell a goal node
22 |
23 | 3. Init.py -> takes as input the height, width and obstacle coordinates and returns an object representing the grid map
24 |
25 | 4. ConfigFileMaker.py -> Makes a .config file in the required format using user input from a gui
26 |
27 | 5. ConfigFileReader.py -> Reads the .config file and determines the characteristics of the map such as height, width, number of robots, start positions, and the obstacle positions
28 |
29 | 6. Gridworld.py -> Gives functionality to the map by basic functions such as :
30 | a. isstart() – if the cell is a start node
31 | b. isgoal() – if the cell is a goal node
32 | c. mark() - if the cell has been visited
33 | d. markjump() – if the cell has been marked as a jump point or not
34 | e. get4neighbors() – returns the 4 cardinal neighbors of the cell
35 | f. get8neighbors() – returns all 8 neighbors(cardinal + diagonal) of the cell
36 |
37 | 7. Interface.py -> creates a GUI interface based on the data obtained from the config file
38 |
39 | 8. Simulator.py -> Main function that simulates the algorithms on the given map.
40 |
41 | 9. BFS.py , Dijsktra.py, Astar.py -> The working algorithms which work the simulator
42 |
--------------------------------------------------------------------------------
/Python Simulator/Frontier Exploration/kmeans.py:
--------------------------------------------------------------------------------
1 | # The MIT License (MIT)
2 |
3 | # Copyright (c) 2015 INSPIRE Lab, BITS Pilani
4 |
5 | # Permission is hereby granted, free of charge, to any person obtaining a copy
6 | # of this software and associated documentation files (the "Software"), to deal
7 | # in the Software without restriction, including without limitation the rights
8 | # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | # copies of the Software, and to permit persons to whom the Software is
10 | # furnished to do so, subject to the following conditions:
11 |
12 | # The above copyright notice and this permission notice shall be included in all
13 | # copies or substantial portions of the Software.
14 |
15 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | # SOFTWARE.
22 |
23 | import numpy
24 | import cluster
25 | import Cluster
26 |
27 |
28 | """
29 | Computes the centroid, given the set of points in a cluster
30 | """
31 | def centroidnp(points):
32 |
33 | x_coords = [t[0] for t in points]
34 | y_coords = [t[1] for t in points]
35 |
36 | centroid_x = sum(x_coords)/len(points)
37 | centroid_y = sum(y_coords)/len(points)
38 | return [centroid_x, centroid_y]
39 |
40 |
41 | """
42 | Computes clusters, given a list of data points, using K-Means
43 | """
44 | class kmeans:
45 |
46 | def __init__(self):
47 | self.freeclusters = []
48 | pass
49 |
50 | def Kmeanscluster(self, frontiers, no_robots):
51 |
52 | from cluster import KMeansClustering
53 | self.freeclusters = []
54 | # Perform clustering
55 | cl = KMeansClustering(frontiers)
56 | clusters = cl.getclusters(no_robots)
57 |
58 | # Compute centroids
59 | centroids=[]
60 | for i in range(no_robots):
61 | # Cheap hack (If the algorithm returns only a tuple convert it into a list,
62 | # because centroidnp takes as input only a list)
63 | if type(clusters[i]) is tuple:
64 | clusters[i] = [clusters[i]]
65 | temp = centroidnp(clusters[i])
66 | centroids.append(temp)
67 | # Store each centroid in its corresponding Cluster object
68 | clusterObject = Cluster.Cluster(centroids[i][0], centroids[i][1])
69 | clusterObject.occupied = False
70 | self.freeclusters.append(clusterObject)
71 |
72 | return self.freeclusters, clusters
73 |
--------------------------------------------------------------------------------
/Python Simulator/Frontier Exploration/backup/1 (initial backup)/kmeans.py:
--------------------------------------------------------------------------------
1 | # The MIT License (MIT)
2 |
3 | # Copyright (c) 2015 INSPIRE Lab, BITS Pilani
4 |
5 | # Permission is hereby granted, free of charge, to any person obtaining a copy
6 | # of this software and associated documentation files (the "Software"), to deal
7 | # in the Software without restriction, including without limitation the rights
8 | # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | # copies of the Software, and to permit persons to whom the Software is
10 | # furnished to do so, subject to the following conditions:
11 |
12 | # The above copyright notice and this permission notice shall be included in all
13 | # copies or substantial portions of the Software.
14 |
15 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | # SOFTWARE.
22 |
23 | import numpy
24 | import cluster
25 | import Cluster
26 |
27 |
28 | """
29 | Computes the centroid, given the set of points in a cluster
30 | """
31 | def centroidnp(points):
32 |
33 | x_coords = [t[0] for t in points]
34 | y_coords = [t[1] for t in points]
35 |
36 | centroid_x = sum(x_coords)/len(points)
37 | centroid_y = sum(y_coords)/len(points)
38 | return [centroid_x, centroid_y]
39 |
40 |
41 | """
42 | Computes clusters, given a list of data points, using K-Means
43 | """
44 | class kmeans:
45 |
46 | def __init__(self):
47 | self.freeclusters = []
48 | pass
49 |
50 | def Kmeanscluster(self, frontiers, no_robots):
51 |
52 | from cluster import KMeansClustering
53 | self.freeclusters = []
54 | # Perform clustering
55 | cl = KMeansClustering(frontiers)
56 | clusters = cl.getclusters(no_robots)
57 |
58 | # Compute centroids
59 | centroids=[]
60 | for i in range(no_robots):
61 | # Cheap hack (If the algorithm returns only a tuple convert it into a list,
62 | # because centroidnp takes as input only a list)
63 | if type(clusters[i]) is tuple:
64 | clusters[i] = [clusters[i]]
65 | temp = centroidnp(clusters[i])
66 | centroids.append(temp)
67 | # Store each centroid in its corresponding Cluster object
68 | clusterObject = Cluster.Cluster(centroids[i][0], centroids[i][1])
69 | clusterObject.occupied = False
70 | self.freeclusters.append(clusterObject)
71 |
72 | return self.freeclusters, clusters
73 |
--------------------------------------------------------------------------------
/Python Simulator/Frontier Exploration/cluster/method/base.py:
--------------------------------------------------------------------------------
1 | #
2 | # This is part of "python-cluster". A library to group similar items together.
3 | # Copyright (C) 2006 Michel Albert
4 | #
5 | # This library is free software; you can redistribute it and/or modify it
6 | # under the terms of the GNU Lesser General Public License as published by the
7 | # Free Software Foundation; either version 2.1 of the License, or (at your
8 | # option) any later version.
9 | # This library is distributed in the hope that it will be useful, but WITHOUT
10 | # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 | # FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
12 | # for more details.
13 | # You should have received a copy of the GNU Lesser General Public License
14 | # along with this library; if not, write to the Free Software Foundation,
15 | # Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 | #
17 |
18 |
19 | class BaseClusterMethod(object):
20 | """
21 | The base class of all clustering methods.
22 |
23 | :param input: a list of objects
24 | :distance_function: a function returning the distance - or opposite of
25 | similarity ``(distance = -similarity)`` - of two items from the input.
26 | In other words, the closer the two items are related, the smaller this
27 | value needs to be. With 0 meaning they are exactly the same.
28 |
29 | .. note::
30 | The distance function should always return the absolute distance between
31 | two given items of the list. Say::
32 |
33 | distance(input[1], input[4]) = distance(input[4], input[1])
34 |
35 | This is very important for the clustering algorithm to work! Naturally,
36 | the data returned by the distance function MUST be a comparable
37 | datatype, so you can perform arithmetic comparisons on them (``<`` or
38 | ``>``)! The simplest examples would be floats or ints. But as long as
39 | they are comparable, it's ok.
40 | """
41 |
42 | def __init__(self, input, distance_function, progress_callback=None):
43 | self.distance = distance_function
44 | self._input = input # the original input
45 | self._data = input[:] # clone the input so we can work with it
46 | # without distroying the original data.
47 | self.progress_callback = progress_callback
48 |
49 | def topo(self):
50 | """
51 | Returns the structure (topology) of the cluster.
52 |
53 | See :py:meth:`~cluster.cluster.Cluster.topology` for more information.
54 | """
55 | return self.data[0].topology()
56 |
57 | @property
58 | def data(self):
59 | """
60 | Returns the data that is currently in process.
61 | """
62 | return self._data
63 |
64 | @property
65 | def raw_data(self):
66 | """
67 | Returns the raw data (data without being clustered).
68 | """
69 | return self._input
70 |
--------------------------------------------------------------------------------
/Python Simulator/Frontier Exploration/results/temp2.txt:
--------------------------------------------------------------------------------
1 | 8
2 | 2
3 | 1
4 | 1
5 | 0
6 | 3
7 | 1
8 | 1
9 | 1
10 | 3
11 | 2
12 | 2
13 | 0
14 | 0
15 | 0
16 | 0
17 | 0
18 | 0
19 | 0
20 | 0
21 | 1
22 | 1
23 | 0
24 | 1
25 | 1
26 | 1
27 | 1
28 | 2
29 | 1
30 | 0
31 | 0
32 | 0
33 | 0
34 | 0
35 | 0
36 | 0
37 | 0
38 | 0
39 | 0
40 | 0
41 | 0
42 | 1
43 | 1
44 | 1
45 | 2
46 | 2
47 | 1
48 | 2
49 | 2
50 | 1
51 | 1
52 | 2
53 | 2
54 | 2
55 | 2
56 | 3
57 | 3
58 | 3
59 | 3
60 | 2
61 | 1
62 | 1
63 | 1
64 | 1
65 | 1
66 | 1
67 | 1
68 | 1
69 | 1
70 | 1
71 | 1
72 | 1
73 | 1
74 | 1
75 | 0
76 | 1
77 | 1
78 | 1
79 | 2
80 | 2
81 | 1
82 | 1
83 | 2
84 | 3
85 | 3
86 | 2
87 | 1
88 | 1
89 | 1
90 | 1
91 | 1
92 | 1
93 | 1
94 | 2
95 | 1
96 | 1
97 | 2
98 | 2
99 | 3
100 | 2
101 | 2
102 | 3
103 | 2
104 | 1
105 | 0
106 | 0
107 | 0
108 | 0
109 | 0
110 | 0
111 | 0
112 | 0
113 | 0
114 | 0
115 | 0
116 | 0
117 | 0
118 | 0
119 | 0
120 | 0
121 | 0
122 | 0
123 | 0
124 | 0
125 | 0
126 | 0
127 | 1
128 | 1
129 | 1
130 | 2
131 | 2
132 | 1
133 | 1
134 | 3
135 | 1
136 | 1
137 | 0
138 | 0
139 | 1
140 | 1
141 | 1
142 | 1
143 | 1
144 | 1
145 | 2
146 | 2
147 | 3
148 | 4
149 | 3
150 | 4
151 | 4
152 | 3
153 | 1
154 | 0
155 | 1
156 | 0
157 | 1
158 | 0
159 | 0
160 | 0
161 | 0
162 | 0
163 | 0
164 | 0
165 | 0
166 | 0
167 | 0
168 | 0
169 | 0
170 | 0
171 | 0
172 | 0
173 | 0
174 | 1
175 | 1
176 | 1
177 | 0
178 | 0
179 | 0
180 | 1
181 | 2
182 | 1
183 | 2
184 | 2
185 | 1
186 | 0
187 | 0
188 | 0
189 | 1
190 | 1
191 | 2
192 | 2
193 | 2
194 | 0
195 | 0
196 | 0
197 | 4
198 | 2
199 | 3
200 | 3
201 | 2
202 | 2
203 | 2
204 | 3
205 | 3
206 | 3
207 | 3
208 | 2
209 | 1
210 | 0
211 | 0
212 | 2
213 | 0
214 | 0
215 | 0
216 | 0
217 | 1
218 | 0
219 | 0
220 | 0
221 | 0
222 | 0
223 | 0
224 | 0
225 | 0
226 | 0
227 | 0
228 | 0
229 | 0
230 | 0
231 | 0
232 | 0
233 | 0
234 | 0
235 | 0
236 | 0
237 | 1
238 | 0
239 | 0
240 | 0
241 | 1
242 | 1
243 | 0
244 | 1
245 | 1
246 | 1
247 | 1
248 | 2
249 | 2
250 | 1
251 | 1
252 | 0
253 | 0
254 | 0
255 | 1
256 | 1
257 | 1
258 | 1
259 | 2
260 | 1
261 | 1
262 | 2
263 | 2
264 | 3
265 | 2
266 | 1
267 | 1
268 | 1
269 | 1
270 | 2
271 | 3
272 | 3
273 | 2
274 | 2
275 | 2
276 | 2
277 | 2
278 | 2
279 | 2
280 | 1
281 | 2
282 | 4
283 | 3
284 | 3
285 | 2
286 | 1
287 | 1
288 | 1
289 | 1
290 | 1
291 | 0
292 | 0
293 | 0
294 | 0
295 | 0
296 | 1
297 | 1
298 | 0
299 | 0
300 | 0
301 | 0
302 | 0
303 | 0
304 | 0
305 | 0
306 | 0
307 | 1
308 | 1
309 | 1
310 | 0
311 | 1
312 | 3
313 | 3
314 | 4
315 | 4
316 | 4
317 | 4
318 | 4
319 | 2
320 | 3
321 | 3
322 | 2
323 | 2
324 | 2
325 | 2
326 | 2
327 | 1
328 | 2
329 | 2
330 | 2
331 | 2
332 | 2
333 | 2
334 | 3
335 | 2
336 | 2
337 | 2
338 | 3
339 | 1
340 | 1
341 | 2
342 | 2
343 | 3
344 | 4
345 | 5
346 | 4
347 | 4
348 | 3
349 | 4
350 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Path-Planning-Simulator
2 | The repository contains two simulators -
3 | ## Python Simulator
4 | ### Path Planning Algorithms
5 | A python based simulator for path planning algorithms such as A*, JPS, Dijkstra, and other state-of-the-art algorithms.
6 | - Breadth First Search 9 |
- Depth First Search 10 |
- Dijkstra's Algorithm 11 |
- A-Star Algorithm 12 |
- D-Star Algorithm 13 |
- Greedy Best First Search 14 |
- Jump Point Search (JPS) 15 |
- Jump Point Search extensions - JPS+ and JPS+B 16 |
- Yamauchi's Frontier Algorithm 23 |
- Burgard's Frontier Algorithm 24 |
- Faigl's Frontier Algorithm 25 |
- Cluster Allocate Cover 26 |
- Breadth First Search 32 |
- Depth First Search 33 |
- Dijkstra's Algorithm 34 |
- Greedy Best First Search 35 |
- A-Star Algorithm 36 |
- Rapidly Exploring Random Trees (RRT) 37 |
- RRT-Connect 38 |
- RRT-Star 39 |
The project builds upon the Cluster Allocate Cover (CAC) simulator implemented by Prof.Avinash to make it faster and more efficient. The bottle neck, as found by profiling the code was turning out to be the path planning algorithm for the simulator. To tackle this issue, comparative analysis of state-of-the-art path planning and exploration algorithms via simulation and experimentation was performed in this project. The simulation is performed on 50+ custom grid maps of size 50 x 50 on a python based simulator. Experiments are also performed on a Turtlebot, on which a node containing all studied path planning algorithms is written on the ROS Indigo platform and tests on 10+ real maps are performed (On Gazebo/Rviz as well as in the lab). The following graph search algorithms were tested in the study:
7 |-
8 |
JPS was found to be the best performing algorithm on the simulator as well as the Turtlebot.
18 | 19 | ### Exploration Algorithms 20 | The srepository also includes implementations of the following frontier based exploration algorithms 21 |-
22 |
-
31 |