# 雙邊濾波 - 最佳平衡
denoised = cv2.bilateralFilter(image, 15, 25, 25)

# 非局部均值 - 最佳效果
denoised = cv2.fastNlMeansDenoisingColored(image, None, 10, 10, 7, 21)

# 使用形態(tài)學(xué)操作檢測細(xì)長結(jié)構(gòu)
kernel_vertical = cv2.getStructuringElement(cv2.MORPH_RECT, (1, kernel_size))
vertical_scratches = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT, kernel_vertical)

class PhotoRestorer:
    def __init__(self):
        self.original_image = None
        self.processed_image = None

pip install opencv-python pillow numpy

# 一鍵自動修復(fù)
python photo_restorer.py old_photo.jpg --mode auto --preview

# 自定義輸出路徑
python photo_restorer.py input.jpg -o output_restored.jpg

python photo_restorer.py
# 按提示輸入圖像路徑和選擇功能

from photo_restorer import PhotoRestorer

restorer = PhotoRestorer()
restorer.load_image('old_photo.jpg')
result = restorer.comprehensive_restoration()
restorer.save_image(result, 'restored_photo.jpg')

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
老照片修復(fù)工具
支持多種修復(fù)功能：去噪、增強(qiáng)對比度、修復(fù)劃痕、色彩還原等
"""

import cv2
import numpy as np
from PIL import Image, ImageEnhance, ImageFilter
import os
import argparse
from pathlib import Path

class PhotoRestorer:
    def __init__(self):
        self.original_image = None
        self.processed_image = None
        
    def load_image(self, image_path):
        """加載圖像"""
        try:
            self.original_image = cv2.imread(image_path)
            if self.original_image is None:
                raise ValueError(f"無法加載圖像: {image_path}")
            print(f"成功加載圖像: {image_path}")
            print(f"圖像尺寸: {self.original_image.shape}")
            return True
        except Exception as e:
            print(f"加載圖像失敗: {e}")
            return False
    
    def denoise(self, method='bilateral'):
        """去噪處理"""
        if self.original_image is None:
            print("請先加載圖像")
            return None
            
        print("正在進(jìn)行去噪處理...")
        
        if method == 'bilateral':
            # 雙邊濾波去噪，保持邊緣
            denoised = cv2.bilateralFilter(self.original_image, 15, 25, 25)
        elif method == 'gaussian':
            # 高斯濾波去噪
            denoised = cv2.GaussianBlur(self.original_image, (5, 5), 0)
        elif method == 'median':
            # 中值濾波去噪，適合椒鹽噪聲
            denoised = cv2.medianBlur(self.original_image, 5)
        elif method == 'nlm':
            # 非局部均值去噪，效果好但較慢
            denoised = cv2.fastNlMeansDenoisingColored(self.original_image, None, 10, 10, 7, 21)
        else:
            denoised = self.original_image
            
        print(f"去噪完成，使用方法: {method}")
        return denoised
    
    def enhance_contrast_brightness(self, alpha=1.2, beta=10):
        """增強(qiáng)對比度和亮度"""
        if self.original_image is None:
            print("請先加載圖像")
            return None
            
        print("正在增強(qiáng)對比度和亮度...")
        
        # 應(yīng)用線性變換: new_img = alpha * old_img + beta
        enhanced = cv2.convertScaleAbs(self.original_image, alpha=alpha, beta=beta)
        
        print(f"對比度增強(qiáng)完成 (alpha={alpha}, beta={beta})")
        return enhanced
    
    def histogram_equalization(self, method='clahe'):
        """直方圖均衡化"""
        if self.original_image is None:
            print("請先加載圖像")
            return None
            
        print("正在進(jìn)行直方圖均衡化...")
        
        # 轉(zhuǎn)換到Y(jié)UV顏色空間
        yuv = cv2.cvtColor(self.original_image, cv2.COLOR_BGR2YUV)
        
        if method == 'clahe':
            # 對比度限制的自適應(yīng)直方圖均衡化
            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
            yuv[:, :, 0] = clahe.apply(yuv[:, :, 0])
        else:
            # 普通直方圖均衡化
            yuv[:, :, 0] = cv2.equalizeHist(yuv[:, :, 0])
        
        # 轉(zhuǎn)換回BGR
        equalized = cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR)
        
        print(f"直方圖均衡化完成，使用方法: {method}")
        return equalized
    
    def sharpen_image(self, strength=1.0):
        """圖像銳化"""
        if self.original_image is None:
            print("請先加載圖像")
            return None
            
        print("正在進(jìn)行圖像銳化...")
        
        # 創(chuàng)建銳化核
        kernel = np.array([[-1, -1, -1],
                          [-1, 9, -1],
                          [-1, -1, -1]]) * strength
        
        # 應(yīng)用卷積
        sharpened = cv2.filter2D(self.original_image, -1, kernel)
        
        print(f"圖像銳化完成，強(qiáng)度: {strength}")
        return sharpened
    
    def remove_scratches(self, kernel_size=5):
        """修復(fù)劃痕和污漬"""
        if self.original_image is None:
            print("請先加載圖像")
            return None
            
        print("正在修復(fù)劃痕...")
        
        # 轉(zhuǎn)換為灰度圖
        gray = cv2.cvtColor(self.original_image, cv2.COLOR_BGR2GRAY)
        
        # 創(chuàng)建mask來檢測劃痕（通常是細(xì)長的白色或黑色線條）
        # 使用形態(tài)學(xué)操作
        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, kernel_size))
        
        # 檢測垂直劃痕
        vertical_mask = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT, kernel)
        
        # 檢測水平劃痕
        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (kernel_size, 1))
        horizontal_mask = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT, kernel)
        
        # 合并mask
        scratch_mask = cv2.bitwise_or(vertical_mask, horizontal_mask)
        
        # 使用圖像修復(fù)算法
        repaired = cv2.inpaint(self.original_image, scratch_mask, 3, cv2.INPAINT_TELEA)
        
        print("劃痕修復(fù)完成")
        return repaired
    
    def color_restoration(self, saturation_factor=1.3, warmth_adjustment=0.1):
        """色彩還原"""
        if self.original_image is None:
            print("請先加載圖像")
            return None
            
        print("正在進(jìn)行色彩還原...")
        
        # 轉(zhuǎn)換為PIL圖像進(jìn)行色彩調(diào)整
        pil_image = Image.fromarray(cv2.cvtColor(self.original_image, cv2.COLOR_BGR2RGB))
        
        # 增強(qiáng)飽和度
        enhancer = ImageEnhance.Color(pil_image)
        enhanced = enhancer.enhance(saturation_factor)
        
        # 調(diào)整色溫（增加暖色調(diào)）
        enhanced_array = np.array(enhanced).astype(np.float32)
        enhanced_array[:, :, 0] *= (1 + warmth_adjustment)  # 增加紅色通道
        enhanced_array[:, :, 1] *= (1 + warmth_adjustment * 0.5)  # 略微增加綠色通道
        enhanced_array = np.clip(enhanced_array, 0, 255).astype(np.uint8)
        
        # 轉(zhuǎn)換回OpenCV格式
        restored = cv2.cvtColor(enhanced_array, cv2.COLOR_RGB2BGR)
        
        print(f"色彩還原完成 (飽和度: {saturation_factor}, 暖色調(diào): {warmth_adjustment})")
        return restored
    
    def comprehensive_restoration(self, 
                                denoise_method='bilateral',
                                contrast_alpha=1.2,
                                contrast_beta=10,
                                enable_histogram_eq=True,
                                sharpen_strength=0.5,
                                enable_scratch_removal=True,
                                saturation_factor=1.2):
        """綜合修復(fù)"""
        if self.original_image is None:
            print("請先加載圖像")
            return None
            
        print("開始綜合修復(fù)流程...")
        
        # 1. 去噪
        result = self.denoise(denoise_method)
        
        # 2. 修復(fù)劃痕
        if enable_scratch_removal:
            temp_original = self.original_image.copy()
            self.original_image = result
            result = self.remove_scratches()
            self.original_image = temp_original
        
        # 3. 增強(qiáng)對比度和亮度
        temp_original = self.original_image.copy()
        self.original_image = result
        result = self.enhance_contrast_brightness(contrast_alpha, contrast_beta)
        
        # 4. 直方圖均衡化
        if enable_histogram_eq:
            self.original_image = result
            result = self.histogram_equalization('clahe')
        
        # 5. 適度銳化
        if sharpen_strength > 0:
            self.original_image = result
            result = self.sharpen_image(sharpen_strength)
        
        # 6. 色彩還原
        self.original_image = result
        result = self.color_restoration(saturation_factor)
        
        # 恢復(fù)原始圖像
        self.original_image = temp_original
        
        print("綜合修復(fù)完成!")
        return result
    
    def save_image(self, image, output_path, quality=95):
        """保存圖像"""
        try:
            # 確保輸出目錄存在
            os.makedirs(os.path.dirname(output_path), exist_ok=True)
            
            if output_path.lower().endswith('.jpg') or output_path.lower().endswith('.jpeg'):
                cv2.imwrite(output_path, image, [cv2.IMWRITE_JPEG_QUALITY, quality])
            else:
                cv2.imwrite(output_path, image)
            
            print(f"圖像已保存到: {output_path}")
            return True
        except Exception as e:
            print(f"保存圖像失敗: {e}")
            return False
    
    def preview_comparison(self, processed_image, window_name="修復(fù)前后對比"):
        """顯示修復(fù)前后對比"""
        if self.original_image is None or processed_image is None:
            print("缺少圖像數(shù)據(jù)")
            return
        
        # 調(diào)整圖像大小以便顯示
        height = min(600, self.original_image.shape[0])
        scale = height / self.original_image.shape[0]
        width = int(self.original_image.shape[1] * scale)
        
        original_resized = cv2.resize(self.original_image, (width, height))
        processed_resized = cv2.resize(processed_image, (width, height))
        
        # 創(chuàng)建對比圖像
        comparison = np.hstack((original_resized, processed_resized))
        
        # 添加標(biāo)題
        comparison = cv2.copyMakeBorder(comparison, 30, 0, 0, 0, 
                                       cv2.BORDER_CONSTANT, value=[255, 255, 255])
        cv2.putText(comparison, "Original", (width//4, 25), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 0), 2)
        cv2.putText(comparison, "Restored", (width + width//4, 25), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 0), 2)
        
        cv2.imshow(window_name, comparison)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

def main():
    parser = argparse.ArgumentParser(description='老照片修復(fù)工具')
    parser.add_argument('input', help='輸入圖像路徑')
    parser.add_argument('-o', '--output', help='輸出圖像路徑')
    parser.add_argument('--mode', choices=['auto', 'denoise', 'enhance', 'sharpen', 'repair'], 
                       default='auto', help='修復(fù)模式')
    parser.add_argument('--preview', action='store_true', help='顯示預(yù)覽')
    
    args = parser.parse_args()
    
    # 創(chuàng)建修復(fù)器
    restorer = PhotoRestorer()
    
    # 加載圖像
    if not restorer.load_image(args.input):
        return
    
    # 設(shè)置輸出路徑
    if not args.output:
        input_path = Path(args.input)
        args.output = str(input_path.parent / f"{input_path.stem}_restored{input_path.suffix}")
    
    # 執(zhí)行修復(fù)
    if args.mode == 'auto':
        result = restorer.comprehensive_restoration()
    elif args.mode == 'denoise':
        result = restorer.denoise('bilateral')
    elif args.mode == 'enhance':
        result = restorer.enhance_contrast_brightness()
    elif args.mode == 'sharpen':
        result = restorer.sharpen_image()
    elif args.mode == 'repair':
        result = restorer.remove_scratches()
    
    if result is not None:
        # 保存結(jié)果
        restorer.save_image(result, args.output)
        
        # 顯示預(yù)覽
        if args.preview:
            restorer.preview_comparison(result)

if __name__ == "__main__":
    # 如果沒有命令行參數(shù)，運(yùn)行交互式模式
    import sys
    
    if len(sys.argv) == 1:
        print("老照片修復(fù)工具 - 交互式模式")
        print("=" * 40)
        
        image_path = input("請輸入圖像路徑: ").strip()
        if not os.path.exists(image_path):
            print("文件不存在!")
            exit(1)
        
        restorer = PhotoRestorer()
        if not restorer.load_image(image_path):
            exit(1)
        
        print("\n可用的修復(fù)模式:")
        print("1. 自動修復(fù) (推薦)")
        print("2. 僅去噪")
        print("3. 增強(qiáng)對比度")
        print("4. 圖像銳化") 
        print("5. 修復(fù)劃痕")
        print("6. 色彩還原")
        
        choice = input("\n請選擇修復(fù)模式 (1-6): ").strip()
        
        if choice == '1':
            result = restorer.comprehensive_restoration()
        elif choice == '2':
            result = restorer.denoise()
        elif choice == '3':
            result = restorer.enhance_contrast_brightness()
        elif choice == '4':
            result = restorer.sharpen_image()
        elif choice == '5':
            result = restorer.remove_scratches()
        elif choice == '6':
            result = restorer.color_restoration()
        else:
            print("無效選擇，使用自動修復(fù)模式")
            result = restorer.comprehensive_restoration()
        
        if result is not None:
            # 生成輸出文件名
            input_path = Path(image_path)
            output_path = str(input_path.parent / f"{input_path.stem}_restored{input_path.suffix}")
            
            restorer.save_image(result, output_path)
            
            show_preview = input("\n是否顯示修復(fù)前后對比? (y/n): ").strip().lower()
            if show_preview == 'y':
                restorer.preview_comparison(result)
    else:
        main()