code/abstract_reasoning/maze/pixel_based_evaluation/README.md

Pixel-Based Maze Evaluation (Pure Vision)

Pure computer vision-based evaluation for maze-solving generation tasks. Compares generated maze solutions against ground-truth solution images using pixel-level analysis — no VLMs/LLMs involved.

Script	Input	What it evaluates
image_gen_evaluation.py	PNG images	Whether a generated maze-solution image is correct (blue path vs solution)
video_gen_evaluation.py	MP4 videos	Whether a generated maze-solution video is correct (green marker trajectory vs solution)

The video script works by:

1. Extracting frames from the generated video (default: 192 frames @ 24fps)
2. Tracking the green marker position across all frames to form the generated path
3. Comparing the accumulated path with the reference solution image

Installation

pip install opencv-python numpy pillow scipy scikit-image

Usage

Image Evaluation

# Evaluate a single image
python image_gen_evaluation.py --single "/path/to/generated_image.png"

# Evaluate an entire directory (default model: nano_banana_pro)
python image_gen_evaluation.py --model_name nano_banana_pro

# Custom directories
python image_gen_evaluation.py \
  --input_dir "/path/to/generated/images" \
  --solution_dir "/path/to/solution/images" \
  --output_dir "/path/to/output/results" \
  --model_name my_model

Video Evaluation

# Evaluate a single video
python video_gen_evaluation.py --single "/path/to/generated_video.mp4"

# Evaluate an entire directory (default model: veo3)
python video_gen_evaluation.py --model_name veo3

# Custom directories
python video_gen_evaluation.py \
  --input_dir "/path/to/generated/videos" \
  --solution_dir "/path/to/solution/images" \
  --output_dir "/path/to/output/results" \
  --model_name my_model

# Specify number of frames to extract
python video_gen_evaluation.py --num_frames 192

# Loop through round directories
for dir in /path/to/video_results/veo3/dfs/easy_round*; do
    python video_gen_evaluation.py --input_dir "$dir" --model_name veo3
done

Batch Evaluation (All Algorithms / Difficulties / Rounds)

To evaluate a model across all maze algorithms (dfs, wilson), difficulty levels (easy, medium, hard), and generation rounds, run from this directory:

BASE_DIR=/path/to/maze_solving_task   # contains image_results/, video_results/, data/solution/

# Images (e.g. gpt_image_1.5; also: nano_banana, nano_banana_pro, qwen_image)
for round in 1 2 3; do
    for algo in dfs wilson; do
        for difficulty in easy medium hard; do
            python image_gen_evaluation.py \
                --input_dir ${BASE_DIR}/image_results/gpt_image_1.5/${algo}/${difficulty}_round${round} \
                --solution_dir ${BASE_DIR}/data/solution \
                --model_name gpt_image_1.5
        done
    done
done

# Videos (e.g. wan2.2; also: veo3, sora2)
for round in 1 2 3 4 5; do
    for algo in dfs wilson; do
        for difficulty in easy medium hard; do
            python video_gen_evaluation.py \
                --input_dir ${BASE_DIR}/video_results/wan2.2/${algo}/${difficulty}_round${round} \
                --solution_dir ${BASE_DIR}/data/solution \
                --model_name wan2.2
        done
    done
done

Adjust the model name and round range to match what was generated.

Default Paths

When flags are omitted, the scripts fall back to these defaults:

Flag	Default	Relative to
--input_dir	./image_results/<model_name> or ./video_results/<model_name>	current working directory
--solution_dir	./data/solution	current working directory
--output_dir	../evaluation_results/pixel_based_evaluation/<image|video>_evaluation_results/<model_name>	current working directory

Unless you run the scripts from a directory that contains image_results//video_results/ and data/solution/, pass --input_dir and --solution_dir explicitly (as in the batch examples above).

Note: for sora2 models (--model_name containing sora), the video script automatically extracts 360 frames (12s @ 30fps) instead of the default 192, unless --num_frames is set to a non-default value.

Video Path Extraction Methods

1. Green Marker Tracking (Default)

--extraction_method green_marker_tracking

• Tracks the position of the green marker in each frame
• Accumulates all green marker positions to form the generated path
• Works well when the video shows a moving green marker tracing the solution

2. Frame Differencing

--extraction_method frame_differencing

• Uses frame-to-frame differences to detect marker movement
• Detects new green pixels that appear between consecutive frames
• Alternative method for videos with different marker behaviors

Evaluation Metrics

1. Wall Crossing Detection

Purpose: Detect if the generated path crosses black walls (invalid move)

Method:

• Image: Extract blue path and black wall pixels from the generated image; apply 3px erosion tolerance (handles anti-aliasing); flag as crossing only if ratio > 1%
• Video: Accumulate the path from all frames; check against the solution's wall structure (not video frame walls); apply significant erosion (1/4 cell size) to only detect interior crossing; use raw path (no dilation) to avoid false positives at edges; flag only if ratio > 5%

Output:

• wall_crossing_detected: Boolean
• wall_crossing_pixels: Number of crossing pixels
• wall_crossing_ratio: Fraction of path crossing walls

2. Layout Matching

Purpose: Verify maze structure and marker positions match the solution

Method:

• Compare black wall regions using IoU
• Compare green square (start) and red square (end) centroid positions
• Image: single image check, position tolerance 20 pixels
• Video: layout is checked for EACH frame (parallelized with ThreadPoolExecutor) and the minimum score across all frames is reported (worst-case detection); position tolerance 50 pixels (video resolution differences)

Output:

• layout_match_score: Combined score, 0-1 (video: minimum across frames)
• maze_structure_iou: Wall structure IoU (video: at worst frame)
• green_position_match / red_position_match: Boolean
• green_centroid_distance / red_centroid_distance: Distance in pixels

3. Path Matching (Dilate + IoU)

Purpose: Compare the generated path with solution blue cells

Challenge: The generated path is thin (a blue line in images, a marker trajectory in videos) while solutions have filled blue cells

Method:

• Image: dilate the thin generated blue line to match cell width
• Video: dilate the accumulated green marker path to match cell width
• Compute IoU with solution blue regions, plus precision and recall

Output:

• path_match_iou: Intersection over Union
• path_precision: Fraction of generated path that's correct
• path_recall: Fraction of solution path that's covered (pixel-level)
• target_achievement: Fraction of solution cells touched by generated path (cell-level, 0-1)
  • More lenient than recall: counts a cell as "achieved" if generated path touches it at all
  • Better reflects route correctness when generated path is thinner than solution cells

4. Reflection/Exploration Detection

Purpose: Detect if the model shows reasoning behavior (backtracking, exploration)

Method:

• Skeletonize the generated path and trace it
• Detect loops (cells visited multiple times)
• Compare path length vs solution path length
• Flag reflection if loops exist OR path is >1.3x longer

Output:

• has_reflection: Boolean
• loop_count: Number of detected loops
• path_length_ratio: Generated length / Solution length
• exploration_score: Combined exploration metric (0-1)

5. Gated Metrics (Video Only, Binary Pass/Fail)

Purpose: Provide strict pass/fail criteria for evaluation

Criteria:

Metric	Condition
layout_match_score_gated	1 if maze_structure_iou > 0.8, else 0
target_achievement_gated	1 if target_achievement > 0.95, else 0
overall_score_gated	1 if ALL three conditions are met, else 0

Overall Score Gated Requirements (all must be true):

1. layout_match_score_gated == 1 (maze structure IoU > 0.8)
2. wall_crossing_detected == False (no wall crossing)
3. target_achievement_gated == 1 (target achievement > 0.95)

Video-Specific Metrics

• total_frames: Total number of frames extracted from video
• frames_with_marker: Number of frames where green marker was detected
• path_extraction_method: Method used for path extraction

Overall Score Calculation

overall_score = layout_score * 0.2 + path_iou * 0.5 - wall_penalty

where:
  wall_penalty = 0.3 if wall_crossing_detected else 0.0

Output Files

By default, results are written to ../evaluation_results/pixel_based_evaluation/ (relative to this directory). Override with --output_dir.

Image Evaluation Results

../evaluation_results/pixel_based_evaluation/image_evaluation_results/<model_name>/
├── evaluation_results_<timestamp>.json    # Final results
├── evaluation_results_latest.json         # Latest results (overwritten)
├── evaluation_results_incremental.json    # Progress during evaluation
└── visualizations/                        # Visualization images
    └── <image_name>_evaluation.png

Video Evaluation Results

../evaluation_results/pixel_based_evaluation/video_evaluation_results/<model_name>/
├── evaluation_results_<round>_<timestamp>.json    # Final results (with round suffix)
├── evaluation_results_<round>_latest.json         # Latest results (overwritten)
├── evaluation_results_<round>_incremental.json    # Progress during evaluation
├── <video_name>_<round>_result.json               # Individual video result
└── visualizations/                                # Visualization images
    └── <video_name>_<round>_evaluation.png

Round suffix handling: when evaluating directories with round information (e.g. easy_round1), the video script automatically extracts the round suffix from the input directory path and appends it to all output filenames (e.g. _round1), so results from different rounds can be distinguished.

Visualization Layout

Each visualization is a 2x2 grid (top-left is the generated image, or the path accumulated from all video frames):

┌─────────────────┬─────────────────┐
│  Generated /    │  Solution       │
│  Video Path     │  (reference)    │
├─────────────────┼─────────────────┤
│  Wall Crossing  │  Path Compare   │
│  Overlay        │  Overlay        │
└─────────────────┴─────────────────┘

Color Legend (Path Compare):

• Green: Solution path only (missed by generated)
• Red: Generated path only (extra exploration)
• Yellow: Overlap (correct path)

Color Legend (Wall Crossing):

• Yellow: Actual wall crossing (counted)
• Image: Orange = edge touch (tolerated, not counted)
• Video: Light blue = valid path (not crossing walls)

File Naming Convention

	Pattern	Example
Generated image	{algo}_{difficulty}_{size}_n{idx}_{variant}_targeted_solution.png	dfs_easy_3x3_n000_var1_fixed_both_targeted_solution.png
Generated video	{algo}_{difficulty}_{size}_n{idx}_{variant}.mp4	dfs_easy_3x3_n000_var1_fixed_both.mp4
Solution image	{algo}_{difficulty}_{size}_n{idx}_{variant}_solution.png	dfs_easy_3x3_n000_var1_fixed_both_solution.png

Example Output

Video evaluation result (image results contain the same fields minus the video-specific and gated ones):

{
  "filename": "dfs_easy_3x3_n000_var1_fixed_both.mp4",
  "solution_file": "dfs_easy_3x3_n000_var1_fixed_both_solution.png",
  "wall_crossing_detected": false,
  "wall_crossing_pixels": 0,
  "wall_crossing_ratio": 0.0,
  "layout_match_score": 0.988,
  "maze_structure_iou": 0.85,
  "green_position_match": true,
  "red_position_match": true,
  "path_match_iou": 0.369,
  "path_precision": 0.554,
  "path_recall": 0.525,
  "target_achievement": 0.98,
  "has_reflection": true,
  "loop_count": 20,
  "path_length_ratio": 1.95,
  "exploration_score": 1.0,
  "total_frames": 192,
  "frames_with_marker": 180,
  "path_extraction_method": "green_marker_tracking",
  "overall_score": 0.382,
  "layout_match_score_gated": 1,
  "target_achievement_gated": 1,
  "overall_score_gated": 1
}

Gating example breakdown:

• maze_structure_iou = 0.85 → layout_match_score_gated = 1 (0.85 > 0.8)
• wall_crossing_detected = false → passes wall crossing check
• target_achievement = 0.98 → target_achievement_gated = 1 (0.98 > 0.95)
• All three conditions met → overall_score_gated = 1

Summary Statistics

After evaluating a directory, each script outputs aggregated statistics (gated/video-specific blocks appear for video evaluation only):

{
  "summary": {
    "wall_crossing": {
      "count": 5,
      "rate": 0.05
    },
    "path_matching": {
      "mean_iou": 0.45,
      "std_iou": 0.15,
      "mean_precision": 0.62,
      "mean_recall": 0.71,
      "mean_target_achievement": 0.92
    },
    "layout_matching": {
      "mean_score": 0.95,
      "green_match_rate": 0.98,
      "red_match_rate": 0.97
    },
    "reflection": {
      "count": 42,
      "rate": 0.42
    },
    "overall": {
      "mean_score": 0.51,
      "std_score": 0.18,
      "min_score": 0.10,
      "max_score": 0.85
    },
    "gated_metrics": {
      "layout_match_score_gated_count": 80,
      "layout_match_score_gated_rate": 0.80,
      "target_achievement_gated_count": 75,
      "target_achievement_gated_rate": 0.75,
      "overall_score_gated_count": 70,
      "overall_score_gated_rate": 0.70
    },
    "video_specific": {
      "avg_frames_with_marker": 175.5
    }
  }
}

Tuning Parameters

Image evaluation (image_gen_evaluation.py):

Parameter	Default	Description
tolerance_pixels	3	Wall erosion for edge tolerance
min_crossing_ratio	0.01	Min ratio to flag wall crossing
position_tolerance	20.0	Max centroid distance for position match
dilation_size	auto	Size to dilate thin lines (auto-detected)

Video evaluation (video_gen_evaluation.py):

Parameter	Default	Description
num_frames	192	Number of frames to extract from each video
min_crossing_ratio	0.05	Min ratio to flag wall crossing (5%)
position_tolerance	50.0	Max centroid distance for position match
wall_erosion	cell_size/4	Erosion applied to walls before crossing check
dilation_size	auto	Size to dilate paths (auto-detected from cell size)
BLACK_THRESHOLD	30	Grayscale threshold for wall detection
WHITE_THRESHOLD	200	Grayscale threshold for walkable path detection

Image vs Video Evaluation Differences

Aspect	Image Evaluation	Video Evaluation
Input	PNG image files	MP4 video files
Path Source	Blue path in generated image	Accumulated green marker positions
Frame Processing	Single image	192 frames per video
Layout Check	Single image check	Minimum score across ALL frames
Wall Reference	Solution's walls only	Solution's walls only
Position Tolerance	20 pixels	50 pixels
Parallel Processing	N/A	ThreadPoolExecutor for frames
Gated Metrics	N/A	Binary pass/fail (see above)

Comparison with VLM-based Evaluation

Aspect	These Scripts (Vision)	VLM-based (Gemini)
Speed	Fast (~0.5s/image, ~5-10s/video)	Slow (~5s/image, ~30s/video)
Cost	Free	API costs
Consistency	Deterministic	May vary
Interpretability	Pixel-level metrics	Natural language
Edge cases	May miss semantic issues	Better reasoning

Logging

Evaluation logs are saved to:

./evaluation_logs/
├── maze_vis_evaluation_<timestamp>.log          # image evaluation
└── maze_video_vis_evaluation_<timestamp>.log    # video evaluation