프로젝트 1 — 경계 검출 알고리즘 비교 보고서

import time
import cv2
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Malgun Gothic"
plt.rcParams["axes.unicode_minus"] = False

names = ["shapes", "parts", "letters"]
levels = [0, 15, 30]
images, answers = {}, {}
for n in names:
    # 요구사항 1: 그림과 정답 경계를 짝지어 흑백으로 읽는다
    images[n] = cv2.imread(f"ch11_set/{n}.png", cv2.IMREAD_GRAYSCALE)
    answers[n] = cv2.imread(f"ch11_set/{n}_edge.png", cv2.IMREAD_GRAYSCALE)
    print(f"{n:7}: 모양 {images[n].shape}, 정답 경계 칸 비율 {round(float((answers[n] > 0).mean()), 3)}")

# 요구사항 2: 씨앗 하나로 고정하고, 그림·노이즈 단계마다 노이즈 낀 그림을 한 번만 만든다
rng = np.random.default_rng(1130)
noisy = {}
for n in names:
    for s in levels:
        if s == 0:
            noisy[(n, s)] = images[n]
        else:
            noisy[(n, s)] = np.clip(images[n].astype(np.float64) + rng.normal(0, s, images[n].shape),
                                    0, 255).astype(np.uint8)
print("만든 그림:", len(noisy), "장")

# 요구사항 3: 세 방법 모두 5×5 가우시안 블러를 먼저 한다
def sobel_edges(gray):
    b = cv2.GaussianBlur(gray, (5, 5), 0)
    gx = cv2.Sobel(b, cv2.CV_64F, 1, 0)
    gy = cv2.Sobel(b, cv2.CV_64F, 0, 1)
    return np.where(cv2.magnitude(gx, gy) > 100, 255, 0).astype(np.uint8)

def laplacian_edges(gray):
    b = cv2.GaussianBlur(gray, (5, 5), 0)
    return np.where(np.abs(cv2.Laplacian(b, cv2.CV_64F)) > 20, 255, 0).astype(np.uint8)

def canny_edges(gray):
    b = cv2.GaussianBlur(gray, (5, 5), 0)
    return cv2.Canny(b, 50, 150)

methods = {"Sobel": sobel_edges, "Laplacian": laplacian_edges, "Canny": canny_edges}

def edge_score(edges, answer):
    """허용 거리 1칸으로 (정밀도, 재현율, F1) 을 돌려준다(본문의 함수)."""
    kernel = np.ones((3, 3), np.uint8)
    found, real = edges > 0, answer > 0
    precision = (found & (cv2.dilate(answer, kernel) > 0)).sum() / max(found.sum(), 1)
    recall = (real & (cv2.dilate(edges, kernel) > 0)).sum() / real.sum()
    f1 = 2 * precision * recall / (precision + recall) if precision + recall > 0 else 0.0
    return round(float(precision), 3), round(float(recall), 3), round(float(f1), 3)

# 깨끗한 도형 그림으로 세 방법이 잘 도는지 먼저 본다
for name, func in methods.items():
    print(f"{name:9}: {edge_score(func(images['shapes']), answers['shapes'])}")

rows, outputs = [], {}
for n in names:
    for s in levels:
        for name, func in methods.items():
            e = func(noisy[(n, s)])
            outputs[(n, s, name)] = e
            p, r, f = edge_score(e, answers[n])
            rows.append({"그림": n, "노이즈": s, "방법": name, "정밀도": p, "재현율": r, "F1": f})

report = pd.DataFrame(rows)
# 요구사항 4: 그림·노이즈·방법마다의 점수
print(report.to_string(index=False))

# 노이즈 단계마다 방법별 평균 F1
mean_f1 = report.pivot_table(index="노이즈", columns="방법", values="F1").round(3)
print()
print("[노이즈 단계마다 방법별 평균 F1]")
print(mean_f1[list(methods)])

# 요구사항 5: 도형 그림 한 장을 100 번 처리한 평균 시간(밀리초)
times = {}
for name, func in methods.items():
    func(images["shapes"])                    # 첫 실행의 준비 시간을 빼려고 한 번 먼저 돌린다
    start = time.perf_counter()
    for _ in range(100):
        func(images["shapes"])
    times[name] = (time.perf_counter() - start) / 100 * 1000
for name in methods:
    print(f"{name:9}: {round(times[name], 3)} ms, Canny 의 {round(times[name] / times['Canny'], 1)}배")

fig, axes = plt.subplots(len(names), 4, figsize=(10, 6))
for i, n in enumerate(names):
    panels = [("노이즈 30 그림", noisy[(n, 30)])] + [(name, outputs[(n, 30, name)]) for name in methods]
    for j, (title, im) in enumerate(panels):
        axes[i, j].imshow(im, cmap="gray", vmin=0, vmax=255)
        if i == 0:
            axes[i, j].set_title(title)
        axes[i, j].set_xticks([])
        axes[i, j].set_yticks([])
    axes[i, 0].set_ylabel(n)
plt.tight_layout()
# 요구사항 6: 저장을 먼저 하고 띄운다. 큰 격자라 jpg 로
plt.savefig("out_ch11_compare.jpg", dpi=80)
print("저장: out_ch11_compare.jpg")
plt.show()

# 결론을 쓰기 전에 하나 더 확인한다: 노이즈가 많을 때 Canny 의 기준값을 올리면 어떻게 될까
for n in names:
    b = cv2.GaussianBlur(noisy[(n, 30)], (5, 5), 0)
    for low, high in [(50, 150), (100, 200)]:
        print(f"{n:7} Canny {low:3}, {high}: {edge_score(cv2.Canny(b, low, high), answers[n])}")