ROS2 Path Planning and Maze Solving with Computer Vision

Design a differential drive robot for simulation by varying wheel speeds to steer, selecting a simple two-wheel dolly platform for maneuverability, and modeling it in Fusion 360.

Model the maze solving robot in Fusion 360 by sketching a car side view, extruding to form the body, adding wheel spaces with circles, and mirroring to complete both sides.

Design a robot body in Fusion 360 using cylinders and wheels, refine with fillets and circular patterns, then export the model as a mesh and apply ROS related commands.

Learn how to install the correct ROS version for your Ubuntu release, such as Foxy for 20.4, and set up VS Code with the ROS extension for development.

Install ROS Foxy on linux by following official documentation and copying commands. Set up the environment, source the setup script, and test the desktop with Gazebo and Iris.

Structure your robotics projects by organizing code into a workspace and packages within ROS. Discover how packages contain nodes, launch files, meshes, and worlds.

Explore the ros2 publisher and subscriber workflow by creating a workspace and package, writing talker and listener nodes, building, sourcing, and running a simple maze project.

Design and describe a robot using the universal robot description format, outlining links and joints and their connections to the base, then visualize a simple robot without mesh files.

Write a custom URDF to model a robot in ros simulations, defining links and joints with visuals, collision, mass and inertia, and refine with rviz/gazebo previews and mesh-based geometry.

Explore ROS2 path planning by managing launch files and packages, building and sourcing workspaces, and running multiple nodes with publishers and subscribers.

Launch and bring up a robot via a launch file, visualize with RViz, and publish joint states and robot models using robot_state_publisher and joint_state_publisher, handling fixed and continuous joints.

Import STL meshes from CAD into ROS, export base and parts as 3D mesh files, and resize them in Blender to fit simulation; establish parent–child links and joints for movement.

Create and visualize a robot structure by integrating steel meshes in a ROS2 launch workflow, using a shared package and blender to scale meshes for maze simulation.

Create and enforce correct parent-child relationships among robot links to match the Blender model, race simulation, and gazebo, aligning legs, joints, casters, and wheels.

Resize robot meshes and establish origin-aligned parent-child relationships to build a functioning robot model, using Blender and export workflows (SDL) to accurately position joints and links.

The joint axis test fixes wheel rotation alignment by correcting axes (x, y, z) with the joint state publisher, enabling proper forward motion in Gazebo simulations.

Learn how Gazebo simulates real-world physics for robotics, including gravity, inertia, and collisions, and how to compute inertial matrices using MATLAB for accurate mesh-based robot models.

Create a Gazebo launch file to enable ROS communication with Gazebo, spawn a robot into the simulation, and debug inertia, collision, and visual geometry.

Import a mesh, scale it, and compute geometric measures to derive the inertia matrix and inertia metrics; divide by volume to adapt to robot mass for simulation.

Understand ros2 node communication and twist messages to publish velocities. Drive the simulated car in x, y, z and angular z using a keyboard publisher-subscriber setup.

Integrate the differential drive plugin to read command velocity from the topic, require left and right wheel joints, wheel separation, and diameter, and drive the Gazebo robot via keyboard controls.

Publish a Python ROS2 node to the command velocity topic, sending a twist with linear x and angular z to drive the robot in simulation.

Calculate distance and angle to move a robot from an initial to a goal position in 2D, then apply control algorithms for linear x and angular z.

Implement a go to goal pose node in ROS2 by publishing velocity, subscribing to pause messages, and processing pose data to drive the robot toward a target.

Implement a go-to-goal algorithm in ROS2, computing distance and angle to the goal from robot and goal poses, using orientation conversion, geometry messages, and 0.2-second updates.

drive to goal by calculating angle to turn from angle to goal and distance to go, then publish velocity commands to rotate and move toward the goal.

Design and solve custom mazes for ROS2 path planning with computer vision by building start-to-end layouts, exploring multiple paths, and simulating with Gazebo to identify the best route.

Install a Gazebo camera plugin to provide a top view of the maze, configure image size and 30 fps, and record video for computer vision path planning and maze solving.

Create a Gazebo maze world with a top camera, then save it as a world file. Use the model editor to adjust camera properties and prepare the world for launch.

Increase camera height and fix colors from gray to blue to improve wall visibility for maze solving, then test with video recording and adjust the field of view.

Build a ROS2 video saver node to record camera frames into a 1280x720 video for computer vision tasks, using an image subscriber, cv_bridge, and OpenCV to convert and save frames.

Create and tune a maze solving node in ROS2, leveraging publishers, subscribers, and a timer callback to publish command velocities and visualize the video feed.

Create a new development branch on GitHub to collaborate with the computer vision team, clone and push changes, build ros2 path planning in a dedicated workspace, and test mazes.

Explore maze solving as a robot navigation problem, defining mazes, localization, mapping, planning the shortest route, and obstacle avoidance to reach a goal with an automated system.

Break down the project into five steps: localize the robot, map the maze with an occupancy grid and graph, then plan paths with depth-first search and Dijkstra for autonomous navigation.

Localize the robot at each iteration by extracting its position and orientation from the overhead image of the maze. Differentiate localization from SLAM and emphasize frame-by-frame updates for up-to-date information.

Initialize the background model, extract it if needed, then localize the robot as the sole foreground object, and use the centroid to determine its precise location over time.

Apply background subtraction to localize the robot by modeling the static scene, extract the foreground, and track the robot across frames using absolute difference.

Builds a background extraction pipeline for robot localization, including edge detection, region of interest masking, car removal, and a background model used to compute the maze occupancy grid.

Learn to perform background subtraction for foreground extraction, detect the car with absolute difference, convert to grayscale, threshold to reveal the car mask, and compute its relative maze location.

Test the localization module's robustness by driving a mobile robot in simulation with keyboard controls, ensuring accurate tracking across speeds, directions, and wall proximity.

Convert the maze image into an occupancy grid, then build a topological graph of traversable regions with distances, updating the map for static environments to guide ROS2 path planning.

Plan of attack defines the steps to verify mapping, convert the map into an occupancy grade, and extract a topological graph with regions of interest and their distances.

Identify interest points in a maze occupancy grid to build a compact path graph. An interest point is a decision node, such as dead ends and turns.

Stage two covers mapping a localized maze into a graph by simplifying pathways and extracting interest points such as start, end, dead ends, and junctions using OpenCV techniques.

Explore graphs by identifying nodes and edges, distinguish directed and undirected graphs, and compare representations like adjacency matrix and adjacency list, emphasizing adjacency lists for sparse graphs and efficient pathfinding.

Create a graph class to store interest points, add vertices and neighbor connections with traversal costs, and implement a display function to visualize the graph.

Explore topological mapping in a 2D maze by selecting interest points, saving them in a graph, and applying a one-pass algorithm that connects nodes to eight neighbors, enabling diagonal movements.

Builds a graph-based maze representation inside a board member, linking each node to left, top-left, top, and top-right neighbors via connect_neighbors and computing traversal costs for a one-path algorithm.

Test and debug the mapping module for ROS2 path planning using a tiny 10x10 maze to visualize interest points, neighbor connections, and path costs, ensuring proper reset parameters.

Identify path planning strategies for robot navigation, contrasting grid-based and sampling-based planners, and implement DFS, BFS, Dijkstra, and A* to find first available and shortest paths.

The plan of attack outlines using Destroyer to find the shortest spot and stop. If not, perform the recursive implementation of the DFS.

Learn what recursion means through a Starbucks line story, then see how to divide a problem into smaller subproblems, reach a base case, and roll back the solution.

Learn depth-first search, a search that starts at a node, goes as far as possible, backtracks on dead ends, and uses a stack for backtracking until goal node is found.

Implement dfs-based path planning to solve mazes in ros2, using a graph from mapping and recursion to find all paths from start to goal.

Explore dfs analysis for maze solving by testing a tiny mapping, debugging recursion, and visualizing all possible paths from entry to exit to compare path planning strategies.

Learn how dfs can be adapted to find the shortest path by using a get pass cost function, but it is not recommended; the lecture contrasts it with shortest-path algorithms.

Dijkstra theory presents a greedy search that finds the shortest path from start to goal by selecting the least-cost node, updating paths via a priority queue.

Implement a min-heap based priority queue to efficiently select the least-cost node in path planning. Learn binary heap properties, array representation, extract-min and decrease-key operations, and their O(log n) time.

Develop and test a min-heap based priority queue to support shortest path algorithms, implementing heap initialization, node creation, min-heapify, extract-min, and decrease-key operations.

Develop and integrate a Dijkstra-based pathfinding module, building a min-heap priority queue, index mappings, and distance updates to output the shortest path from start to goal in the maze.

Understand why greedy search is inefficient and how A-star uses an admissible heuristic to guide path planning, combining traversal cost with a goal-directed estimate for optimal paths.

Tackle a hands-on code challenge that compares A-star and DICE by implementing ISDA from scratch, using a zero-heuristic baseline to reinforce understanding of these algorithms.

Shows how an improved A-star variant (estar) inherits the dice star, uses Euclidean distance as heuristic, and minimizes visited nodes to compute optimal paths in maze solving.

Examine motion planning for robot navigation in a 2d maze, focusing on obtaining orientation and directing movement from source to goal while avoiding obstacles.

Plan of attack motion planning computes the image to simulation offset, derives a relation from card orientation and image, then updates card orientation and image before moving to the goal.

Learn how to deduce robot orientation for ROS2 path planning by aligning image orientation with simulation using background subtraction, trigonometry, and offset correction to achieve full pose for go-to planning.

Implement motion planning for robot navigation by building a motion planner, computing initial and current locations, publishing velocity, and aligning image and simulation angles via an angle relation.

Go-to-goal planning in ROS2 uses grid-based search to reach the shortest path to the goal via mini goals with a differential drive.

Implement the go to goal function in the board motion class, using the mapping frame as reference to compute angle to go and distance to go toward the maze exit.

Test the missile robot in maze two to evaluate localization, occupancy grids, and planning amid sharp corners, with mini goals, obstacle navigation, and camera distortion considerations to avoid wall stalling.

Explore obstacle navigation theory for ROS2 maze solving, addressing localization errors, uneven surfaces, and overshoot by backtracking to new goals not too close to the last when stagnation occurs.

Implement obstacle navigation in the board motion planner with backpedaling and next point logic, tracking changes to escape stalls and advance toward goals during maze solving.

I celebrate everyone involved, especially you, our students, and offer a starting point for tackling robot navigation problems in ROS2 path planning and maze solving with computer vision.