OCR-PII

EasyOCR

import re  
import cv2  
import easyocr  
import os  
from glob import glob  
import numpy as np  
from PIL import Image, ImageDraw, ImageFont  
# import torch  
  
## ==== 사전 설정 ====  
# EasyOCR 설정 및 파일 경로  
OCR_LANGS = ['ko', 'en']                # 필요한 언어  
INPUT_DIR = "idc_samples"               # 입력 이미지 폴더  
OUTPUT_DIR = "idc_results"              # 결과 저장 폴더  
os.makedirs(OUTPUT_DIR, exist_ok=True)  
  
# 정규식 (3가지 유형 커버)  
rrn_combined_regex = re.compile(r"\b\d{6}\s*-\s*\d{7}\b")  # 6자리-7자리  
rrn_nohyphen_regex = re.compile(r"\b\d{13}\b")       # 13자리 붙은 경우  
rrn_front_regex = re.compile(r"\b\d{6}\b")           # 앞 6자리  
rrn_back_regex = re.compile(r"\b\d{7}\b")            # 뒤 7자리  
  
## ==== 외부 설정값 ====  
# 결합 임계값 설정  
MAX_X_DISTANCE = 50  
MAX_Y_DIFFERENCE = 10  
  
# 비식별화 방식 및 설정  
MASK_METHOD = "black"       # "black", "mosaic", "blur", "replace_text"  
REPLACE_TEXT = "[ REDACTED ]"  # replace_text 모드에서 표시할 텍스트 (한글 사용 x)                           # OpenCV 자체에서 제공하는 내장 폰트를 사용하므로 한글 지원이 안 됩니다.  
MOSAIC_SCALE = 0.05        # (0.01 ~ 0.03 정도 권장, 작을수록 강한 모자이크)  
BLUR_KERNEL = (51, 51)     # 가우시안 블러 커널 크기 (반드시 홀수값 입력, 클수록 강함)  
OCR_LOW_TEXT = 0.4         # 얼마나 낮은 신뢰도의 텍스트까지 포함할지 결정 (기본값: 0.4)  
                           # 화질이 낮거나 흐린 문서라면 ↓ 노이즈가 많은 이미지라면 ↑ 추천  
# -----------------------  
  
  
# ==== 마스킹 유틸리티 함수 ====  
def mask_bbox(img, bbox, method=MASK_METHOD):  
    """  
    EasyOCR bbox (4점 좌표)를 그대로 사용하여 텍스트만 마스킹  
    - bbox: EasyOCR에서 반환한 4점 좌표  
    - method: 마스킹 방식 (black, mosaic, blur, replace_text)    """  
    pts = np.array(bbox, dtype=np.int32)  
  
    if method == "black":  
        cv2.fillPoly(img, [pts], (0, 0, 0))  
  
    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]  
  
    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]  
  
    elif method == "replace_text":  
        # bbox 좌표 추출  
        pts = np.array(bbox, dtype=np.int32)  
  
        # bbox 크기와 중심 계산  
        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 이미지 생성  
        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()  
  
        # 7) 텍스트 크기 계산  
        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]  
  
        # 8) 텍스트 위치 계산 (bbox 중심 기준)  
        offset = 5 # 텍스트 위로 올릴 픽셀 수  
        text_x = center_x - text_w / 2  
        text_y = center_y - text_h / 2 - offset  
  
        # 9) 텍스트 레이어 생성  
        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))  
  
        # 10) 텍스트 레이어 회전 (bbox 중심 기준)  
        rotated_layer = text_layer.rotate(angle, center=(center_x, center_y), resample=Image.BICUBIC)  
  
        # 11) 합성  
        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  
  
  
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]]  
  
  
# ==== 메인 처리 함수 ====def process_image(image_path, reader):  
    image = cv2.imread(image_path)  
    if image is None or image.size == 0:  
        print(f"[ERROR] 이미지를 읽을 수 없음: {image_path}")  
        return 0  
  
    try:  
        ocr_results = reader.readtext(image, low_text=OCR_LOW_TEXT)  
    except Exception as e:  
        print(f"[ERROR] EasyOCR 실행 중 오류 발생: {e}")  
        return 0  
  
    found = 0  
    masked_bboxes_coords = []  
  
    # 1) 통합 패턴 처리  
    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  
  
    # 2) 분리 패턴 처리  
    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})  
  
    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  
  
    # 결과 저장  
    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 found  
  
  
def main():  
    reader = easyocr.Reader(OCR_LANGS, gpu=True)  
  
    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  
  
    total_masked = 0  
    for img_path in img_files:  
        print(f"\n처리 중: {img_path}")  
        total_masked += process_image(img_path, reader)  
  
        # GPU VRAM 상태 출력 (GB 단위)  
        # if torch.cuda.is_available():        #     allocated = torch.cuda.memory_allocated(0) / 1024**3  # GB        #     reserved  = torch.cuda.memory_reserved(0) / 1024**3   # GB        #     print(f"현재 VRAM 사용: {allocated:.3f} GB, 예약된 VRAM: {reserved:.3f} GB")  
    print(f"\n=== 전체 완료 ===\n총 {len(img_files)}장 처리, {total_masked}개 주민등록번호 처리")  
  
  
if __name__ == "__main__":  
    main()

PaddleOCR

import os
import re
import cv2
import numpy as np
from paddleocr import PaddleOCR
from PIL import Image, ImageDraw, ImageFont
# import paddle
 
# 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")
 
# ----- OCR 초기화 -----
ocr = PaddleOCR(
    lang='korean',
    use_doc_orientation_classify=False,
    use_doc_unwarping=False,
    use_textline_orientation=False,
    device='gpu:0',
)
 
# ----- 주민등록번호 정규식 -----
patterns = [
    re.compile(r"\b\d{6}\s*-\s*\d{7}\b"),
    re.compile(r"\b\d{13}\b")
]
 
# ----- 마스킹 함수 (dt_polys 좌표 그대로 사용) -----
def mask_black(img, box):
    pts = np.array(box, dtype=np.int32)
    cv2.fillPoly(img, [pts], color=(0,0,0))
    return img
 
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
 
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
 
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
 
masking_methods = {
    "black": mask_black,
    "blur": mask_blur,
    "mosaic": mask_mosaic,
    "replace_text": mask_replace_text
}
 
# ----- 이미지 처리 함수 -----
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}")
 
# ----- 메인 -----
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)
            # 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 메모리 확인
# mem_alloc = paddle.device.cuda.memory_allocated()
# mem_reserved = paddle.device.cuda.max_memory_reserved()
# print(f"OCR 실행 후 메모리: {paddle.device.cuda.memory_allocated()/1024**2:.2f} MB")
# print(f"최대 예약된 메모리: {mem_reserved / 1024**2:.2f} MB")