OCR-PII-review

EasyOCR

Import Library

import re
import cv2
import easyocr
import os
from glob import glob
import numpy as np
from PIL import Image, ImageDraw, ImageFont
# import torch

• re: 정규식 검사(숫자 패턴 탐지)
• cv2: (OpenCV): 이미지 입출력, 폴리곤(polygon) 마스크, 리사이즈, 블러 등
• easyocr: OCR 엔진 (readtext → [(bbox, text, confidence),...])
• numpy: 좌표/배열 연산
• PIL(Pillow): 텍스트 대체 모드(replace_text)에서 글자 렌더링 및 회전 합성
• glob, os: 파일 입출력/폴더 처리
• torch: gpu 메모리 사용량 확인 (필수 x)
  

사전 설정

# EasyOCR 설정값
OCR_LANGS = ['ko', 'en']
 
# 정규식 (3가지 유형 커버)
rrn_combined_regex = re.compile(r"\b\d{6}\s*-\s*\d{7}\b")
rrn_nohyphen_regex = re.compile(r"\b\d{13}\b")
rrn_front_regex = re.compile(r"\b\d{6}\b")
rrn_back_regex = re.compile(r"\b\d{7}\b")

• OCR_LANGS = ['ko', 'en']: EasyOCR이 사용할 언어
• rrn_combined_regex : \b\d{6}\s*-\s*\d{7}\b (6자리, 하이픈(옵션 공백) 후 7자리)
• rrn_nohyphen_regex : \b\d{13}\b (13자리 붙어있을 때)
• rrn_front_regex : \b\d{6}\b (앞 6자리)
• rrn_back_regex : \b\d{7}\b (뒤 7자리)
  

⚠️현재 정규식 패턴의 한계

• 점(.), 슬래시(/) 등 다른 구분자와 특수문자, OCR 오타(예: o→0, l→1)는 패턴에서 제외됨.
  

# 결합 임계값 설정
MAX_X_DISTANCE = 50
MAX_Y_DIFFERENCE = 10
 
# 비식별화 방식 및 설정
MASK_METHOD = "black" # "black", "mosaic", "blur", "replace_text"
REPLACE_TEXT = "[ REDACTED ]"
MOSAIC_SCALE = 0.05
BLUR_KERNEL = (51, 51)
OCR_LOW_TEXT = 0.4

• MAX_X_DISTANCE = 50: 앞의 숫자(6자리)와 뒤의 숫자(7자리) 사이 x 거리 최대 허용 (픽셀 단위)

• MAX_Y_DIFFERENCE = 10: 중심선 y 차이 최대 허용

• MASK_METHOD: 마스킹 방식. “black”, “mosaic”, “blur”, “replace_text”으로 총 4가지

• MOSAIC_SCALE, BLUR_KERNEL, OCR_LOW_TEXT: 보정 파라미터

  
  

마스킹 유틸리티 함수

mask_bbox 함수

def mask_bbox(img, bbox, method=MASK_METHOD):
 
    pts = np.array(bbox, dtype=np.int32)
    
    ...
    
    return img  

ℹ️ 기능

• 이미지 안에서 특정 글자 영역만 가리거나 마스킹하는 함수
• EasyOCR의 readtext()에서 반환된 **글자의 위치(bbox)**를 입력 받아 처리

매개 변수

이름	의미
img	OpenCV 이미지 배열(numpy array)
bbox	EasyOCR이 반환한 글자 위치 4점 좌표
method	마스킹 방법: "black","mosaic","blur","replace_text"

• pts = np.array(bbox, dtype=np.int32)

  bbox은 예를 들어 다음과 같은 값을 갖는다.

  bbox = [[np.int32(296), np.int32(188)], [np.int32(640), np.int32(188)], [np.int32(640), np.int32(264)], [np.int32(296), np.int32(264)]]
  

• OpenCV에서 도형 그리기 함수(cv2.fillPoly)는 numpy 배열 형태로 좌표를 받아야 한다. EasyOCR에서는 좌표값을 numpy(np)의 int32 타입으로 반환하므로 dtype=np.in32로 지정한다.

  결론적으로 pts는 다음과 같은 2차원 numpy array가 된다.

  [[296 188]
   [640 188]
   [640 264]
   [296 264]]
  

검정색 마스킹(black)

    if method == "black":  
        cv2.fillPoly(img, [pts], (0, 0, 0))  

• cv2.fillPoly(img, [pts], (0, 0, 0))
  • 입력 받은 이미지(img)에서 지정된 다각형 영역([pts])을 검정색((0, 0, 0))으로 채우는 함수
  • pts 좌표를 기준으로 이미지에 다각형 영역을 정의하고, 다각형 내부 픽셀값을 검정색으로 채운다.
  • 공식 문서 참조

매개 변수

이름	의미
img	검정색 도형을 그릴 대상 이미지 (OpenCV 이미지, numpy array)
[pts]	채울 다각형 좌표. 리스트 안에 numpy array 형태여야 함
(0,0,0)	색상(B,G,R 순서). OpenCV는 RGB가 아닌 BGR 사용. (0,0,0) → 검정색

❓ 왜 [pts]처럼 리스트 안에 넣을까?

• cv2.fillPoly()는 여러 개 다각형을 한 번에 처리할 수 있다!!
• 예를 들어, 여러 다각형을 한 번에 그리려면 다음과 같이 하면 된다.

  cv2.fillPoly(img, [pts1, pts2, pts3], (0,0,0))

• 즉, 단일 다각형이라도 리스트 안에 넣어야 함수 규격에 맞는다.

---

모자이크 마스킹(mosaic)

    elif method == "mosaic":  
        """ 작은 이미지로 축소 후 다시 확대하여 픽셀화 (모자이크) """  
        mask = np.zeros(img.shape[:2], dtype=np.uint8)  
        cv2.fillPoly(mask, [pts], 255)  
        x, y, w, h = cv2.boundingRect(pts) # bbox 크기 계산  
        roi = img[y:y+h, x:x+w]  
        mask_roi = mask[y:y+h, x:x+w]  
        if roi.size != 0:  
            small_w = max(1, int(w * MOSAIC_SCALE))  
            small_h = max(1, int(h * MOSAIC_SCALE))  
            small = cv2.resize(roi, (small_w, small_h))  
            mosaic = cv2.resize(small, (w, h), interpolation=cv2.INTER_NEAREST)  
            roi[mask_roi==255] = mosaic[mask_roi==255]

• 모자이크는 **대상 영역(다각형)**만 따로 잘라서, 그 부분을 아주 작게 축소했다가(정보 손실) 다시 원래 크기로 확대해서 픽셀을 뭉개는 방식. 위의 코드에서 np.zeros로 만든 **마스크(mask)**는 “어디에 모자이크를 적용할지”를 표시하는 도화지 역할을 한다.

  
  

• mask = np.zeros(img.shape[:2], dtype=np.unit8)

  • img.shape[:2]는 입력 받은 이미지의 (height, width)를 뜻한다. 참고로 OpenCV의 이미지는 (height, width, channels)의 형태를 갖는다.
  • np.zeros(shape, dtype=None, order='C')는 주어진 형태(shape)의 배열을 생성하며, 모든 요소를 0으로 초기화하는 함수다. shape은 정수 또는 정수들의 튜플 형태로 입력된다.
  • 즉, mask = np.zeros(...)는 모든 요소를 0으로 갖는 2차원 배열이며, OpenCV 이미지의 관점에서는 입력 받은 이미지와 같은 크기의 단일 채널(2D) 이미지다.

"마스크(mask)"란?

컴퓨터 비전에서 mask는 “이 영역은 처리하고, 저 영역은 무시하라”를 표시하는 이진 이미지(binary image)다. · 흰색(255) → “이 부분은 포함하라” = 관심 영역(ROI: Region of Interest) · 검은색(0) → “이 부분은 제외하라” = mask mask가 단일 채널(2D) 이미지인 이유는 색(3채널) 정보는 필요 없고, “여기인가/아닌가”만 판단하면 되기 때문이다. (메모리 절약 효과도 있다!)

• cv2.fillPoly(mask, [pts], 255)

  • mask 이미지 안에서 pts(관심 영역의 꼭짓점 좌표들)로 둘러싸인 부분을 흰색(255)으로 채움.
  • 결과적으로 이 부분이 모자이크 대상(흰색)이다” 라는 정보가 mask 안에 담긴다.

• x, y, w, h = cv2.boundingRect(pts)

  • boundingRect()는 주어진 점을 감싸는 최소 크기의 사각형(바운딩 박스)을 반환하는 OpenCV의 외각선 함수다. (x, y 좌상단, 너비, 높이)

• roi = img[y:y+h, x:x+w] mask_roi = mask[y:y+h, x:x+w]

  • roi는 원본 이미지에서 관심 영역만 잘라낸 부분(높이 h, 너비 w, 채널 3) → 여기서 모자이크를 처리한다.
  • mask_roi는 마스크에서 roi와 동일한 영역을 잘라낸 것(높이 h, 너비 w, 단일 채널)

  전체 큰 이미지에서 작업하는 대신, 이런 식으로 관심 영역(ROI)만 잘라서 연산하면 속도와 메모리 면에서 효율적이다.

• small_w = max(1, int(w * MOSAIC_SCALE)) small_h = max(1, int(h * MOSAIC_SCALE))

  • MOSAIC_SCALE은 원본 ROI를 얼마나 작게 만들지 정하는 비율 예: w=200, MOSAIC_SCALE=0.05 → small_w=10
  • max(1, ...)는 ROI가 아주 작아서 0이 되는 것을 방지하기 위함(0이면 resize 에러남)
  • 작게 줄일수록 모자이크가 더욱 식별 불가능해짐

• small = cv2.resize(roi, (small_w, small_h))

  • roi(원본 칼라 이미지)를 (small_w, small_h) 크기로 축소.

• mosaic = cv2.resize(small, (w, h), interpolation=cv2.INTER_NEAREST)

  • 다시 원래 크기 (w,h)로 확대.
  • 보간법(interpolation)으로는 INTER_NEAREST, INTER_AREA, INTER_CUBIC, INTER_LINEAR(기본값) 등 다양하다. INTER_NEAREST는 가장 가까운 픽셀을 복제하는 보간법이다.

• roi[mask_roi==255] = mosaic[mask_roi==255]

  • 직사각형 roi 안에서 **마스크가 흰색(255)**인 픽셀들만 골라서, 그 픽셀들을 같은 위치의 mosaic 값으로 교체

---

블러 마스킹(blur)

    elif method == "blur":  
        """ 가우시안 블러 적용 """ 
        mask = np.zeros(img.shape[:2], dtype=np.uint8)  
        cv2.fillPoly(mask, [pts], 255)  
        x, y, w, h = cv2.boundingRect(pts)  
        roi = img[y:y+h, x:x+w]  
        mask_roi = mask[y:y+h, x:x+w]  
        if roi.size != 0:  
            blur = cv2.GaussianBlur(roi, BLUR_KERNEL, 0)  
            roi[mask_roi==255] = blur[mask_roi==255] 

• cv2.GaussianBlur → 지정한 커널만큼 이미지를 흐리게 처리
• 모자이크(mosaic)와 마찬가지로 mask 영역만 적용

---

텍스트 교체 마스킹(replace_text)

⭐ 이 함수가 하는 일

• 폴리곤(bbox) 영역을 흰색 박스로 덮어 원래 글자를 지운다. (검정색 마스킹과 원리 동일)
• 그 영역에 빨간색 대체 텍스트 이미지를 그린다.
• 폴리곤 영역이 기울어져 있다면 텍스트 이미지도 그 기울기에 맞춰 같은 각도로 회전시켜 넣는다.
• PIL(RGBA)를 이용해 이미지 합성 후 OpenCV(BGR) 이미지로 변환해서 반환한다.

    elif method == "replace_text":  
        cv2.fillPoly(img, [pts], (255, 255, 255))
        x, y, w, h = cv2.boundingRect(pts)  
        center_x = x + w // 2  
        center_y = y + h // 2    
        max_len = 0  
        angle = 0  
        for i in range(4):  
            dx = pts[(i+1)%4][0] - pts[i][0]  
            dy = pts[(i+1)%4][1] - pts[i][1]  
            length = np.hypot(dx, dy)  
            if length > max_len:  
                max_len = length  
                angle = -np.degrees(np.arctan2(dy, dx))   
        pil_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))  
        draw = ImageDraw.Draw(pil_img)  
        diagonal = np.hypot(w, h)  
        font_size = min(max(int(diagonal * 0.1), 12), h)   
        try:  
            font = ImageFont.truetype("malgunbd.ttf", font_size) # 맑은 고딕 bold
        except:  
            font = ImageFont.load_default()  
        bbox_text = draw.textbbox((0, 0), REPLACE_TEXT, font=font)  
        text_w = bbox_text[2] - bbox_text[0]  
        text_h = bbox_text[3] - bbox_text[1]  
        offset = 5 # 텍스트 위로 올릴 픽셀 수  
        text_x = center_x - text_w / 2  
        text_y = center_y - text_h / 2 - offset  
        text_layer = Image.new("RGBA", pil_img.size, (255, 255, 255, 0))  
        text_draw = ImageDraw.Draw(text_layer)  
        text_draw.text((text_x, text_y), REPLACE_TEXT, font=font, fill=(255, 0, 0, 255))   
        rotated_layer = text_layer.rotate(angle, center=(center_x, center_y), resample=Image.BICUBIC)  
        pil_img = Image.alpha_composite(pil_img.convert("RGBA"), rotated_layer)  
        img[:] = cv2.cvtColor(np.array(pil_img.convert("RGB")), cv2.COLOR_RGB2BGR)

개빡세다

• cv2.fillPoly(img, [pts], (255, 255, 255))
  • 입력 받은 이미지(img)에서 지정된 다각형 영역([pts])을 흰색((255, 255, 255))으로 채우는 함수.
  • 텍스트를 입력하기 위한 배경
• center_x = x + w // 2 center_y = y + h // 2
  • bbox 가운데 좌표 계산 → 텍스트를 중앙에 표시하기 위함.

max_len = 0  
angle = 0  
for i in range(4):  
    dx = pts[(i+1)%4][0] - pts[i][0]  
    dy = pts[(i+1)%4][1] - pts[i][1]  
    length = np.hypot(dx, dy)  
    if length > max_len:  
        max_len = length  
        angle = -np.degrees(np.arctan2(dy, dx))

Info

OpenCV에서 각도를 반환하는 cv2.minAreaRect()를 이용하거나, cv2.PCACompute2()을 이용해 텍스트의 각도를 계산해봤지만, 결과가 좋지 않았음.

• 마스킹해야 하는 텍스트가 기울어져 있을 때 대체할 텍스트 회전을 위해 각도를 계산하기 위한 루프
• 위 코드는 **각 변(연속된 점 쌍)**에 대해 (dx, dy)와 그 길이 length를 구하고, 가장 긴 변을 찾은 뒤 그 변의 방향을 angle로 지정하는 루프다.

numpy.hypot(x1, x2)

직각삼각형의 두 변의 길이를 입력받아 빗변의 길이를 계산하는 함수. 즉, numpy.hypot($x_1,x_2$) = $\sqrt{{x_1}^2+{x_2}^2}$ 길이(length)를 구할 때, 이 공식을 사용하는 것은 **두 점 사이의 거리 공식 $\sqrt{{(x_2-x_1)}^2+{(y_2-y_1)}^2}$**에 근거한다.

numpy.arctan2(y, x)

arctan2(y, x)는 2차원 벡터 (x, y)가 **x축과 이루는 방향각(각도)**을 안전하게 계산해주는 함수.

❓ 왜 ‘가장 긴 변’의 각도를 쓰는가?

• 주민등록번호의 경우, 보통 생성되는 bounding box는 가로 방향으로 길게 생성된다고 가정.
• 따라서 가장 긴 변을 텍스트의 기준선으로 보고, 그 변의 방향으로 대체 텍스트를 회전시키면 된다는 논리!

Example

pts의 값이 다음과 같이 주어졌다고 가정해보자.

pts = np.array([[296, 188],
		[640, 188],
		[640, 264],
		[296, 264]
		], dtype=np.int32)

pts = np.array([[296, 188],
		[640, 188],
		[640, 264],
		[296, 264]
		], dtype=np.int32)

pts = np.array([[296, 188],
		[640, 188],
		[640, 264],
		[296, 264]
		], dtype=np.int32)

주어진 pts 값을 바탕으로 bounding box(bbox)를 그림으로 표현하면 다음과 같다.

위의 루프와 동일한 방식으로 각 변을 계산해보면:

• i=0: p0→p1 = (640-296, 188-188) = (344, 0)
  
  • length = $\sqrt{{344}^2+0^2}$= 344
    
  • arctan2(dy, dx) = arctan2(0, 344) = 0.0 → degrees = 0.0°(radian)
    
  • angle = -0 = 0°
    
• i=1: p1→p2 = (640-640, 264-188) = (0, 76)
  
  • length = 76
    
  • arctan2 = arctan2(76, 0) = ０≈ 1.57 → degrees = 90°
    
  • angle = -90° (하지만 길이가 더 작으므로 사용되지 않음)
    
• i=2: p2→p3 = (296-640, 264-264) = (-344, 0)
  
  • length = 344
    
  • arctan2 = arctan2(0, -344) ≈ 3.14 → degrees = 180°
    
  • angle = -180°
    
  • 길이는 344로 최대와 같지만 일반적으로 첫 번째로 만난 최대를 사용하므로 i=0의 값(0°)이 남음.
    
• i=3: p3→p0 = (296-296, 188-264) = (0, -76)
  
  • length = 76
    
  • arctan2 = arctan2(-76,0) ≈ -1.57 → angle = 90° (미사용)
    

결론적으로 가장 긴 변은 길이 344인 가로 변 → angle=0°
텍스트를 회전시킬 필요가 없으므로 0°를 사용하게 된다.

• angle = -np.degrees(np.arctan2(dy, dx))
  • pillow(PIL)의 rotate 메서드는 양수(+) 각도를 입력 받으면, 반시계 방향으로 회전한다. 따라서 angle에 적절한 부호를 맞춰줘야 텍스트가 동일 방향으로 놓인다.
  • 예를 들어, 박스가 왼쪽으로 15° 기울어졌다면, np.degrees(np.arctan2(dy, dx))는 약 -15°로 나오고, angle = 15가 된다. 이때 pillow(PIL)의 rotate에 의해 대체 텍스트가 반시계 방향으로 15° 회전하게 되면서 박스와 대체 텍스트가 동일 방향으로 놓이게 된다.

⚠️ 각도 계산 루프의 한계

• 다음과 같은 상황에서 위 루프는 실패한다.
  • 세로 방향으로 길게 나열된 텍스트(하지만 애초에 EasyOCR이 세로 방향 텍스트 인식에 약하다.)
  • 비정형 polygon(네 점이 사각형 순서로 오지 않는 경우)
  • 정사각형 polygon (가능성이 거의 없긴 하다)
• 더 좋은 방식을 생각해볼 필요가 있다..

PIL 변환 및 텍스트 렌더링

# PIL 이미지 생성  
pil_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
draw = ImageDraw.Draw(pil_img)  
  
diagonal = np.hypot(w, h)  
font_size = min(max(int(diagonal * 0.1), 12), h)  
  
# 폰트 선택과 로드
try:  
    font = ImageFont.truetype("malgunbd.ttf", font_size) # 맑은 고딕 bold
except:  
    font = ImageFont.load_default() 

• pil_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
  • OpenCV는 img는 numpy.ndarray이고 색 채널 순서는 BGR, dtype은 보통 unit8
  • PIL(pillow)은 색 채널 순서가 RGB(그리고 RGBA)다.
  • 따라서 OpenCV → PIL 변환 시 반드시 cv2.cvtColor(img, cv2.COLOR_BGR2RGB)로 BGR → RGB 변환을 하고, numpy 배열을 Image.fromarray()를 통해 PIL 이미지로 변환해야 색이 올바르게 보인다.
• draw = ImageDraw.Draw(pil_img)
  • 대체 텍스트 이미지를 그리기 위한 PIL ImageDraw 객체 생성.
  • Image.fromarray(...)의 과정은 numpy.ndarray 이미지를 Pillow가 이해할 수 있는 PIL.Image 객체로 변환하는 과정이었다면, ImageDraw.Draw()는 그 이미지 위에 다른 이미지를 그리기 위한 객체를 생성하는 역할을 한다.
• diagonal = np.hypot(w, h) font_size = min(max(int(diagonal * 0.1), 12), h)
  • diagonal은 폴리곤 영역의 대각선 길이
  • int(diagonal * 0.1): 대각선 길이의 10%를 폰트 크기로.
  • max(..., 12): 아무리 작은 이미지라도 최소 12px이상 폰트 크기 유지.
  • min(..., h): 폰트 크기가 이미지 높이보다 커지는 걸 방지.

텍스트 크기 계산

bbox_text = draw.textbbox((0, 0), REPLACE_TEXT, font=font)  
text_w = bbox_text[2] - bbox_text[0]  
text_h = bbox_text[3] - bbox_text[1]

ImageDraw.textbbox((x,y), text, font, ...) 참조

메서드 이름 그대로 텍스트를 그렸을 때의 바운딩 박스 좌표를 반환한다. 반환값은 다음과 같은 4-튜플 형태다.

(x0, y0, x1, y1)

• (x0, y0): 바운딩 박스의 왼쪽 위 좌표

• (x1, y1): 바운딩 박스의 오른쪽 아래 좌표

• 공식 문서에서는 “(left, top, right, bottom) bounding box” 을 반환한다고 설명한다.

OpenCV, PIL 등에서 사용하는 좌표계는 수학 좌표계와 다르다!

ImageDraw.textbbox(...)의 반환값을 출력해보면 다음의 예시와 같은 값이 출력된다.

(0, 13, 229, 45))

이러한 반환값은 수학적 좌표계 관점에서 바라보면 말이 되지 않는다. 왜냐하면 왼쪽(left)에 있는 x0의 값이 오른쪽(right)에 있는 x1의 값 보다 작은 것은 이해가 가지만, 위(top)에 있는 y0의 값이 아래(bottom)에 있는 y1의 값보다 작은 것은 이해가 되지 않기 때문이다. 이는 OpenCV, Pillow(=PIL), 그리고 수학적 좌표계가 서로 “y축 방향”을 다르게 쓰기 때문에 생기는 혼동이다.

• 📈 수학적 좌표계(우리에게 익숙한 좌표계)

       ↑ y (위로 증가)
       |
       |
(0,0)──└────────→ x (오른쪽으로 증가)

• y값이 위로 갈수록 커짐 → 그래서 “아래에 있는 점”은 y값이 작음

• 📉 이미지 좌표계

(0,0) ─────────→ x (오른쪽으로 증가)
  |
  |
  ↓
  y (아래로 증가)

• 대부분의 이미지 처리 라이브러리(Pillow, OpenCV, numpy 배열 등)는 화면의 맨 위 왼쪽을 (0,0) 으로 둔다.
• 즉, y값이 아래로 갈수록 커짐 (화면은 위에서 아래로 스캔하니까!)

반면에 EasyOCR은 수학적 좌표계를 사용한다. EasyOCR이 반환하는 바운딩 박스의 좌표(코드에서는 pts 값)는 수학적 좌표를 사용하는 걸 확인할 수 있다. 이미지 처리할 때 가장 혼동하는 포인트 중 하나이므로 헷갈리지 말자~

• ImageDraw.textbbox()가 반환한 값을 바탕으로 텍스트의 너비와 높이를 구한다.

텍스트 위치 계산

offset = 5 # 텍스트 위로 올릴 픽셀 수
text_x = center_x - text_w / 2
text_y = center_y - text_h / 2 - offset

• center_x, center_y는 bbox 중심의 좌표.
• text_x = center_x - text_w / 2
  • 텍스트를 수평 중앙 정렬: bbox의 중심에서 텍스트 너비의 절반만큼 왼쪽에 놓음.
• text_y = center_y - text_h / 2 - offset
  • 텍스트를 수직 중앙 정렬후, offset만큼 위로 올림.
  • 이미지 좌표계에서 y값은 아래로 증가하므로 -offset은 시각적으로 텍스트를 위로 올리는 동작이다.
  • 테스트 결과 바운딩박스의 중심에 딱 맞춰 넣으면 텍스트가 bbox의 중앙보다 살짝 아래에 위치했기 때문에 offset으로 텍스트를 조금 위로 이동시키는 것.

텍스트 레이어 생성 및 회전

# 텍스트 레이어 생성
text_layer = Image.new("RGBA", pil_img.size, (255, 255, 255, 0))
text_draw = ImageDraw.Draw(text_layer)
text_draw.text((text_x, text_y), REPLACE_TEXT, font=font, fill=(255, 0, 0, 255))
 
# 텍스트 레이어 회전
rotated_layer = text_layer.rotate(angle, center=(center_x, center_y), resample=Image.BICUBIC)

❓ 왜 텍스트 레이어를 만드나?

• 목적: 원본 이미지에 직접 텍스트를 그리지 않고, “투명한 캔버스(RGBA)” 위에 텍스트만 그리기 위해.
• 이유:
  • PIL 이미지를 이용하는 근본적인 이유는
    1. OpenCV를 이용할 경우, 한글 폰트 사용 불가능.
    2. OpenCV를 이용한 대체 텍스트 생성 시, 텍스트의 화질이 매우 좋지 않은 것이 확인됨.
  • 따라서 텍스트 레이어를 생성 후, 합성하는 방식을 통해 한글 폰트를 사용해야 하는 경우도 대비하고, 텍스트 화질 저하 문제도 해결.

• text_layer = Image.new("RGBA", pil_img.size, (255, 255, 255, 0))
  • RGBA: A = 알파 채널 투명도
  • (255, 255, 255, 0)은 완전한 투명색을 의미 - 즉 아무 것도 그려지지 않은 투명 캔버스
• text_draw.text((text_x, text_y), REPLACE_TEXT, font=font, fill=(255, 0, 0, 255))
  • fill=(255, 0, 0, 255)에서 마지막 값 255는 알파=불투명(완전 표시). 즉, 텍스트는 불투명한 빨간색으로 그려짐.
• rotated_layer = text_layer.rotate(angle, center=(center_x, center_y), resample=Image.BICUBIC)
  • angle: 텍스트 회전 각도 계산 루프를 통해 구한 각도.
  • center=(center_x, center_y): 회전의 중심점
  • resample: 회전 시 사용할 보간법을 지정하는 파라미터. 주요 옵션은 다음과 같다.
    • Image.NEAREST : 가장 가까운 픽셀 복제 (계산 빠름, 에일리어싱 심함)
    • Image.BILINEAR : 2×2 선형 보간 (부드러움 ↑)
    • Image.BICUBIC : 4×4 비큐빅 보간 (더 부드럽고 품질 좋음)
    • Image.LANCZOS : 고급 필터 (보통 축소시에 좋음)
  • 텍스트를 회전하면 계단현상(aliasing)이 생기기 쉬움. BICUBIC은 픽셀 경계를 부드럽게 보간해 회전 후 텍스트가 좀 더 일기 좋게 보이도록 해주므로 해당 옵션 사용.

이미지 합성

pil_img = Image.alpha_composite(pil_img.convert("RGBA"), rotated_layer)
img[:] = cv2.cvtColor(np.array(pil_img.convert("RGB")), cv2.COLOR_RGB2BGR)

Image.alpha_composite(base, overlay) 작동 원리

• alpha_composite는 두 RGBA 이미지를 받아서 전경(over) 알파 채널에 따라 픽셀 단위로 합성 솔직히 잘 모름
• 전제 조건: 두 이미지의 크기가 같아야 함(pil_img.size와 동일 크기의 text_layer를 만든 이유)
• pil_img.convert("RGBA"):
  • 원본 PIL 이미지가 RGB이면 알파 채널이 없으므로 RGBA로 바꿔야 합성 가능. convert("RGBA")로 알파=255(불투명)인 base가 만들어짐.

alpha_composite를 쓰는 이유

• rotated_layer는 텍스트 영역이 불투명(예: 알파=255)이고, 나머지 영역은 투명(알파=0)인 RGBA 이미지.
• 이 레이어를 base에 alpha_composite하면 텍스트만 base에 덮이고, 투명 부분은 base가 유지되므로 깨끗하고 비파괴적인 방법. → 텍스트 이미지만 깔끔하게 덮인다~

• img[:] = cv2.cvtColor(np.array(pil_img.convert("RGB")), cv2.COLOR_RGB2BGR)
  • pil_img.convert("RGB"): RGBA → RGB로 바꾼 다음 numpy로 변환한다.
  • cv2.cvtColor(..., cv2.COLOR_RGB2BGR) : Pillow는 RGB, OpenCV는 BGR 이므로 채널 순서를 맞춰준다.
  • img[:] = ... : 원본 img(NumPy 배열)를 전체 바꾼다.
    

combine_bboxes 함수

def combine_bboxes(bbox1, bbox2):  
    xs1 = [p[0] for p in bbox1]  
    ys1 = [p[1] for p in bbox1]  
    xs2 = [p[0] for p in bbox2]  
    ys2 = [p[1] for p in bbox2]  
  
    x_min = min(min(xs1), min(xs2))  
    x_max = max(max(xs1), max(xs2))  
    y_min = min(min(ys1), min(ys2))  
    y_max = max(max(ys1), max(ys2))  
  
    return [[x_min, y_min], [x_max, y_min], [x_max, y_max], [x_min, y_max]]  

ℹ️ 기능

• EasyOCR이 주민등록번호를 두 조각으로 인식하는 경우를 대비하기 위한 함수

🧩 상황 배경: EasyOCR의 분리 인식 문제 예를 들어 이미지 안에 아래와 같은 주민등록번호가 있다고 하자.

123456-7891011

EasyOCR이 주민등록번호를 인식하는 과정에서 다음과 같이 인식하는 경우가 있다.

인식된 텍스트	bbox(사각형 좌표)	설명
123456	bbox1	앞 6자리만 인식
7891011	bbox2	뒤 7자리만 인식

이렇게 나누어 인식하게 되면 해당 텍스트가 주민등록번호인지 정규식으로 걸러낼 수가 없다. 따라서

1. 앞자리 후보(front_parts)와 뒷자리 후보(back_parts)를 각각 따로 수집
2. x축 거리(MAX_X_DISTANCE)와 y축 거리(MAX_Y_DISTANCE)를 기준으로 “붙어 있는지” 판별 (앞자리 후보와 뒷자리 후보가 너무 멀리 떨어져 있다면 주민등록번호가 아니라고 판정)
3. “붙어 있다”고 판단되면 두 bbox를 하나로 결합(combine_bboxes(bbox1, bbox2) 사용)

⚙️ 작동 방식

def combine_bboxes(bbox1, bbox2):  
    xs1 = [p[0] for p in bbox1]  
    ys1 = [p[1] for p in bbox1]  
    xs2 = [p[0] for p in bbox2]  
    ys2 = [p[1] for p in bbox2]

bbox 예시

bbox = [[np.int32(296), np.int32(188)], [np.int32(640), np.int32(188)],
      [np.int32(640), np.int32(264)], [np.int32(296), np.int32(264)]]

• 각 bbox의 x, y 좌표들을 각각 분리해 리스트로 추출
  

x_min = min(min(xs1), min(xs2))  
x_max = max(max(xs1), max(xs2))  
y_min = min(min(ys1), min(ys2))  
y_max = max(max(ys1), max(ys2)) 

• 두 bbox의 모든 점을 비교하여, x_min, x_max, y_min, y_max 값을 구한다.
• 두 텍스트를 완전히 덮는 최소 크기의 직사각형의 꼭지점 좌표는 다음과 같다.

return [[x_min, y_min], [x_max, y_min], [x_max, y_max], [x_min, y_max]]

메인 처리 함수

process_image 함수

def process_image(image_path, reader):

⭐ 이 함수가 하는 일

1. 이미지를 입력 받아(image_path) EasyOCR로 이미지에서 텍스트를 읽고
2. 주민등록번호(전체 인식되거나, 분리 인식된 것)를 정규식으로 찾아
3. 해당 부분을 마스킹(mask_bbox()) 처리한 뒤
4. 결과 이미지를 저장하는 핵심 함수

---

이미지 읽기 및 예외 처리

image = cv2.imread(image_path)  
if image is None or image.size == 0:  
    print(f"[ERROR] 이미지를 읽을 수 없음: {image_path}")  
    return 0

• image = cv2.imread() → OpenCV로 입력 이미지 읽기
• 파일이 깨져 있거나 없는 경우를 대비해 예외 처리.
  • cv2.imread()는 실패 시 None을 반환하기 때문에 이 조건문으로 안정성 확보.
  • 이 함수의 반환값(found)은 “탐지된 주민번호 수”이므로, 0은 ‘없음’으로 의미 있게 작동

---

이미지 읽기 및 예외 처리

try:
    ocr_results = reader.readtext(image, low_text=OCR_LOW_TEXT)
except Exception as e:
    print(f"[ERROR] EasyOCR 실행 중 오류 발생: {e}")
    return 0

• EasyOCR 모델(reader.readtext())을 이용해 이미지 내의 모든 텍스트 박스와 인식 결과 얻음.
• ocr_results는 리스트 형태이며, 각 항목은 (bbox, text, confidence) 튜플.

  ocr_results 예시

  [(([[np.int32(87), np.int32(215)], [np.int32(119), np.int32(215)],
      [np.int32(119), np.int32(235)], [np.int32(87), np.int32(235)]], 
      '주민등록증', np.float64(0.35778852344696405)),
    ([[np.float64(16.990464937253567), np.float64(101.67997636823249)],
      [np.float64(180.36775881930328), np.float64(36.506987062360956)],
      [np.float64(198.00953506274644), np.float64(93.32002363176751)],
      [np.float64(34.63224118069672), np.float64(158.49301293763904)]],
      '홍길동', np.float64(0.12592596196615638)),
    ...)]
  

• 오류가 날 가능성을 대비하기 위해 try-except로 감싸 안전성 확보.

---

초기 변수 설정

found = 0  
masked_bboxes_coords = [] 

• found: 현재 이미지에서 마스킹된 주민등록번호의 개수 카운트
• masked_bboxes_coords: 나중에 마스킹된 bbox들의 좌표를 저장할 리스트

---

완전한 주민등록번호 패턴 탐지

for bbox, text, conf in ocr_results:
    m_combined = rrn_combined_regex.search(text)
    if m_combined:
         image = mask_bbox(image, bbox, method=MASK_METHOD)
         found += 1
         masked_bboxes_coords.append(bbox)
         print(f"[MASKED] Combined RRN='{m_combined.group()}' | conf={conf:.2f}")
         continue
  
    m_nohyphen = rrn_nohyphen_regex.search(text)
    if m_nohyphen:
         image = mask_bbox(image, bbox, method=MASK_METHOD)
         found += 1
         masked_bboxes_coords.append(bbox)
         print(f"[MASKED] NoHyphen RRN='{m_nohyphen.group()}' | conf={conf:.2f}")
         continue

re.search(pattern, text(string), flags=0)

text가 pattern(정규 표현식 패턴)과 일치하는지 검색하는 메서드. flags는 선택적 인수로 정규 표현식의 동작을 수정하는 플래그. 정규표현식과 패턴이 일치하는 경우에 re.match 객체 반환, 일치하지 않으면 None 반환.

반환값 예시

rrn_combined_regex = re.compile(r"\b\d{6}\s*-\s*\d{7}\b")
text_1 = "501111-1234566"
text_2 = "주민등록증"
 
m_combined_1 = rrn_combined_regex.search(text)
m_combined_2 = rrn_combined_regex.search(text_2)
 
print(m_combined_1)
print(m_combined_2)

위의 코드를 실행하게 되면 다음과 같은 결과값을 얻는다.

<re.Match object; span=(0, 14), match='501111-1234566'>
None

참고로 group()은 검색된 객체 자체를 가져올 수 있는 메서드다. 예를 들어,

m_combined_1.group()

위를 실행하면 결과는 다음과 같다.

'501111-1234566'

ℹ️ 기능

• EasyOCR 결과 중 “주민등록번호 전체(6자리-7자리)“가 들어 있는 텍스트 검색.
• 2개의 정규식 사용
  • rrn_combined_regex → -
  • rrn_nohyphen_regex → (하이픈 없는 13자리)

• None이 아닌 re.match 객체 반환 시 mask_bbox() 호출 → 지정된 방식(검정, 모자이크, 블러, 텍스트 교체)로 마스킹 수행
• continue를 써서 한 번 마스킹된 bbox는 다음 검사 생략 → 중복 마스킹 방지 (아마 java의 continue와 기능적으로 일치)

  continue는 반복문(for, while)에서 아래의 코드를 실행 시키지 않고, 다음 반복 구문으로 넘어가도록 하는 제어자

---

분리 인식된 주민번호 탐지

front_parts, back_parts = [], []
 
for bbox, text, conf in ocr_results:
    clean_text = re.sub(r'[- ]', '', text)
    if rrn_front_regex.search(clean_text) and len(clean_text) == 6:
        front_parts.append({'bbox': bbox, 'text': text, 'conf': conf})
    elif rrn_back_regex.search(clean_text) and len(clean_text) == 7:
        back_parts.append({'bbox': bbox, 'text': text, 'conf': conf})

re.sub(pattern, replace, text)

text 중 pattern에 해당하는 부분을 replace로 대체하는 메서드.

• clean_text = re.sub(r'[- ]', '', text): 하이픈(-)이나 공백을 제거해서 숫자만 남김 → "123456 -"와 같은 텍스트를 "123456"으로 변환
• **rrn_front_regex(6자리)와 rrn_back_regex(7자리)**에 의해 숫자 길이와 패턴을 만족하는 항목을 각각 front_parts와 back_parts에 보관
• 각 항목은 {'bbox': bbox, 'text': text, 'conf': conf} 형태로 저장되어 좌표와 원문을 유지

---

앞/뒤 페어링 및 bbox 결합

masked_fronts = set()
masked_backs = set()
 
for i, front in enumerate(front_parts):
    if i in masked_fronts:
        continue
        
    front_xs = [p[0] for p in front['bbox']]
    front_ys = [p[1] for p in front['bbox']]
    front_x_max = max(front_xs)
    front_y_center = (min(front_ys) + max(front_ys)) / 2
    
    for j, back in enumerate(back_parts):
        if j in masked_backs:
            continue
            
        back_xs = [p[0] for p in back['bbox']]
        back_ys = [p[1] for p in back['bbox']]
        back_x_min = min(back_xs)
        back_y_center = (min(back_ys) + max(back_ys)) / 2
        
        x_distance = back_x_min - front_x_max
        y_diff = abs(front_y_center - back_y_center)
        
        if 0 <= x_distance <= MAX_X_DISTANCE and y_diff <= MAX_Y_DIFFERENCE:  
            combined_bbox = combine_bboxes(front['bbox'], back['bbox'])
            image = mask_bbox(image, combined_bbox, method=MASK_METHOD)
            found += 1
            # 중복 방지  
            masked_fronts.add(i)
            masked_backs.add(j)
            
            combined_text = f"{front['text']}-{back['text']}"  
            print(f"[MASKED] Combined (Split) RRN='{combined_text}' | dist={x_distance:.1f} | y_diff={y_diff:.1f}")
            break

ℹ️ 기능

• “앞 숫자 박스의 오른쪽 끝과, 뒤 숫자 박스의 왼쪽 시작이 가깝고(수평 거리), 두 박스의 세로 중심이 거의 같은 경우(같은 행)”, 이를 하나의 주민번호로 판단한다.

set()

Python 내장 함수로, 집합에 관련된 것을 쉽게 처리할 수 있다.

Example

s1 = set([1, 2, 3])
s2 = set("hello")
print(s1) # result : {1,2,3}
print(s2) # result : {'l', 'h', 'e', 'o'}

abs(x)

Python 내장 함수로, x의 절댓값 반환

• front_x_max = max(fronts_xs): 앞 박스의 오른쪽 끝(x 좌표)
• back_x_min = min(back_xs): 뒤 박스의 왼쪽 시작(x좌표)
• x_distance = back_x_min - front_x_max
  • 이 값이 0 이상이면 뒤 박스가 앞 박스 오른쪽에 위치(논리적 동치)
  • ⇐ MAX_X_DISTANCE 이면 붙어 있다(하이픈이나 공백 정도의 거리).
• front_y_center, back_y_center: 각 박스의 수직 중심.
  • y_diff = abs(...)가 ⇐ MAX_Y_DISTANCE이면 같은 행에 있다고 취급.

---

결과 저장

fname = os.path.basename(image_path)
out_path = os.path.join(OUTPUT_DIR, f"EasyOCR_masked_{MASK_METHOD}_{fname}")
cv2.imwrite(out_path, image)
print(f"완료: {out_path} (총 {found}개 주민등록번호 처리)")
return fou

• 마스킹 완료된 이미지를 OUTPUT_DIR에 저장
• 파일명에 MASK_METHOD를 포함시켜 구분

메인 함수

main 함수

def main():

⭐ 이 함수가 하는 일

1. OCR Reader 초기화부터 이미지 폴더 전체 순회
2. process_image() 호출
3. 통계 출력까지 전체 마스킹 파이프라인을 제어하는 진입점(entry point) 함수

EasyOCR Reader 초기화

reader = easyocr.Reader(OCR_LANGS, gpu=True)

• EasyOCR의 Reader 객체 초기화

---

이미지 목록 수집

img_files = []  
for ext in ("*.jpg", "*.jpeg", "*.png"):  
    img_files.extend(glob(os.path.join(INPUT_DIR, ext)))
    
if not img_files:  
    print(f"[INFO] 입력 폴더에 이미지가 없습니다: {INPUT_DIR}")  
    return

• 지정된 INPUT_DIR에서 이미지 파일 모두 수집
• JPG, JPEG, PNG 확장자만 인식 대상으로 포함.
• 입력 폴더에 이미지가 없을 경우 조기 종료

---

전체 파일 루프 및 처리

total_masked = 0
for img_path in img_files:  
    print(f"\n처리 중: {img_path}")  
    total_masked += process_image(img_path, reader)  
 
print(f"\n=== 전체 완료 ===\n총 {len(img_files)}장 처리, {total_masked}개 주민등록번호 처리")

• 수집한 이미지 파일들을 하나씩 순회하며 처리
• process_image() 함수에 각 이미지 경로와 reader 객체를 전달
• 함수가 반환한 “마스킹된 주민등록번호 개수”(found)를 누적
• 마지막으로 전체 요약 결과를 콘솔에 출력

---

스크립트 진입점

if __name__ == "__main__":  
    main()

끝!

---

PaddleOCR

Import Library

import re
import os
import cv2
import numpy as np
from paddleocr import PaddleOCR
from PIL import Image, ImageDraw, ImageFont
# import paddle

• paddleocr.PaddleOCR: OCR 모델 로드·예측
• paddle: GPU 메모리 조회하려면 paddle 필요 (필수 x)

(주석 처리된) GPU 메모리 출력 코드

# GPU 메모리 사용량 확인
# mem_alloc = paddle.device.cuda.memory_allocated()
# mem_reserved = paddle.device.cuda.max_memory_reserved()
# print(f"시작 전 메모리: {mem_alloc/1024**2:.2f} MB")
# print(f"최대 예약된 메모리: {mem_reserved / 1024**2:.2f} MB")

• GPU 메모리 사용량을 출력하는 코드(주석 처리됨).

OCR 초기화

ocr = PaddleOCR(
    lang='korean',
    use_doc_orientation_classify=False,
    use_doc_unwarping=False,
    use_textline_orientation=False,
    device='gpu:0', # 'cpu' 로 변경 가능
)

• PaddleOCR 객체를 생성하여 모델을 로드한다.

paddleocr.PaddleOCR()

• lang
  • 사용할 OCR 모델 언어.
  • PaddleOCR이 지원하는 언어 목록
• use_doc_orientation_classify
  • 문서 방향 분류 모듈 활성화 여부. 기본값은 True.
  • 스캔한 문서 이미지가 올바른 방향인지(회전되어 있는지) 자동으로 판별.
• use_doc_unwarping
  • text image unwarping 모듈 활성화 여부. 기본값은 True.
  • “text image unwarping”이란 구부러지거나 왜곡된 문서 이미지를 평평하고 올바른 형태로 복원하는 기술을 뜻한다.
• use_textline_orientation
  • 텍스트 방향 분류 모듈 활성화 여부. 기본값은 True
  • 이미지 속 텍스트가 올바른 방향인지(회전되어 있는지) 자동으로 판별.

매개변수에 대한 더 자세한 내용은 PaddleOCR Documentation 참조.

• use_doc_orientation_classify
  • 문서 방향 분류 모듈 활성화 여부를 나타내는 매개변수. 기본값은 True.
  • 스캔한 문서 이미지가 올바른 방향인지(회전되어 있는지) 자동으로 판별.
• use_doc_unwarping
  • text image unwarping 모듈 활성화 여부를 나타내는 매개변수. 기본값은 True.
  • “text image unwarping”이란 구부러지거나 왜곡된 문서 이미지를 평평하고 올바른 형태로 복원하는 기술을 뜻한다.
• use_textline_orientation
  • 텍스트 방향 분류 모듈 활성화 여부를 나타내는 매개변수. 기본값은 True
  • 이미지 속 텍스트가 올바른 방향인지(회전되어 있는지) 자동으로 판별.

주민등록번호 정규식

patterns = [
    re.compile(r"\b\d{6}\s*-\s*\d{7}\b"),
    re.compile(r"\b\d{13}\b")
]

• EasyOCR-PII.py와 동일.

마스킹 함수들

paddleocr.PaddleOCR.predict가 반환하는 dt_polys(텍스트 바운디 박스 좌표, 4개 꼭짓점) 포맷을 그대로 받아서 처리한다. 아래에 후술할 각 함수는 폴리곤을 마스크로 만들고 그 내부를 조작하는 방식으로 마스킹 처리를 하며, EasyOCR의 마스킹 함수들과 거의 동일한 방식으로 이루어진다.

검정색 채우기

def mask_black(img, box):
    pts = np.array(box, dtype=np.int32)
    cv2.fillPoly(img, [pts], color=(0,0,0))
    return img

• 주어진 box 폴리곤 내부를 (B,G,R)=(0,0,0)으로 채움.

블러 처리

def mask_blur(img, box):
    pts = np.array(box, dtype=np.int32)
    mask = np.zeros(img.shape[:2], dtype=np.uint8)
    cv2.fillPoly(mask, [pts], 255)
    x, y, w, h = cv2.boundingRect(pts)
    roi = img[y:y+h, x:x+w]
    roi_mask = mask[y:y+h, x:x+w]
    if roi.size > 0:
        kernel = (51, 51) # kernel: 블러 강도 조절 (홀수값 입력, 값이 클수록 강도 ↑)
        blurred = cv2.GaussianBlur(roi, kernel, 30)
        roi[roi_mask==255] = blurred[roi_mask==255]
        img[y:y+h, x:x+w] = roi
    return img

EasyOCR의 블러 마스킹과 동일

• mask를 만들어 ROI에만 블러를 적용.
• kernel은 반드시 홀수. 값이 클수록 블러 강해짐. (51은 매우 강함)

모자이크 처리

def mask_mosaic(img, box, ratio=0.05): # ratio: 모자이크 강도 조절 (값이 낮을수록 강도 ↑)
    pts = np.array(box, dtype=np.int32)
    mask = np.zeros(img.shape[:2], dtype=np.uint8)
    cv2.fillPoly(mask, [pts], 255)
    x, y, w, h = cv2.boundingRect(pts)
    roi = img[y:y+h, x:x+w]
    roi_mask = mask[y:y+h, x:x+w]
    if roi.size > 0:
        small = cv2.resize(roi, (max(1,int(w*ratio)), max(1,int(h*ratio))), interpolation=cv2.INTER_LINEAR)
        mosaic = cv2.resize(small, (w,h), interpolation=cv2.INTER_NEAREST)
        roi[roi_mask==255] = mosaic[roi_mask==255]
        img[y:y+h, x:x+w] = roi
    return img

EasyOCR의 모자이크 마스킹과 동일

텍스트로 대체 (회전 반영)

def mask_replace_text(img, box, text="[ REDACTED ]"):
        pts = np.array(box, dtype=np.int32)
        x, y, w, h = cv2.boundingRect(pts)
        center_x = x + w // 2
        center_y = y + h // 2
        cv2.fillPoly(img, [pts], (255, 255, 255))
        max_len = 0
        angle = 0
        for i in range(4):
            dx = pts[(i+1)%4][0] - pts[i][0]
            dy = pts[(i+1)%4][1] - pts[i][1]
            length = np.hypot(dx, dy)
            if length > max_len:
                max_len = length
                angle = -np.degrees(np.arctan2(dy, dx))
        pil_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
        draw = ImageDraw.Draw(pil_img)
        diagonal = np.hypot(w, h)
        font_size = min(max(int(diagonal * 0.1), 12), h)
        try:
            font = ImageFont.truetype("malgunbd.ttf", font_size) # 맑은 고딕 bold
        except:
            font = ImageFont.load_default()
        bbox_text = draw.textbbox((0, 0), text, font=font)
        text_w = bbox_text[2] - bbox_text[0]
        text_h = bbox_text[3] - bbox_text[1]
        offset = 5 # 텍스트 위로 올릴 픽셀 수
        text_x = center_x - text_w / 2
        text_y = center_y - text_h / 2 - offset
        text_layer = Image.new("RGBA", pil_img.size, (255, 255, 255, 0))
        text_draw = ImageDraw.Draw(text_layer)
        text_draw.text((text_x, text_y), text, font=font, fill=(255, 0, 0, 255))
        rotated_layer = text_layer.rotate(angle, center=(center_x, center_y), resample=Image.BICUBIC)
        pil_img = Image.alpha_composite(pil_img.convert("RGBA"), rotated_layer)
        img[:] = cv2.cvtColor(np.array(pil_img.convert("RGB")), cv2.COLOR_RGB2BGR)
 
        return img

EasyOCR의 텍스트 교체 마스킹과 동일

마스킹 메서드 매핑

masking_methods = {
    "black": mask_black,
    "blur": mask_blur,
    "mosaic": mask_mosaic,
    "replace_text": mask_replace_text
}

• 문자열로 처리 방식 선택을 쉽게 하기 위해 딕셔너리 매핑(dictionary mapping).
• 후술할 masking 인자값 간편하게 선택 가능.

이미지 처리 함수

def process_image(img_path, save_path, masking="black"):
    img = cv2.imread(img_path)
    if img is None:
        print(f"이미지를 읽을 수 없습니다: {img_path}")
        return
 
    result = ocr.predict(img_path)[0]  # result[0] 사용
    rec_texts = result['rec_texts']
    #print(rec_texts) # OCR한 텍스트를 출력해보고 싶으면 주석을 지우세용
    dt_polys = result['dt_polys']
 
    for text, box in zip(rec_texts, dt_polys):
        if any(p.search(text) for p in patterns):
            if masking in masking_methods:
                img = masking_methods[masking](img, box)
 
    cv2.imwrite(save_path, img)
    print(f"저장 완료: {save_path}")

• cv2.imread(img_path): 이미지 로드 (BGR numpy array).

• if img is None: 파일 읽기 실패 체크.

• result = ocr.predict(img_path)[0]: OCR 실행 및 결과 불러오기. (사용하신 버전에서 predict가 path를 받아서 결과 리스트를 반환한다고 가정)

• rec_texts = result['rec_texts'], dt_polys = result['dt_polys'] : 텍스트 목록과 각 텍스트의 폴리곤 좌표 추출.

• for text, box in zip(...): 텍스트와 좌표를 묶어 순회.

• if any(p.search(text) for p in patterns): 정규식으로 주민등록번호 패턴을 찾으면 true.

• img = masking_methods[masking](img, box): 선택한 마스킹 함수로 이미지 갱신.

• cv2.imwrite(save_path, img): 결과 저장.

메인 실행 블록

if __name__ == "__main__":
    input_dir = "idc_samples"
    output_dir = "idc_results"
    os.makedirs(output_dir, exist_ok=True)
 
    # 선택: "black", "blur", "mosaic", "replace_text"
    masking_type = "black"
 
    for file in os.listdir(input_dir):
        if file.lower().endswith((".jpg", ".jpeg", ".png")):
            input_path = os.path.join(input_dir, file)
            output_path = os.path.join(output_dir, f"PaddleOCR_{masking_type}_{file}")
            process_image(input_path, output_path, masking=masking_type)

• 입력/출력 디렉토리 지정 및 출력 디렉토리 생성.

• masking_type으로 마스킹 방식 선택.

• 입력 디렉토리의 이미지들을 순회하면서 process_image 호출.