AOI Tutorial
Learn step-by-step Greedy FOV placement with a small example (10 components)
📘 This is a supplementary document. For official contest rules, see Contest Rules ★
1 Input Data
Let's examine the example PCB data. 10 components are placed on a 160×120mm PCB.
PCB Component Layout
Fiducial (type=2)
Barcode (type=1)
Normal (type=0)
Side (side=1)
Side FOV (fov/2)
Step Region (step=1)
🛠
Python 3.11 required for kohyoung_solver
The provided
The provided
kohyoung_solver package only works in a Python 3.11 environment.
Other versions (3.10, 3.12, etc.) may cause import errors, so be sure to set up a virtual environment with Python 3.11.conda create -n iccas_contest python=3.11 or pyenv install 3.11| tl_x | tl_y | br_x | br_y | type | side | step | time | |
|---|---|---|---|---|---|---|---|---|
| 0 | 12 | 8 | 18 | 14 | 2 | 0 | 0 | 0 |
| 1 | 130 | 10 | 145 | 22 | 1 | 0 | 0 | 0 |
| 2 | 20 | 45 | 32 | 55 | 0 | 0 | 0 | 0.3 |
| 3 | 35 | 38 | 45 | 48 | 0 | 0 | 0 | 0.3 |
| 4 | 25 | 35 | 35 | 43 | 0 | 1 | 0 | 0.3 |
| 5 | 70 | 40 | 85 | 52 | 0 | 0 | 0 | 0.3 |
| 6 | 80 | 55 | 95 | 65 | 0 | 0 | 0 | 0.3 |
| 7 | 68 | 50 | 78 | 60 | 0 | 1 | 0 | 0.3 |
| 8 | 110 | 85 | 125 | 95 | 0 | 0 | 1 | 0.3 |
| 9 | 128 | 90 | 142 | 100 | 0 | 0 | 1 | 0.3 |
💡
type: 2=Fiducial, 1=Barcode, 0=Normal | side: If 1, Side camera capture is required (must fit within half-size FOV area) | step: If 1, the component is in a step region
| pcb_x | pcb_y | fov_x | fov_y |
|---|---|---|---|
| 160 | 120 | 50 | 50 |
💡PCB size 160×120mm, FOV size 50×50mm
| capture_time | recon_time | side_capture_time | max_core | v_x | v_y | a_x | a_y |
|---|---|---|---|---|---|---|---|
| 0.5 | 0.5 | 0.25 | 8 | 1000 | 1000 | 9800 | 9800 |
💡Capture 0.5s, Reconstruction 0.5s, Side additional 0.25s, Max 8 cores, Movement speed 1000mm/s, Acceleration 9800mm/s²
Note: v_x, v_y (200–1000) and a_x, a_y (4900–9800) vary per dataset. This example uses v=1000, a=9800.
Note: v_x, v_y (200–1000) and a_x, a_y (4900–9800) vary per dataset. This example uses v=1000, a=9800.
| tl_x | tl_y | br_x | br_y | |
|---|---|---|---|---|
| 0 | 100 | 75 | 160 | 120 |
💡Step region: bottom-right of PCB (100,75)~(160,120). Components within this region have step=1
2 Step-by-Step Greedy Solution
Follow along as we place FOVs one by one using the Greedy algorithm. Click the buttons below.
Initial State
0
Covered Components
10
Unassigned Components
0
Placed FOVs
Greedy Algorithm Pseudocode
Algorithm: Greedy FOV Placement
────────────────────────────────────
Phase 1: Fiducial-Only FOVs
1. FOR EACH comp WHERE type == 2:
2. Create FOV(center = comp.center, comps = [comp]) // 1 Fiducial per FOV
Phase 2: Origin-Distance Greedy Placement
3. remaining ← sort unassigned components by distance to (0,0)
4. FOR EACH seed IN remaining:
5. fov_center ← (seed.tl_x + fov_w/2, seed.tl_y + fov_h/2) // component at FOV top-left
6. fov_center ← clamp to PCB boundary
7. covered ← all same-step unassigned components fully inside FOV
8. Note: side=1 components checked against Side FOV (fov/2) area
9. Create FOV(fov_center, covered)
Phase 3: Big Component Tiling
10. FOR EACH comp WHERE size > FOV:
11. Place ceil(w/fov_w) × ceil(h/fov_h) grid of FOVs
Phase 4: Path Ordering
12. type descending groups (2 → 1 → 0) × nearest neighbor ordering
3 Coverage Error Demo
What happens when a component is not included in any FOV? See how errors are displayed in the Checker and Viewer.
✓ Correct Result (Cover: PASS)
Combined View — Normal
,x,y,comp_idx
0,15,11,[0]
1,138,16,[1]
2,30,40,"[2, 3, 4]"
3,74,55,"[5, 6, 7]"
4,126,93,"[8, 9]"
✗ Error Result (Cover: FAIL)
Combined View — Error
,x,y,comp_idx
0,15,11,[0]
1,138,16,[1]
2,30,40,"[2, 3, 4]"
3,95,46,"[5, 6]" ← #7 missing!
4,126,93,"[8, 9]"
⚠
Component #7 is not included in any FOV.
When the Checker's
• The component's
• The component is displayed in red (#d63031) in the Viewer
• The error FOV is shown with a red border (#cd4547) and red background (rgba(205,99,71,0.2))
• The Cover result is shown as FAIL
When the Checker's
cover_all_components() detects uncovered components:• The component's
error flag is set to 1• The component is displayed in red (#d63031) in the Viewer
• The error FOV is shown with a red border (#cd4547) and red background (rgba(205,99,71,0.2))
• The Cover result is shown as FAIL
💡
Other error cases:
• If components with different step values are mixed in the same FOV → Cover FAIL
• If a component assigned to an FOV is outside the FOV area → Cover FAIL
• If a side=1 component is outside the Side FOV (fov/2 = 25×25) area → Cover FAIL
• If the FOV order is not in descending type order → Order FAIL (e.g., Barcode → Fiducial order)
• If components with different step values are mixed in the same FOV → Cover FAIL
• If a component assigned to an FOV is outside the FOV area → Cover FAIL
• If a side=1 component is outside the Side FOV (fov/2 = 25×25) area → Cover FAIL
• If the FOV order is not in descending type order → Order FAIL (e.g., Barcode → Fiducial order)
4 Final Result
Review the final output_fov.csv from the Greedy solution and the pipeline inspection process.
output_fov.csv
| x (center) | y (center) | comp_idx | FOV Type | Side Component? | |
|---|---|---|---|---|---|
| 0 | 15 | 11 | [0] | 2 (Fid) | - |
| 1 | 138 | 16 | [1] | 1 (BC) | - |
| 2 | 30 | 40 | [2, 3, 4] | 0 | side=1 (#4) |
| 3 | 74 | 55 | [5, 6, 7] | 0 | side=1 (#7) |
| 4 | 126 | 93 | [8, 9] | 0 | - |
💡
FOV Type is not explicitly specified in the output. The Checker automatically determines it as the maximum type value among components in comp_idx.
Inspection order rule: FOV 0(type=2) ≥ FOV 1(type=1) ≥ FOV 2(type=0) ≥ FOV 3(type=0) ≥ FOV 4(type=0) → Order: PASS
Inspection order rule: FOV 0(type=2) ≥ FOV 1(type=1) ≥ FOV 2(type=0) ≥ FOV 3(type=0) ≥ FOV 4(type=0) → Order: PASS
Pipeline Inspection Process (Concept)
The AOI equipment uses a pipeline structure to perform capture, reconstruction, and inspection simultaneously. FOVs are processed in order, with reconstruction/inspection of the previous FOV overlapping with the capture of the next FOV.
💡
The exact CT is automatically calculated by the Checker, considering movement time (trapezoidal velocity profile based on v and a), Side capture time, inspection time distribution, etc.
Run
python 2_run.py --solver greedy to compute the CT. Then run python 3_view.py --solver greedy --open to generate and open the result Viewer (result.html).
Verification Summary
PASS
Cover
PASS
Order
5
FOVs
10
Components
✅
All 10 components are covered with 5 FOVs. Greedy is a simple but reasonable baseline solution.
For better CT, consider fine-tuning FOV positions, optimizing movement paths, and using component clustering algorithms.
5 Penalty Solver — Constraint Violation Behavior
When components are not included in any FOV or the inspection order is violated, the Checker automatically runs penalty_solver to recalculate the CT.
⚠ How the Penalty Solver Works
1. Constraint violation detected: If cover_all_components() or fov_inspection_order() returns FAIL, the penalty_solver is triggered.
2. Solver output discarded: The participant's output_fov.csv is completely ignored, and FOVs are re-placed from scratch using the greedy baseline solution below.
3. Greedy baseline solution: Fiducial-only FOVs → origin-distance sorted component placement at FOV top-left → absorb same-step neighbors → big component tiling → nearest neighbor path ordering.
Algorithm: Penalty Solver (Greedy Baseline)
────────────────────────────────────
1. Fiducial(type=2) → individual FOV each // 1 per FOV
2. remaining ← unassigned components, sorted by dist to (0,0)
3. FOR EACH seed IN remaining:
4. fov_center ← (seed.tl + fov_size/2) // component at FOV top-left
5. covered ← all same-step unassigned comps inside FOV
6. Big components → tiling grid FOVs
7. type descending (2→1→0) × nearest neighbor order
8. RETURN ordered FOVs → Checker recalculates CT
⚠ Penalty Effect
• Your optimization results are completely discarded and replaced with the greedy baseline solution.
• The greedy baseline is reasonable but far from optimal, so CT will be significantly higher than a well-tuned solver.
• Finding better FOV placements while satisfying all constraints is the core challenge of this contest.
• The greedy baseline is reasonable but far from optimal, so CT will be significantly higher than a well-tuned solver.
• Finding better FOV placements while satisfying all constraints is the core challenge of this contest.
💡
Behavior in code: In
2_run.py, if cover or order is False, c.penalty_solver() is automatically called.
c = Checker(path)
cover = c.cover_all_components()
order = c.fov_inspection_order()
if not cover or not order:
c.penalty_solver() # Discard solver output → replace with greedy baseline
ct = c.compute_ct() # Recalculate CT based on penalty FOVs
⚠
Always verify
Cover: PASS and Order: PASS!
When penalty_solver is applied, your optimization is discarded. Be sure to check the Cover/Order results in the 2_run.py output.