Survey On Path Planning and Navigational Algorithms

Saurabh Pethkar, Anirudhh Kalkura, Krishna Reddy

Drexel University

Abstract - This paper comprehensively surveys various path
planning and navigational algorithms, highlighting their
unique characteristics, applications, and limitations. The
focus is on grid-based, graph-based, sampling-based,
dynamic programming, heuristic, AI and ML-based, fuzzy
logic and expert systems, hybrid, and bio-inspired
algorithms, and a special mention of bug algorithms. Each
category is examined for its method, efficiency, and
suitability in different scenarios. The paper aims to offer
insights into how these algorithms are integral to robotics,
autonomous navigation, and virtual environment mapping.
Comparative analysis and discussions on the adaptability
and robustness of these algorithms, particularly in dynamic
and complex environments, supply valuable perspectives for
future technological advancements.
Introduction
Path planning and navigation algorithms are pivotal
in shaping the future of autonomous systems. This
paper delves into the intricacies of various
algorithms that form the backbone of such systems.
We begin by exploring the fundamental concepts
underlying path planning and navigation, laying a
foundation for understanding the complexities
involved. We then address the significance of these
algorithms in diverse applications, ranging from
robotics to autonomous vehicle navigation. The
aim is to supply a detailed overview, emphasizing
the critical role these algorithms play in decision-
making processes and their impact on the
effectiveness of autonomous systems. This
introduction sets the stage for a comprehensive
exploration of several types of algorithms, each
with its unique method and application. A type of
many-valued logic known as fuzzy logic deals with
approximations in reasoning as opposed to precise
and fixed inferences. Because exact and binary
logic can't always account for the complexity and
unpredictability of real-world surroundings, it's
especially helpful in robot path planning and
navigation. Fuzzy logic is used in robotics to make
judgments based on inaccurate input, which
enables robots to navigate and plan routes in
dynamic and unpredictable settings. Robots can
now handle ambiguity and vagueness because to
this technique, which makes navigation algorithms
more fluid and adaptive.
Grid-Based Algorithm - Grid-based algorithms
are fundamental in path planning and navigation,
particularly in robotics and computer graphics.
These algorithms discretize the navigation space
into a manageable grid, which simplifies the
process of finding paths and navigating around
obstacles. This section explores two primary grid-
based algorithms: the Wavefront Algorithm and
Voronoi Diagrams, elucidating their mechanisms,
applications, and limitations.
1. Wavefront Algorithm
The Wavefront Algorithm is a pathfinding method
renowned for its simplicity and effectiveness in
structured environments. This algorithm functions
by assigning numerical values to the cells in a grid,
starting from the goal point. The value assigned to
each cell represents its distance from the goal, with
the goal cell typically assigned the value of zero.
This process creates a gradient or 'wavefront'
across the grid. The algorithm systematically
propagates these values outward from the goal,
incrementally increasing them with each step away
from the goal.
When navigating, a robot or agent starts at its
initial position and moves toward adjacent cells
with lower values, effectively following the
gradient toward the goal. This deterministic
approach ensures that if a path exists, the algorithm
will find it. However, it's most effective in static
environments, as dynamic changes require
recalculating the entire grid. The algorithm's
memory consumption can also be considerable,
especially in large environments.
Figure 1. Wavefront Algorithm
2. Voronoi Diagrams
Voronoi Diagrams offer a different approach to
grid-based pathfinding. This method involves
dividing a space into regions or cells, each
corresponding to a specific obstacle or point of
interest. The edges of these regions represent points
that are equidistant from the nearest two obstacles,
forming what is known as Voronoi edges. These
edges constitute paths that maximize the distance
from the nearest obstacles, thereby enhancing
safety in navigation, particularly in scenarios where
collision avoidance is paramount.
Figure 2. Voronoi Diagrams
In path planning, Voronoi Diagrams are
particularly advantageous in open spaces, where
they can effectively navigate around sparse
obstacles while maintaining a safe distance.
However, their utility diminishes in densely
populated areas with numerous obstacles, as the
diagrams become exceedingly complex and
computationally intensive. The computation of
Voronoi Diagrams can be challenging, particularly
in real-time applications or environments with
dynamic changes.
Comparing the Wavefront Algorithm and Voronoi
Diagrams reveals distinct advantages and
limitations of each method. The Wavefront
Algorithm's strength lies in its straightforward
implementation and reliability in static, structured
environments. It is well-suited for indoor robotics
navigation and simple game environments. On the
other hand, Voronoi Diagrams excel in providing
safer paths in open spaces, making them ideal for
applications like autonomous vehicle navigation in
less cluttered environments.
Both algorithms demonstrate the versatility and
adaptability of grid-based pathfinding methods.
They underscore the importance of context in
choosing the most appropriate algorithm for a
given task. Understanding these algorithms'
underlying principles, applications, and limitations
enables more informed decision-making in the
design and implementation of pathfinding and
navigation systems.
Graph-Based Algorithm - Graph-based
algorithms are fundamental in the field of computer
science, particularly in solving problems related to
networks and pathfinding. Among these, the
Dijkstra and Bellman-Ford algorithms stand out
due to their unique approaches to finding the
shortest paths in a graph. This section supplies an
overview and comparison of these two algorithms,
highlighting their applicability and efficiency in
various scenarios.
1. Dijkstra Algorithm
Developed by Edsger W. Dijkstra in 1956,
Dijkstra's algorithm is a graph search algorithm that
solves the single-source shortest path problem for a
graph with non-negative edge weights. The
algorithm works by iteratively selecting the vertex
with the minimum distance from the source and
updating the distances of its adjacent vertices. It
employs a greedy approach and is often
implemented using priority queues, which can
significantly improve its efficiency. Dijkstra's
algorithm is renowned for its simplicity and
effectiveness in many practical applications such as
GPS navigation and network routing.
Figure 3. Dijkstra's Algorithm
Dijkstra's algorithm begins at the chosen source
node and examines the edges of its adjacent nodes.
In the context of the provided graph, let's choose
node A as the source. The algorithm initializes the
distance to the source node as 0 and all other nodes
as infinity. It then proceeds as follows:
• From node A, the algorithm considers its
adjacent nodes B and C, with distances 4
and 5, respectively, and updates the
shortest distance to these nodes.
• Next, the algorithm selects the node with
the smallest tentative distance from the
source, which is node B in this case, and
examines its neighbors. It updates the
distance to node D to 13 (4 from A to B
plus 9 from B to D).
• The algorithm then moves to the next
closest node, which is C, and updates the
distance to its neighbor E to 8 (5 from A to
C plus 3 from C to E).
• This process continues, selecting the node
with the smallest known distance at each
step and updating the distances to its
neighbors by adding the weight of the
edge that connects them.
• If a shorter path to a node is discovered,
the algorithm replaces the previously
known distance with the new, shorter
distance.
 • The process repeats until the algorithm has
found the shortest path to all nodes or the
nodes reachable from the source node.
In the final output, Dijkstra's algorithm provides
the shortest distance from the source node A to all
other nodes in the graph. It also typically stores the
predecessors for each node, allowing the shortest
path to be reconstructed from the source node to
any other node.
2. Bellman-Ford Algorithm
The Bellman-Ford algorithm, on the other hand,
was developed by Richard Bellman and Lester
Ford independently in 1958. This algorithm is
designed to handle graphs with negative edge
weights, thus offering a broader scope of
application compared to Dijkstra's. It iteratively
relaxes edges and updates the cost of the shortest
paths. A significant advantage of the Bellman-Ford
algorithm is its ability to detect negative cycles in a
graph, a feature that Dijkstra's algorithm lacks.
However, this comes at the cost of higher time
complexity.
Figure 4. Bellman-Ford Algorithm
The Bellman-Ford algorithm is adept at handling
graphs with negative weight edges and can even
detect negative weight cycles. For the given graph,
assuming node 1 is the source, the algorithm
proceeds as follows:
• The algorithm initializes the distance to
the source node (node 1) as 0 and all other
nodes as infinity.
• It then relaxes all the edges by updating
the distance to the destination node if the
sum of the edge weight and the distance to
the source node is less than the currently
known distance. For example, it checks
the edge from node 1 to node 2 (weight 6),
and node 1 to node 3 (weight 5), updating
the distances accordingly.
• The algorithm continues this process for
each edge, for a total of V−1 iterations,
where V is the number of vertices in the
graph. This ensures that the shortest path
has been found to every node, assuming
there is no negative weight cycle. For
instance, it will update the distance from
node 1 to node 4 through node 2 if the
path 1→2→4 offers a shorter route than
the current known path.
• After V−1 iterations, the algorithm will
perform one final check on all edges to
detect any negative weight cycles. If the
distance to a node can still be reduced, it
indicates a negative weight cycle exists.
For the given graph, the Bellman-Ford algorithm
will supply the shortest path from node 1 to all
other nodes while checking for the feasibility of the
solution in the presence of negative weight cycles.
While both algorithms aim to find the shortest
paths in a graph, they differ significantly in their
operations and applications. Dijkstra's algorithm is
typically faster and more efficient for graphs with
non-negative weights. In contrast, the Bellman-
Ford algorithm is more versatile and capable of
handling graphs with negative edge weights and
detecting negative cycles. The choice between
these algorithms depends largely on the graph's
characteristics and the specific requirements of the
problem at hand.
Sampling-Based Algorithm - In the realm of
robotic motion planning and pathfinding, sampling-
based algorithms have appeared as powerful tools
for navigating complex, high-dimensional spaces.
These algorithms circumvent the need for explicit
computation of the configuration space by
randomly sampling the space. This section delves
into the nuances of Rapidly-exploring Random
Trees (RRT), RRT*, and Probabilistic Roadmaps
(PRM), elucidating their methodologies and
applications.
1. Rapidly-exploring Random Trees (RRT)
RRT is a path-planning algorithm renowned for its
efficiency and simplicity. It constructs a space-
filling tree that incrementally grows from the start
state by randomly sampling points in the search
space and extending the tree towards them. The
algorithm's strength lies in its ability to quickly
explore uncharted spaces, making it suitable for
environments where the path to the goal is not at
once clear. Its probabilistic nature ensures that
given enough time, it can find a path if one exists,
albeit without guarantees of optimality.

Figure 5. Rapidly-exploring Random Trees (RRT)
The RRT algorithm starts at the 'Start' node and
grows a tree by randomly sampling the space. In
this image, the nodes represent positions in space,
while the lines between them represent feasible
paths that the RRT has explored.
• Initialization: The algorithm initializes the
tree with the 'Start' node as the root.
• Random Sampling: It then randomly
selects a point in the search space and
identifies the nearest node in the tree to
this random point.
• Node Expansion: From the nearest node,
the algorithm extends the tree towards the
random point by a predefined step size,
adding a new node to the tree.
• Collision Checking: The paths are
checked for collisions with obstacles,
represented by the red circles. If a path
segment intersects an obstacle, it is
discarded.
• Growth: This process of random sampling
and node expansion continues, with the
tree rapidly exploring the space and
avoiding obstacles, always growing
towards unexplored areas.
• Reaching the Goal: The algorithm
proceeds until a node is created within a
predefined distance from the 'Goal' node.
This final node becomes the goal node's
parent, effectively finding a feasible path
from 'Start' to 'Goal'.
In the context of the provided image, the blue
nodes and green lines illustrate the incremental
construction of the tree, with the nodes avoiding
the red obstacle areas and finally reaching the
'Goal' node. RRT does not guarantee the shortest
path but is prized for its efficiency and
effectiveness in complex environments.
2. RRT Algorithm*
RRT* builds upon the foundational principles of
RRT with the added capability of path
optimization. As the tree grows, RRT*
continuously refines its branches to approach the
optimal path. This is achieved by considering not
only the nearest neighbor but also a set of nearby
vertices and choosing the parent that will result in
the lowest path cost. Over time, RRT* converges
towards an optimal solution, striking a balance
between exploration and exploitation.
Figure 6. RRT*
The four images provided depict the iterative
process of the RRT* (Rapidly-exploring Random
Trees Star) algorithm. This algorithm is an
optimized version of RRT and seeks to find the
most optimal path to the goal as more nodes are
added. Here is a step-by-step explanation based on
the images:
• Initialization: The process starts with the
'Start' node, and the algorithm begins to
incrementally build a tree. In the first
image, we see a few initial nodes
branching out from the start, showing the
early exploration of space.
• Random Sampling and Expansion: The
second image shows the tree after more
iterations. The algorithm randomly
samples the space and adds new nodes by
connecting them to the closest vertex in
the existing tree, ensuring that the path
does not intersect with any obstacles (red
circles).
• Nearest Neighbor Search and Rewiring: In
the third image, the tree has grown
significantly, and the algorithm is now
looking for neighbors within a certain
radius (depicted by the circles) to connect
the newly added nodes in a way that could
potentially offer a shorter path. The
algorithm checks if these new connections
can reduce the path cost to any of the
existing nodes and rewires the tree
accordingly.
• Path Optimization: By the fourth image,
the tree has reached the 'Goal' node.
However, the RRT* algorithm doesn’t
 stop at the first connection. It continues to
sample, add, and rewire nodes. During this
process, it constantly refines the path,
seeking shorter connections and
optimizing the route from 'Start' to 'Goal'
through the iterative process of rewiring.
• Convergence to Optimal Path: Over time
and with sufficient iterations, RRT*
improves the paths within the tree. It
gradually converges towards an optimal
solution that is the shortest path from the
start to the goal, given the constraints of
the sampled space and the obstacles within
it.
The RRT* algorithm is particularly useful in
robotics and autonomous vehicle navigation where
the path planning must be both efficient and as
optimal as possible given the unpredictable nature
of the environment. The images demonstrate how
the algorithm not only finds a feasible path but
refines it toward the optimal path as it progresses.
3. Probabilistic Roadmaps (PRM)
PRM is a multi-query path planning algorithm that
constructs a roadmap of the environment by
sampling random configurations and connecting
them through local paths. Once the roadmap is
constructed, the algorithm can answer multiple path
queries by connecting start and goal states to the
nearest points on the roadmap and searching for the
shortest path. PRM is particularly effective in static
environments and for problems where the
computational cost of multiple path queries needs
to be amortized over a single representation of the
space.
Figure 7. Probabilistic Roadmaps (PRM)
The two images illustrate the Probabilistic
Roadmap (PRM) method, a popular motion
planning algorithm in robotics and computer-aided
design. PRM is particularly well-suited for high-
dimensional spaces and complex environments.
Here's how PRM works, as depicted in the images:
• Sampling: The first step in PRM is to
sample random configurations in the
search space. The first image could
represent this phase where nodes (blue
dots) are placed randomly while avoiding
collision with obstacles (red circles).
• Node Connection: After the nodes are
sampled, the algorithm attempts to
connect these nodes with local paths. The
connections (blue lines) are made between
nodes that are within a certain distance of
each other, creating a network of vertices
and edges. This process avoids obstacles,
ensuring that paths do not intersect with
them.
• Roadmap Construction: The result of the
sampling and connection phases is a
roadmap of connected paths that navigate
around the obstacles. This roadmap is a
graph-like structure that represents
possible paths through the space, as seen
in the first image.
• Query: The second image shows the
addition of 'Start' and 'End' nodes. When a
query is made to the PRM for a path from
start to end, the algorithm connects the
start and end points to the nearest nodes in
the roadmap.
• Path Finding: Using graph search
algorithms like A* or Dijkstra's, the PRM
searches the constructed roadmap for the
shortest path from the start node to the end
node. This is represented by the path in
the second image, which shows a feasible
route connecting 'Start' to 'End' while
avoiding obstacles.
• Path Smoothing (optional): The initially
found path may be suboptimal or jagged,
so path smoothing techniques can be
applied to create a more direct and
efficient route.
In summary, the PRM algorithm is a two-phase
process where the first phase builds a graph that
captures the connectivity of the free space, and the
second phase queries this graph to find a path
between start and end configurations. This method
is efficient because the roadmap needs to be
computed only once and can be reused for multiple
queries, which is beneficial in static environments
where the obstacles do not change position.
While RRT and RRT* are single-query algorithms,
excelling in scenarios where a path needs to be
found quickly without prior knowledge of the
environment, PRM is more suited for scenarios
where the environment is known, and multiple path
queries will be made. RRT* offers a significant
advantage over RRT by providing a path that
asymptotically approaches the optimal solution,
while PRM provides a comprehensive
representation of the space that can be reused. The
choice of algorithm thus depends on the specific
requirements of the application, the nature of the
environment, and the computational resources
available.
Experiments
In robotics, fuzzy logic encompasses various
fundamental ideas:
Fuzzy Sets: These sets permit partial membership,
in contrast to conventional sets that have binary
membership (an element is either in or out). This is
an example of ambiguous or uncertain data, which
is necessary for practical uses.
Degree of Membership: In a fuzzy set, the degree
of membership of each element ranges from 0 to 1.
This helps robotics decision-making to be more
nuanced by indicating the degree of truth or the
extent to which an element is part of a set.
Fuzzy Rules and Inference: Conditional statements
that define relationships using linguistic variables
are known as fuzzy rules. Because a fuzzy
inference system processes these principles, robots
can infer actions from imprecise inputs.
Defuzzification: The last stage of fuzzy logic
transforms fuzzy set outputs into a single, sharp
value, giving the robot a clear course of action or
decision. Practical applicability in real-world
situations is ensured by this method.
Working
Static environment - Robots can travel in static
settings with the use of fuzzy logic, which
interprets layout limitations and fixed barriers.
Since static environments are immutable, as
opposed to dynamic ones, the fuzzy logic system
concentrates on path optimization using
predetermined parameters. The robot utilizes fuzzy
rules to make judgments, taking into account the
level of safety and proximity to barriers. Fuzzy sets
are used to represent environmental components
such as walls or stationary gear. This enables the
robot to select the most effective, collision-free
course even in complex environments or situations
when accurate data are not available.
Dynamic environment - Fuzzy logic is essential
for real-time adaptability in changing contexts.
Robots may continually reevaluate and modify
their routes thanks to fuzzy logic, even in the
presence of changing situations or moving objects.
The system uses fuzzy rules to interpret changes in
the dynamics of the environment by processing
sensor data. This leads to an adaptable decision-
making process, which helps robots navigate safely
in unpredictable environments. Continually
updated to reflect real-time changes, the degree of
membership in fuzzy sets facilitates informed and
flexible path-planning decisions.
Hybrid Versions of Fuzzy Logic
Figure 8. Collaboration of different types of algorithms
with fuzzy logic
Hybridization with neural networks -
The goal of robotics' hybridization of fuzzy logic
and neural networks is to improve robots' path-
planning abilities. This combination improves
decision-making in complicated contexts by
combining the interpretability of fuzzy logic with
the adaptive learning capabilities of neural
networks. These systems are appropriate for real-
time applications in both static and dynamic
environments since they can learn more quickly
and require less time and money to create. With
increased computational efficiency, they navigate,
optimize pathways, and adjust to changing
conditions by using fuzzy rules that are based on
neural learning.
Hybridization with Multi-Agent Systems - Fuzzy
logic hybridization with multi-agent systems
(MAS) leverages agent collective behavior to
improve robotic path planning. Every joint in a
robot is thought of as an agent with certain
objectives, including lining up with a target or
dodging obstacles. Each agent behaves
independently yet cooperatively through the use of
fuzzy logic controllers (FLC), allowing a global
behavior to evolve for efficient path planning.
Experiments with robotic manipulators navigating
around obstacles show that this approach is ideal
for real-time applications and enables for dynamic
adjustment to unknown and new surroundings.
Hybridization with Particle Swarm
Optimization - The interpretive power of fuzzy
logic and the powerful searching capabilities of
particle swarm optimization (PSO) are combined in
the hybridization of the two techniques. PSO
assists in optimizing fuzzy logic controller
parameters, particularly the antecedent and
consequent parameters of fuzzy logic systems of
the Mamdani type. Avoiding local minima, a
common optimization issue is made especially
successful by this synergy. The hybrid approach
has proven to be more reliable and efficient for
trajectory control in robotic route planning than
conventional methods by utilizing cost functions
such as Mean of Root of Squared Error and others.
Hybridization with probabilistic roadmap
methods - Fuzzy systems are combined with
PRM's stochastic path planning in the hybridization
of fuzzy logic with probabilistic roadmap methods
(FL-PRM) to address uncertainty in robotics
navigation. In Nielsen and Kavraki's method,
complicated path planning is broken down into
more manageable point-to-point problems using a
fuzzy roadmap. These problems are then resolved
using fuzzy PRM planners. Experiments with
robotic manipulators handling huge objects verify
this two-level system, which reduces collision
checks and boosts efficiency. By using this method,
robots in static situations can be more adaptable
and have more reliable path planning.
Hybridization with rapidly-exploring random
trees - Fuzzy logic and the quickly developing
random tree (RRT) technique are hybridized when
fuzzy systems are used to improve the RRT's
performance in static settings. Fuzzy logic, which
is more adept than classical RRT in determining the
closeness to barriers and probable collisions, can be
used to evaluate cost functions in a more nuanced
manner because to this fusion. The modified
method, called Transition-based RRT (T-RRT),
provides manipulator robots with a more advanced
navigation solution in environments with stationary
obstacles by making the path-planning process
more flexible to the geometrical complexities of the
surroundings.
Applications
Path Optimization - Path optimization is essential
for achieving maximum energy and time economy
in robotic manipulator systems. Fuzzy logic helps
improve motion efficiency and kinematic model
refinement; nonetheless, rule quality plays a major
role in path optimality. Hybrid approaches, such as
fuzzy logic combined with evolutionary
algorithms, have the potential to optimize energy
usage while accounting for stochastic parameters
such as friction, especially in robots with limited
degrees of freedom.
Fault Tolerance - Fuzzy logic techniques are used
in robotic fault tolerance to guarantee operational
continuity in the event of mechanical faults. These
online methods combine obstacle avoidance and
fuzzy path planning to allow robots to continue
operating and pursuing goals despite joint or
mechanical problems. These techniques—validated
by simulations—are essential for reliable end-
effector performance across a range of models.
Part Assembly - Robotics part assembly tasks have
led to the development of fuzzy logic techniques
that concentrate on path planning in environments
with both static and dynamic impediments. Fuzzy
minimal entropy, which evaluates variance and
uncertainty during assembly, is one method that has
improved decision-making under uncertainty. Other
methods combine fuzzy logic and neural networks
(FL-NN). These techniques, which are supported
by simulations and real-world trials using cutting-
edge sensors, show how to execute tasks efficiently
in path planning, increasing the precision and
dependability of robotic manipulators throughout
assembly processes.
Pick and place/object grasping tasks - Hybrids of
neural networks (NN) and fuzzy logic (FL)
increase the efficiency of manipulator robots in
pick-and-place and object-grasping tasks. To ensure
accurate movements, these systems employ fuzzy
logic to correct for flaws in inverse kinematics
calculations. By using sensors and making real-
time movement adjustments, they improve robots'
capacity to recognize things and carry out
activities, such as picking tomatoes, demonstrating
the efficacy of FL in terms of robotic precision and
stability.
Experimental results in papers
Paper 1
Problem statement - The high dimensionality
configuration space (C-space) challenge in
collision-free path planning for manipulator robots
(CFPPMR) is the paper's stated problem. It entails
developing a path planner algorithm that, while
avoiding static and dynamic impediments, abiding
by mechanical limitations, and taking into account
potential joint failures, connects a robot's starting
location and orientation (Source) to a desired
configuration (Target).
Results - The experimental findings demonstrate a
mobile robot with ultrasonic sensors that uses a
minimum-risk strategy to navigate through
uncharted territory. The robot varies the impact of
goal-seeking (GS) and obstacle avoidance (OA)
behaviors by adjusting its speed and trajectory in
reaction to obstacles. One can exhibit effective
 Figure 9. Simulation result for fuzzy logic integrated with path searching algorithm
navigation in intricate settings, such as spaces with
shifting obstructions and U-shaped routes. Even in
the presence of possible sensor drift, the method
works well, underscoring the significance of
adaptive behavior and risk mitigation in robotic
path planning.
Paper 2
Problem statement - The research takes into
account the high dimensionality of the
configuration space (C-space) when building path
planners for the Collision-Free Path Planning for
Manipulator Robots (CFPPMR). Finding a solution
that utilizes data on the explicit geometric
representation of the free C-space and ensures the
translation and rotation of the robot's end-effector
from the starting position (Source) to the desired
configuration (Target), while staying within
mechanical constraints and dodging obstacles, is
frequently made more difficult by this complexity.
Results
Figure 10. Simulation result (varied obstacle size)
Fuzzy logic is used by a mobile robot to navigate
by analyzing sensor data and modifying its motor
speeds to avoid obstacles. The system's objective is
to efficiently reach a target by adjusting direction
and speed in response to the proximity of obstacles.
With 27 rules, the fuzzy controller guarantees
motion free from collisions, as proven by
simulations involving a range of obstacle
situations.
Paper 3
Problem statement - The difficulty of creating
route planners for Collision-Free route Planning for
Manipulator Robots (CFPPMR) because of the
configuration space's high dimensionality (C-
space) is the paper's stated concern. Its main
objective is to create a system that links a robot's
initial configuration (Source) to its intended
configuration (Target), taking into account
mechanical limitations and the requirement to
avoid both static and dynamic impediments.
Results
Figure 11. simulation result
The outcomes of the experiment verified that a
mobile robot with ultrasonic sonars may
successfully navigate across an unknown
environment with local minimums when using the
minimum risk strategy. The robot was able to avoid
collisions and escape from local minimums by
detecting obstructions within three meters of its
path and modifying its route accordingly.
Paper 4
Problem statement - The paper's problem
statement centers on developing a path planner to
guide a robot from its initial configuration to its
intended destination. It is challenging to identify
solutions based on explicit geometric
representations of the free C-space while taking
mechanical restrictions and avoiding obstructions
into account due to the complexity of the high-
dimensional configuration space (C-space).
Results - The main objective of the experimental
results was to assess the accuracy, precision, and
localization ratio of the suggested model to
determine its efficiency. The average localization
error and its standard deviation among models
served as a proxy for localization accuracy, a
crucial component of path planning. Reducing
localization error was the aim to increase the
model's accuracy.
References
[1] Roadmap-Based Path Planning - Using the
Voronoi Diagram for a Clearance-Based Shortest
Path DOI: 10.1109/MRA.2008.921540
[2] Voronoi Diagrams — A Survey of a
Fundamental Geometric Data Structure, FRANZ
AURENHAMMER DOI: 116873.116880
[3] Parimala, M., Broumi, S., Prakash, K. et al.
Bellman–Ford algorithm for solving shortest path
problem of a network under a picture fuzzy
environment. Complex Intell. Syst. 7, 2373–2381
(2021). https://doi.org/10.1007/s40747-021-00430-
w
[4] Rodriguez, Xinyu Tang, Jyh-Ming Lien and N.
M. Amato, "An obstacle-based rapidly-exploring
random tree," Proceedings 2006 IEEE International
Conference on Robotics and Automation, 2006.
ICRA 2006., Orlando, FL, USA, 2006, pp. 895-
900, doi: 10.1109/ROBOT.2006.1641823.
[5] Alomari, A.; Phillips, W.; Aslam, N.; Comeau, F.
Dynamic Fuzzy-Logic Based Path Planning for
Mobility-Assisted Localization in Wireless Sensor
Networks. Sensors 2017, 17,1904.
https://doi.org/10.3390/s17081904
[6] Meng Wang and Liu, "Fuzzy logic based robot
path planning in unknown environment," 2005
International Conference on Machine Learning and
Cybernetics, Guangzhou, China, 2005, pp. 813-818
Vol. 2, doi: 10.1109/ICMLC.2005.1527055.
[7] Horacio Martı́nez-Alfaro, Simón Gómez-
Garcı́a,Mobile robot path planning and tracking
using simulated annealing and fuzzy logic
control,Expert Systems with Applications,Volume
15, Issues 3–4,1998,Pages 421-429,ISSN 0957-
4174,https://doi.org/10.1016/S0957-
4174(98)00055-4.
[8] B. Li and B. Chen, "An Adaptive Rapidly-
Exploring Random Tree," in IEEE/CAA Journal of
Automatica Sinica, vol. 9, no. 2, pp. 283-294,
February 2022, doi: 10.1109/JAS.2021.1004252.
[9] A. Pandey, R. K. Sonkar, K. K. Pandey and D.
R. Parhi, "Path planning navigation of mobile robot
with obstacles avoidance using fuzzy logic
controller," 2014 IEEE 8th International
Conference on Intelligent Systems and Control
(ISCO), Coimbatore, India, 2014, pp. 39-41, doi:
10.1109/ISCO.2014.7103914.
[10] Hentout, A., Maoudj, A. & Aouache, M. A
review of the literature on fuzzy-logic approaches
for collision-free path planning of manipulator
robots. Artif Intell Rev 56, 3369–3444 (2023).
https://doi.org/10.1007/s10462-022-10257-7
[11] Minguez, Javier and Luis Montano. “Nearness
diagram (ND) navigation: collision avoidance in
troublesome scenarios.” IEEE Transactions on
Robotics and Automation 20 (2004): 45-59.
[12] Javaid, Muhammad Adeel, Understanding
Dijkstra's Algorithm (April 10, 2013). Available at
SSRN: https://ssrn.com/abstract=2340905 or
http://dx.doi.org/10.2139/ssrn.2340905