웹폰트 최적화 완전 가이드: 다운로드부터 배포까지

# font_optimizer.py
from fontTools import subset
from fontTools.ttLib import TTFont
import os

def create_korean_subset(input_font, output_font):
    """
    한글 전용 서브셋 생성
    """
    # 한글 완성형 유니코드 범위
    korean_unicode_ranges = [
        'U+AC00-D7AF',  # 한글 완성형
        'U+1100-11FF',  # 한글 자모
        'U+3130-318F',  # 한글 호환 자모
        'U+0020-007F',  # 기본 라틴 문자
        'U+00A0-00FF',  # 라틴-1 보충
    ]
    
    # 서브셋 옵션 설정
    options = subset.Options()
    options.flavor = 'woff2'  # 출력 형식
    options.with_zopfli = True  # 압축 최적화
    options.desubroutinize = True  # 서브루틴 제거로 크기 감소
    
    # 서브셋 생성
    subsetter = subset.Subsetter(options=options)
    
    # 유니코드 범위 파싱
    unicodes = []
    for range_str in korean_unicode_ranges:
        if '-' in range_str:
            start, end = range_str.replace('U+', '').split('-')
            unicodes.extend(range(int(start, 16), int(end, 16) + 1))
        else:
            unicodes.append(int(range_str.replace('U+', ''), 16))
    
    subsetter.populate(unicodes=unicodes)
    
    # 폰트 로드 및 서브셋 적용
    font = TTFont(input_font)
    subsetter.subset(font)
    
    # 저장
    font.save(output_font)
    print(f"서브셋 생성 완료: {output_font}")
    
    # 파일 크기 비교
    original_size = os.path.getsize(input_font)
    subset_size = os.path.getsize(output_font)
    reduction = (1 - subset_size / original_size) * 100
    
    print(f"원본 크기: {original_size:,} bytes")
    print(f"서브셋 크기: {subset_size:,} bytes")
    print(f"크기 감소: {reduction:.1f}%")

# 사용 예시
if __name__ == "__main__":
    create_korean_subset(
        'NotoSansKR-Regular.otf',
        'NotoSansKR-Regular-subset.woff2'
    )

# font_metadata_optimizer.py
from fontTools.ttLib import TTFont
from fontTools.ttLib.tables._n_a_m_e import NameRecord

def optimize_font_metadata(input_font, output_font):
    """
    폰트 메타데이터 최적화 및 불필요한 테이블 제거
    """
    font = TTFont(input_font)
    
    # 1. 불필요한 테이블 제거
    unnecessary_tables = [
        'DSIG',  # 디지털 서명
        'LTSH',  # 선형 임계값
        'VDMX',  # 수직 디바이스 메트릭
        'hdmx',  # 수평 디바이스 메트릭
        'PCLT',  # PCL 5 테이블
    ]
    
    for table in unnecessary_tables:
        if table in font:
            del font[table]
            print(f"테이블 제거: {table}")
    
    # 2. 이름 테이블 최적화
    if 'name' in font:
        name_table = font['name']
        
        # 필수 이름 레코드만 유지
        essential_name_ids = [
            1,   # 폰트 패밀리명
            2,   # 서브패밀리명
            4,   # 전체 폰트명
            6,   # PostScript명
            16,  # 선호 패밀리명
            17,  # 선호 서브패밀리명
        ]
        
        # 기존 레코드 백업
        original_records = list(name_table.names)
        
        # 새로운 레코드 리스트 생성
        new_records = []
        for record in original_records:
            if record.nameID in essential_name_ids:
                # 영어(1033)와 유니코드(0) 플랫폼만 유지
                if (record.platformID == 3 and record.langID == 1033) or \
                   (record.platformID == 0):
                    new_records.append(record)
        
        # 이름 테이블 업데이트
        name_table.names = new_records
        print(f"이름 레코드 최적화: {len(original_records)} → {len(new_records)}")
    
    # 3. 힌팅 정보 제거 (웹폰트에서는 불필요)
    if 'fpgm' in font:
        del font['fpgm']
        print("fpgm 테이블 제거 (폰트 프로그램)")
    
    if 'prep' in font:
        del font['prep']
        print("prep 테이블 제거 (사전 프로그램)")
    
    if 'cvt ' in font:
        del font['cvt ']
        print("cvt 테이블 제거 (제어 값)")
    
    # 저장
    font.save(output_font)
    
    # 파일 크기 비교
    original_size = os.path.getsize(input_font)
    optimized_size = os.path.getsize(output_font)
    reduction = (1 - optimized_size / original_size) * 100
    
    print(f"\n메타데이터 최적화 완료:")
    print(f"원본 크기: {original_size:,} bytes")
    print(f"최적화 크기: {optimized_size:,} bytes")
    print(f"크기 감소: {reduction:.1f}%")

# 사용 예시
if __name__ == "__main__":
    optimize_font_metadata(
        'NotoSansKR-Regular-subset.woff2',
        'NotoSansKR-Regular-optimized.woff2'
    )

# batch_font_optimizer.py
import os
import glob
from font_optimizer import create_korean_subset
from font_metadata_optimizer import optimize_font_metadata

def batch_optimize_fonts(input_dir, output_dir):
    """
    폴더 내 모든 폰트 파일을 일괄 최적화
    """
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
    
    # 지원하는 폰트 형식
    font_extensions = ['*.otf', '*.ttf', '*.woff', '*.woff2']
    
    total_original_size = 0
    total_optimized_size = 0
    
    for extension in font_extensions:
        pattern = os.path.join(input_dir, extension)
        font_files = glob.glob(pattern)
        
        for font_file in font_files:
            print(f"\n처리 중: {os.path.basename(font_file)}")
            
            base_name = os.path.splitext(os.path.basename(font_file))[0]
            
            # 1단계: 서브셋 생성
            subset_file = os.path.join(output_dir, f"{base_name}-subset.woff2")
            create_korean_subset(font_file, subset_file)
            
            # 2단계: 메타데이터 최적화
            final_file = os.path.join(output_dir, f"{base_name}-final.woff2")
            optimize_font_metadata(subset_file, final_file)
            
            # 임시 파일 정리
            os.remove(subset_file)
            
            # 크기 누적
            original_size = os.path.getsize(font_file)
            optimized_size = os.path.getsize(final_file)
            
            total_original_size += original_size
            total_optimized_size += optimized_size
    
    # 전체 결과 출력
    total_reduction = (1 - total_optimized_size / total_original_size) * 100
    print(f"\n=== 전체 최적화 결과 ===")
    print(f"총 원본 크기: {total_original_size:,} bytes")
    print(f"총 최적화 크기: {total_optimized_size:,} bytes")
    print(f"총 크기 감소: {total_reduction:.1f}%")

# 사용 예시
if __name__ == "__main__":
    batch_optimize_fonts('./fonts/original', './fonts/optimized')