mirror of
https://github.com/kuhyx/praca_magisterska.git
synced 2026-07-04 12:03:01 +02:00
1402 lines
57 KiB
Python
1402 lines
57 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
Generate ALL diagrams for PYTANIE 24: Detekcja obiektów.
|
||
Monochrome, A4-printable PNGs (300 DPI).
|
||
"""
|
||
|
||
import matplotlib
|
||
matplotlib.use('Agg')
|
||
import matplotlib.pyplot as plt
|
||
import matplotlib.patches as mpatches
|
||
from matplotlib.patches import FancyBboxPatch, FancyArrowPatch
|
||
import numpy as np
|
||
import os
|
||
|
||
DPI = 300
|
||
BG = 'white'
|
||
LN = 'black'
|
||
FS = 8
|
||
FS_TITLE = 11
|
||
FS_SMALL = 6.5
|
||
FS_LABEL = 9
|
||
OUTPUT_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'img')
|
||
os.makedirs(OUTPUT_DIR, exist_ok=True)
|
||
|
||
GRAY1 = '#E8E8E8'
|
||
GRAY2 = '#D0D0D0'
|
||
GRAY3 = '#B8B8B8'
|
||
GRAY4 = '#F5F5F5'
|
||
GRAY5 = '#C0C0C0'
|
||
|
||
|
||
def draw_box(ax, x, y, w, h, text, fill='white', lw=1.2, fontsize=FS,
|
||
fontweight='normal', ha='center', va='center', rounded=True,
|
||
edgecolor=LN, linestyle='-'):
|
||
if rounded:
|
||
rect = FancyBboxPatch((x, y), w, h, boxstyle="round,pad=0.05",
|
||
lw=lw, edgecolor=edgecolor, facecolor=fill,
|
||
linestyle=linestyle)
|
||
else:
|
||
rect = mpatches.Rectangle((x, y), w, h, lw=lw, edgecolor=edgecolor,
|
||
facecolor=fill, linestyle=linestyle)
|
||
ax.add_patch(rect)
|
||
ax.text(x + w/2, y + h/2, text, ha=ha, va=va, fontsize=fontsize,
|
||
fontweight=fontweight, wrap=True)
|
||
|
||
|
||
def draw_arrow(ax, x1, y1, x2, y2, lw=1.2, style='->', color=LN):
|
||
ax.annotate("", xy=(x2, y2), xytext=(x1, y1),
|
||
arrowprops=dict(arrowstyle=style, color=color, lw=lw))
|
||
|
||
|
||
def save_fig(fig, name):
|
||
path = os.path.join(OUTPUT_DIR, name)
|
||
fig.savefig(path, dpi=DPI, bbox_inches='tight', facecolor=BG, pad_inches=0.15)
|
||
plt.close(fig)
|
||
print(f" Saved: {path}")
|
||
|
||
|
||
def draw_table(ax, headers, rows, x0, y0, col_widths, row_h=0.4,
|
||
header_fill=GRAY2, row_fills=None, fontsize=FS, header_fontsize=None):
|
||
if header_fontsize is None:
|
||
header_fontsize = fontsize
|
||
n_cols = len(headers)
|
||
cx = x0
|
||
for j, hdr in enumerate(headers):
|
||
draw_box(ax, cx, y0, col_widths[j], row_h, hdr, fill=header_fill,
|
||
fontsize=header_fontsize, fontweight='bold', rounded=False)
|
||
cx += col_widths[j]
|
||
for i, row in enumerate(rows):
|
||
cy = y0 - (i + 1) * row_h
|
||
cx = x0
|
||
fill = GRAY4 if (i % 2 == 0) else 'white'
|
||
if row_fills and i < len(row_fills):
|
||
fill = row_fills[i]
|
||
for j, cell in enumerate(row):
|
||
fw = 'bold' if j == 0 else 'normal'
|
||
draw_box(ax, cx, cy, col_widths[j], row_h, cell, fill=fill,
|
||
fontsize=fontsize, fontweight=fw, rounded=False)
|
||
cx += col_widths[j]
|
||
|
||
|
||
# ============================================================
|
||
# 1. HOG + SVM Pipeline
|
||
# ============================================================
|
||
def draw_hog_svm_pipeline():
|
||
fig, ax = plt.subplots(figsize=(10, 4.5))
|
||
ax.set_xlim(-0.5, 10.5)
|
||
ax.set_ylim(-1, 4.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('HOG + SVM — pipeline detekcji pieszych', fontsize=FS_TITLE,
|
||
fontweight='bold', pad=12)
|
||
|
||
# Step 1: Image with sliding window
|
||
ax.add_patch(mpatches.Rectangle((0, 1.5), 2, 2, lw=1.5, edgecolor=LN,
|
||
facecolor=GRAY1))
|
||
ax.text(1, 2.5, 'Obraz\nwejściowy', ha='center', va='center', fontsize=FS)
|
||
# sliding window overlay
|
||
ax.add_patch(mpatches.Rectangle((0.3, 1.8), 0.8, 1.2, lw=1.5, edgecolor='black',
|
||
facecolor='none', linestyle='--'))
|
||
ax.text(0.7, 1.35, 'okno 64×128', ha='center', va='center', fontsize=FS_SMALL,
|
||
style='italic')
|
||
|
||
draw_arrow(ax, 2.1, 2.5, 2.8, 2.5, lw=1.5)
|
||
ax.text(2.45, 2.75, '①', ha='center', fontsize=FS_LABEL, fontweight='bold')
|
||
|
||
# Step 2: Gradient computation
|
||
draw_box(ax, 2.9, 1.8, 1.6, 1.4, 'Oblicz\ngradienty\nGx, Gy', fill=GRAY4,
|
||
fontsize=FS)
|
||
ax.text(3.7, 1.55, 'kierunek + siła', ha='center', fontsize=FS_SMALL, style='italic')
|
||
|
||
draw_arrow(ax, 4.6, 2.5, 5.2, 2.5, lw=1.5)
|
||
ax.text(4.9, 2.75, '②', ha='center', fontsize=FS_LABEL, fontweight='bold')
|
||
|
||
# Step 3: HOG histogram
|
||
draw_box(ax, 5.3, 1.8, 1.6, 1.4, 'Histogramy\nkierunkowe\n9 binów/cel',
|
||
fill=GRAY4, fontsize=FS)
|
||
ax.text(6.1, 1.55, 'komórki 8×8 px', ha='center', fontsize=FS_SMALL, style='italic')
|
||
|
||
draw_arrow(ax, 7.0, 2.5, 7.6, 2.5, lw=1.5)
|
||
ax.text(7.3, 2.75, '③', ha='center', fontsize=FS_LABEL, fontweight='bold')
|
||
|
||
# Step 4: SVM
|
||
draw_box(ax, 7.7, 1.8, 1.4, 1.4, 'SVM\nklasyfikator\npieszy/tło',
|
||
fill=GRAY3, fontsize=FS, fontweight='bold')
|
||
|
||
draw_arrow(ax, 9.2, 2.5, 9.7, 2.5, lw=1.5)
|
||
ax.text(9.45, 2.75, '④', ha='center', fontsize=FS_LABEL, fontweight='bold')
|
||
|
||
# Step 5: NMS + output
|
||
draw_box(ax, 9.3, 2.0, 1.0, 1.0, 'NMS\n→ wynik', fill=GRAY1, fontsize=FS)
|
||
|
||
# Bottom: HOG feature vector illustration
|
||
ax.text(5.0, 0.7, 'Wektor HOG: 3780 cech = 105 bloków × 4 komórki × 9 binów',
|
||
ha='center', fontsize=FS, style='italic',
|
||
bbox=dict(boxstyle='round,pad=0.3', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
# Show small histogram bars
|
||
bar_x = 3.2
|
||
bar_y = 0.0
|
||
angles = [0, 20, 40, 60, 80, 100, 120, 140, 160]
|
||
values = [0.3, 0.1, 0.5, 0.8, 0.2, 0.6, 0.15, 0.4, 0.25]
|
||
for i, (a, v) in enumerate(zip(angles, values)):
|
||
ax.add_patch(mpatches.Rectangle((bar_x + i*0.18, bar_y), 0.15, v*0.6,
|
||
facecolor=GRAY3, edgecolor=LN, lw=0.5))
|
||
ax.text(bar_x + 0.8, -0.2, '9 binów (0°–160°)', ha='center', fontsize=FS_SMALL)
|
||
|
||
save_fig(fig, 'q24_hog_svm_pipeline.png')
|
||
|
||
|
||
# ============================================================
|
||
# 2. HOG Gradient Step-by-Step
|
||
# ============================================================
|
||
def draw_hog_gradient_steps():
|
||
fig, axes = plt.subplots(1, 4, figsize=(12, 3.5))
|
||
fig.suptitle('HOG — kroki obliczania cech', fontsize=FS_TITLE, fontweight='bold', y=1.02)
|
||
|
||
# Step 1: Original patch
|
||
ax = axes[0]
|
||
patch = np.array([[50, 50, 200],
|
||
[50, 50, 200],
|
||
[50, 50, 200]])
|
||
ax.imshow(patch, cmap='gray', vmin=0, vmax=255)
|
||
for i in range(3):
|
||
for j in range(3):
|
||
ax.text(j, i, str(patch[i, j]), ha='center', va='center',
|
||
fontsize=FS_LABEL, fontweight='bold',
|
||
color='white' if patch[i, j] > 127 else 'black')
|
||
ax.set_title('① Fragment obrazu\n(jasność pikseli)', fontsize=FS, fontweight='bold')
|
||
ax.set_xticks([])
|
||
ax.set_yticks([])
|
||
|
||
# Step 2: Gradient magnitude
|
||
ax = axes[1]
|
||
gx = np.array([[0, 150, 0],
|
||
[0, 150, 0],
|
||
[0, 150, 0]])
|
||
ax.imshow(gx, cmap='gray', vmin=0, vmax=255)
|
||
for i in range(3):
|
||
for j in range(3):
|
||
ax.text(j, i, str(gx[i, j]), ha='center', va='center',
|
||
fontsize=FS_LABEL, fontweight='bold',
|
||
color='white' if gx[i, j] > 100 else 'black')
|
||
ax.set_title('② Gradient Gx\n(krawędź pionowa!)', fontsize=FS, fontweight='bold')
|
||
ax.set_xticks([])
|
||
ax.set_yticks([])
|
||
|
||
# Step 3: Cell histogram
|
||
ax = axes[2]
|
||
angles = ['0°', '20°', '40°', '60°', '80°', '100°', '120°', '140°', '160°']
|
||
values = [150, 0, 0, 0, 0, 0, 0, 0, 0]
|
||
bars = ax.bar(range(9), values, color=GRAY3, edgecolor=LN, linewidth=0.5)
|
||
bars[0].set_facecolor(GRAY5)
|
||
ax.set_xticks(range(9))
|
||
ax.set_xticklabels(angles, fontsize=5, rotation=45)
|
||
ax.set_title('③ Histogram komórki\n(bin 0° = krawędź pionowa)', fontsize=FS, fontweight='bold')
|
||
ax.set_ylabel('siła', fontsize=FS_SMALL)
|
||
|
||
# Step 4: Block normalization
|
||
ax = axes[3]
|
||
# 2x2 block of cells
|
||
for i in range(2):
|
||
for j in range(2):
|
||
rect = mpatches.Rectangle((j*1.2, (1-i)*1.2), 1.0, 1.0,
|
||
lw=1.2, edgecolor=LN, facecolor=GRAY4)
|
||
ax.add_patch(rect)
|
||
ax.text(j*1.2+0.5, (1-i)*1.2+0.5, f'hist\n{i*2+j+1}',
|
||
ha='center', va='center', fontsize=FS_SMALL)
|
||
ax.add_patch(mpatches.Rectangle((-0.1, -0.1), 2.6, 2.6,
|
||
lw=2, edgecolor=LN, facecolor='none',
|
||
linestyle='--'))
|
||
ax.text(1.2, -0.4, 'blok 2×2 → L2-norm', ha='center', fontsize=FS_SMALL,
|
||
fontweight='bold')
|
||
ax.set_xlim(-0.3, 2.8)
|
||
ax.set_ylim(-0.7, 2.8)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('④ Normalizacja bloków\n(odporność na oświetlenie)', fontsize=FS,
|
||
fontweight='bold')
|
||
|
||
fig.tight_layout()
|
||
save_fig(fig, 'q24_hog_gradient_steps.png')
|
||
|
||
|
||
# ============================================================
|
||
# 3. Viola-Jones Cascade
|
||
# ============================================================
|
||
def draw_viola_jones_cascade():
|
||
fig, ax = plt.subplots(figsize=(10, 5))
|
||
ax.set_xlim(-0.5, 10.5)
|
||
ax.set_ylim(-1.5, 5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('Viola-Jones — kaskada klasyfikatorów (SITO)', fontsize=FS_TITLE,
|
||
fontweight='bold', pad=12)
|
||
|
||
# Input
|
||
draw_box(ax, -0.3, 2.5, 1.5, 1.2, '500 000\nokien', fill=GRAY1, fontsize=FS,
|
||
fontweight='bold')
|
||
|
||
stages = [
|
||
('Etap 1\n2 cechy', '50%\nodrzucone', '250 000', GRAY4),
|
||
('Etap 2\n10 cech', '80%\nodrzucone', '50 000', GRAY4),
|
||
('Etap 3\n25 cech', '90%\nodrzucone', '5 000', GRAY4),
|
||
('Etap 25\n200 cech', '99%\nodrzucone', '50', GRAY3),
|
||
]
|
||
|
||
x_pos = 1.6
|
||
for i, (label, reject, remain, col) in enumerate(stages):
|
||
# Stage box
|
||
draw_box(ax, x_pos, 2.5, 1.6, 1.2, label, fill=col, fontsize=FS,
|
||
fontweight='bold')
|
||
|
||
# Arrow from previous
|
||
draw_arrow(ax, x_pos - 0.3, 3.1, x_pos - 0.05, 3.1, lw=1.5)
|
||
|
||
# Reject arrow down
|
||
draw_arrow(ax, x_pos + 0.8, 2.45, x_pos + 0.8, 1.6, lw=1.2)
|
||
ax.text(x_pos + 0.8, 1.3, reject, ha='center', fontsize=FS_SMALL,
|
||
color='black', style='italic')
|
||
ax.text(x_pos + 0.8, 0.8, '✗ NIE-TWARZ', ha='center', fontsize=FS_SMALL,
|
||
fontweight='bold')
|
||
|
||
# Remaining count above
|
||
if i < len(stages) - 1:
|
||
ax.text(x_pos + 2.0, 3.9, f'→ {remain}', ha='center', fontsize=FS_SMALL,
|
||
style='italic')
|
||
|
||
# Dots between stage 3 and stage 25
|
||
if i == 2:
|
||
ax.text(x_pos + 2.0, 3.1, '· · ·', ha='center', fontsize=12,
|
||
fontweight='bold')
|
||
x_pos += 2.5
|
||
else:
|
||
x_pos += 2.1
|
||
|
||
# Final output
|
||
draw_arrow(ax, x_pos + 0.3, 3.1, x_pos + 0.9, 3.1, lw=1.5)
|
||
draw_box(ax, x_pos + 0.5, 2.5, 1.3, 1.2, '~50\nTWARZE\n✓', fill=GRAY2,
|
||
fontsize=FS, fontweight='bold')
|
||
|
||
# Timing info
|
||
ax.text(5.0, -0.5, 'Czas: 99% okien odrzucone w etapach 1-3 (~5 μs każde)\n'
|
||
'Tylko 0.01% dochodzi do etapu 25 → cały obraz w ~30 ms = 30+ fps',
|
||
ha='center', fontsize=FS, style='italic',
|
||
bbox=dict(boxstyle='round,pad=0.4', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
save_fig(fig, 'q24_viola_jones_cascade.png')
|
||
|
||
|
||
# ============================================================
|
||
# 4. Haar Features
|
||
# ============================================================
|
||
def draw_haar_features():
|
||
fig, axes = plt.subplots(1, 4, figsize=(11, 3))
|
||
fig.suptitle('Cechy Haar — typy i zastosowanie na twarzy', fontsize=FS_TITLE,
|
||
fontweight='bold', y=1.02)
|
||
|
||
# Feature 1: Vertical edge
|
||
ax = axes[0]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 1, 2, facecolor=GRAY4, edgecolor=LN, lw=1.5))
|
||
ax.add_patch(mpatches.Rectangle((1, 0), 1, 2, facecolor=GRAY3, edgecolor=LN, lw=1.5))
|
||
ax.text(0.5, 1, '+Σ₁', ha='center', va='center', fontsize=FS_LABEL, fontweight='bold')
|
||
ax.text(1.5, 1, '−Σ₂', ha='center', va='center', fontsize=FS_LABEL, fontweight='bold')
|
||
ax.set_xlim(-0.2, 2.2)
|
||
ax.set_ylim(-0.5, 2.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('Krawędź pionowa\nwartość = Σ₁ − Σ₂', fontsize=FS)
|
||
|
||
# Feature 2: Horizontal edge
|
||
ax = axes[1]
|
||
ax.add_patch(mpatches.Rectangle((0, 1), 2, 1, facecolor=GRAY4, edgecolor=LN, lw=1.5))
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 2, 1, facecolor=GRAY3, edgecolor=LN, lw=1.5))
|
||
ax.text(1, 1.5, '+Σ₁', ha='center', va='center', fontsize=FS_LABEL, fontweight='bold')
|
||
ax.text(1, 0.5, '−Σ₂', ha='center', va='center', fontsize=FS_LABEL, fontweight='bold')
|
||
ax.set_xlim(-0.2, 2.2)
|
||
ax.set_ylim(-0.5, 2.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('Krawędź pozioma\n(oczy vs czoło)', fontsize=FS)
|
||
|
||
# Feature 3: Three-rectangle (line)
|
||
ax = axes[2]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 0.7, 2, facecolor=GRAY3, edgecolor=LN, lw=1.5))
|
||
ax.add_patch(mpatches.Rectangle((0.7, 0), 0.7, 2, facecolor=GRAY4, edgecolor=LN, lw=1.5))
|
||
ax.add_patch(mpatches.Rectangle((1.4, 0), 0.7, 2, facecolor=GRAY3, edgecolor=LN, lw=1.5))
|
||
ax.text(0.35, 1, '−Σ₁', ha='center', va='center', fontsize=FS_SMALL, fontweight='bold')
|
||
ax.text(1.05, 1, '+Σ₂', ha='center', va='center', fontsize=FS_SMALL, fontweight='bold')
|
||
ax.text(1.75, 1, '−Σ₃', ha='center', va='center', fontsize=FS_SMALL, fontweight='bold')
|
||
ax.set_xlim(-0.2, 2.3)
|
||
ax.set_ylim(-0.5, 2.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('Linia (3 prostokąty)\n(nos vs policzki)', fontsize=FS)
|
||
|
||
# Feature 4: Application on face (schematic)
|
||
ax = axes[3]
|
||
# Draw face outline (oval)
|
||
face = mpatches.Ellipse((1.2, 1.2), 2.0, 2.4, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1.5)
|
||
ax.add_patch(face)
|
||
# Eyes (dark)
|
||
ax.add_patch(mpatches.Ellipse((0.7, 1.6), 0.4, 0.2, facecolor=GRAY3,
|
||
edgecolor=LN, lw=1))
|
||
ax.add_patch(mpatches.Ellipse((1.7, 1.6), 0.4, 0.2, facecolor=GRAY3,
|
||
edgecolor=LN, lw=1))
|
||
# Nose (light)
|
||
ax.plot([1.2, 1.1, 1.3], [1.3, 0.9, 0.9], color=LN, lw=1)
|
||
# Mouth
|
||
ax.plot([0.8, 1.0, 1.2, 1.4, 1.6], [0.55, 0.5, 0.55, 0.5, 0.55],
|
||
color=LN, lw=1)
|
||
# Haar feature overlay on eyes
|
||
ax.add_patch(mpatches.Rectangle((0.3, 1.4), 1.8, 0.4, facecolor='none',
|
||
edgecolor=LN, lw=2, linestyle='--'))
|
||
ax.annotate('cechy Haar\n(oczy ciemne\nvs czoło jasne)', xy=(1.2, 1.85),
|
||
xytext=(2.2, 2.3), fontsize=FS_SMALL, ha='center',
|
||
arrowprops=dict(arrowstyle='->', color=LN, lw=1))
|
||
ax.set_xlim(-0.2, 3.0)
|
||
ax.set_ylim(-0.2, 2.8)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('Zastosowanie na twarzy', fontsize=FS)
|
||
|
||
fig.tight_layout()
|
||
save_fig(fig, 'q24_haar_features.png')
|
||
|
||
|
||
# ============================================================
|
||
# 5. Integral Image
|
||
# ============================================================
|
||
def draw_integral_image():
|
||
fig, axes = plt.subplots(1, 3, figsize=(11, 3.5))
|
||
fig.suptitle('Integral Image — suma prostokąta w O(1)', fontsize=FS_TITLE,
|
||
fontweight='bold', y=1.02)
|
||
|
||
# Original image
|
||
ax = axes[0]
|
||
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
|
||
ax.imshow(data, cmap='gray', vmin=0, vmax=10)
|
||
for i in range(3):
|
||
for j in range(3):
|
||
ax.text(j, i, str(data[i, j]), ha='center', va='center',
|
||
fontsize=12, fontweight='bold', color='white' if data[i,j] > 5 else 'black')
|
||
ax.set_title('① Obraz oryginalny', fontsize=FS, fontweight='bold')
|
||
ax.set_xticks([])
|
||
ax.set_yticks([])
|
||
|
||
# Integral image
|
||
ax = axes[1]
|
||
ii = np.array([[1, 3, 6], [5, 12, 21], [12, 27, 45]])
|
||
ax.imshow(ii, cmap='gray', vmin=0, vmax=50)
|
||
for i in range(3):
|
||
for j in range(3):
|
||
ax.text(j, i, str(ii[i, j]), ha='center', va='center',
|
||
fontsize=12, fontweight='bold',
|
||
color='white' if ii[i,j] > 25 else 'black')
|
||
ax.set_title('② Integral Image\n(sumy kumulatywne)', fontsize=FS, fontweight='bold')
|
||
ax.set_xticks([])
|
||
ax.set_yticks([])
|
||
|
||
# Formula illustration
|
||
ax = axes[2]
|
||
ax.axis('off')
|
||
ax.set_xlim(0, 4)
|
||
ax.set_ylim(0, 4)
|
||
# Draw rectangle
|
||
ax.add_patch(mpatches.Rectangle((0.5, 0.5), 3, 3, facecolor='white',
|
||
edgecolor=LN, lw=1))
|
||
ax.add_patch(mpatches.Rectangle((1.5, 0.5), 2, 2, facecolor=GRAY3,
|
||
edgecolor=LN, lw=2))
|
||
# Labels
|
||
ax.text(0.3, 3.7, 'A', fontsize=12, fontweight='bold')
|
||
ax.text(3.6, 3.7, 'B', fontsize=12, fontweight='bold')
|
||
ax.text(0.3, 0.3, 'C', fontsize=12, fontweight='bold')
|
||
ax.text(3.6, 0.3, 'D', fontsize=12, fontweight='bold')
|
||
ax.text(2.5, 1.5, 'SZUKANA\nSUMA', ha='center', va='center',
|
||
fontsize=FS, fontweight='bold')
|
||
ax.text(2.0, -0.3, 'Suma = D − B − C + A\n= 4 odczyty → O(1) ZAWSZE!',
|
||
ha='center', fontsize=FS, fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.3', facecolor=GRAY4, edgecolor=GRAY3))
|
||
ax.set_title('③ Formuła: 4 odczyty\n= O(1) niezależnie od rozmiaru', fontsize=FS,
|
||
fontweight='bold')
|
||
|
||
fig.tight_layout()
|
||
save_fig(fig, 'q24_integral_image.png')
|
||
|
||
|
||
# ============================================================
|
||
# 6. R-CNN Evolution
|
||
# ============================================================
|
||
def draw_rcnn_evolution():
|
||
fig, ax = plt.subplots(figsize=(11, 7))
|
||
ax.set_xlim(-0.5, 11)
|
||
ax.set_ylim(-0.5, 7.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('Ewolucja R-CNN: od 50s do 0.2s na obraz', fontsize=FS_TITLE,
|
||
fontweight='bold', pad=12)
|
||
|
||
y_positions = [5.5, 3.0, 0.5]
|
||
labels = ['R-CNN (2014) — 50 s/obraz', 'Fast R-CNN (2015) — 2 s/obraz',
|
||
'Faster R-CNN (2015) — 0.2 s/obraz']
|
||
|
||
# R-CNN
|
||
y = y_positions[0]
|
||
ax.text(0, y + 1.3, labels[0], fontsize=FS_LABEL, fontweight='bold')
|
||
draw_box(ax, 0, y, 2, 0.9, 'Selective\nSearch', fill=GRAY2, fontsize=FS)
|
||
draw_arrow(ax, 2.1, y+0.45, 2.5, y+0.45)
|
||
ax.text(2.3, y+0.8, '~2000', ha='center', fontsize=FS_SMALL, style='italic')
|
||
draw_box(ax, 2.6, y, 1.5, 0.9, 'Resize\n224×224', fill=GRAY4, fontsize=FS)
|
||
draw_arrow(ax, 4.2, y+0.45, 4.6, y+0.45)
|
||
draw_box(ax, 4.7, y, 1.5, 0.9, 'CNN\n×2000!', fill=GRAY3, fontsize=FS, fontweight='bold')
|
||
draw_arrow(ax, 6.3, y+0.45, 6.7, y+0.45)
|
||
draw_box(ax, 6.8, y, 1.3, 0.9, 'SVM\nklasyf.', fill=GRAY4, fontsize=FS)
|
||
draw_arrow(ax, 8.2, y+0.45, 8.6, y+0.45)
|
||
draw_box(ax, 8.7, y, 1.0, 0.9, 'NMS', fill=GRAY1, fontsize=FS)
|
||
# Problem annotation
|
||
ax.text(5.5, y - 0.4, '⚠ CNN uruchamiane 2000× → 50 sek!',
|
||
ha='center', fontsize=FS_SMALL, fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.2', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
# Fast R-CNN
|
||
y = y_positions[1]
|
||
ax.text(0, y + 1.3, labels[1], fontsize=FS_LABEL, fontweight='bold')
|
||
draw_box(ax, 0, y, 2, 0.9, 'Selective\nSearch', fill=GRAY2, fontsize=FS)
|
||
draw_arrow(ax, 2.1, y+0.45, 2.5, y+0.45)
|
||
draw_box(ax, 2.6, y, 1.5, 0.9, 'CNN\n×1 (RAZ!)', fill=GRAY3, fontsize=FS,
|
||
fontweight='bold')
|
||
draw_arrow(ax, 4.2, y+0.45, 4.6, y+0.45)
|
||
draw_box(ax, 4.7, y, 1.5, 0.9, 'ROI\nPooling', fill=GRAY1, fontsize=FS,
|
||
fontweight='bold')
|
||
draw_arrow(ax, 6.3, y+0.45, 6.7, y+0.45)
|
||
draw_box(ax, 6.8, y, 1.3, 0.9, 'FC\nklasa+bbox', fill=GRAY4, fontsize=FS)
|
||
draw_arrow(ax, 8.2, y+0.45, 8.6, y+0.45)
|
||
draw_box(ax, 8.7, y, 1.0, 0.9, 'NMS', fill=GRAY1, fontsize=FS)
|
||
ax.text(3.8, y - 0.4, '✓ CNN RAZ na cały obraz → 25× szybciej',
|
||
ha='center', fontsize=FS_SMALL, fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.2', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
# Faster R-CNN
|
||
y = y_positions[2]
|
||
ax.text(0, y + 1.3, labels[2], fontsize=FS_LABEL, fontweight='bold')
|
||
draw_box(ax, 0.5, y, 1.5, 0.9, 'CNN\nBackbone', fill=GRAY3, fontsize=FS,
|
||
fontweight='bold')
|
||
draw_arrow(ax, 2.1, y+0.45, 2.5, y+0.45)
|
||
draw_box(ax, 2.6, y, 1.5, 0.9, 'Feature\nMap', fill=GRAY1, fontsize=FS)
|
||
draw_arrow(ax, 4.2, y+0.45, 4.6, y+0.45)
|
||
draw_box(ax, 4.7, y, 1.3, 0.9, 'RPN\n(w sieci!)', fill=GRAY2, fontsize=FS,
|
||
fontweight='bold')
|
||
draw_arrow(ax, 6.1, y+0.45, 6.5, y+0.45)
|
||
draw_box(ax, 6.6, y, 1.3, 0.9, 'ROI\nPooling', fill=GRAY1, fontsize=FS)
|
||
draw_arrow(ax, 8.0, y+0.45, 8.4, y+0.45)
|
||
draw_box(ax, 8.5, y, 1.3, 0.9, 'FC\nklasa+bbox', fill=GRAY4, fontsize=FS)
|
||
ax.text(5.0, y - 0.4, '✓ RPN zastępuje Selective Search → end-to-end',
|
||
ha='center', fontsize=FS_SMALL, fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.2', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
save_fig(fig, 'q24_rcnn_evolution.png')
|
||
|
||
|
||
# ============================================================
|
||
# 7. YOLO Grid
|
||
# ============================================================
|
||
def draw_yolo_grid():
|
||
fig, axes = plt.subplots(1, 3, figsize=(12, 4))
|
||
fig.suptitle('YOLO — detekcja jednoetapowa (siatka S×S)', fontsize=FS_TITLE,
|
||
fontweight='bold', y=1.02)
|
||
|
||
# Grid on image
|
||
ax = axes[0]
|
||
S = 7
|
||
ax.set_xlim(0, S)
|
||
ax.set_ylim(0, S)
|
||
for i in range(S + 1):
|
||
ax.axhline(y=i, color=LN, lw=0.5, alpha=0.5)
|
||
ax.axvline(x=i, color=LN, lw=0.5, alpha=0.5)
|
||
ax.add_patch(mpatches.Rectangle((0, 0), S, S, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1.5))
|
||
# Highlight one cell
|
||
ax.add_patch(mpatches.Rectangle((3, 3), 1, 1, facecolor=GRAY2,
|
||
edgecolor=LN, lw=2))
|
||
# Object center dot
|
||
ax.plot(3.5, 3.5, 'ko', markersize=8)
|
||
# Bounding box from that cell
|
||
ax.add_patch(mpatches.Rectangle((2.0, 2.2), 3.0, 2.6, facecolor='none',
|
||
edgecolor=LN, lw=2, linestyle='--'))
|
||
ax.text(3.5, 1.8, 'bbox z komórki (3,3)', ha='center', fontsize=FS_SMALL,
|
||
fontweight='bold')
|
||
ax.set_aspect('equal')
|
||
ax.invert_yaxis()
|
||
ax.set_title('① Siatka 7×7\nna obrazie', fontsize=FS, fontweight='bold')
|
||
ax.set_xticks([])
|
||
ax.set_yticks([])
|
||
|
||
# Cell prediction
|
||
ax = axes[1]
|
||
ax.axis('off')
|
||
ax.set_xlim(0, 6)
|
||
ax.set_ylim(-1, 5)
|
||
|
||
# Draw prediction vector
|
||
labels = ['x', 'y', 'w', 'h', 'conf', 'x', 'y', 'w', 'h', 'conf',
|
||
'P(c₁)', '...', 'P(c₂₀)']
|
||
colors_vec = [GRAY4]*5 + [GRAY2]*5 + [GRAY1]*3
|
||
|
||
bw = 0.42
|
||
for i, (l, c) in enumerate(zip(labels, colors_vec)):
|
||
x_pos = 0.3 + i * bw
|
||
ax.add_patch(mpatches.Rectangle((x_pos, 2.5), bw-0.02, 0.6,
|
||
facecolor=c, edgecolor=LN, lw=0.8))
|
||
ax.text(x_pos + bw/2, 2.8, l, ha='center', va='center',
|
||
fontsize=5, fontweight='bold')
|
||
|
||
# Brackets for grouping
|
||
ax.annotate('', xy=(0.3, 2.4), xytext=(2.4, 2.4),
|
||
arrowprops=dict(arrowstyle='-', lw=1))
|
||
ax.text(1.35, 2.15, 'bbox 1 (5 wartości)', ha='center', fontsize=FS_SMALL)
|
||
|
||
ax.annotate('', xy=(2.4, 2.4), xytext=(4.5, 2.4),
|
||
arrowprops=dict(arrowstyle='-', lw=1))
|
||
ax.text(3.45, 2.15, 'bbox 2 (5 wartości)', ha='center', fontsize=FS_SMALL)
|
||
|
||
ax.annotate('', xy=(4.5, 2.4), xytext=(5.8, 2.4),
|
||
arrowprops=dict(arrowstyle='-', lw=1))
|
||
ax.text(5.15, 2.15, '20 klas', ha='center', fontsize=FS_SMALL)
|
||
|
||
ax.text(3.0, 3.5, 'Każda komórka → 30 wartości\n= 2×(x,y,w,h,conf) + 20 klas',
|
||
ha='center', fontsize=FS, fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.3', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
ax.set_title('② Predykcja jednej komórki\n(S=7, B=2, C=20)', fontsize=FS,
|
||
fontweight='bold')
|
||
|
||
# Speed comparison
|
||
ax = axes[2]
|
||
ax.axis('off')
|
||
ax.set_xlim(0, 5)
|
||
ax.set_ylim(0, 5)
|
||
|
||
methods = ['R-CNN', 'Fast R-CNN', 'Faster R-CNN', 'YOLO', 'YOLOv8']
|
||
fps_vals = [0.02, 0.5, 5, 45, 100]
|
||
bar_colors = [GRAY3, GRAY3, GRAY3, GRAY2, GRAY1]
|
||
|
||
for i, (m, f, c) in enumerate(zip(methods, fps_vals, bar_colors)):
|
||
bar_w = f / 100 * 4.0
|
||
y_pos = 4.0 - i * 0.8
|
||
ax.add_patch(mpatches.Rectangle((0.5, y_pos), max(bar_w, 0.1), 0.5,
|
||
facecolor=c, edgecolor=LN, lw=0.8))
|
||
ax.text(0.4, y_pos + 0.25, m, ha='right', va='center', fontsize=FS,
|
||
fontweight='bold')
|
||
ax.text(max(0.7, 0.5 + bar_w + 0.1), y_pos + 0.25, f'{f} fps',
|
||
ha='left', va='center', fontsize=FS)
|
||
|
||
ax.set_title('③ Porównanie szybkości\n(fps = klatki/sek)', fontsize=FS,
|
||
fontweight='bold')
|
||
|
||
fig.tight_layout()
|
||
save_fig(fig, 'q24_yolo_grid.png')
|
||
|
||
|
||
# ============================================================
|
||
# 8. IoU Diagram
|
||
# ============================================================
|
||
def draw_iou_diagram():
|
||
fig, axes = plt.subplots(1, 3, figsize=(11, 3.5))
|
||
fig.suptitle('IoU (Intersection over Union) — miara nakładania bboxów',
|
||
fontsize=FS_TITLE, fontweight='bold', y=1.02)
|
||
|
||
# Low IoU
|
||
ax = axes[0]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 3, 3, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1.5, label='A'))
|
||
ax.add_patch(mpatches.Rectangle((2.5, 2.5), 3, 3, facecolor=GRAY2,
|
||
edgecolor=LN, lw=1.5, alpha=0.7, label='B'))
|
||
# Intersection
|
||
ax.add_patch(mpatches.Rectangle((2.5, 2.5), 0.5, 0.5, facecolor=GRAY3,
|
||
edgecolor=LN, lw=2))
|
||
ax.text(1.5, 1.5, 'A', ha='center', va='center', fontsize=12, fontweight='bold')
|
||
ax.text(4, 4, 'B', ha='center', va='center', fontsize=12, fontweight='bold')
|
||
ax.set_xlim(-0.5, 6)
|
||
ax.set_ylim(-0.5, 6)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('IoU ≈ 0.04\n(prawie się nie nakładają)', fontsize=FS, fontweight='bold')
|
||
|
||
# Medium IoU
|
||
ax = axes[1]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 3, 3, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1.5))
|
||
ax.add_patch(mpatches.Rectangle((1.5, 1.5), 3, 3, facecolor=GRAY2,
|
||
edgecolor=LN, lw=1.5, alpha=0.7))
|
||
ax.add_patch(mpatches.Rectangle((1.5, 1.5), 1.5, 1.5, facecolor=GRAY3,
|
||
edgecolor=LN, lw=2))
|
||
ax.text(0.7, 0.7, 'A', ha='center', va='center', fontsize=12, fontweight='bold')
|
||
ax.text(3.5, 3.5, 'B', ha='center', va='center', fontsize=12, fontweight='bold')
|
||
ax.text(2.25, 2.25, '∩', ha='center', va='center', fontsize=14, fontweight='bold')
|
||
ax.set_xlim(-0.5, 5)
|
||
ax.set_ylim(-0.5, 5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('IoU ≈ 0.14\n(częściowe nakładanie)', fontsize=FS, fontweight='bold')
|
||
|
||
# High IoU
|
||
ax = axes[2]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 3, 3, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1.5))
|
||
ax.add_patch(mpatches.Rectangle((0.3, 0.3), 3, 3, facecolor=GRAY2,
|
||
edgecolor=LN, lw=1.5, alpha=0.7))
|
||
ax.add_patch(mpatches.Rectangle((0.3, 0.3), 2.7, 2.7, facecolor=GRAY3,
|
||
edgecolor=LN, lw=2))
|
||
ax.text(-0.3, -0.3, 'A', ha='center', va='center', fontsize=12, fontweight='bold')
|
||
ax.text(3.5, 3.5, 'B', ha='center', va='center', fontsize=12, fontweight='bold')
|
||
ax.text(1.65, 1.65, '∩', ha='center', va='center', fontsize=14, fontweight='bold')
|
||
ax.set_xlim(-0.8, 4)
|
||
ax.set_ylim(-0.8, 4)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('IoU ≈ 0.74\n(duże nakładanie → duplikat!)', fontsize=FS, fontweight='bold')
|
||
|
||
fig.tight_layout()
|
||
save_fig(fig, 'q24_iou_diagram.png')
|
||
|
||
|
||
# ============================================================
|
||
# 9. NMS Step-by-Step
|
||
# ============================================================
|
||
def draw_nms_steps():
|
||
fig, axes = plt.subplots(1, 3, figsize=(12, 4))
|
||
fig.suptitle('NMS (Non-Maximum Suppression) — usuwanie duplikatów',
|
||
fontsize=FS_TITLE, fontweight='bold', y=1.02)
|
||
|
||
# Before NMS
|
||
ax = axes[0]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 6, 5, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1))
|
||
# Multiple overlapping boxes for same object
|
||
ax.add_patch(mpatches.Rectangle((1, 1), 2.5, 3, facecolor='none',
|
||
edgecolor=LN, lw=2))
|
||
ax.text(2.25, 4.2, 'conf=0.95', ha='center', fontsize=FS_SMALL, fontweight='bold')
|
||
ax.add_patch(mpatches.Rectangle((1.2, 1.3), 2.3, 2.8, facecolor='none',
|
||
edgecolor=LN, lw=1.5, linestyle='--'))
|
||
ax.text(2.35, 1.1, 'conf=0.90', ha='center', fontsize=FS_SMALL)
|
||
ax.add_patch(mpatches.Rectangle((0.8, 0.8), 2.7, 3.2, facecolor='none',
|
||
edgecolor=LN, lw=1, linestyle=':'))
|
||
ax.text(2.15, 0.6, 'conf=0.85', ha='center', fontsize=FS_SMALL)
|
||
# Different object
|
||
ax.add_patch(mpatches.Rectangle((4, 2), 1.5, 1.5, facecolor='none',
|
||
edgecolor=LN, lw=1.5))
|
||
ax.text(4.75, 3.7, 'conf=0.80', ha='center', fontsize=FS_SMALL)
|
||
ax.text(2, 0.2, '⚠ 4 detekcje (3 duplikaty!)', ha='center', fontsize=FS_SMALL,
|
||
fontweight='bold')
|
||
ax.set_xlim(-0.3, 6.3)
|
||
ax.set_ylim(-0.3, 5.3)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('① Przed NMS\n(wiele nakładających się)', fontsize=FS, fontweight='bold')
|
||
|
||
# NMS process
|
||
ax = axes[1]
|
||
ax.axis('off')
|
||
ax.set_xlim(0, 6)
|
||
ax.set_ylim(0, 5)
|
||
|
||
steps = [
|
||
('1. Sortuj: [0.95, 0.90, 0.85, 0.80]', 4.5),
|
||
('2. Weź najlepszą (0.95) → ZACHOWAJ', 3.7),
|
||
('3. IoU(0.95, 0.90)=0.82 > 0.5 → USUŃ', 2.9),
|
||
('4. IoU(0.95, 0.85)=0.75 > 0.5 → USUŃ', 2.1),
|
||
('5. IoU(0.95, 0.80)=0.10 < 0.5 → ZACHOWAJ', 1.3),
|
||
]
|
||
colors = [GRAY4, GRAY2, GRAY4, GRAY4, GRAY2]
|
||
for (text, yp), c in zip(steps, colors):
|
||
ax.text(3.0, yp, text, ha='center', fontsize=FS,
|
||
bbox=dict(boxstyle='round,pad=0.2', facecolor=c, edgecolor=GRAY3))
|
||
|
||
ax.set_title('② Algorytm NMS\n(próg IoU = 0.5)', fontsize=FS, fontweight='bold')
|
||
|
||
# After NMS
|
||
ax = axes[2]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 6, 5, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1))
|
||
# Only best box for each object
|
||
ax.add_patch(mpatches.Rectangle((1, 1), 2.5, 3, facecolor='none',
|
||
edgecolor=LN, lw=2.5))
|
||
ax.text(2.25, 4.2, 'conf=0.95 ✓', ha='center', fontsize=FS_SMALL, fontweight='bold')
|
||
ax.add_patch(mpatches.Rectangle((4, 2), 1.5, 1.5, facecolor='none',
|
||
edgecolor=LN, lw=2.5))
|
||
ax.text(4.75, 3.7, 'conf=0.80 ✓', ha='center', fontsize=FS_SMALL, fontweight='bold')
|
||
ax.text(3, 0.2, '✓ 2 unikalne obiekty', ha='center', fontsize=FS_SMALL,
|
||
fontweight='bold')
|
||
ax.set_xlim(-0.3, 6.3)
|
||
ax.set_ylim(-0.3, 5.3)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('③ Po NMS\n(1 bbox na obiekt)', fontsize=FS, fontweight='bold')
|
||
|
||
fig.tight_layout()
|
||
save_fig(fig, 'q24_nms_steps.png')
|
||
|
||
|
||
# ============================================================
|
||
# 10. Detector from Classifier — 3 approaches
|
||
# ============================================================
|
||
def draw_detector_from_classifier():
|
||
fig, ax = plt.subplots(figsize=(11, 9))
|
||
ax.set_xlim(-0.5, 11)
|
||
ax.set_ylim(-1, 9.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('Jak zbudować detektor z klasyfikatora? — 3 podejścia',
|
||
fontsize=FS_TITLE, fontweight='bold', pad=12)
|
||
|
||
# ---- Approach 1: Sliding Window ----
|
||
y = 7.0
|
||
ax.text(0, y + 1.5, '① Sliding Window (NAJWOLNIEJSZE)', fontsize=FS_LABEL,
|
||
fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.2', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
# Image with sliding window
|
||
ax.add_patch(mpatches.Rectangle((0, y - 0.6), 1.8, 1.8, facecolor=GRAY1,
|
||
edgecolor=LN, lw=1.5))
|
||
ax.text(0.9, y + 0.3, 'obraz', ha='center', fontsize=FS_SMALL)
|
||
# Sliding windows
|
||
for dx, dy in [(0.1, 0.1), (0.4, 0.1), (0.7, 0.1), (0.1, 0.5), (0.4, 0.5)]:
|
||
ax.add_patch(mpatches.Rectangle((dx, y - 0.5 + dy), 0.5, 0.5,
|
||
facecolor='none', edgecolor=LN, lw=0.8, linestyle='--'))
|
||
|
||
draw_arrow(ax, 2.0, y + 0.3, 2.7, y + 0.3, lw=1.2)
|
||
ax.text(2.35, y + 0.6, '×miliony', fontsize=FS_SMALL, style='italic')
|
||
|
||
draw_box(ax, 2.8, y - 0.3, 1.8, 1.2, 'Klasyfikator\n(ResNet)\n"kot? pies? tło?"',
|
||
fill=GRAY4, fontsize=FS)
|
||
draw_arrow(ax, 4.7, y + 0.3, 5.3, y + 0.3, lw=1.2)
|
||
draw_box(ax, 5.4, y - 0.3, 1.2, 1.2, 'NMS', fill=GRAY1, fontsize=FS)
|
||
draw_arrow(ax, 6.7, y + 0.3, 7.3, y + 0.3, lw=1.2)
|
||
ax.text(8.5, y + 0.3, '~3.3h / obraz!\n⚠ NIEPRAKTYCZNE',
|
||
ha='center', fontsize=FS, fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.3', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
# ---- Approach 2: Region Proposals ----
|
||
y = 3.8
|
||
ax.text(0, y + 1.5, '② Region Proposals + Klasyfikator (= R-CNN)', fontsize=FS_LABEL,
|
||
fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.2', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
ax.add_patch(mpatches.Rectangle((0, y - 0.6), 1.8, 1.8, facecolor=GRAY1,
|
||
edgecolor=LN, lw=1.5))
|
||
ax.text(0.9, y + 0.3, 'obraz', ha='center', fontsize=FS_SMALL)
|
||
# A few smart regions
|
||
ax.add_patch(mpatches.Rectangle((0.1, y - 0.4), 0.7, 0.9, facecolor='none',
|
||
edgecolor=LN, lw=1.5))
|
||
ax.add_patch(mpatches.Rectangle((0.9, y + 0.0), 0.7, 0.6, facecolor='none',
|
||
edgecolor=LN, lw=1.5))
|
||
|
||
draw_arrow(ax, 2.0, y + 0.3, 2.7, y + 0.3, lw=1.2)
|
||
draw_box(ax, 2.8, y - 0.3, 1.6, 1.2, 'Selective\nSearch\n~2000 regionów',
|
||
fill=GRAY2, fontsize=FS)
|
||
draw_arrow(ax, 4.5, y + 0.3, 5.1, y + 0.3, lw=1.2)
|
||
ax.text(4.8, y + 0.6, '×2000', fontsize=FS_SMALL, style='italic')
|
||
draw_box(ax, 5.2, y - 0.3, 1.5, 1.2, 'Klasyfikator\n(CNN)', fill=GRAY4, fontsize=FS)
|
||
draw_arrow(ax, 6.8, y + 0.3, 7.4, y + 0.3, lw=1.2)
|
||
draw_box(ax, 7.5, y - 0.3, 1.0, 1.2, 'NMS', fill=GRAY1, fontsize=FS)
|
||
draw_arrow(ax, 8.6, y + 0.3, 9.0, y + 0.3, lw=1.2)
|
||
ax.text(10.0, y + 0.3, '~20-50 s/obraz\n(250× szybciej)',
|
||
ha='center', fontsize=FS, fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.3', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
# ---- Approach 3: Fine-tune backbone ----
|
||
y = 0.5
|
||
ax.text(0, y + 1.5, '③ Fine-tune backbone + detection head (NAJLEPSZE)',
|
||
fontsize=FS_LABEL, fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.2', facecolor=GRAY2, edgecolor=GRAY3))
|
||
|
||
ax.add_patch(mpatches.Rectangle((0, y - 0.6), 1.8, 1.8, facecolor=GRAY1,
|
||
edgecolor=LN, lw=1.5))
|
||
ax.text(0.9, y + 0.3, 'obraz', ha='center', fontsize=FS_SMALL)
|
||
|
||
draw_arrow(ax, 2.0, y + 0.3, 2.7, y + 0.3, lw=1.2)
|
||
draw_box(ax, 2.8, y - 0.3, 1.8, 1.2, 'Pretrained\nbackbone\n(ResNet)',
|
||
fill=GRAY3, fontsize=FS, fontweight='bold')
|
||
draw_arrow(ax, 4.7, y + 0.3, 5.3, y + 0.3, lw=1.2)
|
||
|
||
# Two heads from feature map
|
||
draw_box(ax, 5.4, y + 0.3, 1.6, 0.6, 'cls head\nP(klasa)', fill=GRAY4, fontsize=FS)
|
||
draw_box(ax, 5.4, y - 0.5, 1.6, 0.6, 'bbox head\nΔx,Δy,Δw,Δh', fill=GRAY4, fontsize=FS)
|
||
|
||
draw_arrow(ax, 7.1, y + 0.6, 7.7, y + 0.6, lw=1.0)
|
||
draw_arrow(ax, 7.1, y - 0.2, 7.7, y - 0.2, lw=1.0)
|
||
draw_box(ax, 7.8, y - 0.3, 1.0, 1.2, 'NMS', fill=GRAY1, fontsize=FS)
|
||
|
||
draw_arrow(ax, 8.9, y + 0.3, 9.3, y + 0.3, lw=1.2)
|
||
ax.text(10.2, y + 0.3, '5-155 fps!\n✓ NAJLEPSZE',
|
||
ha='center', fontsize=FS, fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.3', facecolor=GRAY2, edgecolor=GRAY3))
|
||
|
||
save_fig(fig, 'q24_detector_from_classifier.png')
|
||
|
||
|
||
# ============================================================
|
||
# 11. SVM Hyperplane
|
||
# ============================================================
|
||
def draw_svm_hyperplane():
|
||
fig, ax = plt.subplots(figsize=(6, 5))
|
||
ax.set_title('SVM — hiperpłaszczyzna i margines', fontsize=FS_TITLE,
|
||
fontweight='bold', pad=12)
|
||
|
||
np.random.seed(42)
|
||
# Class +1 (top-right)
|
||
x_pos = np.random.randn(15) * 0.5 + 3
|
||
y_pos = np.random.randn(15) * 0.5 + 3
|
||
ax.scatter(x_pos, y_pos, marker='o', s=50, facecolors='white',
|
||
edgecolors=LN, linewidths=1.5, label='klasa +1 (pieszy)', zorder=3)
|
||
|
||
# Class -1 (bottom-left)
|
||
x_neg = np.random.randn(15) * 0.5 + 1
|
||
y_neg = np.random.randn(15) * 0.5 + 1
|
||
ax.scatter(x_neg, y_neg, marker='x', s=50, c=LN, linewidths=1.5,
|
||
label='klasa -1 (tło)', zorder=3)
|
||
|
||
# Hyperplane (decision boundary)
|
||
x_line = np.linspace(-0.5, 5, 100)
|
||
y_line = -x_line + 4.0
|
||
ax.plot(x_line, y_line, 'k-', lw=2, label='hiperpłaszczyzna')
|
||
|
||
# Margin lines
|
||
ax.plot(x_line, y_line + 0.7, 'k--', lw=1, alpha=0.5)
|
||
ax.plot(x_line, y_line - 0.7, 'k--', lw=1, alpha=0.5)
|
||
|
||
# Margin annotation
|
||
ax.annotate('', xy=(2.5, 1.5 + 0.7), xytext=(2.5, 1.5 - 0.7),
|
||
arrowprops=dict(arrowstyle='<->', color=LN, lw=1.5))
|
||
ax.text(2.8, 1.5, 'margines\n(MAX!)', fontsize=FS, fontweight='bold')
|
||
|
||
# Support vectors (highlight closest points)
|
||
# Find points closest to the line
|
||
ax.scatter([2.5], [2.2], marker='o', s=120, facecolors='none',
|
||
edgecolors=LN, linewidths=2.5, zorder=4)
|
||
ax.scatter([1.5], [1.8], marker='x', s=120, c=LN, linewidths=2.5, zorder=4)
|
||
ax.annotate('support\nvectors', xy=(1.5, 1.8), xytext=(0.2, 3.0),
|
||
fontsize=FS, fontweight='bold',
|
||
arrowprops=dict(arrowstyle='->', color=LN, lw=1))
|
||
|
||
ax.set_xlim(-0.5, 5)
|
||
ax.set_ylim(-0.5, 5)
|
||
ax.set_xlabel('cecha 1 (np. gradient pionowy)', fontsize=FS)
|
||
ax.set_ylabel('cecha 2 (np. gradient poziomy)', fontsize=FS)
|
||
ax.legend(fontsize=FS_SMALL, loc='lower right')
|
||
ax.set_aspect('equal')
|
||
|
||
save_fig(fig, 'q24_svm_hyperplane.png')
|
||
|
||
|
||
# ============================================================
|
||
# 12. Two-stage vs One-stage comparison table
|
||
# ============================================================
|
||
def draw_two_vs_one_stage():
|
||
fig, ax = plt.subplots(figsize=(10, 3.5))
|
||
ax.set_xlim(0, 10)
|
||
ax.set_ylim(-0.5, 4.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('Two-stage vs One-stage — porównanie', fontsize=FS_TITLE,
|
||
fontweight='bold', pad=8)
|
||
|
||
headers = ['Cecha', 'Two-stage\n(Faster R-CNN)', 'One-stage\n(YOLO)']
|
||
rows = [
|
||
['Szybkość', '~5 fps', '45-155 fps'],
|
||
['Dokładność (mAP)', 'wyższa (historycznie)', 'dorównuje (YOLOv8)'],
|
||
['Małe obiekty', 'lepszy', 'gorszy (SSD/FPN pomaga)'],
|
||
['Architektura', '2 etapy + NMS', '1 etap + NMS'],
|
||
['Real-time?', 'NIE', 'TAK'],
|
||
]
|
||
col_widths = [2.5, 3.5, 3.5]
|
||
draw_table(ax, headers, rows, 0.2, 3.8, col_widths, row_h=0.65,
|
||
fontsize=FS, header_fontsize=FS)
|
||
|
||
save_fig(fig, 'q24_two_vs_one_stage.png')
|
||
|
||
|
||
# ============================================================
|
||
# 13. ROI Pooling illustration
|
||
# ============================================================
|
||
def draw_roi_pooling():
|
||
fig, axes = plt.subplots(1, 3, figsize=(12, 4))
|
||
fig.suptitle('ROI Pooling — dowolny rozmiar → stały rozmiar',
|
||
fontsize=FS_TITLE, fontweight='bold', y=1.02)
|
||
|
||
# Feature map with ROI
|
||
ax = axes[0]
|
||
# Draw feature map grid
|
||
fm = np.random.randint(0, 10, (8, 8))
|
||
ax.imshow(fm, cmap='gray', vmin=0, vmax=10, alpha=0.3)
|
||
for i in range(9):
|
||
ax.axhline(y=i-0.5, color=LN, lw=0.3)
|
||
ax.axvline(x=i-0.5, color=LN, lw=0.3)
|
||
# ROI rectangle
|
||
ax.add_patch(mpatches.Rectangle((1.5, 1.5), 4, 4, facecolor='none',
|
||
edgecolor=LN, lw=3, linestyle='-'))
|
||
ax.text(3.5, 0.8, 'ROI', ha='center', fontsize=FS_LABEL, fontweight='bold')
|
||
ax.set_xlim(-0.5, 7.5)
|
||
ax.set_ylim(7.5, -0.5)
|
||
ax.set_title('① Feature map\nz zaznaczonym ROI', fontsize=FS, fontweight='bold')
|
||
ax.set_xticks([])
|
||
ax.set_yticks([])
|
||
|
||
# ROI divided into grid
|
||
ax = axes[1]
|
||
roi_data = np.array([
|
||
[1, 3, 2, 1],
|
||
[0, 5, 1, 6],
|
||
[0, 4, 1, 0],
|
||
[7, 2, 9, 1],
|
||
])
|
||
ax.imshow(roi_data, cmap='gray', vmin=0, vmax=10)
|
||
for i in range(5):
|
||
ax.axhline(y=i-0.5, color=LN, lw=1)
|
||
ax.axvline(x=i-0.5, color=LN, lw=1)
|
||
# Grid lines for 2x2 pooling
|
||
ax.axhline(y=0.5, color=LN, lw=3, linestyle='--')
|
||
ax.axvline(x=0.5, color=LN, lw=3, linestyle='--')
|
||
for i in range(4):
|
||
for j in range(4):
|
||
ax.text(j, i, str(roi_data[i, j]), ha='center', va='center',
|
||
fontsize=10, fontweight='bold',
|
||
color='white' if roi_data[i, j] > 5 else 'black')
|
||
ax.set_title('② ROI podzielony\nna siatkę 2×2', fontsize=FS, fontweight='bold')
|
||
ax.set_xticks([])
|
||
ax.set_yticks([])
|
||
|
||
# Output after pooling
|
||
ax = axes[2]
|
||
out = np.array([[5, 6], [7, 9]])
|
||
ax.imshow(out, cmap='gray', vmin=0, vmax=10)
|
||
for i in range(3):
|
||
ax.axhline(y=i-0.5, color=LN, lw=1.5)
|
||
ax.axvline(x=i-0.5, color=LN, lw=1.5)
|
||
for i in range(2):
|
||
for j in range(2):
|
||
ax.text(j, i, str(out[i, j]), ha='center', va='center',
|
||
fontsize=14, fontweight='bold',
|
||
color='white' if out[i, j] > 5 else 'black')
|
||
ax.set_title('③ Po ROI Pool 2×2\n(max z każdej komórki)', fontsize=FS, fontweight='bold')
|
||
ax.set_xticks([])
|
||
ax.set_yticks([])
|
||
|
||
fig.tight_layout()
|
||
save_fig(fig, 'q24_roi_pooling.png')
|
||
|
||
|
||
# ============================================================
|
||
# 14. DETR Pipeline
|
||
# ============================================================
|
||
def draw_detr_pipeline():
|
||
fig, ax = plt.subplots(figsize=(11, 4.5))
|
||
ax.set_xlim(-0.5, 11.5)
|
||
ax.set_ylim(-1, 4.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('DETR — Transformer do detekcji (bez NMS, bez anchorów)',
|
||
fontsize=FS_TITLE, fontweight='bold', pad=12)
|
||
|
||
# Pipeline
|
||
draw_box(ax, 0, 1.5, 1.5, 1.5, 'Obraz\nwejściowy', fill=GRAY1, fontsize=FS)
|
||
draw_arrow(ax, 1.6, 2.25, 2.1, 2.25, lw=1.5)
|
||
|
||
draw_box(ax, 2.2, 1.5, 1.5, 1.5, 'CNN\nBackbone\n(ResNet)', fill=GRAY3,
|
||
fontsize=FS, fontweight='bold')
|
||
draw_arrow(ax, 3.8, 2.25, 4.3, 2.25, lw=1.5)
|
||
|
||
draw_box(ax, 4.4, 1.5, 1.8, 1.5, 'Transformer\nEncoder\n(self-attention)',
|
||
fill=GRAY2, fontsize=FS)
|
||
draw_arrow(ax, 6.3, 2.25, 6.8, 2.25, lw=1.5)
|
||
|
||
draw_box(ax, 6.9, 1.5, 1.8, 1.5, 'Transformer\nDecoder\n(N=100 queries)',
|
||
fill=GRAY2, fontsize=FS, fontweight='bold')
|
||
|
||
# Output branches
|
||
draw_arrow(ax, 8.8, 2.5, 9.5, 3.0, lw=1.2)
|
||
draw_box(ax, 9.6, 2.7, 1.5, 0.7, 'klasa₁...klasa₁₀₀', fill=GRAY4, fontsize=FS_SMALL)
|
||
|
||
draw_arrow(ax, 8.8, 2.0, 9.5, 1.5, lw=1.2)
|
||
draw_box(ax, 9.6, 1.2, 1.5, 0.7, 'bbox₁...bbox₁₀₀', fill=GRAY4, fontsize=FS_SMALL)
|
||
|
||
# Annotations
|
||
ax.text(7.8, 0.5, '100 object queries → 5 obiektów + 95× "brak"',
|
||
ha='center', fontsize=FS, style='italic',
|
||
bbox=dict(boxstyle='round,pad=0.3', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
ax.text(5.5, 0.0, 'Hungarian matching (trening): optymalne dopasowanie predykcji do GT',
|
||
ha='center', fontsize=FS_SMALL, style='italic',
|
||
bbox=dict(boxstyle='round,pad=0.2', facecolor=GRAY4, edgecolor=GRAY5))
|
||
|
||
# Big benefit box
|
||
ax.text(5.5, 4.0, 'BEZ anchorów • BEZ NMS • end-to-end • prosty pipeline',
|
||
ha='center', fontsize=FS, fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.3', facecolor=GRAY2, edgecolor=GRAY3))
|
||
|
||
save_fig(fig, 'q24_detr_pipeline.png')
|
||
|
||
|
||
# ============================================================
|
||
# 15. Sliding Window illustration
|
||
# ============================================================
|
||
def draw_sliding_window():
|
||
fig, axes = plt.subplots(1, 3, figsize=(12, 4))
|
||
fig.suptitle('Sliding Window — najprostsze podejście do detekcji',
|
||
fontsize=FS_TITLE, fontweight='bold', y=1.02)
|
||
|
||
# Multi-position
|
||
ax = axes[0]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 8, 6, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1.5))
|
||
# Grid of sliding windows
|
||
for i in range(4):
|
||
for j in range(3):
|
||
ax.add_patch(mpatches.Rectangle((i*1.8 + 0.2, j*1.8 + 0.2), 1.5, 1.5,
|
||
facecolor='none', edgecolor=LN, lw=0.6, linestyle='--'))
|
||
# Highlight current window
|
||
ax.add_patch(mpatches.Rectangle((2.0, 2.0), 1.5, 1.5, facecolor='none',
|
||
edgecolor=LN, lw=2.5))
|
||
ax.set_xlim(-0.5, 8.5)
|
||
ax.set_ylim(-0.5, 6.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('① Wiele pozycji\n(krok co 8 px)', fontsize=FS, fontweight='bold')
|
||
|
||
# Multi-scale
|
||
ax = axes[1]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 6, 5, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1.5))
|
||
sizes = [(0.8, 0.8), (1.5, 1.5), (2.5, 2.5), (3.5, 3.5)]
|
||
for i, (w, h) in enumerate(sizes):
|
||
ax.add_patch(mpatches.Rectangle((0.3 + i*0.3, 0.3 + i*0.3), w, h,
|
||
facecolor='none', edgecolor=LN, lw=1 + i*0.3,
|
||
linestyle=[':', '--', '-.', '-'][i]))
|
||
ax.text(3, 0, '4+ skal', ha='center', fontsize=FS_SMALL, fontweight='bold')
|
||
ax.set_xlim(-0.5, 6.5)
|
||
ax.set_ylim(-0.5, 5.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('② Wiele skal\n(obiekty mają różne rozmiary)', fontsize=FS,
|
||
fontweight='bold')
|
||
|
||
# Count
|
||
ax = axes[2]
|
||
ax.axis('off')
|
||
ax.set_xlim(0, 6)
|
||
ax.set_ylim(0, 5)
|
||
|
||
lines = [
|
||
('Obraz: 640 × 480 px', 4.5),
|
||
('Okno: 64 × 64 px, krok 8 px', 3.8),
|
||
('Pozycje: ~72 × 52 = 3 744', 3.1),
|
||
('× 5 skal = 18 720 okien', 2.4),
|
||
('× klasyfikacja = WOLNE!', 1.7),
|
||
('→ ~3h na jeden obraz', 0.8),
|
||
]
|
||
for text, yp in lines:
|
||
fw = 'bold' if '~3h' in text or 'WOLNE' in text else 'normal'
|
||
col = GRAY2 if 'WOLNE' in text or '~3h' in text else GRAY4
|
||
ax.text(3.0, yp, text, ha='center', fontsize=FS,
|
||
fontweight=fw,
|
||
bbox=dict(boxstyle='round,pad=0.2', facecolor=col, edgecolor=GRAY3))
|
||
|
||
ax.set_title('③ Dlaczego wolne?\n(miliony klasyfikacji)', fontsize=FS, fontweight='bold')
|
||
|
||
fig.tight_layout()
|
||
save_fig(fig, 'q24_sliding_window.png')
|
||
|
||
|
||
# ============================================================
|
||
# 16. FPN (Feature Pyramid Network)
|
||
# ============================================================
|
||
def draw_fpn():
|
||
fig, ax = plt.subplots(figsize=(9, 5))
|
||
ax.set_xlim(-0.5, 9.5)
|
||
ax.set_ylim(-0.5, 5.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('FPN (Feature Pyramid Network) — detekcja obiektów wszystkich rozmiarów',
|
||
fontsize=FS_TITLE, fontweight='bold', pad=12)
|
||
|
||
# Bottom-up (backbone)
|
||
levels = [
|
||
(0, 0, 2.0, 2.0, 'C2\n56×56', 'duże\ndetale'),
|
||
(0, 2.2, 1.5, 1.5, 'C3\n28×28', ''),
|
||
(0, 3.9, 1.0, 1.0, 'C4\n14×14', ''),
|
||
(0, 5.1, 0.6, 0.6, 'C5\n7×7', 'kontekst'),
|
||
]
|
||
|
||
for x, y, w, h, label, note in levels:
|
||
ax.add_patch(mpatches.Rectangle((x, y - h), w, h, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1.5))
|
||
ax.text(x + w/2, y - h/2, label, ha='center', va='center',
|
||
fontsize=FS_SMALL, fontweight='bold')
|
||
if note:
|
||
ax.text(x + w + 0.15, y - h/2, note, ha='left', va='center',
|
||
fontsize=5, style='italic')
|
||
|
||
ax.text(1.0, -0.3, 'Bottom-up\n(backbone)', ha='center', fontsize=FS,
|
||
fontweight='bold')
|
||
|
||
# Top-down + lateral
|
||
td_levels = [
|
||
(4.5, 5.1, 0.6, 0.6, 'P5'),
|
||
(4.5, 3.9, 1.0, 1.0, 'P4'),
|
||
(4.5, 2.2, 1.5, 1.5, 'P3'),
|
||
(4.5, 0, 2.0, 2.0, 'P2'),
|
||
]
|
||
|
||
for x, y, w, h, label in td_levels:
|
||
ax.add_patch(mpatches.Rectangle((x, y - h + h), w, h, facecolor=GRAY2,
|
||
edgecolor=LN, lw=1.5))
|
||
ax.text(x + w/2, y - h/2 + h, label, ha='center', va='center',
|
||
fontsize=FS_SMALL, fontweight='bold')
|
||
|
||
# Lateral connections
|
||
for (_, y1, w1, h1, _, _), (x2, y2, w2, h2, _) in zip(levels, td_levels):
|
||
draw_arrow(ax, w1 + 0.2, y1 - h1/2, x2 - 0.1, y2 + h2/2, lw=1, style='->')
|
||
|
||
# Top-down arrows
|
||
for i in range(len(td_levels) - 1):
|
||
x2, y2, w2, h2, _ = td_levels[i]
|
||
x3, y3, w3, h3, _ = td_levels[i + 1]
|
||
draw_arrow(ax, x2 + w2/2, y2, x3 + w3/2, y3 + h3 + 0.1, lw=1.2,
|
||
style='->', color=GRAY3)
|
||
|
||
ax.text(5.5, -0.3, 'Top-down + lateral\n(FPN)', ha='center', fontsize=FS,
|
||
fontweight='bold')
|
||
|
||
# Detection outputs
|
||
det_labels = ['małe obj.', 'średnie', 'duże', 'b. duże']
|
||
for i, (x, y, w, h, label) in enumerate(td_levels):
|
||
draw_arrow(ax, x + w + 0.1, y + h/2, 7.5, y + h/2, lw=0.8)
|
||
ax.text(7.7, y + h/2, f'detekcja:\n{det_labels[3-i]}', fontsize=FS_SMALL,
|
||
va='center')
|
||
|
||
save_fig(fig, 'q24_fpn.png')
|
||
|
||
|
||
# ============================================================
|
||
# 17. Anchor boxes
|
||
# ============================================================
|
||
def draw_anchor_boxes():
|
||
fig, ax = plt.subplots(figsize=(7, 5))
|
||
ax.set_title('Anchor boxes — predefiniowane kształty', fontsize=FS_TITLE,
|
||
fontweight='bold', pad=12)
|
||
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 6, 5, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1))
|
||
|
||
# Center point
|
||
cx, cy = 3, 2.5
|
||
ax.plot(cx, cy, 'ko', markersize=8, zorder=5)
|
||
ax.text(cx + 0.15, cy + 0.15, '(x, y)', fontsize=FS, fontweight='bold')
|
||
|
||
# 9 anchors: 3 sizes × 3 ratios
|
||
anchors = [
|
||
# (w, h, style, label)
|
||
(0.8, 0.8, '-', '1:1 small'),
|
||
(1.6, 1.6, '-', '1:1 medium'),
|
||
(2.4, 2.4, '-', '1:1 large'),
|
||
(0.6, 1.2, '--', '1:2 small'),
|
||
(1.2, 2.4, '--', '1:2 medium'),
|
||
(1.8, 3.6, '--', '1:2 large'),
|
||
(1.2, 0.6, ':', '2:1 small'),
|
||
(2.4, 1.2, ':', '2:1 medium'),
|
||
(3.6, 1.8, ':', '2:1 large'),
|
||
]
|
||
|
||
drawn = []
|
||
for w, h, ls, label in anchors:
|
||
rect = mpatches.Rectangle((cx - w/2, cy - h/2), w, h,
|
||
facecolor='none', edgecolor=LN,
|
||
lw=1.2, linestyle=ls)
|
||
ax.add_patch(rect)
|
||
|
||
# Legend-style labels
|
||
ax.text(3, -0.5, '9 anchorów = 3 rozmiary × 3 proporcje (1:1, 1:2, 2:1)\n'
|
||
'Sieć predykuje PRZESUNIĘCIE od najbliższego anchora',
|
||
ha='center', fontsize=FS, style='italic',
|
||
bbox=dict(boxstyle='round,pad=0.3', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
ax.set_xlim(-0.5, 6.5)
|
||
ax.set_ylim(-1.2, 5.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
|
||
save_fig(fig, 'q24_anchor_boxes.png')
|
||
|
||
|
||
# ============================================================
|
||
# 18. Detection task comparison
|
||
# ============================================================
|
||
def draw_detection_tasks():
|
||
fig, axes = plt.subplots(1, 3, figsize=(12, 4))
|
||
fig.suptitle('Klasyfikacja vs Detekcja vs Segmentacja',
|
||
fontsize=FS_TITLE, fontweight='bold', y=1.02)
|
||
|
||
# Classification
|
||
ax = axes[0]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 4, 4, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1.5))
|
||
# Simple cat silhouette
|
||
ax.add_patch(mpatches.Ellipse((2, 2), 2, 1.5, facecolor=GRAY3,
|
||
edgecolor=LN, lw=1))
|
||
ax.add_patch(mpatches.Ellipse((2, 3), 1, 0.8, facecolor=GRAY3,
|
||
edgecolor=LN, lw=1))
|
||
# Ears
|
||
ax.plot([1.6, 1.5, 1.8], [3.3, 3.8, 3.4], color=LN, lw=1.5)
|
||
ax.plot([2.2, 2.5, 2.4], [3.3, 3.8, 3.4], color=LN, lw=1.5)
|
||
ax.text(2, -0.4, '→ "KOT" (jedna etykieta)', ha='center',
|
||
fontsize=FS, fontweight='bold')
|
||
ax.set_xlim(-0.5, 4.5)
|
||
ax.set_ylim(-0.8, 4.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('Klasyfikacja\n(co?)', fontsize=FS, fontweight='bold')
|
||
|
||
# Detection
|
||
ax = axes[1]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 4, 4, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1.5))
|
||
# Cat
|
||
ax.add_patch(mpatches.Ellipse((1.2, 2), 1.2, 1, facecolor=GRAY3,
|
||
edgecolor=LN, lw=1))
|
||
ax.add_patch(mpatches.Ellipse((1.2, 2.8), 0.7, 0.5, facecolor=GRAY3,
|
||
edgecolor=LN, lw=1))
|
||
# Dog
|
||
ax.add_patch(mpatches.Ellipse((3, 1.5), 1.2, 1, facecolor=GRAY2,
|
||
edgecolor=LN, lw=1))
|
||
ax.add_patch(mpatches.Ellipse((3, 2.3), 0.7, 0.5, facecolor=GRAY2,
|
||
edgecolor=LN, lw=1))
|
||
# Bounding boxes
|
||
ax.add_patch(mpatches.Rectangle((0.3, 1.2), 1.8, 2.2, facecolor='none',
|
||
edgecolor=LN, lw=2.5))
|
||
ax.text(1.2, 3.5, 'KOT', ha='center', fontsize=FS_SMALL, fontweight='bold')
|
||
ax.add_patch(mpatches.Rectangle((2.1, 0.8), 1.7, 2.0, facecolor='none',
|
||
edgecolor=LN, lw=2.5))
|
||
ax.text(3.0, 2.9, 'PIES', ha='center', fontsize=FS_SMALL, fontweight='bold')
|
||
ax.text(2, -0.4, '→ bbox + klasa (N obiektów)', ha='center',
|
||
fontsize=FS, fontweight='bold')
|
||
ax.set_xlim(-0.5, 4.5)
|
||
ax.set_ylim(-0.8, 4.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('Detekcja\n(co? + gdzie?)', fontsize=FS, fontweight='bold')
|
||
|
||
# Segmentation
|
||
ax = axes[2]
|
||
ax.add_patch(mpatches.Rectangle((0, 0), 4, 4, facecolor=GRAY4,
|
||
edgecolor=LN, lw=1.5))
|
||
# Cat mask (detailed)
|
||
theta = np.linspace(0, 2*np.pi, 30)
|
||
cat_x = 1.2 + 0.6*np.cos(theta) + 0.1*np.sin(3*theta)
|
||
cat_y = 2 + 0.5*np.sin(theta) + 0.1*np.cos(2*theta)
|
||
ax.fill(cat_x, cat_y, facecolor=GRAY3, edgecolor=LN, lw=1.5)
|
||
# Dog mask
|
||
dog_x = 3.0 + 0.6*np.cos(theta) + 0.05*np.sin(4*theta)
|
||
dog_y = 1.5 + 0.5*np.sin(theta) + 0.08*np.cos(3*theta)
|
||
ax.fill(dog_x, dog_y, facecolor=GRAY2, edgecolor=LN, lw=1.5)
|
||
ax.text(1.2, 2, 'KOT', ha='center', fontsize=FS_SMALL, fontweight='bold')
|
||
ax.text(3.0, 1.5, 'PIES', ha='center', fontsize=FS_SMALL, fontweight='bold')
|
||
ax.text(2, -0.4, '→ maska pikseli (per piksel)', ha='center',
|
||
fontsize=FS, fontweight='bold')
|
||
ax.set_xlim(-0.5, 4.5)
|
||
ax.set_ylim(-0.8, 4.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('Segmentacja\n(dokładna maska)', fontsize=FS, fontweight='bold')
|
||
|
||
fig.tight_layout()
|
||
save_fig(fig, 'q24_detection_tasks.png')
|
||
|
||
|
||
# ============================================================
|
||
# 19. CNN Architecture overview
|
||
# ============================================================
|
||
def draw_cnn_architecture():
|
||
fig, ax = plt.subplots(figsize=(12, 4))
|
||
ax.set_xlim(-0.5, 12.5)
|
||
ax.set_ylim(-1, 4.5)
|
||
ax.set_aspect('equal')
|
||
ax.axis('off')
|
||
ax.set_title('CNN — od obrazu do predykcji (architektura)', fontsize=FS_TITLE,
|
||
fontweight='bold', pad=12)
|
||
|
||
# Input image
|
||
draw_box(ax, 0, 0.5, 1.5, 3, 'Obraz\n224×224×3', fill=GRAY1, fontsize=FS)
|
||
|
||
# Conv1
|
||
draw_arrow(ax, 1.6, 2.0, 2.1, 2.0, lw=1.2)
|
||
draw_box(ax, 2.2, 0.8, 1.2, 2.4, 'Conv1\n+ReLU\n55×55×96', fill=GRAY4, fontsize=FS_SMALL)
|
||
|
||
# Pool1
|
||
draw_arrow(ax, 3.5, 2.0, 3.9, 2.0, lw=1.2)
|
||
draw_box(ax, 4.0, 1.0, 1.0, 2.0, 'Pool\n27×27\n×96', fill=GRAY2, fontsize=FS_SMALL)
|
||
|
||
# Conv2
|
||
draw_arrow(ax, 5.1, 2.0, 5.5, 2.0, lw=1.2)
|
||
draw_box(ax, 5.6, 0.8, 1.2, 2.4, 'Conv2\n+ReLU\n27×27\n×256', fill=GRAY4, fontsize=FS_SMALL)
|
||
|
||
# Pool2
|
||
draw_arrow(ax, 6.9, 2.0, 7.3, 2.0, lw=1.2)
|
||
draw_box(ax, 7.4, 1.2, 0.8, 1.6, 'Pool\n13×13\n×256', fill=GRAY2, fontsize=FS_SMALL)
|
||
|
||
# More conv...
|
||
draw_arrow(ax, 8.3, 2.0, 8.7, 2.0, lw=1.2)
|
||
ax.text(9.0, 2.0, '...', fontsize=14, ha='center', va='center')
|
||
draw_arrow(ax, 9.3, 2.0, 9.7, 2.0, lw=1.2)
|
||
|
||
# FC
|
||
draw_box(ax, 9.8, 1.2, 1.0, 1.6, 'FC\n4096', fill=GRAY3, fontsize=FS)
|
||
|
||
draw_arrow(ax, 10.9, 2.0, 11.3, 2.0, lw=1.2)
|
||
|
||
# Output
|
||
draw_box(ax, 11.4, 1.5, 1.0, 1.0, 'Softmax\n1000 klas', fill=GRAY1, fontsize=FS_SMALL)
|
||
|
||
# Annotations below
|
||
ax.text(3.0, 0.0, 'rozmiar maleje\n224→55→27→13→6', ha='center', fontsize=FS_SMALL,
|
||
style='italic')
|
||
ax.text(6.0, 0.0, 'kanały rosną\n3→96→256→384', ha='center', fontsize=FS_SMALL,
|
||
style='italic')
|
||
ax.text(10.0, 0.0, 'decyzja\nkońcowa', ha='center', fontsize=FS_SMALL,
|
||
style='italic')
|
||
|
||
# hierarchy
|
||
ax.text(6.0, 4.0, 'Hierarchia: krawędzie → rogi → fragmenty → obiekty (K-R-F-O)',
|
||
ha='center', fontsize=FS, fontweight='bold',
|
||
bbox=dict(boxstyle='round,pad=0.3', facecolor=GRAY4, edgecolor=GRAY3))
|
||
|
||
save_fig(fig, 'q24_cnn_architecture.png')
|
||
|
||
|
||
# ============================================================
|
||
# MAIN
|
||
# ============================================================
|
||
if __name__ == '__main__':
|
||
print("Generating PYTANIE 24 diagrams...")
|
||
draw_hog_svm_pipeline()
|
||
draw_hog_gradient_steps()
|
||
draw_viola_jones_cascade()
|
||
draw_haar_features()
|
||
draw_integral_image()
|
||
draw_rcnn_evolution()
|
||
draw_yolo_grid()
|
||
draw_iou_diagram()
|
||
draw_nms_steps()
|
||
draw_detector_from_classifier()
|
||
draw_svm_hyperplane()
|
||
draw_two_vs_one_stage()
|
||
draw_roi_pooling()
|
||
draw_detr_pipeline()
|
||
draw_sliding_window()
|
||
draw_fpn()
|
||
draw_anchor_boxes()
|
||
draw_detection_tasks()
|
||
draw_cnn_architecture()
|
||
print("\nAll PYTANIE 24 diagrams generated!")
|