C++ | Henry Kou

A* Pursuit of Dynamic Target

Wed, 06 May 2026 00:00:00 +0000

I built this planner to answer a simple pursuit question: if the target is moving on a cost map and I know its future trajectory, where should the robot move next? Instead of planning only in (x, y), I lift the search into (x, y, t) so an interception is defined as both agents occupying the same cell at the same time.

The core method is weighted A* over 8-connected grid motion plus a wait action. The edge cost comes from the destination cell, cells above the collision threshold are treated as blocked, and the planner returns only the first action from the best path. That receding-horizon structure matters because the useful plan changes as the target advances.

The interesting engineering detail is the heuristic. I cache a multi-source Dijkstra table from feasible near-future target cells, then combine that with a static meet-point estimate chosen by travel cost plus wait time. The implementation also exposes eps, time_budget_ms, and heu_band so I can trade optimality against response time, and it uses deterministic priority-queue tie breaking on f, h, g, and packed state keys. The repo includes map files, recorded robot trajectories such as rtraj_map*.txt, and a Matplotlib visualizer for replaying the pursuit.

Sources I leaned on: Hart, Nilsson, and Raphael’s 1968 A* paper for best-first graph search; Pearl’s heuristic-search framing; and Koenig and Likhachev’s D* Lite work as background for why replanning problems often need incremental or receding-horizon structure.

Keywords: weighted A*, time-expanded A*, dynamic target pursuit, receding-horizon replanning, 8-connected grid search, wait action, collision threshold, cost map, multi-source Dijkstra, static meet point, trajectory visualization, C++, CMake, Python, Matplotlib.

Sampling Based Planners

Wed, 06 May 2026 00:00:00 +0000

I used this project to compare how different sampling-based planners behave on the same high-DOF arm problem. The planner executable receives an occupancy-grid map, the arm DOF count, comma-separated start and goal joint angles, a planner ID, and an output path, then returns a collision-free sequence of joint configurations for a planar arm with fixed 10-cell links.

The important idea is that planning happens in configuration space even though collision is checked in workspace. For each candidate joint vector, I rasterize every link with Bresenham line traversal, reject poses that hit nonzero map cells, sample joint angles in [0, 2*pi), and score path quality as cumulative wrap-around L1 joint motion.

The planner modes show the tradeoff nicely. Single-tree RRT is simple and usually finds something. RRT-Connect grows start and goal trees toward shared samples and is much faster for single-query planning. RRT* adds local rewiring, which can lower cost but spends more time improving the tree. PRM pays an upfront roadmap cost, then uses Dijkstra search over collision-checked graph edges.

In my report, I compare fixed start/goal pairs over 3-, 4-, and 5-DOF settings on map2.txt. RRT-Connect was the fastest and most reliable single-query planner overall, RRT* reduced path cost through rewiring at higher runtime, and PRM produced strong global path quality but paid a larger roadmap construction cost.

Sources I leaned on: Kavraki et al. on probabilistic roadmaps; LaValle’s original RRT work; Kuffner and LaValle’s RRT-Connect paper; and Karaman and Frazzoli’s RRT* optimality result.

Technical stack: C++, CMake, Python, Matplotlib, Pillow, occupancy-grid maps, CSV evaluation outputs.

Keywords: sampling-based motion planning, high-DOF arm planning, planar robot arm, configuration space, collision checking, Bresenham rasterization, occupancy grid, RRT, RRT-Connect, RRT*, PRM, roadmap planning, Dijkstra search, goal bias, nearest-neighbor search, rewiring, path quality, wrap-around joint cost, C++, CMake, Python visualization.

Symbolic Planner

Wed, 06 May 2026 00:00:00 +0000

I built this symbolic planner to make classical AI planning concrete. Instead of commanding robot trajectories directly, the planner reasons over facts such as Clear(A), On(A, B), or domain-specific predicates for a robot-fire-extinguisher task. It parses compact domain files into symbols, grounded initial facts, goal facts, and action schemas with positive and negated preconditions and effects.

The planner grounds action schemas by enumerating ordered symbol tuples of the required arity, substitutes them into each action’s preconditions and effects, filters actions whose grounded preconditions are satisfied in the current state, and applies add/delete effects to generate successor states. Search uses an OPEN priority queue and CLOSED state set, with parent pointers for plan reconstruction once all goal facts are reached.

The repository includes several planning environments: standard Blocks World problems using MoveToTable and Move; a Blocks Triangle variant with Block, Triangle, NotTable, Clear, and On predicates; and a FireExtinguisher domain where a robot and quadrotor coordinate movement, landing, charging, water refill, and repeated pour actions to reach ExtThree(F).

The implementation exposes heuristic modes for Dijkstra-style search (h = 0), missing-goal-count guidance, delete-effect penalties, and a combined heuristic. This makes the project a small testbed for seeing how much a heuristic can help when the branching factor comes from grounded actions rather than grid neighbors.

Sources I leaned on: Fikes and Nilsson’s STRIPS paper for add/delete-list planning; Bonet and Geffner’s HSP work for heuristic planning; and Russell and Norvig’s AI planning chapters for the connection between symbolic search and robotics task planning.

Keywords: symbolic planning, STRIPS-style planning, grounded actions, action schemas, preconditions, add/delete effects, Blocks World, Blocks Triangle, FireExtinguisher domain, heuristic search, Dijkstra search, priority queue, state-space search, plan reconstruction, C++14, CMake.