영상처리 기술, 그 이야기

import cv2
import cv2.aruco as aruco

# 기본 카메라 열기
cap = cv2.VideoCapture(0)

# ArUco 사전(Dictionary) 선택
aruco_dict = aruco.getPredefinedDictionary(aruco.DICT_4X4_50)

# 마커 검출 파라미터 생성
parameters = aruco.DetectorParameters()

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # 그레이스케일 변환 (검출 성능 향상)
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # ArUco 마커 검출
    corners, ids, rejected = aruco.detectMarkers(
        gray, aruco_dict, parameters=parameters
    )

    # 마커가 검출된 경우
    if ids is not None:
        # 검출된 마커 테두리와 ID 시각화
        aruco.drawDetectedMarkers(frame, corners, ids)
        print("Detected IDs:", ids.flatten())

    cv2.imshow("ArUco Marker Detection", frame)

    # ESC 키 입력 시 종료
    if cv2.waitKey(1) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

• 아래 마커는 DICT 4X4_50 마커이며, 웹켐 연결 되어 있는 PC에서 위 예제 코드를 이용하여 쉽게 테스트 해 볼 수 있습니다.

import cv2 as cv

# 그래프 입력 정의
in_gmat = cv.GMat()

# 그래프 연산 정의
gray = cv.gapi.RGB2Gray(in_gmat)
edges = cv.gapi.Canny(gray, 50, 150)

# 그래프 컴파일
graph = cv.GComputation(cv.GIn(in_gmat), cv.GOut(edges))

# 이미지 로드
input_img = cv.imread("input.jpg")

# 그래프 실행
output = graph.apply(cv.gin(input_img))

# 결과 출력
cv.imshow("G-API Edges", output)
cv.waitKey(0)
cv.destroyAllWindows()

처리 결과는 아래와 같이 원본 이미지와 처리 이미지이며 속도에 최적화 되어 있습니다. Canny Edge 결과를 볼 수 있습니다.

엣지 컴퓨팅은 데이터를 중앙 서버나 클라우드가 아닌 ‘데이터가 발생하는 지점(Edge)’에서 직접 처리하는 기술입니다. 카메라, IoT 센서, 임베디드 기기(라즈베리파이 등)와 같은 엣지 디바이스에서 데이터를 실시간 처리함으로써 다음과 같은 장점이 있습니다.

• 지연(Latency) 감소 → 실시간 처리 가능
• 대역폭 절약 → 서버 전송 데이터 최소화
• 보안 강화 → 민감한 영상이 클라우드로 가지 않음
• 운영 비용 절감 → 클라우드 사용량 감소

OpenCV는 가벼우면서도 빠르게 동작해 엣지 디바이스에서도 효율적으로 실행할 수 있으므로 엣지 컴퓨팅 환경에서 가장 널리 사용되는 컴퓨터 비전 라이브러리입니다.

엣지 컴퓨팅에서 자주 사용하는 OpenCV 핵심 기능 설명

1. 이미지 전처리(Image Preprocessing)

엣지 장치에서는 빠른 연산이 중요하기 때문에 간단하면서도 효율적인 필터/변환을 많이 사용합니다.

• cv2.resize() : 이미지 크기 축소/확대
• cv2.cvtColor() : BGR ↔ Gray, HSV 변환
• cv2.GaussianBlur() : 노이즈 제거
• cv2.threshold() : 이진화 처리

2. 객체 감지(Object Detection)

엣지 환경에서는 가벼운 알고리즘이 사용됩니다.

• Haar Cascade (cv2.CascadeClassifier)
• HOG + SVM (cv2.HOGDescriptor())
• MobileNet-SSD 등 경량 DNN 모델 (cv2.dnn)

3. 영상 스트리밍 처리

엣지 디바이스 카메라에서 실시간 프레임 처리를 지향합니다.

• cv2.VideoCapture(0) : 카메라 입력
• cv2.imencode() : 네트워크 전송용 포맷 변환
• cv2.imshow() : 디스플레이용

4. OpenCV DNN 모듈 활용 (경량 모델)

엣지 환경에서는 TensorFlow Lite, ONNX Runtime과 함께 가벼운 모델을 로드해 inference를 수행합니다.

• cv2.dnn.readNetFromONNX()
• cv2.dnn.blobFromImage()
• net.forward()

5. 라즈베리파이, Jetson Nano 등에서 최적화

• OpenCV 빌드 시 NEON, VFPV3 활성화
• cv2.setNumThreads(2)로 CPU 사용량 제한
• GPU가 있다면 CUDA 지원 OpenCV 사용

엣지 컴퓨팅에서 OpenCV 사용 예제

첫번째 예는 라즈베리파이에서 실시간 얼굴 검출이며, 두번째는 MobileNet을 이용한 경량 객체 검출, 세번째는 영상 압축 후 서버 전송 파이썬 예제 입니다.

import cv2

# Haar Cascade 불러오기
cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")

# 카메라 영상 읽기
cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    faces = cascade.detectMultiScale(gray, 1.3, 5)

    for (x, y, w, h) in faces:
        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)

    cv2.imshow("Edge Face Detection", frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import cv2
import numpy as np

# MobileNet-SSD 로드
net = cv2.dnn.readNetFromCaffe(
    "deploy.prototxt",
    "mobilenet_ssd.caffemodel"
)

cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()

    blob = cv2.dnn.blobFromImage(frame, 0.007843, (300, 300), 127.5)
    net.setInput(blob)
    detections = net.forward()

    for i in range(detections.shape[2]):
        confidence = detections[0, 0, i, 2]
        if confidence & 0.4:
            box = detections[0, 0, i, 3:7] * np.array(
                [frame.shape[1], frame.shape[0], frame.shape[1], frame.shape[0]]
            )
            (startX, startY, endX, endY) = box.astype("int")

            cv2.rectangle(frame, (startX, startY), (endX, endY), (255, 0, 0), 2)

    cv2.imshow("Edge Object Detection", frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import cv2
import requests

cap = cv2.VideoCapture(0)

SERVER_URL = "http://server-ip/upload"

while True:
    ret, frame = cap.read()

    # JPEG 압축
    _, buffer = cv2.imencode('.jpg', frame)
    files = {'image': buffer.tobytes()}

    # 서버로 전송
    requests.post(SERVER_URL, files=files)

엣지 컴퓨팅 환경에서는 속도·경량화·실시간 처리가 핵심이며, OpenCV는 이러한 요구에 적합한 기능을 제공합니다. 라즈베리파이, Jetson, ARM 기반 보드 등 다양한 엣지 디바이스에서 OpenCV를 활용하여 객체 감지, 영상 처리, DNN 추론 등의 다양한 작업을 효율적으로 수행할 수 있습니다.

프로세스 마이닝은 시스템에 남겨진 로그 등의 과거 데이터를 통해 업무 프로세스가 어떻게 이뤄지는지 분석하고 비교하여 최적화 할 수 있는 분석 기법이라고 했습니다. 기본적인 설명은 이전 블로그 링크를 참고해 보시면 좋을 것 같습니다.

2025.11.09 - [프로그래밍 기술] - 데이터 분석 프로세스 마이닝 (Process Mining) 개요

실제 이벤트 로그를 이용하여 프로세스 모델을 만들고 시각화하는 예제를 파이썬 라이브러리인 PM4Py를 통해 설명하겠습니다. PM4Py(Process Mining for Python)는 오픈소스 프로세스 마이닝 라이브러리이며, 이벤트 로그로부터 프로세스 모델 생성, 시각화, 적합성 검사, 병목 분석 및 KPI분석을 지원합니다.

설치는 pip을 이용하며, 윈도우와 맥, 리눅스 모두를 지원합니다.

• pip install pm4py 

아래는 이벤트 로그를 활용한 PM4Py의 가단한 예제입니다. 로그는 CSV 포맷으로 로드됩니다. 주위할 점은 로그를 구성할 때 “case_id”, “activity”, “timestamp”는 필수적으로 존재해야 합니다. 프로세스 마이닝의 개념 자체가 시간 흐름에 따른 활동 분석이 목적이기 때문입니다. 모델 생성 알고리즘은 다양하며, 예제에서는 휴리스틱 마이너(Heuristic Miner) 방법을 사용했습니다. 휴리스틱 마이너 방법은 실제 로그에 담겨진 정보에 누락이나 오류, 반복과 드문 경로 등이 존재할 때 좋은 성능을 낼 수 있는 방법으로 알려져 있습니다.

# 이벤트 로그(CSV)로부터 프로세스 모델 생성 및 시각화
import pm4py

# 1. event log read ----------------------
log = pm4py.read_csv('event_log.csv')

# 2. column name define ------------------
log = pm4py.format_dataframe(
    log,
    case_id='case_id',
    activity_key='activity',
    timestamp_key='timestamp'
)

# 3. process discovery (Heuristic Miner) ---
net, im, fm = pm4py.discover_petri_net_heuristics(log)

# 4. model display -------------------------
# 각 activity를 노드로 표시하고 실제 실행 경로를 기반으로 연결선 표시
pm4py.view_petri_net(net, im, fm)

# 5. process map display ------------------
# 각 activity 간 이동 횟수, 평군 시간 등 시간적 요약
pm4py.view_process_map(log)

추가로 아래는 기존 모델과 실제 로그를 비교해 위반 탐지를 위한 적합성 검사(Conformance Checking)와 각 활동 간 평균 처리시간 계산(Throughput Time)을 위한 예제 코드입니다. 

# Conformance Checking (규정 위반 탐지)
from pm4py.algo.conformance.tokenreplay import algorithm as token_replay

replayed_traces = token_replay.apply(log, net, im, fm)
print(replayed_traces)

# Throughput time (각 활동 평균 처리 시간)
from pm4py.statistics.traces.generic.log import case_statistics

durations = case_statistics.get_all_case_durations(log, parameters={"timestamp_key": "timestamp"})
print("평균 처리시간:", sum(durations)/len(durations))

유전 알고리즘(GA)은 최적화 문제에 활용될 수 있습니다. 당연히 영상처리 기술들에도 적용이 가능하며, 윤곽선 검출에 대표 기술 중에 하나인 캐니 엣지 탐색(Canny Edge Detection)에 적용해 보겠습니다. 캐니 엣지 탐색 방법에서는 윤곽선 검출을 위해 두 개의 임계값인 Threshold1과 Threshold2를 사용하며, Threshold1 이하는 엣지가 아닌 영역이며 Threshold2 이상은 엣지영역으로 구분하고 Thresholds의 사이는 Canny Procedure에 의해 엣지 유무를 판단하게 됩니다.

2025.10.26 - [영상처리 기술] - 영상처리 유전 알고리즘 Genetic Algorithm 이해

2018.01.15 - [영상처리 도구] - OpenCV 윤곽선 검출 Edge Detection

유전 알고리즘의 기본과 윤곽선 검출에 대해서는 기존 블로그를 참고해 보시면 도움이 될 수 있습니다. 아래는 OpenCV와 파이썬을 활용한 캐니 엣지 탐색 알고리즘의 파라미터 Threshold1과 Threshold2 최적화 예제입니다. 개체(염색체)는 [Threshold1, Threshold2]로 설정이 되고 적합도(Fitness) 평가에는 당연히 캐니 엣지 탐색 방법과 그 윤곽선 수로 Score를 계산합니다.

기존 블로그에서도 언급을 했지만 반복 수행을 통해 최적해를 찾는 점과 교차율과 돌연변이율 등 매개변수 설정이 있다는 것은 설정 차이를 통해 Solution에 차이가 생길 수 있다는 점을 인식해야 하며 이런 이유로 항상 최적해를 보장하지 않는다는 점을 알고 유전 알고리즘을 활용해야 합니다.

import cv2
import numpy as np
import random

# ------- gray image read  ---------
img = cv2.imread('image.tif', cv2.IMREAD_GRAYSCALE)

# ------ 1. fitness define ------------
def fitness(threshold1, threshold2):
    edges = cv2.Canny(img, threshold1, threshold2)
    score = np.sum(edges > 0) # total number of edges
    return score

# --------2. initialization --------------
def random_chromosome():
    return [random.randint(0, 100), random.randint(100, 255)]  # [t1, t2]

population_size = 20
population = [random_chromosome() for _ in range(population_size)]

# ------ 3. GA parameters --------------
generations = 30
mutation_rate = 0.2

# ------- 4. repetition ----------------
for gen in range(generations):
    fitness_scores = [fitness(ch[0], ch[1]) for ch in population] # fitness calc.
    
    # selection (선택)
    sorted_pop = [x for _, x in sorted(zip(fitness_scores, population), reverse=True)]
    parents = sorted_pop[:int(population_size/2)]

    # Crossover (교차)
    children = []
    while len(children) < population_size - len(parents):
        p1, p2 = random.sample(parents, 2)
        cross_point = random.randint(0, 1)
        child = p1[:cross_point+1] + p2[cross_point+1:]
        children.append(child)
    
    # Mutation (돌연변이)
    for child in children:
        if random.random() < mutation_rate:
            idx = random.randint(0, 1)
            child[idx] = random.randint(0, 255)
    
    # Replacement (대체)
    population = parents + children

    # best sol
    best_fit = max(fitness_scores)
    best_chrom = population[np.argmax(fitness_scores)]
    print(f"세대 {gen+1}: 최고점 ={best_fit}, 임계값={best_chrom}")

# ------- display --------------------
best_t1, best_t2 = best_chrom
best_edge = cv2.Canny(img, best_t1, best_t2)

cv2.imshow("Canny Best Edges", best_edge)
cv2.waitKey(0)
cv2.destroyAllWindows()

위너필터는 신호처리와 영상처리 시 잡음을 제거하고 원래 신호를 복원할 때 사용하는 적응형 필터 중에 하나 입니다. 1949년 Norbert Wiener가 제안한 방법으로 프로세스 사이의 평균제곱오차(Mean Square Error)를 최소화 합니다. 위너 필터는 주파수 영역에서 계산되며 저주파에서는 실제 영상의 정보가 많기 때문에 보존하고 고주파에서는 잡음이 많을 가능성이 있기 때문에 억제 합니다. 결국 주파수별 신화와 잡음비(SNR)에 따라 가변적으로 동작하는 적응형 필터라고 말할 수 있습니다.

이미지에 블러링 효과와 잡음이 동시에 결합된 경우에 많이 사용됩니다. 블러(흐림) 전달함수를 H, H의 켤레복소수 H*, 잡음의 파워 스펙트럼 Snn, 원영상의 파워 스펙트럼 Sxx라고 할 때 수식은 아래의 같습니다.

특징으로는 신호대 잡음비(SNR)의 통계적 특성을 고려한 최적의 적응형 필터이며 영상의 복원과 잡음제거에 대표적인 필터 중에 하나 입니다. 반대로 신호대 잡음의 스펙트럼 정보를 미리 알아야 한다는 점은 단점으로 실제 영상처리에서 정확한 스펙트럼을 알기 어려워 근사치를 사용하게 됩니다.

수학적 접근으로 간략히 정리해 보면, 어떤 공간에서 선형적인 움직임과 잡음을 포함한 이미지를 g라고 해보겠습니다. 원래 이미지를 f, 움직임에 대한 효과(PSF)를 h, 잡음을 n이라고 하면 아래와 같이 표현됩니다. 푸리에 주파수 영역으로 변환을 하면 각 G, H, F, N으로 표현될 수 있습니다.

g(x,y) = h(x,y)*f(x,y) + h(x,y) → G(u,v) = H(u,v)F(u,v) + N(u,v)

목표는 위너 필터를 W라고 했을 때, F’(u,v) = W(u,v)G(u,v)에 평균제곱오차(MSE)를 최소화하는 것입니다. 중간 과정은 제외하면 최종적으로 아래 수식을 구하게 됩니다. 

앞에 언급했듯이 입력으로 들어오는 잡음비를 정확히 알 수 없으므로 실무에서는 Sn/Sf (Snn/Sxx)를 상수 K로 두고 근사값으로 적용합니다. 아래는 위너 필터에 대한 Python 예제 코드니 살펴 보시면 이해에 도움이 될 수 있으며, 코드에서는 Noise/Signal 비율 K가 0.01이 적용되었습니다.

# wiener filter example ------------------------------
import cv2
import numpy as np
import matplotlib.pyplot as plt

# image read -----------------------------------------
img = cv2.imread("image.tif", cv2.IMREAD_GRAYSCALE)
img = img.astype(np.float32) / 255.0 # 0~1 normalization

# blur PSF --------------------------------------------
def motion_blur_psf(length, angle, shape): 
psf = np.zeros(shape, dtype=np.float32) 
center = (shape[0] // 2, shape[1] // 2) 
x = np.linspace(-length // 2, length // 2, length) 
y = np.zeros_like(x) 
coords = np.vstack((x, y)).T 
rot = cv2.getRotationMatrix2D((0, 0), angle, 1) # rotation effect
coords = coords @ rot[:, :2].T 
for (dx, dy) in coords.astype(int): 
px, py = int(center[0] + dx), int(center[1] + dy) 
if 0 <= px < shape[0] and 0 <= py < shape[1]: 
psf[px, py] = 1 
psf /= psf.sum()  
return psf
psf = motion_blur_psf(15, 30, img.shape)

# noise -----------------------------------------------
H = np.fft.fft2(np.fft.ifftshift(psf)) # PSF - FFT
G_blur = np.fft.ifft2(np.fft.fft2(img) * H).real
noise = np.random.normal(0, 0.01, img.shape)
g = np.clip(G_blur + noise, 0, 1)

# wiener -----------------------------------
def wiener_filter(G, H, K): 
H_conj = np.conj(H) 
return (H_conj / (np.abs(H)**2 + K)) * G

G = np.fft.fft2(g) # fft transform
K = 0.01 # NSR (Noise-to-Signal Ratio)
F_hat = wiener_filter(G, H, K)

f_hat = np.fft.ifft2(F_hat).real # inverse fft
f_hat = np.clip(f_hat, 0, 1)

# display ---------------------------
plt.figure(figsize=(12,4))
plt.subplot(1,3,1), plt.imshow(img, cmap="gray"), plt.title("Original"), plt.axis("off")
plt.subplot(1,3,2), plt.imshow(g, cmap="gray"), plt.title("Blur + Noise"), plt.axis("off")
plt.subplot(1,3,3), plt.imshow(f_hat, cmap="gray"), plt.title("Wiener Restored"), plt.axis("off")
plt.show()

칼만 필터는 어떤 시스템에 잡음이 포함되어 있는 측정치에 기반하여 상태를 추정하는 재귀 필터라고 했습니다. 기본적인 내용은 이전 블로그 2025.08.24 - [영상처리 기술] - 칼만 필터 Kalman Filter 이해와 활용(1) 를 먼저 참고해 보시면 이해하기 쉬울 듯 합니다.

어떤 움직이는 물체를 모델로 해서 위치를 추정해 보는 예를 살펴보겠습니다. 기본적으로 칼만 필터의 수행은 예측(Prediction), 측정(Measurement), 그리고 추정(Update)의 반복이라고 했습니다. 우리가 추적하고 싶은 물체는 아래와 같은 초기 조건로 가정합니다.

(초기 조건)

• 시작 추정 위치 x_0 = 10 m
• 초기 오차 P_0 = 1.0
• 속도 u = 1.0 m/s
• 시간 간격 Δt = 1.0 s
• 프로세스 노이즈 Q = 0.1
• 측정 노이즈 R = 0.5 (GPS 오차)
• 첫 번째 GPS 측정값 z_1 = 11.2, 두 번째 GPS 측정값 z_2 = 12.4
• 상태 전이 모델(상태 공간 모형) x_k = x_k-1 + u·Δt 

첫 번째 계산 (첫 번째 루프)

1) 예측: 

• (위치) x’_1 = x_0 + u·Δt = 10m + 1.0m/s * 1.0s = 11.0m
• (오차 공분산) P’_1 = P_0 + Q = 1.0 + 0.1 = 1.1

2) 측정 및 업데이트

• (칼만 이득) K_1 = P’_1 / (P’_1+R) = 1.1 / (1.1+0.5) = 0.6875
• (위치) x_1 = x’_1+K_1(z_1-x’_1) = 11.0+0.6875(11.2-11.0) = 11.1375
• (오차 공분산) P_1=(1-K_1)*P’_1 = (1-0.6875)*1.1 = 0.34375

두 번째 계산 (두 번째 루프)

1) 예측

• (위치) x’_2 = x_1 + u·Δt = 11.1375 + 1.0 = 12.1375
• (오차 공분산) P’_2 = P_1 + Q = 0.34375 + 0.1 = 0.44375

2) 측정 및 업데이트

• (칼만 이득) K_2 = 0.44375 / (0.44375 + 0.5) = 0.4702
• (위치) x_2 = 12.1375 + 0.4702*(12.4-12.1375) = 12.261
• (오차 공분산) P_2 = (1-0.4702)*0.44375 = 0.235 

첫 번째 1초 후 추정 위치 x는 11.1375m, 오차 P는 0.34375, 두 번째 2초 후에는 추정 위치 12.261m, 오차 P는 0.235로 계산 되었고 시간에 따라 오차가 작아지는 것을 알 수 있습니다. 이는 추정 신뢰도가 상승 한다는 의미로도 볼 수 있습니다. 아래는 위 예제의 1차원 위치 추정을 위한 칼만 필터 파이썬 코드니 테스트 해보시면 이해하는데 도움이 될 수 있습니다.

# Kalman Filter 1D Exmaple
import numpy as np
import matplotlib.pyplot as plt

num_steps = 10
true_position = 10.0
velocity = 1.0 # 속도

process_noise = 0.1   # 프로세스 노이즈 Q
measurement_noise = 0.5  # 센서 노이즈 R

# 초기 추정값
x_est = 10.0  # 추정 위치
P = 1.0       # 추정 오차 공분산

true_positions = [true_position]
measured_positions = []
estimated_positions = [x_est]
errors = [P]

# Kalman Filter Loop
for step in range(1, num_steps + 1):
    # 실제 위치 업데이트 (노이즈 없는 이동)
    true_position += velocity
    true_positions.append(true_position)

    # 측정값 (노이즈 포함 GPS)
    z = true_position + np.random.normal(0, np.sqrt(measurement_noise))
    measured_positions.append(z)

    # 예측 단계
    x_pred = x_est + velocity
    P_pred = P + process_noise

    # 칼만 이득 계산
    K = P_pred / (P_pred + measurement_noise)

    # 업데이트 단계
    x_est = x_pred + K * (z - x_pred)
    P = (1 - K) * P_pred

    # 저장
    estimated_positions.append(x_est)
    errors.append(P)

# 결과 디스플레이
plt.figure(figsize=(10, 6))
plt.plot(true_positions, label="True Position", color='green', linestyle='--')
plt.plot(range(1, num_steps + 1), measured_positions, label="Measured (GPS)", color='red', linestyle=':', marker='o')
plt.plot(estimated_positions, label="Estimated (Kalman Filter)", color='blue', marker='s')
plt.xlabel("Time Step")
plt.ylabel("Position")
plt.title("Kalman Filter Position Estimation (1D)")
plt.legend()
plt.grid(True)
plt.show()

허프 변환(Hough Transform)은 컴퓨터 비전, 이미지 처리 및 패턴 인식 분야에서 사용되는 특징 추출 기술들 중 하나 입니다. 1972년에 발표된 오래된 이론으로 처음에는 이미지 내에 직선 성분을 찾기 위한 방법이었지만 추후 원과 타원 추출 방법으로 확장 되었습니다. 현 글에서는 허프 변환을 이용한 직선 추출 방법에 대해 설명하겠습니다.

일반적인 에지 탐색 등을 활용한 직선 성분 추출 시 잡음 등에 의해 중간 중간이 끊겨서 완전한 직선을 탐색하기 어려운 경우가 많습니다. 이 때, 허프 변환을 활용하면 일부 좌표 손실 상황에서도 직선 형태를 강건하게 검출할 수 있다는 장점이 있습니다. 일반적으로 카테시안(데카르트) 좌표계에서 직선식 표현하면 1)와 같으며 기울기 m의 경우 무한대가 나올 수 있어 활용하는데 문제가 될 수 있습니다. 그래서 허프 변환에서는 2)와 같이 극좌표계로 변환하여 직선 성분을 탐색합니다.  

1) y = mx + b // m: 기울기, b: y절편

2) r = xcosθ + ysinθ // r: 원점에서 직선까지 수직 거리, θ: 수직선과 x축 사이의 각도

허프 변환은 일부 가려짐이나 잡음에 강한 특성을 가지는 반면 계산량이 많아 질 수 있다는 점과 파라미터 설정이 중요할 수 있습니다. 그림에서처럼 이미지 평면에 점 A, B, C가 존재할 때, 각 점에 대해 각도 별(0~180도)로 거리(r)와 각도(theta)를 구하게 됩니다. 각 점을 지나는 극좌표점을 비교해 보면 60도 일때 가장 비슷한 수치를 얻게되며 파랑색 직선을 얻을 수 있습니다.

OpenCV에서는 직선 탐색을 위한 허프변환에 HoughLines()와 HoughLinesP()의 두 가지 함수를 제공합니다. 전자는 기본 허프 변환이며, 후자는 확률적 허프 변환(Probabilistic Hough Transform)입니다. 파이썬 예제 코드를 통해 파라미터 설정을 참고해보면 이해하기 쉬울 수 있습니다.

lines = cv2.HoughLines(image, rho, theta, threshold)

- image: 8-bit, Canny 등 에지 탐색 된 이진화 이미지

- rho(r): 거리 해상도(1이면 1-pixel 간격)

- theta: 각도 해상도 (0~180), 라디안 값으로 적용 

- threshold: 겹치는 점들의 축적값에 대한 임계값

lines = cv2.HoughLinesP(image, rho, theta, threshold, minLineLength, maxLineGap)

- minLineLength: 직선의 최소 길이

- maxLineGap: 탐색된 직선들 사이에 최대 허용 간격 

# Basic Hough Transform -------------------
import cv2
import numpy as np

img = cv2.imread('image.tif')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray, 50, 150)

lines = cv2.HoughLines(edges, 1, np.pi / 180, 150) # 허프 변환

for line in lines:
    rho, theta = line[0]
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a * rho
    y0 = b * rho
    # 두 점(x1,y1), (x2,y2)로 직선을 그림
    x1 = int(x0 + 1000*(-b))
    y1 = int(y0 + 1000*(a))
    x2 = int(x0 - 1000*(-b))
    y2 = int(y0 - 1000*(a))
    cv2.line(img, (x1,y1), (x2,y2), (0,0,255), 2)

cv2.imshow("Hough Lines", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

# Probabilistic Hough Transform --------------------------
import cv2
import numpy as np

img = cv2.imread('image.tif')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray, 50, 150)

# 확률 허프 변환
lines = cv2.HoughLinesP(edges, 1, np.pi/180, 80, minLineLength=50, maxLineGap=10)

for line in lines:
    x1, y1, x2, y2 = line[0]
    cv2.line(img, (x1, y1), (x2, y2), (0, 255, 0), 2)

cv2.imshow("Probabilistic Hough", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

K-means 알고리즘은 비지도 학습 Unsupervised Learning 방법 중 하나로 군집화 Clustering 문제를 풀기 위한 기술 중 하나 입니다. 명칭에서처럼 데이터를 평균값을 기반으로 K 개의 유사한 그룹으로 묶어주는 방법입니다. 계산 복잡도가 낮아 처리 속도에서 빠른 편에 속하며 원형 형태의 군집을 구분할 때 적합합니다. 다양하고 복잡한 형태의 군집에 적용은 한계가 있으며, 군집 수 K는 자동 결정이 아닌 사전에 결정해야 할 변수 입니다.

단계별 작동 원리는 간단합니다. 

1) 초기값 K개 중심점 선택 또는 특정 방식으로 초기화

2) 각 데이터 포인트를 Euclidean Distance 기반하여 가장 가까운 중심점 할당

3) 각 군집(Cluster)에 속한 모든 데이터의 평균값 계산 및 중심점 업데이트

4) 더 이상 중심점이 변화하지 않거나 지정된 반복 횟수를 만족할 때까지 반복

그림에서처럼 초기점이 C1과 C2라면 각 포인트 별 거리 계산을 통해 평균값을 업데이트 하면 초기점들은 우측 그림에서처럼 각 군집에 중심으로 이동하게 됩니다.

K-means에서는 군집수 K가 제대로 설정되느냐에 따라 성능을 좌우합니다. 사전에 군집수를 알고 있으면 좋겠지만 대부분 알지 못하기 때문에 적절한 K를 찾아야 할 때가 많습니다. 아래는 적절한 K를 찾기 위한 몇 방법들입니다.

Elbow method (엘보우 방법)

클러스터 수에 따른 총 제곱거리 합(Sum of Squared Errors: SSE)을 그래프로 그려서 꺾이는 지점을 K로 선택, 시각적으로 직관적이어서 많이 활용.

Silhouette (실루엣 계수)

각 데이터가 해당 클러스터에 잘 속해 있는지를 평가, 범위 -1.0 ~ +1.0 사이로 값이 클수록 군집화가 잘 되었다는 의미. 다양한 K값에 대해 계산하고 가장 높은 값을 갖는 K를 선택하며 정량적으로 평가.

Gap Statistic (갭 통계량)

군집화 결과의 SSE와 랜덤한 군집화 SSE의 차이를 비교하여 최적 K를 결정, 구현 복잡성과 계산 비용이 큰 단점이 있음.

이 외에 Davies-Bouldin Index와 Calinski-Harabasz Index 등이 있습니다. 아래는 적절한 K를 찾기 위한 Elbow Method 예제와 K-means 군집화 파이썬 예제 입니다.

# Elbow Method Example ----------------------------------
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

# 샘플 데이터 생성
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.6, random_state=42)

# K 값에 따른 SSE 리스트
sse = []

# 다양한 K값(1~11)에 대해 K-Means
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, random_state=42)
    kmeans.fit(X)
    sse.append(kmeans.inertia_)  # inertia_가 바로 SSE 값

# Elbow 그래프 시각화
plt.plot(range(1, 11), sse, marker='o')
plt.xlabel('클러스터 수 (K)')
plt.ylabel('오차 제곱합 (SSE)')
plt.title('Optimal K')
plt.grid(True)
plt.show()

# K-means algorithm example ------------------------
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

# 1.샘플 데이터 생성 
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)

# 2.KMeans (K=4)
kmeans = KMeans(n_clusters=4)
kmeans.fit(X)

# 3.예측된 클러스터
y_kmeans = kmeans.predict(X)

# 4. 결과 시각화
plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=50, cmap='viridis')  # 각 클러스터 색상표시

# 5. 중심점 표시
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, alpha=0.75, marker='X')
plt.title("K-means Clustering Result")
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.grid(True)
plt.show()

시간 영역의 신호를 주파수 영역으로 변환하여 처리나 해석하는 이론이 푸리에 변환 Fourier Transform 입니다. 신호처리 분야에서 주파수 영역 분석을 위한 중요한 이론이기도 합니다. 영상처리에서는 이미지를 2차원 신호로 보고 푸리에 변환을 이용할 수 있으며, 이미지 공간 정보를 주파수 성분으로 바꾸어 분석할 수 있습니다. 분석을 통한 응용은 이미지 필터링, 압축, 복원등에 활용됩니다.

푸리에 변환은 이론적으로 4가지 형식으로 구분됩니다. 영상처리에 활용되는 기법은 이산 푸리에 변환 DFT (Discrete Fourier Transform) 입니다. 아래는 2차원 이산 푸리에 변환 수식이며 오일러 공식과 결합된 형태 입니다.

여기서 f(x,y)는 원본 이미지의 픽셀 값, F(u,v)는 주파수 평면에서의 값, M과 N은 이미지 크기인 Width와 Height 입니다. 추가로 푸리에 변환 요소에는 각 주파수 성분의 세기를 나타내는 크기 Magnitude와 성분의 위치 정보를 나타내는 위상 Phase 정보가 있으며, 위상 정보는 이미지의 구조를 유지하는데 중요한 요소입니다.

이미지를 푸리에 변환하면 최종 주파수 영역에 중심에는 저주파, 바깥쪽에는 고주파로 구성됩니다. 고주파는 이미지에서 물체의 윤곽선과 같은 에지 Edge 성분들을 의미하고 저주파는 물체의 전반적인 형태를 나타냅니다. 따라서 응용에서는 이러한 특징을 이용하여 저역통과 Low-pass 필터링 및 고역통과 High-pass 필터링을 통해 이미지의 경계 강조나 블러 효과를 낼 수 있습니다. 이미지 압축에서는 고주파 성분이 적으면 적을 수록 작은 정보만으로 이미지 재구성이 가능해지며, 대표적으로 JPEG 손실 압축 알고리즘에서 푸리에 이론의 일종인 이산 코사인 변환 DCT(Discrete Cosine Transform)을 사용합니다.

코드를 통해 푸리에 활용 방법을 확인해 보겠습니다. 실무에서는 C/C++, Python, Matlab 등 알고리즘 구현시 FFT (Fast Fourier Transform)을 이용합니다. DFT의 계산 복잡도 때문에 FFT를 활용하게 되며, 예를 들어 샘플 수가 N=1024일 때 DFT는 약 100만번의 연산이 필요한 반면 FFT는 10,000번의 연산이 필요합니다. 아래와 같이 파이썬 Numpy에서는 “np.fft.fft2” 함수를 사용하여 이미지 평면을 주파수 평면으로 변환하며, “np.fft.fftshift” 함수를 통해 저주파 성분을 중심으로 이동 시킵니다. 반대로 주파수 평면에서 이미지 평면으로 변환 시, “np.fft.ifftshift” > “np.fft.ifft2” 함수 순으로 적용할 수 있습니다. 

FFT의 이론 및 응용에 대해서는 추후 예와 함께 좀더 상세히 다루도록 하겠습니다.

import cv2
import numpy as np

# 이미지 불러오기 (그레이스케일)
img = cv2.imread('lena.jpg', cv2.IMREAD_GRAYSCALE)

f = np.fft.fft2(img) # 푸리에 FFT 변환
fshift = np.fft.fftshift(f)  # 중심 이동

magnitude_spectrum = 20 * np.log(np.abs(fshift)) # 주파수 스펙트럼 확인

f_ishift = np.fft.ifftshift(fshift_filtered) # 중심 복원
img_ifft = np.fft.ifft2(f_ishift) # 역 FFT 적용

# 실수 이미지 변환
img_re = np.abs(img_ifft)

이미지에서 우리가 원하는 영역을 찾거나 추출할 때 필요한 방법이 이진화 Binarization 입니다. 물체 탐색, 물체 추적, 이미지 분할 등 알고리즘을 구현할 때 필수적으로 사용해야하는 기법이 이진화 기술들입니다. 이진화 방법에는 다양한 기술들이 있으며, OpenCV 에서 제공하는 기술들 중 하나인 적응적 이진화 기술 Adaptive Thresholding Method에 대해 알아보겠습니다.

이진화 방법은 크게 전역적 처리 Global Processing과 지역적 처리 방법 Local Processing 방법으로 구분할 수 있습니다. OpenCV에서 제공하는 “adaptiveThreshold” 방법은 지역적 처리 방법과 적응적 방법이 합쳐진 이진화 방법입니다. Python에서는 아래와 같이 “cv2.adaptiveThreshold” 명으로 적용해 볼 수 있으며, 입력 변수는 아래와 같습니다.

[Python] dst = cv2.adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C)

(입력 변수 설명)

- src: 입력 이미지 (Gray Scale Image)

- maxValue: 임계값 Threshold을 초과한 픽셀에 적용할 값 (일반적으로 255)

- adaptiveMethod: 1) cv2.ADAPTIVE_THRESH_MEAN_C, 2) cv2.ADAPTIVE_THRESH_GAUSSIAN_C

- thresholdType: 1) cv2.THRESH_BINARY, 2) cv2.THRESH_BINARY_INV

- blockSize: 픽셀 임계값을 계산할 영역 크기 (홀수: 3, 5, 7 ...)

- C: 계산된 임계값에서 빼는 상수 (일반적으로 0 또는 2~10)

여기서 “cv2.ADAPTIVE_THRESH_MEAN_C”는 “blockSize”가 3이라면 3x3 크기 영역 안에 평균 값에서 “C”를 뺀 값을 임계값으로 사용하게 됩니다. “cv2.ADAPTIVE_THRESH_GAUSSIAN_C”는 3x3 크기 영역 안에 가우시안 가중 평균값에서 “C”를 뺀 값을 임계값으로 사용합니다. 앞에서 언급했듯이 “blockSize”는 3은 3x3, 5는 5x5의 블럭을 의미하며 블럭 크기가 작아질 수록 잡음 Noise에 민감해지고 너무 크면 지역적 처리의 이점이 줄어들 수 있으니 설정 시 고민이 필요할 수 있습니다.

C/C++ 코드를 사용한다면 아래와 같이 사용할 수 있습니다. 파이썬 함수와 다르게 결과 이미지는 입력 변수와 함께 설정해야 합니다. (dst = 결과 이미지)

[C/C++] adaptiveThreshold(src, dst, maxValue, adaptiveMethod, thresholdType, blockSize, C)

지역적이면서 적응적 이진화 방법은 이미지에 조명이 균일하지 않거나 배경이 복잡하여 명암이 불균일한 경우 유용할 수 있으며, 문서 이미지에서 문자 추출 시에도 잘 활용될 수 있습니다. 아래는 파이썬과 C/C++에서 “adaptiveThreshold”를 활용한 예이니 참고해서 보면 좋을 듯 합니다.

import cv2

# 그레이 이미지 읽기
img = cv2.imread('grayimage.jpg', cv2.IMREAD_GRAYSCALE)

# 가우시안 적응형 이진화
thresh = cv2.adaptiveThreshold(
    img,
    255,
    cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
    cv2.THRESH_BINARY,
    11,
    2
)

cv2.imshow("Adaptive Threshold", thresh)
cv2.waitKey(0)
cv2.destroyAllWindows()

#include <opencv2/opencv.hpp>
using namespace cv;

int main() {
    // 이미지 불러오기 (그레이스케일)
    Mat src = imread("grayimage.jpg", IMREAD_GRAYSCALE);
    Mat dst;
    // 적응형 이진화 적용
    adaptiveThreshold(
        src,              // 입력 이미지
        dst,              // 출력 이미지
        255,              // 최대값
        ADAPTIVE_THRESH_GAUSSIAN_C,  // 적응형 방법
        THRESH_BINARY,    // 임계값 타입
        7,               // 블록 크기 (홀수)
        2                 // C 상수
    );

    // 결과 출력
    imshow("Original", src);
    imshow("Adaptive Threshold", dst);
    waitKey(0);
    return 0;
}

영상처리 기술에서 보간법은 이미지 확대나 회전, 좌표 변환 기술 Affine Transform 등 알고리즘 구현 시 빈번히 사용됩니다. 머신 러닝 Machine Learning 및 딥러닝 Deep Learning 등 특히 CNN 계열에 Coarse Map을 Dense Map으로 Up-Sampling시 활용되는 기술이기도 합니다. 이미지를 두 배로 확대할 때 보간법은 새로운 픽셀 Pixel 값을 그럴듯하게 예측하는 기술로 볼 수 있습니다. 이론적인 부분은 영상처리 기술에서 다루도록 하겠습니다.

기본적인 보간법 세가지는 아래와 같습니다.

1. 최근접 이웃 보간법 Nearest Neighbor Interpolation

- 소수점 좌표에서 가장 가까운 정수 좌표 픽셀 사용, 수행속도가 가장 빠르지만 계단 현상 및 깨짐 현상 발생

2. 양선형 보간법 Bilinear Interpolation

- 주변 4개 픽셀을 사용해 선형 평균을 이용, 최근접 보다 자연스러운 결과를 보이고 일반적으로 많이 활용되는 기술

3. 양큐빅 보간법 Bicubic Interpolation

- 주변 16개 픽셀을 활용하며 앞에 두 기술보다 자연스러우며, Super Resolution 기술들에서 비교 결과로 많이 사용, 고화질 이미지 편집에 사용되는 기술이며 처리속도는 느림

이미지 회전 시 보간법이 사용되는 이유는 회전은 수학적으로 기존 픽셀 좌표를 회전 행렬로 이동시키는 과정입니다. 회전 시 생성되는 좌표는 보통 소수점 좌표가 되며, 새로운 평면에 매칭 시 좌표는 소수점이 아닌 정수이기때문에 빈공간이 생기게 됩니다. 그 빈공간을 채워주기 위해 보간법이 활용됩니다. 예를 들어 좌표 (5, 5)를 30도 회전하면 (5.3, 3.9) 되므로 실제 좌표 매칭을 위해서는 주변 픽셀 (5, 3), (6, 3), (5, 4), (6, 4)를 이용하여 추정해야 합니다.

OpenCV에서 이미지 회전 및 확대 시 보간법을 지정할 수 있습니다. 아래는 파이썬 활용시 CV 상수 입니다. 첫번째 예제는 회전시 파이썬 코드이며, 이전 블로그에서 설명한 “cv2.warpAffine” 함수를 사용합니다. 두번째 예제는 “cv2.resize” 함수를 활용한 보간법 사용 예입니다. 

1. 최근접 이웃 보간법 - cv2.INTER_NEAREST

2. 양선형 보간법 - cv2.INTER_LINEAR

3. 양큐빅 보간법 - cv2.INTER_CUBIC

4. Lanczos 보간법 - cv2.INTER_LANCZOS4

# 이미지 회전 예제
import cv2
import numpy as np

# 이미지 로드
img = cv2.imread('lena.jpg')

# 회전 중심, 각도, 스케일
center = (img.shape[1] // 2, img.shape[0] // 2)
angle = 50
scale = 1.0

# 회전 행렬 생성
M = cv2.getRotationMatrix2D(center, angle, scale)

# 양큐빅 보간법 사용예
rotated = cv2.warpAffine(img, M, (img.shape[1], img.shape[0]), flags=cv2.INTER_CUBIC)

# 결과 보기
cv2.imshow('Rotated Image', rotat_result)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 이미지 확대 예제
img = cv2.imread('lena.jpg')

# 2배 확대, 선형 보간법
resized = cv2.resize(img, None, fx=2, fy=2, interpolation=cv2.INTER_LINEAR)

# 결과 보기
cv2.imshow('Resized Image', resiz_result)
cv2.waitKey(0)
cv2.destroyAllWindows()