import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt import matplotlib.patches as patches from matplotlib.patches import FancyArrowPatch, Rectangle import numpy as np from scipy.interpolate import splprep, splev import math def pretty_plot_maze( maze_loader, W=4, H=4, save_path=None, model_solution=None, ground_truth_solution=None, mode="comparison", ): """ Display the maze using Matplotlib and optionally save to a file. Args: mode: Visualization mode - "comparison": Side-by-side optimal vs model (default) - "empty": Just maze structure - "optimal": Maze + optimal path only - "model": Maze + model path only """ plt.rcParams["font.size"] = 10 plt.rcParams["font.family"] = "sans-serif" plt.rcParams["figure.dpi"] = 100 # Configure subplot layout based on mode if mode == "comparison": fig, (ax2, ax3) = plt.subplots(1, 2, figsize=(15, 8.5)) axes = [ax2, ax3] elif mode == "empty": # Special layout for empty maze with legend space fig, ax = plt.subplots(1, 1, figsize=(14, 8.5)) axes = [ax] else: fig, ax = plt.subplots(1, 1, figsize=(10, 8.5)) axes = [ax] # Draw the base maze on all plots for ax in axes: covered_cells = set() for cell in maze_loader.connected_cells.keys(): for neighbor in maze_loader.connected_cells[cell]: if (cell, neighbor) in covered_cells or ( neighbor, cell, ) in covered_cells: continue covered_cells.add((cell, neighbor)) add_path_segment( (cell[0] * W, cell[1] * H), (neighbor[0] * W, neighbor[1] * H), ax, door=(cell, neighbor) in maze_loader.doors.keys(), status=None if (cell, neighbor) not in maze_loader.doors.keys() else maze_loader.doors[(cell, neighbor)][0].split(" ")[0], lock_status=( None if (cell, neighbor) not in maze_loader.doors.keys() or maze_loader.doors[(cell, neighbor)][0] == "open" else maze_loader.doors[(cell, neighbor)][0].split(" ")[-1] ), ) # Add keys for key_id, key_location in maze_loader.keys_locations.items(): door_locations = { maze_loader.doors[(rA, rB)][1]: ( (rA[0] + rB[0]) * W / 2, (rA[1] + rB[1]) * H / 2, ) for (rA, rB) in maze_loader.doors.keys() } add_key( key_location[0] * W, key_location[1] * H, ax, door_location=door_locations.get(key_id, (0, 0)), ) # Add start and end rooms start = ( maze_loader.data["start_room"][0] * W, maze_loader.data["start_room"][1] * H, ) end = (maze_loader.data["end_room"][0] * W, maze_loader.data["end_room"][1] * H) enhanced_mode = True # Use enhanced mode for all visualizations add_start_and_end_room(start, end, ax, enhanced_mode=enhanced_mode) # Create a mapping from room names to coordinates room_name_to_coord = {} for cell in maze_loader.connected_cells.keys(): room_name_to_coord[maze_loader.room_name[cell]] = cell # Define colors for different action types move_color_gt = "gold" # Yellow for regular movement (ground truth) move_color_model = "mediumpurple" # Purple for regular movement (model) start_color = "#FF7F0E" # Orange for start action pickup_key_color = "#1E88E5" # Blue for key pickup use_key_color = "#43A047" # Green for using a key unlock_color = "#9C27B0" # Purple for unlocking door rescue_color = "#D81B60" # Pink for rescue # Draw a path with numbered steps def process_solution(solution, ax, base_color="gold"): if not solution: return all_actions = [] current_room = None last_position = None # Parse solution into actions for i, action in enumerate(solution): if len(action) < 2: continue action_type, param = action[0], action[1] step_number = i + 1 # Start numbering from 1 # Track the current room for each action if action_type == "start": current_room = param # Mark start position specially all_actions.append((current_room, step_number, action_type, None)) elif action_type == "move_to" and param in room_name_to_coord: prev_room = current_room current_room = param # Store movement with both source and destination all_actions.append((current_room, step_number, action_type, prev_room)) elif action_type in [ "pick_up_key", "use_key", "unlock_and_open_door_to", "rescue", ]: if current_room: # Store special action with current room all_actions.append((current_room, step_number, action_type, None)) used_positions = set() # First draw all movement paths for room, step_number, action_type, prev_room in all_actions: if ( action_type == "move_to" and prev_room and room in room_name_to_coord and prev_room in room_name_to_coord ): start_cell = room_name_to_coord[prev_room] end_cell = room_name_to_coord[room] # Get coordinates x1, y1 = start_cell[0] * W, start_cell[1] * H x2, y2 = end_cell[0] * W, end_cell[1] * H # Draw the path for movement ax.plot( [x1, x2], [y1, y2], "-", color=base_color, linewidth=2, zorder=10, alpha=0.5 ) # Add arrow near destination arrow_pos = 0.9 arrow_x = x1 + (x2 - x1) * arrow_pos arrow_y = y1 + (y2 - y1) * arrow_pos dx = x2 - x1 dy = y2 - y1 length = math.sqrt(dx * dx + dy * dy) if length > 0: dx /= length dy /= length arrow = FancyArrowPatch( (arrow_x - dx * 0.3, arrow_y - dy * 0.3), (arrow_x + dx * 0.3, arrow_y + dy * 0.3), arrowstyle="-|>", mutation_scale=12, color=base_color, linewidth=2, zorder=10, alpha=0.4, ) ax.add_patch(arrow) # Then add step markers for each action for action_idx, (room, step_number, action_type, prev_room) in enumerate( all_actions ): if room in room_name_to_coord: room_cell = room_name_to_coord[room] # Determine position and color based on action type if ( action_type == "move_to" and prev_room and prev_room in room_name_to_coord ): # For movement, place marker along the path start_cell = room_name_to_coord[prev_room] end_cell = room_name_to_coord[room] x1, y1 = start_cell[0] * W, start_cell[1] * H x2, y2 = end_cell[0] * W, end_cell[1] * H pos_x = x1 + (x2 - x1) * 0.6 pos_y = y1 + (y2 - y1) * 0.6 # Add perpendicular offset to avoid placing directly on line dx = x2 - x1 dy = y2 - y1 length = math.sqrt(dx * dx + dy * dy) if length > 0: perp_x = -dy / length * 0.7 perp_y = dx / length * 0.7 # Alternate sides for consecutive steps if step_number % 2 == 0: perp_x = -perp_x perp_y = -perp_y pos_x += perp_x pos_y += perp_y color = base_color else: # For non-movement actions, place at the room with offset pos_x = room_cell[0] * W pos_y = room_cell[1] * H # Special case for door-related actions - place them near but not at the door if action_type in ["use_key", "unlock_and_open_door_to"]: door_cell1 = room_cell door_cell2 = None if action_type == "unlock_and_open_door_to": # Find the destination room for the door dest_room = param if dest_room in room_name_to_coord: door_cell2 = room_name_to_coord[dest_room] elif prev_room in room_name_to_coord: # For use_key, consider the previous room as second door cell door_cell2 = room_name_to_coord[prev_room] if door_cell2: # Calculate door position (midpoint between rooms) door_x = (door_cell1[0] + door_cell2[0]) * W / 2 door_y = (door_cell1[1] + door_cell2[1]) * H / 2 # Calculate vector from door to room (normalized) dx = pos_x - door_x dy = pos_y - door_y dist = math.sqrt(dx * dx + dy * dy) if dist > 0: # Normalize vector dx /= dist dy /= dist # Position marker at 2/3 distance from door to room pos_x = ( door_x + dx * 1.5 ) # Place partway from door toward room pos_y = door_y + dy * 1.5 # Add small perpendicular offset to avoid direct overlap with path perp_x = -dy * 0.5 perp_y = dx * 0.5 # Alternate sides for consecutive markers if step_number % 2 == 0: perp_x = -perp_x perp_y = -perp_y pos_x += perp_x pos_y += perp_y else: # Fallback if rooms are at same location offset_x = 0.7 * (1 if step_number % 2 == 0 else -1) offset_y = 0.7 * (1 if step_number % 4 >= 2 else -1) pos_x += offset_x pos_y += offset_y else: # If second door cell not found, use standard offset from room offset_x = 0.7 * (1 if step_number % 2 == 0 else -1) offset_y = 0.7 * (1 if step_number % 4 >= 2 else -1) pos_x += offset_x pos_y += offset_y else: # Regular offset for other action types if action_type == "start": # Start marker at top-left of room offset_x, offset_y = -0.7, -0.7 else: # Other actions - different offsets for different action types offset_multiplers = { "pick_up_key": (0.7, 0.7), "rescue": (-0.7, -0.7), } multiplier = offset_multiplers.get(action_type, (0, 0)) offset_x, offset_y = multiplier # Further vary offsets for multiple actions in same room same_room_actions = sum( 1 for r, _, a_type, _ in all_actions[:action_idx] if r == room and a_type != "move_to" ) if same_room_actions > 0: offset_x *= 1 + 0.3 * same_room_actions offset_y *= 1 + 0.3 * same_room_actions pos_x += offset_x pos_y += offset_y # Determine color for special actions - now with distinct colors for all types if action_type == "start": color = start_color elif action_type == "pick_up_key": color = pickup_key_color elif action_type == "use_key": color = use_key_color elif action_type == "unlock_and_open_door_to": color = unlock_color elif action_type == "rescue": color = rescue_color else: color = base_color # Avoid overlap with existing markers while any( (abs(pos_x - px) < 0.8 and abs(pos_y - py) < 0.8) for px, py in used_positions ): # Slightly adjust position pos_x += 0.3 * (1 if step_number % 2 == 0 else -1) pos_y += 0.3 * (1 if step_number % 4 >= 2 else -1) # Add marker # ax.text( # pos_x, # pos_y, # f"{step_number}", # color="white", # fontsize=3, # ha="center", # va="center", # bbox=dict( # boxstyle="circle,pad=0.3", # fc=color, # ec="black", # alpha=0.9, # linewidth=1, # ), # zorder=20, # ) # Remember this position used_positions.add((pos_x, pos_y)) title_props = dict(fontsize=12, fontweight="bold") # Set titles and process solutions based on mode if mode == "comparison": axes[0].set_title("Optimal Path", **title_props) axes[1].set_title("Model Path", **title_props) if ground_truth_solution: process_solution(ground_truth_solution, axes[0], base_color=move_color_gt) if model_solution: process_solution(model_solution, axes[1], base_color=move_color_model) elif mode == "empty": axes[0].set_title("Maze Layout", **title_props) # No paths to process for empty maze elif mode == "optimal": axes[0].set_title("Optimal Path", **title_props) if ground_truth_solution: process_solution(ground_truth_solution, axes[0], base_color=move_color_gt) elif mode == "model": axes[0].set_title("Model Path", **title_props) if model_solution: process_solution(model_solution, axes[0], base_color=move_color_model) for ax in axes: ax.set_xticks([]) ax.set_yticks([]) ax.axis("off") current_xlim = ax.get_xlim() current_ylim = ax.get_ylim() ax.set_xlim(current_xlim[0] - 1, current_xlim[1] + 1) ax.set_ylim(current_ylim[0] - 3, current_ylim[1] + 1) # Add legend for empty maze mode (enhanced for LLM interpretability) if mode == "empty": # Clean, simple title axes[0].set_title("Maze Navigation: Find path from START (green) to GOAL (red)", fontsize=12, fontweight='bold', pad=20) legend_elements = [ plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='limegreen', markersize=12, markeredgecolor='darkgreen', markeredgewidth=2, label='START'), plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='red', markersize=12, markeredgecolor='darkred', markeredgewidth=2, label='GOAL'), plt.Rectangle((0, 0), 1, 1, facecolor='red', alpha=0.8, label='locked door'), plt.Line2D([0], [0], marker='o', color='w', markerfacecolor='yellow', markersize=10, markeredgecolor='orange', markeredgewidth=2, label='key'), ] axes[0].legend(handles=legend_elements, loc='center left', bbox_to_anchor=(0.95, 0.5), frameon=True, fancybox=True, shadow=False, fontsize=9) # Only add path legend for non-empty modes if mode != "empty": legend_items = [ ("Start", start_color), ("Move", move_color_gt if ground_truth_solution else move_color_model), ("Key pickup", pickup_key_color), ("Use key", use_key_color), ("Unlock door", unlock_color), ("Rescue", rescue_color), ] legend_patches = [ plt.Rectangle((0, 0), 1, 1, fc=color, ec="black", alpha=0.9) for _, color in legend_items ] # fig.legend( # legend_patches, # [text for text, _ in legend_items], # loc="lower center", # bbox_to_anchor=(0.5, 0.02), # ncol=len(legend_items), # frameon=True, # fancybox=True, # shadow=True, # fontsize=10, # ) # Handle layout based on mode if mode == "empty": plt.tight_layout() # Adjust layout to accommodate legend with less gap plt.subplots_adjust(right=0.90) else: plt.tight_layout() if save_path is not None: try: plt.savefig(save_path, dpi=400, bbox_inches="tight", format="png") except Exception as e: print(f"Error saving plot: {e}") plt.close(fig) def draw_path_with_arrow( point1, point2, ax, color="red", linewidth=1.5, alpha=0.8, arrow_size=5, arrow_color=None, ): """Draw a path between two points with a smaller, more subtle directional arrow.""" if arrow_color is None: arrow_color = color # Calculate the midpoint for the arrow position - shift slightly toward destination # to avoid overlap with nodes midpoint_x = point1[0] + (point2[0] - point1[0]) * 0.6 midpoint_y = point1[1] + (point2[1] - point1[1]) * 0.6 # Draw the line line = ax.plot( [point1[0], point2[0]], [point1[1], point2[1]], color=color, linewidth=linewidth, alpha=alpha, )[0] # Calculate the direction vector dx = point2[0] - point1[0] dy = point2[1] - point1[1] # Normalize the direction vector length = np.sqrt(dx**2 + dy**2) if length > 0: dx /= length dy /= length # Add a small arrow ax.arrow( midpoint_x, midpoint_y, dx * arrow_size / 3, dy * arrow_size / 3, head_width=arrow_size * 0.8, head_length=arrow_size * 0.8, fc=arrow_color, ec=arrow_color, alpha=alpha, length_includes_head=True, ) return line def add_arc_between_points(point1, point2, ax, alpha=0.2): # Use spline of degree 2 (since m = 3) tck, _ = splprep( [ [point1[0], (point1[0] + point2[0]) / 2.0 - alpha, point2[0]], [point1[1], (point1[1] + point2[1]) / 2.0 + alpha, point2[1]], ], s=0, k=2, ) t = np.linspace(0, 1, 100) x_spline, y_spline = splev(t, tck) # Plot ax.plot(x_spline, y_spline, label="Spline curve", linestyle="--") def add_door( x_center, y_center, ax, status="closed", door_color="black", door_location=(0, 0) ): # make a hallow rectangle x1 = x_center - 0.2 x2 = x_center + 0.2 y1 = y_center - 0.4 y2 = y_center + 0.4 if status == "open": # make the fill color transparent rect = patches.Polygon( [[x1, y1], [x2, y1], [x2, y2], [x1, y2]], closed=True, edgecolor="black", facecolor="none", ) else: rect = patches.Polygon( [[x1, y1], [x2, y1], [x2, y2], [x1, y2]], closed=True, facecolor=door_color ) ax.add_patch(rect) def h_link( x1, x2, y, ax, door=False, status="closed", lock_status="unlocked", line_color="#76b5c5", ): # make sure it is brought to the front of all other patches z_order = 100 ax.add_patch(patches.Circle((x1, y), 0.3, facecolor="black", zorder=100000)) ax.add_patch(patches.Circle((x2, y), 0.3, facecolor="black", zorder=100000)) x1 = x1 - 0.05 x2 = x2 + 0.05 y = y - 0.05 rect = patches.Polygon( [[x1, y], [x2, y], [x2, y + 0.1], [x1, y + 0.1]], closed=True, facecolor=line_color, ) ax.add_patch(rect) x_center = (x1 + x2) / 2.0 + 0.05 if door: if status == "open": add_door(x_center, y + 0.05, ax, status="open") else: if lock_status == "locked": door_color = "red" else: door_color = "green" add_door(x_center, y + 0.05, ax, status="closed", door_color=door_color) # add circles at both ends of the line def v_link( x, y1, y2, ax, door=False, status="closed", lock_status="locked", line_color="#76b5c5", ): # make sure it is brought to the front of all other patches z_order = 100 ax.add_patch(patches.Circle((x, y1), 0.3, facecolor="black", zorder=100000)) ax.add_patch(patches.Circle((x, y2), 0.3, facecolor="black", zorder=100000)) y1 = y1 - 0.05 y2 = y2 + 0.05 x = x - 0.05 triangle = patches.Polygon( [[x, y1], [x, y2], [x + 0.1, y2], [x + 0.1, y1]], closed=True, facecolor=line_color, ) ax.add_patch(triangle) y_center = (y1 + y2) / 2.0 if door: if status == "open": add_door(x + 0.05, y_center, ax, status="open") else: if lock_status == "locked": door_color = "red" else: door_color = "green" add_door(x + 0.05, y_center, ax, status="closed", door_color=door_color) # add circles at both ends of the line def add_start_and_end_room(start_room, end_room, ax, size=0.6, enhanced_mode=False): if enhanced_mode: # Enhanced mode for LLM interpretability - clean colored circles only x, y = start_room # Start room: Large green circle (no text) ax.add_patch(patches.Circle((x, y), size*1.5, facecolor="limegreen", edgecolor="darkgreen", linewidth=3, zorder=100000)) x, y = end_room # End room: Large red circle (no text) ax.add_patch(patches.Circle((x, y), size*1.5, facecolor="red", edgecolor="darkred", linewidth=3, zorder=100000)) else: # Original mode: black triangles x, y = start_room ax.add_patch( patches.Polygon( [[x - size, y - size], [x + size, y - size], [x, y + size]], closed=True, facecolor="black", edgecolor="black", zorder=100000, ) ) x, y = end_room ax.add_patch( patches.Polygon( [[x - size, y + size], [x + size, y + size], [x, y - size]], closed=True, facecolor="black", edgecolor="black", zorder=100000, ) ) def add_path_segment( point1, point2, ax, door=False, status="closed", lock_status="locked" ): if point1[0] == point2[0]: v_link(point1[0], point1[1], point2[1], ax, door, status, lock_status) else: h_link(point1[0], point2[0], point1[1], ax, door, status, lock_status) def add_key(x, y, ax, door_location=(0, 0)): # Enhanced key visualization - yellow circle ax.add_patch( patches.Circle((x, y), 0.4, facecolor="yellow", edgecolor="orange", linewidth=2, zorder=100000) ) add_arc_between_points((x, y), door_location, ax) if __name__ == "__main__": # Create a plot fig, ax = plt.subplots() add_path_segment((1, 1), (1, 4), ax, door=True, status="open") add_key(1, 4, ax, door_location=(2.5, 4)) add_path_segment( (1, 4), (4, 4), ax, door=True, status="closed", lock_status="locked" ) add_path_segment((4, 4), (4, 7), ax, door=False) add_path_segment( (4, 7), (1, 7), ax, door=True, status="closed", lock_status="unlocked" ) ax.set_aspect("equal") ax.axis("off") ax.set_xlim(0, 10) ax.set_ylim(0, 10) plt.show() def pretty_plot_maze_vs_noise( maze_loader, W=4, H=4, save_path=None, ground_truth_solution=None, problem_description=None ): """ Display the maze using Matplotlib and optionally save to a file. Shows three plots: Maze Layout, Ground Truth Path, and Model Path. """ plt.rcParams["font.size"] = 10 plt.rcParams["font.family"] = "sans-serif" plt.rcParams["figure.dpi"] = 100 fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 8.5)) # Draw the base maze on all three plots for ax in [ax1, ax2, ax3]: covered_cells = set() for cell in maze_loader.connected_cells.keys(): for neighbor in maze_loader.connected_cells[cell]: if (cell, neighbor) in covered_cells or ( neighbor, cell, ) in covered_cells: continue covered_cells.add((cell, neighbor)) add_path_segment( (cell[0] * W, cell[1] * H), (neighbor[0] * W, neighbor[1] * H), ax, door=(cell, neighbor) in maze_loader.doors.keys(), status=None if (cell, neighbor) not in maze_loader.doors.keys() else maze_loader.doors[(cell, neighbor)][0].split(" ")[0], lock_status=( None if (cell, neighbor) not in maze_loader.doors.keys() or maze_loader.doors[(cell, neighbor)][0] == "open" else maze_loader.doors[(cell, neighbor)][0].split(" ")[-1] ), ) # Add keys for key_id, key_location in maze_loader.keys_locations.items(): door_locations = { maze_loader.doors[(rA, rB)][1]: ( (rA[0] + rB[0]) * W / 2, (rA[1] + rB[1]) * H / 2, ) for (rA, rB) in maze_loader.doors.keys() } add_key( key_location[0] * W, key_location[1] * H, ax, door_location=door_locations.get(key_id, (0, 0)), ) # Add start and end rooms start = ( maze_loader.data["start_room"][0] * W, maze_loader.data["start_room"][1] * H, ) end = (maze_loader.data["end_room"][0] * W, maze_loader.data["end_room"][1] * H) add_start_and_end_room(start, end, ax)