AI模型一键变桌面应用，Paper2GUI让复杂论文算法人人可用！

paper2gui_v2.x/
├── paper2gui.exe          # 主程序，双击运行
├── models/                # 模型权重存放目录
├── configs/               # 配置文件
└── README.md              # 使用说明

git clone https://github.com/Baiyuetribe/paper2gui.git
cd paper2gui

# 创建虚拟环境
python -m venv venv

# 激活虚拟环境
# Windows系统
venv\Scripts\activate
# macOS/Linux系统
source venv/bin/activate

pip install -r requirements.txt

torch                    # PyTorch深度学习框架
torchvision              # 图像处理工具
Pillow                   # Python图像处理库
numpy                    # 数值计算
opencv-python            # OpenCV计算机视觉库
PyQt5                    # GUI界面框架

python paper2gui.py

python paper2gui.py --debug

# 卸载旧版本
pip uninstall torch torchvision

# 重新安装GPU版本（以CUDA 11.8为例）
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118

nvidia-smi

python -c "import torch; print(torch.cuda.is_available())"

"""
老照片修复批量处理脚本
基于Paper2GUI的模型进行封装
"""

import os
import sys
from pathlib import Path

# 添加项目路径
sys.path.insert(0, 'path/to/paper2gui')

# 导入需要的模块
from inference_singleton import inference_image
from basicsr.archs.rrdbnet_arch import RRDBNet

# 配置模型路径
model_dir = Path('./models')
output_dir = Path('./output')
output_dir.mkdir(exist_ok=True)

# 待处理图片目录
input_dir = Path('./old_photos')
image_files = list(input_dir.glob('*.jpg')) + list(input_dir.glob('*.png'))

print(f"找到 {len(image_files)} 张待处理图片")
print("=" * 50)

# 遍历处理每张图片
for idx, img_path in enumerate(image_files, 1):
    print(f"[{idx}/{len(image_files)}] 正在处理: {img_path.name}")

    # 定义输出路径
    output_path = output_dir / f"restored_{img_path.name}"

    try:
        # 调用推理接口
        # 参数说明：
        # img_path: 输入图片路径
        # model: 使用的模型
        # - RRDBNet for general denoising
        # - RealESRGAN-x4plus for upscaling
        # scale: 放大倍数
        # tile: 分块处理大小，0表示不分割

        result = inference_image(
            img=str(img_path),
            model=RRDBNet(
                num_in_ch=3,
                num_out_ch=3,
                num_feat=64,
                num_block=23,
                num_grow_ch=32
            ),
            scale=4,
            tile=0,
            tile_pad=10,
            pre_pad=0,
            face_enhance=True  # 启用人脸增强
        )

        # 保存结果
        result.save(str(output_path))
        print(f"  ✓ 保存到: {output_path}")

    except Exception as e:
        print(f"  ✗ 处理失败: {e}")
        continue

print("=" * 50)
print("全部处理完成！")

"""
背景移除批量处理脚本
使用RMBG-1.4模型
"""

import os
from pathlib import Path
from PIL import Image
import numpy as np

# 假设你已经下载了RMBG模型权重
MODEL_PATH = './models/rmbg-1.4.onnx'
OUTPUT_DIR = './output_transparent'

class BackgroundRemover:
    """背景移除处理器"""

    def __init__(self, model_path):
        # 导入ONNX运行时
        try:
            import onnxruntime as ort
        except ImportError:
            print("正在安装onnxruntime...")
            os.system("pip install onnxruntime")
            import onnxruntime as ort

        # 初始化推理会话
        # providers参数指定使用GPU还是CPU
        # 优先级从高到低：['CUDAExecutionProvider', 'CPUExecutionProvider']
        self.session = ort.InferenceSession(
            model_path,
            providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
        )
        print(f"模型加载成功，使用设备: {self.session.get_providers()}")

    def preprocess(self, image):
        """
        图像预处理
        将PIL Image转换为模型输入格式
        """
        # 转换RGB
        if image.mode != 'RGB':
            image = image.convert('RGB')

        # 缩放到模型要求的尺寸（1024x1024）
        # 保持宽高比，用灰色填充
        target_size = 1024
        w, h = image.size
        ratio = min(target_size / w, target_size / h)
        new_w, new_h = int(w * ratio), int(h * ratio)

        resized = image.resize((new_w, new_h), Image.Resampling.LANCZOS)

        # 创建灰色画布并居中放置
        canvas = Image.new('RGB', (target_size, target_size), (128, 128, 128))
        paste_x = (target_size - new_w) // 2
        paste_y = (target_size - new_h) // 2
        canvas.paste(resized, (paste_x, paste_y))

        # 归一化处理
        img_array = np.array(canvas).astype(np.float32) / 255.0

        # 标准化 (ImageNet统计值)
        mean = np.array([0.485, 0.456, 0.406])
        std = np.array([0.229, 0.224, 0.225])
        img_array = (img_array - mean) / std

        # 转换为CHW格式
        img_array = img_array.transpose(2, 0, 1)

        return img_array, ratio, (paste_x, paste_y)

    def inference(self, image):
        """
        执行推理
        """
        # 预处理
        input_data, ratio, offset = self.preprocess(image)
        input_tensor = input_data[np.newaxis, :, :, :]

        # 运行推理
        # 模型输入名通常可以通过 get_inputs() 获取
        input_name = self.session.get_inputs()[0].name
        output_name = self.session.get_outputs()[0].name

        mask = self.session.run([output_name], {input_name: input_tensor})[0]

        return mask[0, 0], ratio, offset

    def postprocess(self, original, mask, ratio, offset, smooth=True):
        """
        后处理：将mask应用到原图
        """
        # 缩放mask到原图尺寸
        mask_pil = Image.fromarray((mask * 255).astype(np.uint8))

        # 使用Lanczos重采样
        mask_resized = mask_pil.resize(
            original.size, 
            Image.Resampling.LANCZOS
        )

        if smooth:
            # 高斯模糊让边缘更平滑
            from PIL import ImageFilter
            mask_resized = mask_resized.filter(
                ImageFilter.GaussianBlur(radius=2)
            )

        # 转换为numpy进行阈值处理
        mask_array = np.array(mask_resized)

        # 阈值分割：可以根据效果调整
        threshold = 128
        mask_binary = (mask_array > threshold).astype(np.uint8) * 255

        return Image.fromarray(mask_binary)

    def remove_background(self, image_path, output_path=None):
        """
        移除背景并保存透明PNG
        """
        # 加载原图
        original = Image.open(image_path)

        # 推理获取mask
        mask, ratio, offset = self.inference(original)

        # 后处理
        mask_final = self.postprocess(original, mask, ratio, offset)

        # 应用mask创建透明图
        # 先转为RGBA模式
        if original.mode != 'RGBA':
            original = original.convert('RGBA')

        # 将mask作为alpha通道
        original.putalpha(mask_final)

        # 保存
        if output_path:
            original.save(output_path, 'PNG')
            print(f"已保存: {output_path}")

        return original


# 使用示例
def main():
    # 初始化处理器
    remover = BackgroundRemover(MODEL_PATH)

    # 输入输出目录
    input_dir = Path('./product_photos')
    output_dir = Path(OUTPUT_DIR)
    output_dir.mkdir(exist_ok=True)

    # 获取所有图片
    extensions = ['*.jpg', '*.jpeg', '*.png', '*.webp']
    image_files = []
    for ext in extensions:
        image_files.extend(input_dir.glob(ext))

    print(f"找到 {len(image_files)} 张图片\n")

    # 批量处理
    for img_path in image_files:
        print(f"处理中: {img_path.name}")

        output_path = output_dir / f"transparent_{img_path.stem}.png"

        try:
            remover.remove_background(str(img_path), str(output_path))
        except Exception as e:
            print(f"  错误: {e}")

    print("\n全部完成！")


if __name__ == '__main__':
    main()

"""
OCR批量识别脚本
支持PaddleOCR和EasyOCR两种引擎
"""

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

# 配置路径
INPUT_DIR = Path('./documents')
OUTPUT_DIR = Path('./ocr_output')
OUTPUT_DIR.mkdir(exist_ok=True)

# OCR引擎选择
USE_ENGINE = 'paddle'  # 可选: 'paddle' 或 'easyocr'


def init_paddleocr():
    """
    初始化PaddleOCR
    """
    from paddleocr import PaddleOCR

    # PaddleOCR参数说明:
    # use_angle_cls: 使用方向分类器
    # lang: 语言选择，ch=中文，en=英文，japan=日文，korean=韩文
    # use_gpu: 是否使用GPU
    # show_log: 是否显示日志

    ocr = PaddleOCR(
        use_angle_cls=True,
        lang='ch',
        use_gpu=True,  # 有GPU设为True加速
        show_log=False
    )
    return ocr


def init_easyocr():
    """
    初始化EasyOCR
    """
    import easyocr

    # EasyOCR支持的语言列表
    # ['ch_sim', 'en', 'japan', 'korean', 'french', 'german', ...]
    lang_list = ['ch_sim', 'en']

    reader = easyocr.Reader(
        lang_list,
        gpu=True,  # 有GPU设为True
        verbose=False
    )
    return reader


def process_with_paddle(ocr, image_path):
    """
    使用PaddleOCR处理单张图片
    返回格式: [[位置坐标, 文字, 置信度], ...]
    """
    result = ocr.ocr(str(image_path), cls=True)

    texts = []
    for line in result[0]:
        # line[1] 是识别结果 (文字, 置信度)
        text = line[1][0]
        confidence = line[1][1]
        position = line[0]

        texts.append({
            'text': text,
            'confidence': float(confidence),
            'position': position
        })

    return texts


def process_with_easyocr(reader, image_path):
    """
    使用EasyOCR处理单张图片
    返回格式: [(边界框, 文字, 置信度), ...]
    """
    result = reader.readtext(str(image_path))

    texts = []
    for item in result:
        bbox = item[0]
        text = item[1]
        confidence = item[2]

        texts.append({
            'text': text,
            'confidence': float(confidence),
            'position': bbox
        })

    return texts


def save_results(texts, output_path, format='txt'):
    """
    保存识别结果
    """
    if format == 'txt':
        # 纯文本格式
        with open(output_path.with_suffix('.txt'), 'w', encoding='utf-8') as f:
            for item in texts:
                f.write(item['text'] + '\n')

    elif format == 'json':
        # JSON格式，包含位置信息
        with open(output_path.with_suffix('.json'), 'w', encoding='utf-8') as f:
            json.dump(texts, f, ensure_ascii=False, indent=2)

    elif format == 'full':
        # 同时保存txt和json
        # 文本文件
        txt_path = output_path.with_suffix('.txt')
        with open(txt_path, 'w', encoding='utf-8') as f:
            for item in texts:
                f.write(item['text'] + '\n')

        # JSON文件
        json_path = output_path.with_suffix('.json')
        with open(json_path, 'w', encoding='utf-8') as f:
            json.dump(texts, f, ensure_ascii=False, indent=2)


def batch_process():
    """
    批量处理目录下的所有图片
    """
    # 初始化OCR引擎
    if USE_ENGINE == 'paddle':
        print("初始化 PaddleOCR...")
        ocr = init_paddleocr()
        process_func = lambda path: process_with_paddle(ocr, path)
    else:
        print("初始化 EasyOCR...")
        reader = init_easyocr()
        process_func = lambda path: process_with_easyocr(reader, path)

    # 获取所有图片
    extensions = ['*.jpg', '*.jpeg', '*.png', '*.bmp', '*.tiff']
    image_files = []
    for ext in extensions:
        image_files.extend(INPUT_DIR.glob(ext))

    print(f"找到 {len(image_files)} 张图片\n")
    print("-" * 50)

    # 批量处理
    for idx, img_path in enumerate(image_files, 1):
        print(f"[{idx}/{len(image_files)}] {img_path.name}")

        try:
            # 识别文字
            texts = process_func(img_path)

            # 输出统计
            total_chars = sum(len(t['text']) for t in texts)
            avg_conf = sum(t['confidence'] for t in texts) / len(texts) if texts else 0

            print(f"  识别文字块: {len(texts)}")
            print(f"  总字符数: {total_chars}")
            print(f"  平均置信度: {avg_conf:.2%}")

            # 保存结果
            output_path = OUTPUT_DIR / img_path.stem
            save_results(texts, output_path, format='full')
            print(f"  ✓ 已保存")

        except Exception as e:
            print(f"  ✗ 错误: {e}")

        print()

    print("-" * 50)
    print("OCR识别完成！")


if __name__ == '__main__':
    batch_process()

"""
YOLO目标检测脚本
使用Ultralytics YOLOv8
"""

import os
from pathlib import Path
from PIL import Image, ImageDraw, ImageFont
import json

# 路径配置
INPUT_DIR = Path('./images')
OUTPUT_DIR = Path('./detections')
OUTPUT_DIR.mkdir(exist_ok=True)

# 模型配置
MODEL_NAME = 'yolov8s.pt'  # 可选: yolov8n/s/m/l/x
CONFIDENCE_THRESHOLD = 0.5
IOU_THRESHOLD = 0.45

# COCO类别名称（80类）
COCO_CLASSES = [
    'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat',
    'traffic light', 'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat',
    'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack',
    'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball',
    'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
    'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
    'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
    'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote',
    'keyboard', 'cell phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book',
    'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'
]


class YOLODetector:
    """YOLO目标检测器"""

    def __init__(self, model_name='yolov8s.pt'):
        # 导入ultralytics
        try:
            from ultralytics import YOLO
        except ImportError:
            print("正在安装ultralytics...")
            os.system("pip install ultralytics")
            from ultralytics import YOLO

        # 加载模型
        # 可以传入模型名称（如'yolov8s.pt'）或本地模型路径
        self.model = YOLO(model_name)

        # 尝试加载中文字体用于标注
        self.font = None
        self._load_font()

        print(f"模型加载成功: {model_name}")

    def _load_font(self):
        """
        加载字体
        Windows系统使用默认中文字体
        """
        import platform

        if platform.system() == 'Windows':
            font_paths = [
                'C:/Windows/Fonts/msyh.ttc',  # 微软雅黑
                'C:/Windows/Fonts/simhei.ttf',  # 黑体
                'C:/Windows/Fonts/simsun.ttc',  # 宋体
            ]
            for path in font_paths:
                if Path(path).exists():
                    try:
                        self.font = ImageFont.truetype(path, 20)
                        print(f"加载字体: {path}")
                        break
                    except:
                        continue

        if self.font is None:
            # 使用默认字体
            self.font = ImageFont.load_default()
            print("使用默认字体")

    def detect(self, image_path, conf=0.5, iou=0.45):
        """
        执行目标检测

        参数:
            image_path: 图片路径
            conf: 置信度阈值
            iou: IOU阈值

        返回:
            results: 检测结果列表
        """
        # 执行检测
        results = self.model.predict(
            source=str(image_path),
            conf=conf,
            iou=iou,
            save=False,  # 不让yolo自动保存
            verbose=False
        )

        return results[0]

    def parse_results(self, results):
        """
        解析检测结果
        """
        detections = []

        # 获取检测框、类别、置信度
        boxes = results.boxes

        if len(boxes) == 0:
            return detections

        # 遍历每个检测结果
        for i in range(len(boxes)):
            box = boxes[i]

            # 获取坐标 (xyxy格式: 左上x, 左上y, 右下x, 右下y)
            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()

            # 获取类别ID和名称
            cls_id = int(box.cls[0].cpu().numpy())
            cls_name = COCO_CLASSES[cls_id] if cls_id < len(COCO_CLASSES) else f'class_{cls_id}'

            # 获取置信度
            conf = float(box.conf[0].cpu().numpy())

            detections.append({
                'bbox': [float(x1), float(y1), float(x2), float(y2)],
                'class_id': cls_id,
                'class_name': cls_name,
                'confidence': conf
            })

        return detections

    def draw_detections(self, image_path, detections):
        """
        在图片上绘制检测结果
        """
        # 加载原图
        img = Image.open(image_path).convert('RGB')
        draw = ImageDraw.Draw(img)

        # 定义颜色
        colors = [
            (255, 0, 0), (0, 255, 0), (0, 0, 255),
            (255, 255, 0), (255, 0, 255), (0, 255, 255)
        ]

        # 绘制每个检测框
        for det in detections:
            x1, y1, x2, y2 = det['bbox']
            cls_id = det['class_id']
            cls_name = det['class_name']
            conf = det['confidence']

            # 选择颜色
            color = colors[cls_id % len(colors)]

            # 绘制边界框
            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)

            # 绘制标签背景
            label = f'{cls_name} {conf:.2f}'
            if self.font:
                bbox = draw.textbbox((x1, y1), label, font=self.font)
            else:
                bbox = [x1, y1, x1 + 100, y1 + 20]

            draw.rectangle(bbox, fill=color)
            draw.text((x1 + 5, y1 + 2), label, fill=(255, 255, 255), font=self.font)

        return img

    def process_and_save(self, image_path, output_dir):
        """
        处理单张图片并保存结果
        """
        # 执行检测
        results = self.model(str(image_path))
        detections = self.parse_results(results)

        # 保存带标注的图片
        annotated_img = self.draw_detections(image_path, detections)
        output_img_path = output_dir / f"annotated_{Path(image_path).name}"
        annotated_img.save(output_img_path)

        # 保存JSON结果
        output_json_path = output_dir / f"{Path(image_path).stem}.json"
        with open(output_json_path, 'w', encoding='utf-8') as f:
            json.dump({
                'image': str(image_path),
                'detections': detections,
                'summary': self.get_summary(detections)
            }, f, ensure_ascii=False, indent=2)

        return detections

    def get_summary(self, detections):
        """
        获取检测统计摘要
        """
        summary = {}
        for det in detections:
            cls_name = det['class_name']
            summary[cls_name] = summary.get(cls_name, 0) + 1
        return summary


def batch_process():
    """
    批量处理图片
    """
    # 初始化检测器
    detector = YOLODetector(MODEL_NAME)

    # 获取所有图片
    extensions = ['*.jpg', '*.jpeg', '*.png', '*.bmp']
    image_files = []
    for ext in extensions:
        image_files.extend(INPUT_DIR.glob(ext))

    print(f"\n找到 {len(image_files)} 张图片\n")
    print("=" * 60)

    # 统计
    total_objects = 0

    # 批量处理
    for idx, img_path in enumerate(image_files, 1):
        print(f"[{idx}/{len(image_files)}] {img_path.name}")

        try:
            detections = detector.process_and_save(str(img_path), OUTPUT_DIR)

            # 输出统计
            summary = detector.get_summary(detections)
            print(f"  检测到 {len(detections)} 个目标")
            for cls_name, count in summary.items():
                print(f"    - {cls_name}: {count}")

            total_objects += len(detections)

        except Exception as e:
            print(f"  ✗ 错误: {e}")

        print()

    print("=" * 60)
    print(f"处理完成！共检测到 {total_objects} 个目标")
    print(f"结果保存在: {OUTPUT_DIR}")


if __name__ == '__main__':
    batch_process()

# 在程序界面查看状态栏
# 或者运行这个Python代码
import torch
print(f"CUDA可用: {torch.cuda.is_available()}")
print(f"GPU设备: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else '无'}")

输入目录 → 预处理 → 模型处理 → 后处理 → 输出目录