Safe Path Planning Algorithms for Mobile Robots Based on Probabilistic Foam

The planning of safe paths is an important issue for autonomous robot systems. The Probabilistic Foam method (PFM) is a planner that guarantees safe paths bounded by a sequence of structures called bubbles that provides safe regions. This method performs the planning by covering the free configuration space with bubbles, an approach analogous to a breadth-first search. To improve the propagation process and keep the safety, we present three algorithms based on Probabilistic Foam: Goal-biased Probabilistic Foam (GBPF), Radius-biased Probabilistic Foam (RBPF), and Heuristic-guided Probabilistic Foam (HPF); the last two are proposed in this work. The variant GBPF is fast, HPF finds short paths, and RBPF finds high-clearance paths. Some simulations were performed using four different maps to analyze the behavior and performance of the methods. Besides, the safety was analyzed considering the new propagation strategies.


Introduction
Path planning is one of the most important problems in autonomous robot navigation, and it has been discussed in the scientific community since the 1980s [1][2][3]. The issue of planning is particularly relevant because it is almost a requirement for an autonomous mobile robot to perform a motion from an initial to a goal position while avoiding possible collisions in an environment with obstacles and narrow passages [4].
Initially, researches were focused on the development of path planners based on Roadmaps [5], Cell Decomposition [6], and Potential Field [7]. Due to the so-called curse of dimensionality due to high-dimensional configuration spaces, the researchers were motivated to develop sampling-based approaches for path planning, which usually use few computer resources and have been widely used for this sort of problem [8][9][10][11][12]. The most important sampling-based (probabilistic) path planning methods are Rapidly-Exploring Random Tree (RRT) [13,14] and Probabilistic Roadmaps (PRM) [15]. Further, Karaman and Frazzoli [12] have proposed the methods RRT* and PRM*, two of the most successful variants of RRT and PRM, respectively.
Most of the path planning methods are mainly dedicated to generate optimal paths or find feasible paths with reduced execution time [16]. Nevertheless, it is also essential to ensure safety for a robot when moving in unstructured environments [17]. Thus, planning paths sufficiently far from the obstacles is vital for most applications [18].
There are path planners that primarily intend to generate paths with high clearance from obstacles. The path planning methods based on the Voronoi diagram [3,19,20] are approaches that guarantee clearance along the paths. However, they are not practical for In [31,32], we used the PFM to compute a set of safe configurations for a lower limb active orthosis to transpose a simple obstacle. The main contribution of [31] was the modeling of new bubbles inspired by the concept of Bubble of free space, proposed in [33], which enabled PFM to solve robotic problems with many degrees of freedom. In [34], we presented a variant of PFM called Goal-Biased Probabilistic Foam (GBPF). In this variant, we proposed a new foam propagation approach inspired by goal-biased RRT tree growing, which returns paths with the convenient trade-off between finding short paths through narrow passages in the map and keeping the clearance from obstacles. Additionally, GBPF is fast and usually computes a few bubbles.
Beyond the already known algorithms PFM and GBPF, in this paper, we present two new variants of Probabilistic Foam: Radius-biased Probabilistic Foam (RBPF) and Heuristic-Guided Probabilistic Foam (HPF). The variant RBPF is capable of finding paths with high-clearance areas in the map, and HPF converges fast towards to the goal configuration, generating short paths. For the probabilistic foam-based planners, where the rosary bounds the path, it is necessary some metrics to measure the clearance from the obstacles considering the influence of the bubbles. Thus, we also propose in this work some metrics to evaluate the four algorithms.
The remainder of the paper is organized as follows: Section 2 describes the original PFM, and a new approach to determine one of its parameters is proposed. In Section 3, we present the GBPF algorithm [34] and propose two new variants of PFM-RBPF and HPF. Section 5 presents simulation results and discussions. Finally, we present some conclusions and future works in Section 6.

The Probabilistic Foam Method
Probabilistic Foam Method (PFM) is a sampling-based path planning algorithm, initially proposed in [29]. This method ensures a volumetric region for safe maneuverability, ideal for robotic applications that need safety when performing movements.
Let C be a n-dimensional space with all possible robot configurations q and let C f and C o be subsets of C, where C f is the obstacle-free region and C o is the obstacle region in is a volumetric region computed in C f , which provides safe regions. The region b is a n−ball and its surface is a (n − 1)-sphere in the free configuration space C f ; it can be defined as where r is the radius of the bubble, q c is its the center, and d(q, q c ) is the metric adopted in the configuration space. In other words, a bubble expands from its center q c to the nearest C-obstacle C o or it can be computed using metrics in the workspace [31].
In this method, the free-space is covered by a set of overlapped bubbles from an initial configuration to a goal configuration in a tree structure called probabilistic foam. The probabilistic foam performs an approximated coverage, similar to some methods based on approximated convex cell decomposition. The foam propagation strategy is analogous to the mechanisms of a breadth-first search as well as wavefront propagation, commonly used in methods based on potential fields.

Foam Propagation
Propagation occurs by expanding child bubbles b child on the free surface of parent bubbles b parent (bubbles from the previous generation). The propagation starts from the initial bubble b init (i.e., the bubble centered at the initial configuration). Each parent bubble can expand a maximum of N child bubbles, as shown in Equation (2): where r min is the radius of the smallest allowed bubble and can be estimated by analyzing the width of the passages on the map. The parameter n is the dimension of the configuration space and r is the radius of the parent bubble. Finally, K is a constant that indicates the maximum number of child bubbles allowed for the bubble with radius r min . The process of foam propagation is illustrated in Figure 2. Child bubbles are expanded over the parent bubble surface during the foam propagation process. However, this expansion only occurs in regions that were not already covered by the foam (see Figure 2a,b). For each generation, all previous child bubbles are selected as parent bubbles; then, new bubbles are expanded (Figure 2c). When some bubble encircles the goal configuration, b goal , the propagation finishes ( Figure 2d). Finally, the rosary can be found by following the parental relation between the bubbles from b goal to b init , and a collision-free path can be extracted by connecting the center of the bubbles, as shown in Figure 1, solving the path planning problem.
In previous studies [29,31,34], the constant K was determined by empirical analysis. In this paper, we propose a new approach to determine the value of K according to the dimension of the configuration space.

Setting the Constant K
The constant K is an important parameter of Equation (2), which indicates the maximum number of child bubbles necessary to cover the entire surface area of bubble with radius r min .
Considering the best-case scenario, where the bubbles b parent and b child have an equal radius (r min ), the triangle formed between these bubbles (as shown in Figure 3) is equilateral, with all three sides equal to r min . Thus, the colatitude angle of the hyperspherical cap is φ = 60 • and the radius of the portal region is r p = √ 3 2 r min . It is possible to obtain K as a function of the dimension of the configuration space n. This value can be obtained by dividing the surface area A n of a (n − 1)-sphere (hypersphere represented by b parent in Figure 3a) by the volume V n−1 of the portal, the region is resulted by removing the hyperspherical cap (red area), as can be seen in Figure 3b  The well-known surface area A n of a (n − 1)-sphere, with radius r min can be expressed by where Γ denotes the gamma function [35]. Based on [36], the volume V n−1 of a (n − 1)-ball (portal region), with radius r p , is defined as Thus, the value of K, given dimension n of the C-space, can be defined by Using Equation (5), it is possible to compute the number of bubbles necessary for a parent bubble with radius r min . Figure 4 shows the value of K for the dimension n of the C-space varying from 2 to 12.

Pseudocode of PFM
The procedure presented in Algorithm 1 describes the Probabilistic Foam Method. The algorithm receives as input the configurations q init and q goal , the minimum radius r min , and the set of obstacles C o , and returns the rosary R, from which it is possible to extract the path. The list F and the queue Q store all bubbles in the foam and the child bubbles for each generation, respectively. The list F represents the probabilistic foam itself, and the data structure Q has all candidate parent bubbles. When some bubble expands, it is removed from Q. The function expand_bubble(q init , C o ) at line 3 returns the radius of a new bubble. The function add({q init , r}) (line 4) stores a bubble (center and radius) in the list F.
For each generation, a parent bubble is selected from the queue Q (line 7); the maximum number of child bubbles N is computed (line 8); and using the function surface_random_config(q p , r p ), a configuration is sampled on the parent bubble surface (line 10). If the configuration is not sampled in the interior of another bubble in the foam (verified using the function int(q i ) on (line 11), a new bubble is expanded (line 12). If the radius of the new bubble is greater than or equal to r min , this bubble is stored in lists F and Q. For each new bubble added to the foam, it is verified if the new bubble encircles the configuration q goal (line 16). If it does, the rosary R is extracted from the foam F using the function get_rosary() and the algorithm stops, returning success. Otherwise, the current bubble is removed from Q, and the next parent bubble will be selected.
The original Probabilistic Foam method described in this section does not present any mechanism that improves the foam propagation strategy to obtain safer and shorter paths or to decrease the processing time of the algorithm. In this way, in the next sections, we present some variants of the original PFM with different propagation approaches.

Goal-Biased Probabilistic Foam
Goal-Biased Probabilistic Foam (GBPF) is a variant of the original PFM proposed in [34]. In this algorithm, foam propagation is based on the strategy of expanding the search tree of the RRT-GoalBias algorithm [14], a variant of the classic path planner Rapidly-Exploring Random Tree [13]. The algorithm GBPF usually converges to the goal configuration faster than the original PFM, so the search time is reduced. The main difference between GBPF and the original PFM is that random configurations q aux are sampled in the configuration space, and they guide the propagation of the probabilistic foam. This process is illustrated in Figure 5.
A configuration q aux is sampled in the configuration space ( Figure 5a). The parent bubble for this generation will be the one with the center closest to configuration q aux . Next, the configuration q near is found on the parent bubble surface (Figure 5b). Then, a new child bubble centered in q near is expanded ( Figure 5c). Finally, Figure 5d illustrates how the propagation is biased. There is a small probability (such as 0.05, as suggested by [14]) of sampling the configuration q aux on the q goal . In this way, the next parent bubble will be the bubble with the center closest to q goal .
The described process is repeated until a child bubble encloses the goal configuration q goal , then, the method finds the rosary and the associated path. Algorithm 2 describes the steps of GBPF. The method described in Algorithm 2 receives as input q init , q goal , r min , the value of bias, and C o , and returns the rosary R. In the same way as described in Algorithm 1, the first bubble, centered in q init , is added to the foam F. The sampling of q aux occurs on lines 5-9. The function rand() returns a uniform random value between [0,1].
The function nearest_bubble(q aux , F) returns the bubble (center and radius) to F with the nearest center to q aux . Additionally, the function nearest_config(q p , r p , q aux ) returns the nearest point between the surface of this bubble and the configuration q aux (lines 10 and 11). From line 13 to the end, the method follows the same structure from Algorithm 1. The GBPF method runs until the rosary R is found.

Radius-Biased Probabilistic Foam
Radius-Biased Probabilistic Foam (RBPF) is a new variant of PFM proposed in this work that finds a path considering large passages in the environment, i.e., paths with high clearance from the obstacles. Further, it can be applied to problems where finding a short path is not the main objective. The main difference between RBPF and the original PFM is that the bubbles with a large radius have a higher probability of being selected as parent bubbles. Thus, the probabilistic foam will be biased to propagate faster through the passages with high clearance from obstacles on the map.
The new expanded bubbles are stored in a list Open_List during the RBPF propagation, and for each bubble, a probability p i proportional to its radius is calculated. If r i is the radius of the bubble b i in the foam F, its associated probability of being selected is where z is the number of bubbles in the list Open_List. This selection strategy is wellknown as Roulette Wheel Selection, commonly used in metaheuristic applications, such as the Genetic Algorithm [37,38].

Algorithm 2:
Goal-biased Probabilistic Foam. input : q init , q goal , r min , bias, C o output : if rand() > bias then 6 q aux ← random_config(); Foam propagation of RBPF is illustrated in Figure 6 for a better understanding of the process. The first generation of the RBPF is very similar to the original PFM (see Figure 2). As shown in Figure 6a, the parent bubble centered in q init (red border) is covered by four child bubbles. These child bubbles are candidates to be parent bubbles for the next generation, i.e., they are stored in the Open_List.
As previously discussed, in RBPF, the parent bubbles with larger radius are selected with high probability using the Roulette algorithm. In Figure 6b, the Roulette algorithm chose the greatest bubble as parent bubble. However, due to the minimum radius rule, no child bubbles were expanded. In the next generation, shown in Figure 6c, another parent bubble was selected, and a new child bubble was expanded. Figure 6d shows that the algorithm found a path with high clearance from the obstacles by propagating the bubbles through the wider passages. The pseudocode of the RBPF method is described in Algorithm 3. Open_List.remove(q p ); 24 end 25 return fail; The structure of the Algorithm 3 is very similar to Algorithm 1, which describes the original PFM. The queue Q that stores the parent bubbles in Algorithm 1 was replaced to the list Open_List (line 2). The main difference between the algorithms is presented on line 6, where the function roulette() selects the parent bubbles with probabilities proportional to its radius, as shown in Equation (6). When the child bubbles stop expanding, on lines 7-22 (procedure explained in Section 2.1 and in most detail in [31]), the parent bubble is removed from Open_List (line 23).

Heuristic-Guided Probabilistic Foam
The Heuristic-Guided Probabilistic Foam (HPF) is another variant of the original Probabilistic Foam Method that we propose in this work. This method improves the foam propagation process by adding heuristic information about the goal configuration. This strategy of propagation was inspired by the widely known A* search algorithm [39].
The A* algorithm is an informed heuristic search algorithm that solves search problems in graphs by finding a path with the smallest cost from an initial node to a goal node of a graph [40]. This algorithm combines features from two important algorithms: the Uniform Cost Search and the Greedy Algorithm, ensuring completeness, optimality, and finding solutions in a reasonable amount of time [41].
In the HPF method, the foam propagates through free space by choosing the parent bubble with the smallest cost f (q). The cost of each bubble in the foam is computed by The function g(q) computes the uniform cost of a bubble in analysis, centered in q. The cost g is calculated by performing a depth search starting from the bubble under analysis until the initial bubble following the child-parent relationship, and computing the sum of the radius of these bubbles. The function h(q) is a heuristic that estimates the cost between the bubble in analysis and the goal configuration. In this work, this cost is computed using the Euclidean distance. The steps of the variant HPF are described in Algorithm 4.
In this new variant, there is a list Open_List to store the parent bubble candidates (center point and radius) and their assigned cost f . The method only stops when the list Open_List is empty or when the search finds the rosary R. At each iteration of the algorithm, the bubble with the smallest cost f is selected from Open_List by the function get_smaller_cost() (line 6). The procedure of expanding child bubbles on the parent bubble surface is similar to the original PFM algorithm. On line 7, the maximum number N of child bubbles is computed.
The bubbles that met the conditions at lines 10 and 12 are stored in the foam F (line 13). Using Equation (7), the costs of the bubbles are computed, and these bubbles and their respective costs are stored in the list Open_List (lines 14 and 15). Afterwards, child bubbles are computed and the parent bubble is removed from Open_List (line 23).
An illustration of the propagation process of the HPF is shown in Figure 7. First, the initial bubble (red bubble) centered in q init (green point) is expanded (Figure 7a). Four child bubbles are expanded on the parent bubble surface and their costs g are calculated. In this case, g cost is the radius of the parent bubble, g = 3.6. In Figure 7b, the heuristic cost h is calculated by measuring the Euclidean distance between the bubbles and the q goal configuration (blue point). In Figure 7c, the cost f is calculated based on Equation (7). The new parent bubble was chosen by selecting the smallest cost f = 11.2; then, a new generation starts.

Algorithm 4: Heuristic-Guided Probabilistic Foam.
input : q init , q goal , r min , C o output : R 1 F = ∅; 2 Open_List = ∅; 3 r ← expand_bubble(q init , C o ); 4 F.add({q init , r}); 5 while Open_List = ∅ do 6 {q p , r p } ← Open_List.get_smaller_cost(); Two new child bubbles are expanded on the surface of the new parent bubble. The cost g of the new bubbles is computed by summing the radius and the g cost of the parent bubble, which are equal to 1.9 and 3.6, respectively. Therefore, the value of g for the new child bubbles must be equal to 5.5 (1.9 + 3.6), as shown in Figure 7d. Finally, the new costs h and f are calculated in Figure 7e,f, respectively, and a new parent bubble is selected.

Safety Measurement
The studied methods obtain paths with minimum clearance from the obstacles provided by the bubbles. These bubbles are also relevant since they simplify the process of path smoothing, for instance, by imposing safety constraints. However, a rosary usually presents many bubbles with different sizes, which hampers the establishment of a safety measure (i.e., the clearance considering the radius of the bubbles). In this way, we present a metric to measure the path safety based on the Mean Squared Error (MSE) estimator.
Considering that a path is extracted by a sequence of k bubbles called rosary and the path safety is measured by considering the radius r of these bubbles, the Safety Metric SM for a given path can be calculated by where r min is the smallest accepted radius for any bubble in the foam. The Safety Metric SM estimates how far the radii of bubbles of the rosary are to r min . In this case, the bigger the metric SM, the safer the path.

Results
This section presents some simulated experiments with the Probabilistic Foam Method and Goal-Biased Probabilistic Foam algorithms, and the two variants of the original PFM proposed in this work, Radius-Biased Probabilistic Foam and Heuristic-Guided Probabilistic Foam. The algorithms were applied to four maps with particular features to analyze the behavior of each method, such as convergence time, path length, number of generated bubbles, and path safety. The developed maps for this work were categorized as narrow, simple, complex, and 3D, as shown in Table 1. The four maps developed for the simulations are illustrated in Figure 8. Map 1 (Narrow), shown in Figure 8a, was used to analyze the search time and the number of bubbles for each algorithm to pass through the narrow passage. Map 2 (Simple), shown in Figure 8b, presents two possible routes: the first one is short with a narrow passage, and the second one is long with a wide passage. Map 3 (Complex), shown in Figure 8c, represents a general outdoor environment, which usually has many possible routes for the robot to navigate toward its goal. This map is designed with rectangles and circle-shaped randomly distributed and sized objects. Finally, Map 4 (Complex 3D), shown in Figure 8d, represents a complex outdoor environment with many obstacles and routes in a three-dimensional space. This 3D map was used to analyze the behavior of the methods when the dimension of the configuration space is increased. These maps present the obstacle regions explicitly represented in C-space. This representation enables the computation of bubbles considering Equation (1). In addition, these regions better illustrate the resulted probabilistic foam, rosaries, and paths. However, for practical experiments, this representation is computationally unfeasible. In this way, new bubbles can be easily computed using information from the workspace without needing the C-obstacle computation, as shown in [30]. Besides, it also allows us to compute bubbles for different robots.
The simulations with the algorithms PFM, GBPF, RBPF, and HPF were performed on a 1.8 GHz Intel Core i7 processor with 8 GB RAM on the Ubuntu 16.04 operating system. The parameters of the algorithms were determined according to the map and were used for all algorithms. The parameter R min was determined empirically where for Narrow map, R min = 0.08; for simple map, R min = 0.2; for Complex map, R min = 0.15; and for Complex 3D map, R min = 0.3. The parameter bias was necessary only for the GBPF algorithm, and was determined as bias = 0.05 (as suggested by [14]) for all experiments. Finally, the K parameter is determined by Equation (5), according to the dimension of the configuration space. Thus, for the 2D case and 3D case, we use K = 4 and K = 5, respectively.
Simulations were performed to demonstrate the probabilistic foam behavior and some features of the methods. Figure 9 shows the generated probabilistic foam considering the four methods for one simulation using Map 2.
The probabilistic foam generated by PFM (Figure 9a) is dense, i.e., it has a large number of expanded bubbles. Besides, the probabilistic foam generates large bubbles in large passages on the map, resulting in fast propagation in these areas. Thus, the probability of convergence by this route is greater and, consequently, the paths usually have more clearance. On the other hand, this method does not obtain the shortest path. The obtained paths by PFM are shown in Figure 10. The simulation with GBPF generated a probabilistic foam less dense than PFM, as can be seen in Figure 9b. Our approach inspired in the Goal-biased RRT algorithm enabled the foam of GBPF to propagate fast towards the configuration q goal , and generate fewer bubbles. A disadvantage in this randomized approach is that the foam propagates in a disorganized way, generating many irregular bubbles. Additionally, the strategy to choose the parent bubble used in the GBPF makes some small bubbles expand very close to the obstacles. Therefore, some segments of the resulted path can be close to the obstacles even when there is free space available. This configuration can be observed in all paths generated by GBPF, as seen in Figure 10. Figure 9c shows the probabilistic foam generated by the RBPF algorithm. According to the main feature of this approach, bubbles with a larger radius have a higher probability to be chosen as parent bubbles. This characteristic facilitates fast propagation through passages with high clearance from the obstacles, which generates safer paths, as can be seen in Figure 10. However, this approach must only be applied when the path must pass through the route with higher clearance on the map, since the bubbles will reach narrow areas only when the foam covers all large areas on the map. This implies that the convergence time can be harmed when the configuration q goal is placed on difficult access areas. Finally, Figure 9d shows the probabilistic foam generated by the HPF algorithm. The strategy of selecting a parent bubble based on costs allows the foam to propagate faster towards the configuration q goal , generating few bubbles. An important feature illustrated in Map 2 (Simple) is that the foam propagation was faster through the narrow passages, resulting in a short path. The paths obtained by all methods for all maps are shown in Figure 10.
Considering the stochastic characteristics of the algorithms, some simulations were performed for each algorithm to analyze the processing time (Time), the number of generated bubbles (Bubbles), and the path length (Path). Each algorithm was performed 500 times for 2D maps and 300 times for 3D maps. Table 2 presents the results. The simulations performed by the Probabilistic Foam method presented the highest number of generated bubbles in all maps. This happened mainly due to the propagation process of PFM, which conducts an approximated coverage of the entire free space. Moreover, PFM does not have any strategies to optimize the search. The results with the GBPF algorithm were the most inconstant. By analyzing the maximum and minimum processing time for the Narrow map, GBPF presented slower and faster simulations compared with the other methods. On average, GBPF presented the shortest processing time for all maps but the Narrow one. For the last three maps, the Radius-biased Probabilistic Foam method presented the longest paths, since its foam propagates first through the wider passages on the map. In the environment with one passage (Narrow map), RBPF was the fastest algorithm on average.
The main feature of HPF is to find paths with the lowest cost, and the results show that HPF found the shortest paths in all maps. For instance, we ran 500 simulations in Map 2 and the resulted path did not pass through the narrow passage in only 18 of them. Besides, GBPF and HPF presented the lowest number of computed bubbles in relation to the other two methods in all maps.
In Map 4, the dimension of the configuration space is 3D and was considered many obstacles in a complex layout. The methods PFM and RBPF presented a very high number of computed bubbles, which results in a high processing time. On the other hand, both GBPF and HPF were not affected by the increase of the configuration space dimension, presenting a high number of expanded bubbles (as well as the Complex map in 2D), but with low processing time.
Notice that the paths are not smooth, which can be a problem when considering a practical application. However, it is possible to apply optimization techniques to smooth the paths obtained from the probabilistic foam methods, as shown in [30], ensuring both safe and smooth paths.

Measuring the Safety
Considering the same four maps, the values of r max for maps Narrow, Simple, Complex, and Complex 3D are 4, 5, 4, and 2, respectively. The Safety Metric SM averages for the simulations are presented in Table 3. The RBPF method presented the best results regarding safety for all maps, as can be seen in Table 3. This result was expected, since this method presents a higher probability to propagate the probabilistic foam through more large passages; obtain rosaries with large bubbles; and consequently, obtain safer paths.
Observing the safety results for the Simple map, there is a clear difference; PFM and RBPF presented high safety values and the methods GBPF and HPF presented the lowest one. The Simple map presents two possible routes, the longer one is safer than the shorter one. Additionally, the rosaries of these methods presented the most regular bubbles, as shown in Figure 10, and due to the low standard deviation and the high max and min values, it is possible to infer that all obtained paths passed through the longer route. On, the other hand, GBPF and HPF presented a high max value and very low min value. Additionally, they have high std values. In this way, it is possible to infer that the obtained paths for these methods passed through both possible routes but, on average, most paths passed through the short passage.
For the Complex map, the GBPF method presented the most unfavorable results. Due to the propagation strategy of GBPF, its rosary usually presents irregular and small bubbles, which means that some segments of the path are close to an obstacle. For both the Narrow and Complex maps, on average, HPF obtained paths safer than PFM and GBPF.
Finally, for the Complex map, the results were similar to the Simple map for the same reason: RBPF and PFM planned paths passed through the larger spaces in the map and GBPF and HPF converged guided by the goal configuration, generating paths that passed through the narrow passages. However, all methods based on probabilistic foam will generate paths with acceptable safety, since they all have rosary with bubbles with at least a minimal acceptable radius. In other words, all methods based on probabilistic foam will generate paths with acceptable safety.

Conclusions and Future Works
In this paper, we presented some contributions to the robot path planner called the Probabilistic Foam method (PFM). First, an approach to set the value of the constant K was formalized, which facilitates understanding of how the method works. Next, we presented three variants of the original PFM: Goal-biased Probabilistic Foam (GBPF), first proposed in [34]; Radius-Biased Probabilistic Foam (RBPF); and Heuristic-Guided Probabilistic Foam (HPF). The last two methods were proposed in this paper. Some simulations were made to analyze the performance of all these methods.
The original PFM and RBPF present similar results, where both find high clearance paths. However, PFM is recommended when free space coverage is necessary, and RBPF can be used when it is most important to find the safest route. The algorithms GBPF and HPF are variants that solve path planning problems by generating a few bubbles and finding paths with low processing times. An advantage of HPF over all variants is the heuristic function that helps it to find shorter paths, maintaining an acceptable safety.
The method RBPF considers only the information of the bubble's radius as a metric for parent bubble selection. Thus, in future works, we consider investigating metrics that can be used alongside the bubble's radius to bias the search and find safer paths, decrease the number of computed bubbles, and reduce the searching time.
The new approach to finding the value of K is an interesting achievement because the methods PFM, RBPF, and HPF only need to deal with one adjustable parameter, the minimum radius r min admissible for a given environment.
We noticed an increase in the processing time when the complexity of the environment was increased for some maps. In future works, we intend to investigate some strategies to improve the computational efficiency of the methods, making implementation of the method possible for real-time applications.