AI 기반 시각화 전문지식 서비스

프로그램개발 · 분야 선택22개 분야

Ver3.5 전체 열람

Ver3.5 🖼️ 대량 이미지 리사이즈 자동화소스코드 완전정복

2026.04.21

재능넷

댓글 0 전체 59 페이지

🛠️ 프로그램/소스 · 프로그램개발

🖼️ 대량 이미지 리사이즈 자동화
소스코드 완전정복

수백 장도 1초컷? 그거 코드로 가능함 ㅋㅋ
Python부터 Node.js까지 실전 소스 총정리!

📋 오늘 배울 내용 미리보기

📌
왜 자동화?
수동 리사이즈의 한계

🐍
Python Pillow
가장 대중적인 방법

⚡
Node.js Sharp
초고속 처리

🖥️
Bash 스크립트
ImageMagick 활용

🗂️
폴더 구조 설계
실전 프로젝트 세팅

🔧
고급 옵션
워터마크·포맷변환

🚀
성능 최적화
멀티스레딩 처리

💡
실전 팁
에러 핸들링까지

🤔 수동으로 하면 안 되나요? (됩니다만...)

솔직히 말하면 이미지 1~2장은 포토샵이나 그림판으로도 충분함 ㅋㅋ
근데 현실은 그렇지 않잖아요?

쇼핑몰 운영하면서 상품 이미지 500장을 웹용·썸네일용·모바일용으로 각각 만들어야 한다고 생각해봐요.
500장 × 3가지 사이즈 = 1,500번의 수동 작업 😱

이게 바로 자동화가 필요한 이유임. 코드 한 번 짜놓으면 그 다음부터는 그냥 실행만 하면 되거든요!

💡 이런 상황에서 자동화가 빛을 발함! ✅ 쇼핑몰 상품 이미지 대량 업로드 전처리
✅ 블로그/SNS용 이미지 사이즈 규격 맞추기
✅ 앱 개발 시 아이콘 여러 해상도 생성 (1x, 2x, 3x)
✅ 웹사이트 반응형 이미지 세트 생성
✅ 사진 아카이브 정리 및 썸네일 일괄 생성

⚠️ 수동 작업의 현실적인 문제점
❌ 시간이 너무 오래 걸림 (500장 수동 = 몇 시간)
❌ 사람이 하다 보면 실수 발생 (사이즈 잘못 입력 등)
❌ 일관성이 없어짐 (매번 조금씩 다른 결과물)
❌ 반복 작업으로 인한 번아웃 ㅠㅠ

📐 이미지 리사이즈 기본 개념 정리

코드 들어가기 전에 기본 개념 좀 잡고 가야 해요. 이거 모르면 나중에 결과물 보고 "왜 이상하지?" 하게 됨 ㅋㅋ

🔸 리사이즈 방식의 종류

방식	설명	언제 쓰나
resize	가로·세로 비율 무시하고 강제 변환	정확한 사이즈가 필요할 때
thumbnail	비율 유지하며 지정 크기 안에 맞춤	썸네일 생성 시
crop	비율 유지하며 잘라내기	정사각형 프로필 이미지 등
fit/contain	비율 유지, 빈 공간은 배경색으로	균일한 캔버스 크기 필요 시
cover	비율 유지, 영역을 꽉 채우며 넘치는 부분 잘라냄	배너·커버 이미지

🔸 이미지 포맷별 특징

JPEG
사진에 최적화
손실 압축
투명도 없음

PNG
투명도 지원
무손실 압축
파일 크기 큼

WebP
구글 개발
JPEG보다 30% 작음
최신 브라우저 지원

AVIF
차세대 포맷
WebP보다 더 작음
지원 범위 확대 중

💡 리샘플링 알고리즘도 중요해요! 이미지를 줄이거나 늘릴 때 어떤 알고리즘을 쓰느냐에 따라 품질이 달라짐.

• NEAREST: 가장 빠름, 품질 낮음 (픽셀아트에 적합)
• BILINEAR: 중간 속도, 중간 품질
• BICUBIC: 느리지만 품질 좋음 (일반적으로 많이 씀)
• LANCZOS: 가장 고품질, 가장 느림 (고품질 출력 시)

🐍 Python + Pillow로 대량 리사이즈 자동화

Python의 Pillow 라이브러리는 이미지 처리의 국룰임 ㅋㅋ
설치도 쉽고, 문서도 잘 되어 있고, 커뮤니티도 활발해서 입문자한테 강추!

📦 설치 방법

# pip으로 간단 설치!
pip install Pillow

# 설치 확인
python -c "from PIL import Image; print('Pillow 설치 완료!')"

🔰 기본 단일 이미지 리사이즈

먼저 기본부터 익히고 가야죠!

from PIL import Image

# 이미지 열기
img = Image.open("원본이미지.jpg")

# 방법 1: 강제 리사이즈 (비율 무시)
resized = img.resize((800, 600))
resized.save("결과_강제.jpg")

# 방법 2: 비율 유지하며 리사이즈 (thumbnail)
img_copy = img.copy()
img_copy.thumbnail((800, 600), Image.LANCZOS)
img_copy.save("결과_비율유지.jpg")

# 방법 3: 품질 설정하며 저장 (JPEG는 1~95)
resized.save("결과_고품질.jpg", quality=90, optimize=True)

print(f"원본 크기: {img.size}")
print(f"변환 후 크기: {resized.size}")

🚀 대량 이미지 리사이즈 - 기본 버전

이제 진짜 핵심! 폴더 안의 모든 이미지를 한 번에 처리하는 코드임 👇

import os
from PIL import Image

# ===== 설정 부분 (여기만 수정하면 됨!) =====
INPUT_FOLDER = "./원본이미지"       # 원본 이미지 폴더
OUTPUT_FOLDER = "./리사이즈결과"    # 결과물 저장 폴더
TARGET_WIDTH = 800                  # 목표 가로 크기
TARGET_HEIGHT = 600                 # 목표 세로 크기
QUALITY = 85                        # JPEG 품질 (1~95)
# ==========================================

# 지원하는 이미지 확장자
SUPPORTED_FORMATS = ('.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp', '.tiff')

def resize_images_bulk(input_folder, output_folder, width, height, quality=85):
    """폴더 내 모든 이미지를 일괄 리사이즈"""
    
    # 결과 폴더 없으면 자동 생성
    os.makedirs(output_folder, exist_ok=True)
    
    # 처리 통계
    success_count = 0
    fail_count = 0
    
    # 폴더 내 파일 순회
    for filename in os.listdir(input_folder):
        # 이미지 파일만 처리
        if not filename.lower().endswith(SUPPORTED_FORMATS):
            continue
        
        input_path = os.path.join(input_folder, filename)
        output_path = os.path.join(output_folder, filename)
        
        try:
            with Image.open(input_path) as img:
                # RGBA(투명도) 이미지는 RGB로 변환 후 저장
                if img.mode in ('RGBA', 'LA', 'P'):
                    img = img.convert('RGB')
                
                # 비율 유지하며 리사이즈
                img.thumbnail((width, height), Image.LANCZOS)
                
                # 저장 (JPEG 품질 설정)
                if filename.lower().endswith(('.jpg', '.jpeg')):
                    img.save(output_path, 'JPEG', quality=quality, optimize=True)
                else:
                    img.save(output_path)
                
                success_count += 1
                print(f"✅ 완료: {filename} → {img.size}")
                
        except Exception as e:
            fail_count += 1
            print(f"❌ 실패: {filename} - 오류: {e}")
    
    print(f"\n🎉 처리 완료! 성공: {success_count}장, 실패: {fail_count}장")

# 실행!
resize_images_bulk(INPUT_FOLDER, OUTPUT_FOLDER, TARGET_WIDTH, TARGET_HEIGHT, QUALITY)

⚡ 멀티스레딩으로 속도 업그레이드!

이미지가 수백 장이면 위 코드도 좀 느릴 수 있어요.
멀티스레딩 쓰면 CPU 코어를 여러 개 활용해서 훨씬 빠름! 🔥

import os
from PIL import Image
from concurrent.futures import ThreadPoolExecutor, as_completed
import threading

INPUT_FOLDER = "./원본이미지"
OUTPUT_FOLDER = "./리사이즈결과"
TARGET_SIZE = (800, 600)
QUALITY = 85
MAX_WORKERS = 8  # 동시 처리 스레드 수 (CPU 코어 수에 맞게 조정)

SUPPORTED_FORMATS = ('.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp', '.tiff')

# 스레드 안전한 카운터
lock = threading.Lock()
success_count = 0
fail_count = 0

def process_single_image(args):
    """단일 이미지 처리 함수 (스레드에서 실행됨)"""
    global success_count, fail_count
    input_path, output_path, filename = args
    
    try:
        with Image.open(input_path) as img:
            if img.mode in ('RGBA', 'LA', 'P'):
                img = img.convert('RGB')
            
            img.thumbnail(TARGET_SIZE, Image.LANCZOS)
            
            if filename.lower().endswith(('.jpg', '.jpeg')):
                img.save(output_path, 'JPEG', quality=QUALITY, optimize=True)
            else:
                img.save(output_path)
        
        with lock:
            success_count += 1
        return f"✅ {filename}"
        
    except Exception as e:
        with lock:
            fail_count += 1
        return f"❌ {filename}: {e}"

def bulk_resize_multithreaded():
    """멀티스레딩 대량 리사이즈"""
    os.makedirs(OUTPUT_FOLDER, exist_ok=True)
    
    # 처리할 파일 목록 생성
    tasks = []
    for filename in os.listdir(INPUT_FOLDER):
        if filename.lower().endswith(SUPPORTED_FORMATS):
            input_path = os.path.join(INPUT_FOLDER, filename)
            output_path = os.path.join(OUTPUT_FOLDER, filename)
            tasks.append((input_path, output_path, filename))
    
    print(f"📁 총 {len(tasks)}개 파일 처리 시작...")
    
    # 멀티스레딩 실행
    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
        futures = [executor.submit(process_single_image, task) for task in tasks]
        
        for future in as_completed(futures):
            print(future.result())
    
    print(f"\n🎉 완료! 성공: {success_count}장, 실패: {fail_count}장")

bulk_resize_multithreaded()

🎯 여러 사이즈 동시 생성 (실전 최강 버전!)

웹 개발할 때 진짜 많이 쓰는 패턴임.
원본 하나로 여러 사이즈를 한 번에 뽑아내는 코드! 👇

import os
from PIL import Image
from pathlib import Path

INPUT_FOLDER = "./원본이미지"
OUTPUT_FOLDER = "./리사이즈결과"

# 생성할 사이즈 프리셋 정의
SIZE_PRESETS = {
    "thumbnail": (150, 150),    # 썸네일
    "small": (320, 240),        # 소형
    "medium": (640, 480),       # 중형
    "large": (1280, 960),       # 대형
    "hd": (1920, 1080),         # HD
    "square_sm": (200, 200),    # 정사각형 소
    "square_lg": (500, 500),    # 정사각형 대
}

SUPPORTED_FORMATS = ('.jpg', '.jpeg', '.png', '.bmp', '.webp')

def resize_to_multiple_sizes(input_folder, output_folder, presets):
    """여러 사이즈로 일괄 변환"""
    
    # 각 사이즈별 폴더 생성
    for preset_name in presets:
        os.makedirs(os.path.join(output_folder, preset_name), exist_ok=True)
    
    files = [f for f in os.listdir(input_folder) 
             if f.lower().endswith(SUPPORTED_FORMATS)]
    
    print(f"📁 {len(files)}개 파일 × {len(presets)}개 사이즈 = {len(files)*len(presets)}개 생성 예정")
    
    for i, filename in enumerate(files, 1):
        input_path = os.path.join(input_folder, filename)
        name_without_ext = Path(filename).stem
        ext = Path(filename).suffix
        
        print(f"\n[{i}/{len(files)}] 처리 중: {filename}")
        
        try:
            with Image.open(input_path) as original:
                for preset_name, (width, height) in presets.items():
                    img = original.copy()
                    
                    if img.mode in ('RGBA', 'LA', 'P'):
                        img = img.convert('RGB')
                    
                    # 비율 유지 리사이즈
                    img.thumbnail((width, height), Image.LANCZOS)
                    
                    # 파일명: 원본명_사이즈.확장자
                    output_filename = f"{name_without_ext}_{preset_name}{ext}"
                    output_path = os.path.join(output_folder, preset_name, output_filename)
                    
                    if ext.lower() in ('.jpg', '.jpeg'):
                        img.save(output_path, 'JPEG', quality=85, optimize=True)
                    else:
                        img.save(output_path)
                    
                    print(f"  ✅ {preset_name}: {img.size}")
                    
        except Exception as e:
            print(f"  ❌ 오류: {e}")
    
    print(f"\n🎉 모든 작업 완료!")

resize_to_multiple_sizes(INPUT_FOLDER, OUTPUT_FOLDER, SIZE_PRESETS)

💡 재능넷에서도 이미지 처리 관련 프리랜서 의뢰가 꽤 많아요!
이런 자동화 스크립트 하나 만들어두면 클라이언트 작업 시간을 엄청나게 단축할 수 있어서 경쟁력이 생김 ㅋㅋ

⚡ Node.js + Sharp로 초고속 리사이즈

Sharp는 libvips 라이브러리 기반으로 만들어진 Node.js 이미지 처리 모듈임.
Pillow보다 훨씬 빠르고, 특히 WebP·AVIF 같은 최신 포맷 처리에 강함! 🔥

웹 서버에서 실시간으로 이미지 리사이즈할 때 특히 많이 씀.
Next.js의 Image 컴포넌트도 내부적으로 Sharp 씀 ㅋㅋ

📦 설치 방법

# npm으로 설치
npm install sharp

# 또는 yarn
yarn add sharp

# 설치 확인
node -e "const sharp = require('sharp'); console.log('Sharp 설치 완료!');"

🔰 기본 사용법

const sharp = require('sharp');

// 기본 리사이즈
sharp('원본이미지.jpg')
  .resize(800, 600)           // 가로 800, 세로 600
  .toFile('결과.jpg')
  .then(info => console.log('완료:', info))
  .catch(err => console.error('오류:', err));

// 비율 유지 리사이즈 (fit 옵션)
sharp('원본이미지.jpg')
  .resize(800, 600, {
    fit: 'inside',            // 비율 유지, 안쪽에 맞춤
    withoutEnlargement: true  // 원본보다 크게 확대 안 함
  })
  .jpeg({ quality: 85 })     // JPEG 품질 설정
  .toFile('결과_비율유지.jpg');

// WebP로 변환하며 리사이즈
sharp('원본이미지.jpg')
  .resize(800)                // 가로만 지정 (세로는 비율 자동)
  .webp({ quality: 80 })
  .toFile('결과.webp');

🚀 대량 처리 - Promise.all 활용

const sharp = require('sharp');
const fs = require('fs');
const path = require('path');

// ===== 설정 =====
const INPUT_DIR = './원본이미지';
const OUTPUT_DIR = './리사이즈결과';
const TARGET_WIDTH = 800;
const TARGET_HEIGHT = 600;
const JPEG_QUALITY = 85;
// ================

const SUPPORTED_EXTS = ['.jpg', '.jpeg', '.png', '.webp', '.tiff', '.bmp'];

async function resizeSingleImage(filename) {
  const inputPath = path.join(INPUT_DIR, filename);
  const outputPath = path.join(OUTPUT_DIR, filename);
  const ext = path.extname(filename).toLowerCase();
  
  try {
    let pipeline = sharp(inputPath)
      .resize(TARGET_WIDTH, TARGET_HEIGHT, {
        fit: 'inside',
        withoutEnlargement: true
      });
    
    // 확장자에 따라 출력 포맷 설정
    if (ext === '.jpg' || ext === '.jpeg') {
      pipeline = pipeline.jpeg({ quality: JPEG_QUALITY, mozjpeg: true });
    } else if (ext === '.png') {
      pipeline = pipeline.png({ compressionLevel: 8 });
    } else if (ext === '.webp') {
      pipeline = pipeline.webp({ quality: JPEG_QUALITY });
    }
    
    const info = await pipeline.toFile(outputPath);
    return { success: true, filename, info };
    
  } catch (error) {
    return { success: false, filename, error: error.message };
  }
}

async function bulkResize() {
  // 출력 폴더 생성
  if (!fs.existsSync(OUTPUT_DIR)) {
    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
  }
  
  // 이미지 파일 목록 필터링
  const files = fs.readdirSync(INPUT_DIR)
    .filter(f => SUPPORTED_EXTS.includes(path.extname(f).toLowerCase()));
  
  console.log(`📁 총 ${files.length}개 파일 처리 시작...`);
  
  // 배치 처리 (한 번에 너무 많이 열면 메모리 부족 가능)
  const BATCH_SIZE = 20;
  let successCount = 0;
  let failCount = 0;
  
  for (let i = 0; i < files.length; i += BATCH_SIZE) {
    const batch = files.slice(i, i + BATCH_SIZE);
    const results = await Promise.all(batch.map(resizeSingleImage));
    
    results.forEach(result => {
      if (result.success) {
        successCount++;
        console.log(`✅ ${result.filename} (${result.info.width}x${result.info.height})`);
      } else {
        failCount++;
        console.log(`❌ ${result.filename}: ${result.error}`);
      }
    });
    
    console.log(`진행: ${Math.min(i + BATCH_SIZE, files.length)}/${files.length}`);
  }
  
  console.log(`\n🎉 완료! 성공: ${successCount}장, 실패: ${failCount}장`);
}

bulkResize();

🎯 여러 사이즈 + 포맷 동시 변환 (Sharp 고급)

const sharp = require('sharp');
const fs = require('fs');
const path = require('path');

const INPUT_DIR = './원본이미지';
const OUTPUT_DIR = './리사이즈결과';

// 출력 프리셋 정의
const OUTPUT_PRESETS = [
  { name: 'thumbnail', width: 150, height: 150, fit: 'cover', format: 'webp', quality: 80 },
  { name: 'small',     width: 320, height: null, format: 'webp', quality: 80 },
  { name: 'medium',    width: 640, height: null, format: 'jpeg', quality: 85 },
  { name: 'large',     width: 1280, height: null, format: 'jpeg', quality: 90 },
  { name: 'og_image',  width: 1200, height: 630, fit: 'cover', format: 'jpeg', quality: 90 },
];

async function processImageAllPresets(filename) {
  const inputPath = path.join(INPUT_DIR, filename);
  const nameWithoutExt = path.basename(filename, path.extname(filename));
  const results = [];
  
  for (const preset of OUTPUT_PRESETS) {
    const outputFilename = `${nameWithoutExt}_${preset.name}.${preset.format}`;
    const outputDir = path.join(OUTPUT_DIR, preset.name);
    const outputPath = path.join(outputDir, outputFilename);
    
    // 폴더 생성
    fs.mkdirSync(outputDir, { recursive: true });
    
    try {
      let pipeline = sharp(inputPath).resize(preset.width, preset.height, {
        fit: preset.fit || 'inside',
        withoutEnlargement: true,
        position: 'center'
      });
      
      if (preset.format === 'webp') {
        pipeline = pipeline.webp({ quality: preset.quality });
      } else if (preset.format === 'jpeg') {
        pipeline = pipeline.jpeg({ quality: preset.quality, mozjpeg: true });
      } else if (preset.format === 'avif') {
        pipeline = pipeline.avif({ quality: preset.quality });
      }
      
      const info = await pipeline.toFile(outputPath);
      results.push({ preset: preset.name, success: true, size: `${info.width}x${info.height}`, bytes: info.size });
      
    } catch (err) {
      results.push({ preset: preset.name, success: false, error: err.message });
    }
  }
  
  return { filename, results };
}

async function main() {
  const SUPPORTED_EXTS = ['.jpg', '.jpeg', '.png', '.webp', '.tiff'];
  const files = fs.readdirSync(INPUT_DIR)
    .filter(f => SUPPORTED_EXTS.includes(path.extname(f).toLowerCase()));
  
  console.log(`🚀 ${files.length}개 파일 × ${OUTPUT_PRESETS.length}개 프리셋 처리 시작!`);
  
  for (const file of files) {
    const result = await processImageAllPresets(file);
    console.log(`\n📸 ${result.filename}`);
    result.results.forEach(r => {
      if (r.success) {
        console.log(`  ✅ ${r.preset}: ${r.size} (${(r.bytes/1024).toFixed(1)}KB)`);
      } else {
        console.log(`  ❌ ${r.preset}: ${r.error}`);
      }
    });
  }
  
  console.log('\n🎉 전체 완료!');
}

main();

🖥️ Bash + ImageMagick으로 커맨드라인 자동화

Python이나 Node.js 없이 터미널 명령어만으로도 대량 리사이즈 가능함!
Linux/Mac 서버 환경에서 특히 유용하고, cron job이랑 연동하면 스케줄 자동화도 됨 👍

📦 ImageMagick 설치

# Ubuntu/Debian
sudo apt-get install imagemagick

# macOS (Homebrew)
brew install imagemagick

# 설치 확인
convert --version
# 또는 최신 버전은
magick --version

🔰 기본 명령어

# 단일 이미지 리사이즈 (비율 유지)
convert 원본.jpg -resize 800x600 결과.jpg

# 강제 리사이즈 (비율 무시, ! 사용)
convert 원본.jpg -resize 800x600! 결과.jpg

# 가로만 지정 (세로 자동)
convert 원본.jpg -resize 800 결과.jpg

# 세로만 지정 (가로 자동)
convert 원본.jpg -resize x600 결과.jpg

# 품질 설정
convert 원본.jpg -resize 800x600 -quality 85 결과.jpg

# WebP로 변환
convert 원본.jpg -resize 800x600 -quality 80 결과.webp

🚀 Bash 스크립트 - 대량 처리

#!/bin/bash
# bulk_resize.sh - 대량 이미지 리사이즈 스크립트

# ===== 설정 =====
INPUT_DIR="./원본이미지"
OUTPUT_DIR="./리사이즈결과"
TARGET_SIZE="800x600"
QUALITY=85
# ================

# 결과 폴더 생성
mkdir -p "$OUTPUT_DIR"

# 카운터 초기화
SUCCESS=0
FAIL=0

echo "🚀 대량 리사이즈 시작..."
echo "입력: $INPUT_DIR → 출력: $OUTPUT_DIR"
echo "목표 크기: $TARGET_SIZE"
echo "================================"

# 지원 포맷 처리
for ext in jpg jpeg png bmp gif webp tiff; do
    for file in "$INPUT_DIR"/*.$ext "$INPUT_DIR"/*.${ext^^}; do
        # 파일이 실제로 존재하는지 확인
        [ -f "$file" ] || continue
        
        filename=$(basename "$file")
        output_path="$OUTPUT_DIR/$filename"
        
        # ImageMagick으로 리사이즈
        if convert "$file" \
            -resize "$TARGET_SIZE" \
            -quality "$QUALITY" \
            -strip \
            "$output_path" 2>/dev/null; then
            
            echo "✅ 완료: $filename"
            ((SUCCESS++))
        else
            echo "❌ 실패: $filename"
            ((FAIL++))
        fi
    done
done

echo "================================"
echo "🎉 완료! 성공: ${SUCCESS}장, 실패: ${FAIL}장"

# 스크립트 실행 권한 부여 후 실행
chmod +x bulk_resize.sh
./bulk_resize.sh

# 또는 mogrify 명령어로 더 간단하게! (원본 덮어쓰기 주의!)
# 원본 폴더 복사 후 사용 권장
cp -r ./원본이미지 ./리사이즈결과
mogrify -resize 800x600 -quality 85 ./리사이즈결과/*.jpg

# 여러 포맷 한 번에
mogrify -resize 800x600 -quality 85 ./리사이즈결과/*.{jpg,jpeg,png}

⚠️ mogrify 사용 시 주의! mogrify는 원본 파일을 직접 수정함!
반드시 원본 폴더를 백업하거나 복사한 후에 사용하세요.
실수로 원본 날리면 복구 불가능 ㅠㅠ

🔧 고급 기능 - 워터마크, 포맷 변환, EXIF 처리

💧 워터마크 자동 삽입 (Python)

리사이즈하면서 워터마크까지 한 번에 박아버리는 코드! 쇼핑몰에서 진짜 많이 씀 ㅋㅋ

from PIL import Image, ImageDraw, ImageFont
import os

def add_watermark_and_resize(input_path, output_path, 
                              target_size=(800, 600),
                              watermark_text="© MyBrand",
                              opacity=128):
    """리사이즈 + 워터마크 동시 처리"""
    
    with Image.open(input_path) as img:
        # RGB 변환
        if img.mode != 'RGB':
            img = img.convert('RGB')
        
        # 리사이즈
        img.thumbnail(target_size, Image.LANCZOS)
        
        # 워터마크 레이어 생성 (투명)
        watermark_layer = Image.new('RGBA', img.size, (0, 0, 0, 0))
        draw = ImageDraw.Draw(watermark_layer)
        
        # 폰트 설정 (시스템 폰트 또는 기본 폰트)
        try:
            font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 
                                       size=max(20, img.width // 20))
        except:
            font = ImageFont.load_default()
        
        # 텍스트 크기 계산
        bbox = draw.textbbox((0, 0), watermark_text, font=font)
        text_width = bbox[2] - bbox[0]
        text_height = bbox[3] - bbox[1]
        
        # 우측 하단에 워터마크 배치
        margin = 10
        x = img.width - text_width - margin
        y = img.height - text_height - margin
        
        # 그림자 효과 (가독성 향상)
        draw.text((x+2, y+2), watermark_text, font=font, fill=(0, 0, 0, opacity))
        draw.text((x, y), watermark_text, font=font, fill=(255, 255, 255, opacity))
        
        # 워터마크 합성
        img_rgba = img.convert('RGBA')
        img_rgba = Image.alpha_composite(img_rgba, watermark_layer)
        final_img = img_rgba.convert('RGB')
        
        # 저장
        final_img.save(output_path, 'JPEG', quality=85, optimize=True)
        print(f"✅ 완료: {os.path.basename(output_path)}")

# 폴더 전체 처리
input_folder = "./원본이미지"
output_folder = "./워터마크결과"
os.makedirs(output_folder, exist_ok=True)

for filename in os.listdir(input_folder):
    if filename.lower().endswith(('.jpg', '.jpeg', '.png')):
        add_watermark_and_resize(
            os.path.join(input_folder, filename),
            os.path.join(output_folder, filename),
            target_size=(1000, 800),
            watermark_text="© 2024 MyShop"
        )

📋 EXIF 데이터 처리

스마트폰으로 찍은 사진은 EXIF 데이터에 회전 정보가 들어있어서
그냥 리사이즈하면 이미지가 옆으로 눕는 경우가 있음 ㅋㅋ 이거 처리해야 함!

from PIL import Image, ExifTags
import os

def fix_rotation_and_resize(input_path, output_path, target_size=(800, 600)):
    """EXIF 회전 정보 반영 + 리사이즈"""
    
    with Image.open(input_path) as img:
        # EXIF 회전 정보 자동 수정
        try:
            # EXIF 태그에서 Orientation 찾기
            exif = img._getexif()
            if exif:
                for tag_id, value in exif.items():
                    tag = ExifTags.TAGS.get(tag_id, tag_id)
                    if tag == 'Orientation':
                        if value == 3:
                            img = img.rotate(180, expand=True)
                        elif value == 6:
                            img = img.rotate(270, expand=True)
                        elif value == 8:
                            img = img.rotate(90, expand=True)
                        break
        except (AttributeError, Exception):
            pass  # EXIF 없으면 그냥 진행
        
        # RGB 변환
        if img.mode != 'RGB':
            img = img.convert('RGB')
        
        # 리사이즈
        img.thumbnail(target_size, Image.LANCZOS)
        
        # EXIF 제거하고 저장 (개인정보 보호 + 파일 크기 감소)
        img.save(output_path, 'JPEG', quality=85, optimize=True)
        print(f"✅ {os.path.basename(input_path)} → {img.size}")

# 실행
input_folder = "./원본이미지"
output_folder = "./처리결과"
os.makedirs(output_folder, exist_ok=True)

for filename in os.listdir(input_folder):
    if filename.lower().endswith(('.jpg', '.jpeg')):
        fix_rotation_and_resize(
            os.path.join(input_folder, filename),
            os.path.join(output_folder, filename)
        )

🔄 포맷 일괄 변환 (PNG → WebP)

from PIL import Image
import os
from pathlib import Path

def convert_to_webp_bulk(input_folder, output_folder, quality=80, resize_width=None):
    """모든 이미지를 WebP로 변환 (선택적 리사이즈 포함)"""
    
    os.makedirs(output_folder, exist_ok=True)
    
    supported = ('.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.gif')
    files = [f for f in os.listdir(input_folder) 
             if f.lower().endswith(supported)]
    
    print(f"📁 {len(files)}개 파일을 WebP로 변환 시작...")
    
    total_original_size = 0
    total_webp_size = 0
    
    for filename in files:
        input_path = os.path.join(input_folder, filename)
        # 확장자를 .webp로 변경
        output_filename = Path(filename).stem + '.webp'
        output_path = os.path.join(output_folder, output_filename)
        
        original_size = os.path.getsize(input_path)
        
        try:
            with Image.open(input_path) as img:
                if img.mode in ('RGBA', 'LA'):
                    # 투명도 있는 이미지는 RGBA 유지
                    pass
                else:
                    img = img.convert('RGB')
                
                # 선택적 리사이즈
                if resize_width:
                    ratio = resize_width / img.width
                    new_height = int(img.height * ratio)
                    img = img.resize((resize_width, new_height), Image.LANCZOS)
                
                img.save(output_path, 'WEBP', quality=quality, method=6)
                
                webp_size = os.path.getsize(output_path)
                total_original_size += original_size
                total_webp_size += webp_size
                
                reduction = (1 - webp_size/original_size) * 100
                print(f"✅ {filename} → {output_filename}")
                print(f"   {original_size//1024}KB → {webp_size//1024}KB ({reduction:.1f}% 감소)")
                
        except Exception as e:
            print(f"❌ {filename}: {e}")
    
    total_reduction = (1 - total_webp_size/total_original_size) * 100 if total_original_size > 0 else 0
    print(f"\n📊 전체 통계:")
    print(f"   원본 합계: {total_original_size//1024//1024}MB")
    print(f"   변환 후: {total_webp_size//1024//1024}MB")
    print(f"   총 절약: {total_reduction:.1f}%")

convert_to_webp_bulk("./원본이미지", "./webp결과", quality=80, resize_width=1200)

🗂️ 실전 프로젝트 폴더 구조 설계

코드만 잘 짜는 게 아니라 폴더 구조도 잘 설계해야 나중에 관리가 편함!
실무에서 많이 쓰는 구조 알려드림 👇

image-resize-project/
│
├── 📁 input/                    # 원본 이미지 보관
│   ├── products/                # 상품 이미지
│   ├── banners/                 # 배너 이미지
│   └── profiles/                # 프로필 이미지
│
├── 📁 output/                   # 처리 결과물
│   ├── products/
│   │   ├── thumbnail/           # 150x150
│   │   ├── small/               # 320x320
│   │   ├── medium/              # 640x640
│   │   └── large/               # 1200x1200
│   ├── banners/
│   │   ├── desktop/             # 1920x600
│   │   ├── tablet/              # 1024x320
│   │   └── mobile/              # 640x200
│   └── profiles/
│       ├── small/               # 50x50
│       └── large/               # 200x200
│
├── 📁 config/
│   └── presets.json             # 사이즈 프리셋 설정
│
├── 📁 logs/
│   └── resize_log.txt           # 처리 로그
│
├── 📄 resize_main.py            # 메인 실행 파일
├── 📄 utils.py                  # 유틸리티 함수
├── 📄 requirements.txt          # 의존성 목록
└── 📄 README.md                 # 사용법 문서

⚙️ JSON 설정 파일로 프리셋 관리

하드코딩 대신 JSON 파일로 설정 관리하면 코드 수정 없이 프리셋 변경 가능!

// config/presets.json
{
  "global": {
    "quality": 85,
    "format": "jpeg",
    "strip_exif": true
  },
  "presets": {
    "products": [
      {"name": "thumbnail", "width": 150, "height": 150, "fit": "cover"},
      {"name": "small",     "width": 320, "height": 320, "fit": "cover"},
      {"name": "medium",    "width": 640, "height": 640, "fit": "cover"},
      {"name": "large",     "width": 1200, "height": 1200, "fit": "inside"}
    ],
    "banners": [
      {"name": "desktop",  "width": 1920, "height": 600, "fit": "cover"},
      {"name": "tablet",   "width": 1024, "height": 320, "fit": "cover"},
      {"name": "mobile",   "width": 640,  "height": 200, "fit": "cover"}
    ],
    "profiles": [
      {"name": "small", "width": 50,  "height": 50,  "fit": "cover"},
      {"name": "large", "width": 200, "height": 200, "fit": "cover"}
    ]
  }
}

import json
import os
from PIL import Image

def load_config(config_path="./config/presets.json"):
    """JSON 설정 파일 로드"""
    with open(config_path, 'r', encoding='utf-8') as f:
        return json.load(f)

def process_by_config(input_folder, output_base, preset_name, config):
    """설정 파일 기반 처리"""
    
    global_config = config['global']
    presets = config['presets'].get(preset_name, [])
    
    if not presets:
        print(f"❌ 프리셋 '{preset_name}'을 찾을 수 없음!")
        return
    
    supported = ('.jpg', '.jpeg', '.png', '.webp', '.bmp')
    files = [f for f in os.listdir(input_folder) 
             if f.lower().endswith(supported)]
    
    print(f"📁 '{preset_name}' 프리셋으로 {len(files)}개 파일 처리")
    
    for filename in files:
        input_path = os.path.join(input_folder, filename)
        
        with Image.open(input_path) as img:
            if img.mode != 'RGB':
                img = img.convert('RGB')
            
            for preset in presets:
                output_dir = os.path.join(output_base, preset_name, preset['name'])
                os.makedirs(output_dir, exist_ok=True)
                output_path = os.path.join(output_dir, filename)
                
                img_copy = img.copy()
                fit = preset.get('fit', 'inside')
                
                if fit == 'cover':
                    # cover: 비율 유지하며 영역 꽉 채우기
                    img_copy = img_copy.resize(
                        (preset['width'], preset['height']), 
                        Image.LANCZOS
                    )
                else:
                    # inside: 비율 유지하며 안쪽에 맞춤
                    img_copy.thumbnail(
                        (preset['width'], preset['height']), 
                        Image.LANCZOS
                    )
                
                quality = preset.get('quality', global_config['quality'])
                img_copy.save(output_path, 'JPEG', quality=quality, optimize=True)
        
        print(f"  ✅ {filename} 처리 완료")

# 실행
config = load_config()
process_by_config("./input/products", "./output", "products", config)
process_by_config("./input/banners", "./output", "banners", config)

🛡️ 에러 핸들링 & 로깅 - 실무에서 필수!

코드 짤 때 에러 처리 안 하면 나중에 진짜 고생함 ㅋㅋ
특히 대량 처리할 때 중간에 하나 오류나면 전체가 멈추는 상황 방지해야 해요!

import os
import logging
import json
from PIL import Image
from datetime import datetime
from pathlib import Path

# ===== 로깅 설정 =====
def setup_logger(log_dir="./logs"):
    """로거 설정"""
    os.makedirs(log_dir, exist_ok=True)
    
    log_filename = f"resize_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
    log_path = os.path.join(log_dir, log_filename)
    
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s [%(levelname)s] %(message)s',
        handlers=[
            logging.FileHandler(log_path, encoding='utf-8'),
            logging.StreamHandler()  # 콘솔에도 출력
        ]
    )
    return logging.getLogger(__name__)

logger = setup_logger()

# ===== 안전한 이미지 처리 함수 =====
def safe_resize(input_path, output_path, target_size, quality=85):
    """에러 핸들링이 포함된 안전한 리사이즈"""
    
    # 파일 존재 확인
    if not os.path.exists(input_path):
        logger.error(f"파일 없음: {input_path}")
        return False
    
    # 파일 크기 확인 (0바이트 파일 방지)
    if os.path.getsize(input_path) == 0:
        logger.error(f"빈 파일: {input_path}")
        return False
    
    try:
        with Image.open(input_path) as img:
            # 이미지 유효성 검증
            img.verify()
        
        # verify() 후 다시 열어야 함 (verify는 파일 포인터를 소모함)
        with Image.open(input_path) as img:
            # 최대 이미지 크기 제한 (메모리 보호)
            MAX_PIXELS = 50_000_000  # 5천만 픽셀
            if img.width * img.height > MAX_PIXELS:
                logger.warning(f"이미지가 너무 큼: {img.size} - {input_path}")
                # 그래도 처리는 계속
            
            if img.mode not in ('RGB', 'L'):
                img = img.convert('RGB')
            
            img.thumbnail(target_size, Image.LANCZOS)
            
            # 출력 폴더 자동 생성
            os.makedirs(os.path.dirname(output_path), exist_ok=True)
            
            ext = Path(output_path).suffix.lower()
            if ext in ('.jpg', '.jpeg'):
                img.save(output_path, 'JPEG', quality=quality, optimize=True)
            elif ext == '.png':
                img.save(output_path, 'PNG', optimize=True)
            elif ext == '.webp':
                img.save(output_path, 'WEBP', quality=quality)
            else:
                img.save(output_path)
            
            logger.info(f"성공: {Path(input_path).name} → {img.size}")
            return True
            
    except Image.UnidentifiedImageError:
        logger.error(f"이미지 파일이 아님: {input_path}")
    except PermissionError:
        logger.error(f"권한 없음: {input_path}")
    except OSError as e:
        logger.error(f"OS 오류 ({input_path}): {e}")
    except Exception as e:
        logger.error(f"알 수 없는 오류 ({input_path}): {type(e).__name__}: {e}")
    
    return False

# ===== 처리 결과 리포트 생성 =====
def generate_report(results, output_path="./logs/report.json"):
    """처리 결과 JSON 리포트 생성"""
    
    success_list = [r for r in results if r['success']]
    fail_list = [r for r in results if not r['success']]
    
    report = {
        "generated_at": datetime.now().isoformat(),
        "summary": {
            "total": len(results),
            "success": len(success_list),
            "failed": len(fail_list),
            "success_rate": f"{len(success_list)/len(results)*100:.1f}%" if results else "0%"
        },
        "failed_files": [r['filename'] for r in fail_list]
    }
    
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(report, f, ensure_ascii=False, indent=2)
    
    logger.info(f"리포트 생성: {output_path}")
    logger.info(f"총 {len(results)}개 | 성공 {len(success_list)}개 | 실패 {len(fail_list)}개")
    
    return report

# ===== 메인 실행 =====
def main():
    INPUT_DIR = "./원본이미지"
    OUTPUT_DIR = "./리사이즈결과"
    TARGET_SIZE = (800, 600)
    
    SUPPORTED = ('.jpg', '.jpeg', '.png', '.bmp', '.webp', '.tiff')
    files = [f for f in os.listdir(INPUT_DIR) 
             if f.lower().endswith(SUPPORTED)]
    
    logger.info(f"처리 시작: {len(files)}개 파일")
    results = []
    
    for filename in files:
        input_path = os.path.join(INPUT_DIR, filename)
        output_path = os.path.join(OUTPUT_DIR, filename)
        
        success = safe_resize(input_path, output_path, TARGET_SIZE)
        results.append({'filename': filename, 'success': success})
    
    generate_report(results)

main()

🚀 성능 최적화 팁 모음

이미 처리된 파일 스킵하기

매번 전체를 다시 처리하면 비효율적임. 이미 결과물이 있으면 건너뛰는 로직 추가!

# 이미 처리된 파일 스킵
if os.path.exists(output_path):
    # 원본보다 결과물이 더 최신이면 스킵
    if os.path.getmtime(output_path) > os.path.getmtime(input_path):
        print(f"⏭️ 스킵 (이미 처리됨): {filename}")
        continue

진행률 표시 (tqdm 라이브러리)

대량 처리할 때 진행률 표시 없으면 멈춘 건지 돌아가는 건지 모름 ㅋㅋ

# pip install tqdm
from tqdm import tqdm

files = [...]  # 처리할 파일 목록

for filename in tqdm(files, desc="🖼️ 리사이즈 중", unit="장"):
    # 처리 코드
    process_image(filename)

메모리 효율적인 처리

이미지를 한꺼번에 메모리에 올리지 말고, 처리 후 즉시 해제!

# 좋은 방법: with 문 사용 (자동 메모리 해제)
with Image.open(input_path) as img:
    img.thumbnail(target_size, Image.LANCZOS)
    img.save(output_path)
# 여기서 자동으로 메모리 해제됨

# 나쁜 방법: 명시적 close 없이 변수에 계속 보관
img = Image.open(input_path)  # 메모리에 계속 남아있음
# ... 처리 ...
img.save(output_path)
# img.close() 안 하면 메모리 누수 가능!

ProcessPoolExecutor로 CPU 병렬 처리

ThreadPoolExecutor는 GIL 때문에 CPU 집약적 작업에 한계가 있음.
이미지 처리는 ProcessPoolExecutor가 더 효과적일 수 있어요!

from concurrent.futures import ProcessPoolExecutor
import multiprocessing

def process_image_worker(args):
    """별도 프로세스에서 실행될 함수"""
    input_path, output_path, target_size = args
    try:
        with Image.open(input_path) as img:
            if img.mode != 'RGB':
                img = img.convert('RGB')
            img.thumbnail(target_size, Image.LANCZOS)
            img.save(output_path, 'JPEG', quality=85)
        return True, input_path
    except Exception as e:
        return False, f"{input_path}: {e}"

# CPU 코어 수 자동 감지
cpu_count = multiprocessing.cpu_count()
print(f"🖥️ CPU 코어 수: {cpu_count}개 활용")

tasks = [(inp, out, (800, 600)) for inp, out in file_pairs]

with ProcessPoolExecutor(max_workers=cpu_count) as executor:
    results = list(executor.map(process_image_worker, tasks))

success = sum(1 for ok, _ in results if ok)
print(f"✅ 완료: {success}/{len(tasks)}")

💡 언제 Thread vs Process 쓸까? • ThreadPoolExecutor: I/O 바운드 작업 (파일 읽기/쓰기가 주된 병목일 때)
• ProcessPoolExecutor: CPU 바운드 작업 (이미지 변환 연산이 주된 병목일 때)

이미지 리사이즈는 보통 CPU 바운드라서 ProcessPoolExecutor가 더 효과적이지만,
SSD 환경에서는 I/O도 빠르니까 둘 다 테스트해보고 더 빠른 걸 쓰면 됨!

💼 실전 활용 시나리오 & 완성 코드

🛒 시나리오 1: 쇼핑몰 상품 이미지 처리

쇼핑몰에서 가장 많이 쓰는 패턴! 상품 이미지를 여러 사이즈로 + WebP 변환까지!

"""
쇼핑몰 상품 이미지 자동 처리 스크립트
- 원본 보존
- 썸네일, 목록, 상세 사이즈 생성
- JPEG + WebP 동시 생성
- EXIF 회전 자동 수정
"""
from PIL import Image, ExifTags
import os
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor
import logging

logging.basicConfig(level=logging.INFO, format='%(message)s')
logger = logging.getLogger(__name__)

PRODUCT_SIZES = {
    'thumb':  (150, 150, 'cover'),   # 목록 썸네일
    'list':   (400, 400, 'cover'),   # 목록 이미지
    'detail': (800, 800, 'inside'),  # 상세 이미지
    'zoom':   (1500, 1500, 'inside') # 확대 이미지
}

def fix_exif_rotation(img):
    """EXIF 회전 정보 자동 수정"""
    try:
        exif = img._getexif()
        if exif:
            for tag_id, value in exif.items():
                if ExifTags.TAGS.get(tag_id) == 'Orientation':
                    rotations = {3: 180, 6: 270, 8: 90}
                    if value in rotations:
                        img = img.rotate(rotations[value], expand=True)
                    break
    except:
        pass
    return img

def resize_cover(img, width, height):
    """cover 방식: 비율 유지하며 영역 꽉 채우기"""
    img_ratio = img.width / img.height
    target_ratio = width / height
    
    if img_ratio > target_ratio:
        new_height = height
        new_width = int(height * img_ratio)
    else:
        new_width = width
        new_height = int(width / img_ratio)
    
    img = img.resize((new_width, new_height), Image.LANCZOS)
    
    # 중앙 크롭
    left = (new_width - width) // 2
    top = (new_height - height) // 2
    img = img.crop((left, top, left + width, top + height))
    return img

def process_product_image(input_path, output_base):
    """상품 이미지 전체 처리"""
    filename = Path(input_path).stem
    
    try:
        with Image.open(input_path) as img:
            img = fix_exif_rotation(img)
            if img.mode != 'RGB':
                img = img.convert('RGB')
            
            for size_name, (w, h, fit) in PRODUCT_SIZES.items():
                size_dir = os.path.join(output_base, size_name)
                os.makedirs(size_dir, exist_ok=True)
                
                img_copy = img.copy()
                
                if fit == 'cover':
                    img_copy = resize_cover(img_copy, w, h)
                else:
                    img_copy.thumbnail((w, h), Image.LANCZOS)
                
                # JPEG 저장
                jpeg_path = os.path.join(size_dir, f"{filename}.jpg")
                img_copy.save(jpeg_path, 'JPEG', quality=85, optimize=True)
                
                # WebP 저장 (추가)
                webp_path = os.path.join(size_dir, f"{filename}.webp")
                img_copy.save(webp_path, 'WEBP', quality=80)
            
            logger.info(f"✅ {filename} - {len(PRODUCT_SIZES)}개 사이즈 × 2포맷 완료")
            return True
            
    except Exception as e:
        logger.error(f"❌ {filename}: {e}")
        return False

def process_all_products(input_dir, output_dir, max_workers=8):
    """전체 상품 이미지 처리"""
    supported = ('.jpg', '.jpeg', '.png', '.bmp', '.webp')
    files = [os.path.join(input_dir, f) 
             for f in os.listdir(input_dir) 
             if f.lower().endswith(supported)]
    
    logger.info(f"🛒 상품 이미지 처리 시작: {len(files)}개")
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        results = list(executor.map(
            lambda f: process_product_image(f, output_dir), 
            files
        ))
    
    success = sum(results)
    logger.info(f"\n🎉 완료! {success}/{len(files)}개 성공")

# 실행!
process_all_products("./상품이미지_원본", "./상품이미지_처리결과")

📱 시나리오 2: 앱 아이콘 자동 생성

iOS/Android 앱 개발할 때 아이콘 사이즈가 진짜 많음 ㅋㅋ
이것도 자동화하면 편함!

from PIL import Image
import os

# iOS 아이콘 사이즈 목록
IOS_ICON_SIZES = [
    (20, 1), (20, 2), (20, 3),
    (29, 1), (29, 2), (29, 3),
    (40, 1), (40, 2), (40, 3),
    (60, 2), (60, 3),
    (76, 1), (76, 2),
    (83.5, 2),
    (1024, 1)  # App Store
]

# Android 아이콘 사이즈
ANDROID_ICON_SIZES = {
    'mipmap-mdpi':    48,
    'mipmap-hdpi':    72,
    'mipmap-xhdpi':   96,
    'mipmap-xxhdpi':  144,
    'mipmap-xxxhdpi': 192,
    'playstore':      512
}

def generate_ios_icons(source_image, output_dir):
    """iOS 아이콘 세트 생성"""
    os.makedirs(output_dir, exist_ok=True)
    
    with Image.open(source_image) as img:
        if img.mode != 'RGBA':
            img = img.convert('RGBA')
        
        for base_size, scale in IOS_ICON_SIZES:
            pixel_size = int(base_size * scale)
            icon = img.resize((pixel_size, pixel_size), Image.LANCZOS)
            
            filename = f"icon_{int(base_size)}x{int(base_size)}@{scale}x.png"
            icon.save(os.path.join(output_dir, filename), 'PNG')
            print(f"✅ iOS: {filename} ({pixel_size}x{pixel_size}px)")

def generate_android_icons(source_image, output_dir):
    """Android 아이콘 세트 생성"""
    
    with Image.open(source_image) as img:
        if img.mode != 'RGBA':
            img = img.convert('RGBA')
        
        for density, size in ANDROID_ICON_SIZES.items():
            density_dir = os.path.join(output_dir, density)
            os.makedirs(density_dir, exist_ok=True)
            
            icon = img.resize((size, size), Image.LANCZOS)
            icon.save(os.path.join(density_dir, 'ic_launcher.png'), 'PNG')
            print(f"✅ Android {density}: {size}x{size}px")

# 실행 (1024x1024 이상의 원본 이미지 필요)
generate_ios_icons("./app_icon_원본.png", "./ios_icons")
generate_android_icons("./app_icon_원본.png", "./android_icons")
print("\n🎉 앱 아이콘 세트 생성 완료!")

📊 라이브러리 선택 가이드

어떤 라이브러리를 써야 할지 헷갈릴 때 참고하세요!

라이브러리	언어	속도	난이도	특징
Pillow	Python	⭐⭐⭐	쉬움 😊	가장 범용적, 문서 풍부
Sharp	Node.js	⭐⭐⭐⭐⭐	보통 😐	초고속, WebP/AVIF 강점
ImageMagick	CLI/Bash	⭐⭐⭐⭐	보통 😐	서버 환경, 스크립트 연동
OpenCV	Python/C++	⭐⭐⭐⭐⭐	어려움 😅	컴퓨터 비전, 고급 처리
Jimp	Node.js	⭐⭐⭐	쉬움 😊	순수 JS, 의존성 없음
GD Library	PHP	⭐⭐⭐	쉬움 😊	PHP 웹서버 환경

💡 상황별 추천! 🐍 Python 스크립트로 로컬 처리 → Pillow
⚡ Node.js 웹서버 실시간 처리 → Sharp
🖥️ Linux 서버 cron 자동화 → ImageMagick + Bash
🔬 AI/ML 파이프라인 연동 → OpenCV
🌐 PHP 기반 CMS → GD Library 또는 Imagick

참고로 재능넷에서 이미지 처리 관련 개발 의뢰를 찾아보면 Pillow나 Sharp 기반 자동화 스크립트 요청이 꽤 많아요.
이 글에서 배운 내용으로 충분히 대응 가능하니까 포트폴리오로 활용해봐요! 😊

❓ 자주 묻는 질문 (FAQ)

Q. 리사이즈하면 이미지 품질이 떨어지나요? A. 이미지를 줄일 때는 품질 손실이 거의 없어요. 문제는 늘릴 때인데, 원본보다 크게 확대하면 픽셀이 늘어나서 흐릿해짐.
withoutEnlargement: true 옵션이나 thumbnail() 메서드를 쓰면 원본보다 크게 확대되는 걸 방지할 수 있어요!

Q. PNG를 JPEG로 변환하면 투명도가 사라지는데 어떻게 하나요?
A. JPEG는 투명도(알파 채널)를 지원 안 해요. 변환 전에 배경색을 채워줘야 함!

from PIL import Image

img = Image.open("투명배경.png")
if img.mode in ('RGBA', 'LA', 'P'):
    background = Image.new('RGB', img.size, (255, 255, 255))  # 흰 배경
    if img.mode == 'P':
        img = img.convert('RGBA')
    background.paste(img, mask=img.split()[-1])  # 알파 채널을 마스크로
    img = background
img.save("결과.jpg", 'JPEG', quality=85)

Q. 처리 속도가 너무 느린데 어떻게 개선하나요? A. 몇 가지 방법이 있어요!
① 멀티스레딩/멀티프로세싱 적용
② Sharp(Node.js) 사용 고려 (Pillow보다 훨씬 빠름)
③ 이미 처리된 파일 스킵 로직 추가
④ SSD 사용 (HDD보다 I/O 속도 훨씬 빠름)
⑤ 배치 크기 조절 (한 번에 너무 많이 처리하면 메모리 부족)

Q. 원본 이미지가 손상되지 않게 하려면? A. 항상 원본 폴더와 출력 폴더를 분리하세요!
mogrify처럼 원본을 직접 수정하는 명령어는 특히 주의.
코드에서 input_path와 output_path를 다르게 설정하고,
처음 실행 전에 원본 폴더 백업하는 습관 들이는 게 좋아요 ㅋㅋ

Q. GIF 애니메이션도 리사이즈 가능한가요?
A. 가능하지만 좀 복잡해요. 각 프레임을 개별적으로 처리해야 함!

from PIL import Image

def resize_gif(input_path, output_path, target_size):
    img = Image.open(input_path)
    frames = []
    
    try:
        while True:
            frame = img.copy()
            frame.thumbnail(target_size, Image.LANCZOS)
            frames.append(frame)
            img.seek(img.tell() + 1)
    except EOFError:
        pass
    
    frames[0].save(
        output_path,
        save_all=True,
        append_images=frames[1:],
        loop=0,
        optimize=True
    )

🎯 마무리 & 핵심 요약

오늘 대량 이미지 리사이즈 자동화에 대해 진짜 많은 내용을 다뤘는데요 ㅋㅋ
핵심만 정리하면 이렇게 됨!

✅ 최종 정리! 1️⃣ Python Pillow: 입문자 친화적, 범용 이미지 처리의 국룰
2️⃣ Node.js Sharp: 속도가 최우선이면 이거, 특히 웹서버 환경에서 강력
3️⃣ ImageMagick + Bash: 서버 환경 자동화, cron 연동 시 최고
4️⃣ 멀티스레딩/프로세싱: 대량 처리 시 필수 최적화
5️⃣ 에러 핸들링 + 로깅: 실무에서 절대 빠지면 안 됨
6️⃣ WebP 변환: 웹 성능 최적화를 위해 함께 고려하면 좋음
7️⃣ 원본 백업: 항상! 무조건! 백업하고 시작할 것 ㅋㅋ

이 코드들 잘 활용해서 반복 작업에서 해방되길 바람! 🎉
코드 한 번 짜놓으면 그 다음부터는 진짜 편해요.
처음 세팅하는 데 1시간 투자하면 앞으로 수백 시간을 아낄 수 있으니까요 😊

🔗 참고 공식 문서

• Pillow 공식 문서: https://pillow.readthedocs.io
• Sharp 공식 문서: https://sharp.pixelplumbing.com
• ImageMagick 공식:

https://imagemagick.org/script/command-line-processing.php

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.

4.7K

HDL 코딩 용역 받습니다. (verilog,vhdl,systemverilog)

하드웨어 개발 부서에서 7년 넘게 근무하였습니다. verilog 코딩 경력은 10년, vhdl 코딩 경력은 1년, systemverilog 코딩은 1년 됩니다. (verilog,vhdl,systemverilog) HDL 코딩 용역 받습니다. (물론 과제의 난이도에 따라 명시된 가격과 견적이 다릅니다.) HDL소스 코딩은 주로 시뮬레이션에서 동작 확인후 제

150,000원~

C언어 마이컴 설계까지 가능합니다 현직 펌웨어 개발자입니다

방통대 컴퓨터 과학과 졸업했음 재직기간은 10년이 넘었음 C언어 과제나 펌웨어 개발 프로젝트에 참여가능 아두이노, 프리스케일, 노르딕, 마이크로칩등 다수 마이컴 제어가능 무선 rf, lf, 블루투스 다 개발해봤음 자이로 가속도 기압 거리 온도 빛등 다수의 센서 사용함 자동차 부품 펌웨어개발 태양광 모니터링 시스템 개발 교육용 로봇 개발 현재 드론 개발 중

10,000원~

3.3K

Python 자동화 모듈개발 (주식분석, 마케팅데이터 수집, 테스트자동화, Excel Parser, 크롤러)

안녕하세요. 올해로 개발경력 13년차입니다. Windows Device Driver 부터 시작해서, Windows/Linux Programming, Mobile Programming(iOS/Android), Web Server등 Window, Linux, 그리고 Mac OS까지 다양한 플랫폼에서 개발경험이 있습니다. 프로그래밍 언어는 C, C++, C#,

10,000원~

C#/Java/Go/Android 등 윈도우 앱, 안드로이드 앱, 알고리즘 구현 등 원하시는 프로그램 작성해드립니다

C#/Java/Go/Android 등을 이용하여 테스트 앱, 알고리즘 구현, 윈도우 앱, 안드로이드 앱 등 구현 가능합니다. 기타 서버 개발 및 DB 구축도 가능하니 많은 문의 바랍니다! ● 사용 가능한 언어 C#, Java, Android, Go ● 이런 것들 가능합니다! 1. 가계부, 관리 프로그램, 매크로 등 윈도우에서 사용가능한 간단한 앱부터 복잡

10,000원~

3.8K

[ C, C++, PYTHON, MFC, OPENCV , 스크래치 ]개발해드립니다.

안녕하세요. 컴퓨터공학 석사졸업했고 현직 컴퓨터 비전 관련 연구원입니다. 이런것도 될까 고민 마시고 문의주세요. 난이도에 따라 작업 시간이 결정되고, 작업시간에 의해 비용이 책정되니 상담주시기 바랍니다. 요구사항을 최대한 구체적으로 말씀해주셔야 구현가능성 및 시간을 빠르게 책정할 수 있습니다. 어떤 기능을 구현해야되는지 자세히 알려주세요. [개발 내용] -

20,000원~

5.3K

[C / C++] 프로그램 대행 / 응용프로그램 / 알고리즘

#### 바로 구매하지 마시고 쪽지 문의 후 구매해 주세요 #### (프로그램 요구사양 문서 (PPT,한글,워드등 양식은 상관없습니다.) C언어/C++언어 자료구조 알고리즘등 프로그래밍 대행합니다. 난이도에 따라 가격은 변동될 수 있습니다. 진행 과정은 다음과 같습니다. 1. 쪽지로 프로그램관련 요구사항 문서 파일과 예상 금액 전달(구매자->판매자) 2.

5,000원~

🚀 [Python / C / C++] 빠른 맞춤형 프로그램 개발 (최대 3일 완성)

복잡한 알고리즘부터 업무 자동화, 크롤링, 프로그램 오류 수정까지! Python, C, C++ 전문 개발자가 최대 3일 이내에 신속하고 정확하게 완성해 드립니다. ⚠️ [필독] 구매 전 메시지로 먼저 상담을 신청해 주세요! 작업 내용과 규모에 맞춰 정확한 견적과 작업 기간을 안내해 드립니다. 💡 제공 서비스 분야 Python 개발 웹 크롤링 및 데이

125,000원~ 후기 0개

295

신속한 문제 해결과 관리로 서비스 운영을 지원

서비스 설명 Bluenlabs는 단순 오류 수정이 아닌 서비스 안정성과 운영 효율까지 고려한 실무 중심 유지보수 솔루션을 제공합니다. 기존 프로젝트 분석부터 오류 수정 · 기능 개선 · 서버 점검 · 유지관리까지 안정적으로 진행합니다. - 빠른 오류 대응 - 기존 코드 분석 가능 - 안정적인 시스템 운영 - 유지보수까지 고려한 작업 방식 - 실서비스 운영

3,000,000원~ 후기 0개

프로그램개발 · 분야 선택22개 분야

🖼️ 대량 이미지 리사이즈 자동화소스코드 완전정복

📋 오늘 배울 내용 미리보기

🤔 수동으로 하면 안 되나요? (됩니다만...)

📐 이미지 리사이즈 기본 개념 정리

🔸 리사이즈 방식의 종류

🔸 이미지 포맷별 특징

🐍 Python + Pillow로 대량 리사이즈 자동화

📦 설치 방법

🔰 기본 단일 이미지 리사이즈

🚀 대량 이미지 리사이즈 - 기본 버전

⚡ 멀티스레딩으로 속도 업그레이드!

🎯 여러 사이즈 동시 생성 (실전 최강 버전!)

⚡ Node.js + Sharp로 초고속 리사이즈

📦 설치 방법

🔰 기본 사용법

🚀 대량 처리 - Promise.all 활용

🎯 여러 사이즈 + 포맷 동시 변환 (Sharp 고급)

🖥️ Bash + ImageMagick으로 커맨드라인 자동화

📦 ImageMagick 설치

🔰 기본 명령어

🚀 Bash 스크립트 - 대량 처리

🔧 고급 기능 - 워터마크, 포맷 변환, EXIF 처리

💧 워터마크 자동 삽입 (Python)

📋 EXIF 데이터 처리

🔄 포맷 일괄 변환 (PNG → WebP)

🗂️ 실전 프로젝트 폴더 구조 설계

⚙️ JSON 설정 파일로 프리셋 관리

🛡️ 에러 핸들링 & 로깅 - 실무에서 필수!

🚀 성능 최적화 팁 모음

💼 실전 활용 시나리오 & 완성 코드

🛒 시나리오 1: 쇼핑몰 상품 이미지 처리

📱 시나리오 2: 앱 아이콘 자동 생성

📊 라이브러리 선택 가이드

❓ 자주 묻는 질문 (FAQ)

🎯 마무리 & 핵심 요약

관련 키워드

댓글 작성

로그인이 필요합니다

댓글 0

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

해당 지식과 관련있는 인기재능

🖼️ 대량 이미지 리사이즈 자동화
소스코드 완전정복