conda create -n faceprank python=3.8

conda activate faceprank

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple PyQt5>=5.15.0 opencv-python>=4.5.0 numpy>=1.19.0

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple PyQt5>=5.15.0 opencv-python>=4.5.0 numpy>=1.19.0

# 如果你有g(shù)it
git clone <項(xiàng)目地址>
cd FacePrank

# 或者直接下載ZIP解壓

python main.py

# 計算到中心點(diǎn)的距離
distances = np.sqrt(dx**2 + dy**2)

# 計算影響因子（越近影響越大）
factor = 1.0 - (distances / brush_radius)
factor = factor ** 2  # 平滑過渡

# 放大：像素向內(nèi)收縮
scale = 1.0 - strength * factor * mask
new_x = cx + dx * scale
new_y = cy + dy * scale

# 縮?。合袼叵蛲鈹U(kuò)展
scale = 1.0 + strength * factor * mask
new_x = cx + dx * scale
new_y = cy + dy * scale

# 計算旋轉(zhuǎn)角度（距離越近旋轉(zhuǎn)越多）
angle = (1.0 - distances / brush_radius) * π * strength * direction

# 旋轉(zhuǎn)矩陣變換
cos_angle = np.cos(angle)
sin_angle = np.sin(angle)

new_x = cx + dx * cos_angle - dy * sin_angle
new_y = cy + dx * sin_angle + dy * cos_angle

# 計算拖拽向量
drag_x = end_x - start_x
drag_y = end_y - start_y

# 計算影響因子
factor = (1.0 - distances / brush_radius) ** 2

# 應(yīng)用拖拽位移
new_x = x_indices - drag_x * factor * mask * strength
new_y = y_indices - drag_y * factor * mask * strength

# 計算距離和混合因子
distances = np.sqrt((x_coords - cx)**2 + (y_coords - cy)**2)
factor = (1.0 - distances / brush_radius) ** 0.5

# 向量化混合
blended = current_image * (1 - factor) + original_image * factor

new_image = cv2.remap(image, 
                      new_x.astype(np.float32),
                      new_y.astype(np.float32), 
                      cv2.INTER_LINEAR)

def wheelEvent(self, event):
    if event.modifiers() == Qt.ControlModifier:
        # 獲取鼠標(biāo)位置對應(yīng)的圖像坐標(biāo)
        old_image_pos = self.get_image_pos(event.pos())
        
        # 計算縮放增量
        zoom_factor = 1.1 if delta > 0 else 0.9
        self.zoom_scale *= zoom_factor
        
        # 調(diào)整偏移以保持鼠標(biāo)位置下的圖像點(diǎn)不變
        # ... 坐標(biāo)變換計算 ...

def mouseMoveEvent(self, event):
    if self.is_panning:
        delta = event.pos() - self.pan_start_pos
        self.offset_x += delta.x()
        self.offset_y += delta.y()
        # 限制偏移范圍...

def start_continuous_effect(self):
    self.continuous_timer = QTimer(self)
    self.continuous_timer.timeout.connect(self.apply_continuous_effect)
    self.continuous_timer.start(50)  # 每50ms應(yīng)用一次

# 加載圖像
image_data = np.fromfile(file_path, dtype=np.uint8)
image = cv2.imdecode(image_data, cv2.IMREAD_COLOR)

# 保存圖像
_, encoded_img = cv2.imencode('.png', image)
encoded_img.tofile(file_path)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
捏臉APP - 簡單的圖像變形工具
支持放大、縮小、拖拽扭曲、旋轉(zhuǎn)等變形效果
"""

import sys
import numpy as np
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
                             QHBoxLayout, QPushButton, QLabel, QSlider, 
                             QFileDialog, QToolBar, QAction, QSizePolicy)
from PyQt5.QtCore import Qt, QPoint, QRect
from PyQt5.QtGui import QImage, QPixmap, QPainter, QPen, QColor
import cv2


class ImageCanvas(QLabel):
    """圖像畫布類，處理圖像顯示和鼠標(biāo)交互"""
    
    def __init__(self, parent=None):
        super().__init__(parent)
        self.parent_window = parent
        self.image = None
        self.display_image = None
        self.original_image = None
        
        self.current_tool = None  # 當(dāng)前工具: 'enlarge', 'shrink', 'drag', 'rotate', 'eraser'
        self.brush_radius = 170  # 默認(rèn)畫筆半徑
        self.effect_strength = 0.20  # 變化強(qiáng)度，范圍0.01-1.0，默認(rèn)0.20
        self.rotate_direction = 1  # 旋轉(zhuǎn)方向：1為順時針，-1為逆時針
        
        self.is_drawing = False
        self.last_point = None
        
        # 用于持續(xù)效果的定時器
        self.continuous_timer = None
        self.continuous_pos = None
        
        # 圖像縮放和平移
        self.zoom_scale = 1.0  # 縮放比例
        self.offset_x = 0  # X軸偏移
        self.offset_y = 0  # Y軸偏移
        self.is_panning = False  # 是否正在拖拽視圖
        self.pan_start_pos = None  # 拖拽起始位置
        
        self.setMinimumSize(800, 600)
        self.setAlignment(Qt.AlignCenter)
        self.setStyleSheet("""
            QLabel { 
                background-color: #2b2b2b; 
                color: #9E9E9E;
                font-size: 24px;
                font-weight: bold;
                border: 3px dashed #555;
                border-radius: 10px;
            }
        """)
        self.setText('?? 點(diǎn)擊"上傳圖片"按鈕\n或\n拖拽圖片到此處')
        
        # 啟用拖放功能
        self.setAcceptDrops(True)
        
    def load_image(self, file_path):
        """加載圖像（支持中文路徑）"""
        try:
            # 使用np.fromfile()讀取文件，支持中文路徑
            image_data = np.fromfile(file_path, dtype=np.uint8)
            self.original_image = cv2.imdecode(image_data, cv2.IMREAD_COLOR)
            
            if self.original_image is None:
                return False
                
            # BGR轉(zhuǎn)RGB
            self.original_image = cv2.cvtColor(self.original_image, cv2.COLOR_BGR2RGB)
            self.image = self.original_image.copy()
            self.display_image = self.image.copy()
            
            self.update_display()
            return True
        except Exception as e:
            print(f"加載圖片失敗: {e}")
            return False
        
    def update_display(self):
        """更新顯示的圖像（支持縮放和平移）"""
        if self.image is None:
            return
            
        # 圖片加載后移除虛線邊框
        self.setStyleSheet("""
            QLabel { 
                background-color: #2b2b2b; 
            }
        """)
            
        h, w, ch = self.image.shape
        bytes_per_line = ch * w
        q_image = QImage(self.image.data, w, h, bytes_per_line, QImage.Format_RGB888)
        
        # 創(chuàng)建pixmap
        pixmap = QPixmap.fromImage(q_image)
        
        # 應(yīng)用縮放
        if self.zoom_scale != 1.0:
            # 先按原始比例縮放到窗口
            base_scaled = pixmap.scaled(self.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
            # 再應(yīng)用用戶縮放
            new_width = int(base_scaled.width() * self.zoom_scale)
            new_height = int(base_scaled.height() * self.zoom_scale)
            scaled_pixmap = pixmap.scaled(new_width, new_height, Qt.KeepAspectRatio, Qt.SmoothTransformation)
        else:
            scaled_pixmap = pixmap.scaled(self.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
        
        # 如果圖像大于窗口，需要裁剪并應(yīng)用偏移
        if scaled_pixmap.width() > self.width() or scaled_pixmap.height() > self.height():
            # 計算裁剪區(qū)域
            x = max(0, min(-self.offset_x, scaled_pixmap.width() - self.width()))
            y = max(0, min(-self.offset_y, scaled_pixmap.height() - self.height()))
            w = min(self.width(), scaled_pixmap.width())
            h = min(self.height(), scaled_pixmap.height())
            
            # 裁剪
            scaled_pixmap = scaled_pixmap.copy(x, y, w, h)
        
        self.setPixmap(scaled_pixmap)
        
    def get_image_pos(self, widget_pos):
        """將窗口坐標(biāo)轉(zhuǎn)換為圖像坐標(biāo)（考慮縮放和偏移）"""
        if self.image is None:
            return None
            
        h, w = self.image.shape[:2]
        
        # 計算基礎(chǔ)縮放（適應(yīng)窗口）
        widget_aspect = self.width() / self.height()
        image_aspect = w / h
        
        if widget_aspect > image_aspect:
            base_height = self.height()
            base_width = int(base_height * image_aspect)
        else:
            base_width = self.width()
            base_height = int(base_width / image_aspect)
        
        # 應(yīng)用用戶縮放
        display_width = int(base_width * self.zoom_scale)
        display_height = int(base_height * self.zoom_scale)
        
        # 計算圖像在widget中的位置（考慮偏移）
        if display_width <= self.width():
            x_offset = (self.width() - display_width) // 2
        else:
            x_offset = self.offset_x
            
        if display_height <= self.height():
            y_offset = (self.height() - display_height) // 2
        else:
            y_offset = self.offset_y
        
        # 轉(zhuǎn)換為顯示圖像坐標(biāo)
        img_x = widget_pos.x() - x_offset
        img_y = widget_pos.y() - y_offset
        
        if img_x < 0 or img_y < 0 or img_x >= display_width or img_y >= display_height:
            return None
            
        # 縮放到原始圖像尺寸
        scale_x = w / display_width
        scale_y = h / display_height
        
        orig_x = int(img_x * scale_x)
        orig_y = int(img_y * scale_y)
        
        # 確保在圖像范圍內(nèi)
        orig_x = max(0, min(orig_x, w - 1))
        orig_y = max(0, min(orig_y, h - 1))
        
        return QPoint(orig_x, orig_y)
        
    def mousePressEvent(self, event):
        """鼠標(biāo)按下事件"""
        if event.button() == Qt.LeftButton and self.image is not None and self.current_tool:
            # 左鍵：使用工具
            self.is_drawing = True
            pos = self.get_image_pos(event.pos())
            if pos:
                self.last_point = pos
                self.continuous_pos = pos
                if self.current_tool in ['enlarge', 'shrink', 'rotate']:
                    self.apply_effect(pos)
                    # 啟動定時器實(shí)現(xiàn)持續(xù)效果
                    self.start_continuous_effect()
                elif self.current_tool == 'eraser':
                    # 橡皮擦：開始擦除
                    self.apply_eraser(pos)
        elif event.button() == Qt.RightButton and self.image is not None:
            # 右鍵：拖拽視圖
            self.is_panning = True
            self.pan_start_pos = event.pos()
            self.setCursor(Qt.ClosedHandCursor)
                    
    def mouseMoveEvent(self, event):
        """鼠標(biāo)移動事件"""
        if self.is_panning and self.pan_start_pos:
            # 右鍵拖拽視圖
            delta = event.pos() - self.pan_start_pos
            self.offset_x += delta.x()
            self.offset_y += delta.y()
            
            # 限制偏移范圍
            if self.image is not None:
                h, w = self.image.shape[:2]
                widget_aspect = self.width() / self.height()
                image_aspect = w / h
                
                if widget_aspect > image_aspect:
                    base_height = self.height()
                    base_width = int(base_height * image_aspect)
                else:
                    base_width = self.width()
                    base_height = int(base_width / image_aspect)
                
                display_width = int(base_width * self.zoom_scale)
                display_height = int(base_height * self.zoom_scale)
                
                # 限制偏移
                max_offset_x = max(0, display_width - self.width())
                max_offset_y = max(0, display_height - self.height())
                
                self.offset_x = max(-max_offset_x, min(0, self.offset_x))
                self.offset_y = max(-max_offset_y, min(0, self.offset_y))
            
            self.pan_start_pos = event.pos()
            self.update_display()
            
        elif self.is_drawing and self.image is not None and self.current_tool:
            # 左鍵使用工具
            pos = self.get_image_pos(event.pos())
            if pos:
                if self.current_tool == 'drag':
                    self.apply_drag_effect(self.last_point, pos)
                    self.last_point = pos
                elif self.current_tool == 'eraser':
                    # 橡皮擦：沿路徑擦除
                    if self.last_point:
                        self.apply_eraser_path(self.last_point, pos)
                    self.last_point = pos
                elif self.current_tool in ['enlarge', 'shrink', 'rotate']:
                    # 移動時更新持續(xù)效果的位置
                    self.continuous_pos = pos
                    self.last_point = pos
                
    def mouseReleaseEvent(self, event):
        """鼠標(biāo)釋放事件"""
        if event.button() == Qt.LeftButton:
            self.is_drawing = False
            self.last_point = None
            self.continuous_pos = None
            # 停止持續(xù)效果
            self.stop_continuous_effect()
        elif event.button() == Qt.RightButton:
            self.is_panning = False
            self.pan_start_pos = None
            self.setCursor(Qt.ArrowCursor)
            
    def start_continuous_effect(self):
        """啟動持續(xù)效果定時器"""
        from PyQt5.QtCore import QTimer
        if self.continuous_timer is None:
            self.continuous_timer = QTimer(self)
            self.continuous_timer.timeout.connect(self.apply_continuous_effect)
        self.continuous_timer.start(50)  # 每50ms應(yīng)用一次效果
        
    def stop_continuous_effect(self):
        """停止持續(xù)效果定時器"""
        if self.continuous_timer is not None:
            self.continuous_timer.stop()
            
    def apply_continuous_effect(self):
        """持續(xù)應(yīng)用效果"""
        if self.continuous_pos and self.current_tool in ['enlarge', 'shrink', 'rotate']:
            self.apply_effect(self.continuous_pos)
    
    def apply_effect(self, center):
        """應(yīng)用效果（放大、縮小、旋轉(zhuǎn)）"""
        if self.image is None:
            return
            
        h, w = self.image.shape[:2]
        cx, cy = center.x(), center.y()
        
        # 確保中心點(diǎn)在圖像范圍內(nèi)
        if cx < 0 or cy < 0 or cx >= w or cy >= h:
            return
            
        # 創(chuàng)建網(wǎng)格
        y_indices, x_indices = np.mgrid[0:h, 0:w]
        
        # 計算到中心點(diǎn)的距離
        dx = x_indices - cx
        dy = y_indices - cy
        distances = np.sqrt(dx**2 + dy**2)
        
        # 創(chuàng)建影響掩碼（在半徑內(nèi)的像素）
        mask = distances <= self.brush_radius
        
        if self.current_tool == 'enlarge':
            # 放大效果：像素向內(nèi)收縮（修正：原來的shrink邏輯）
            factor = 1.0 - (distances / self.brush_radius)
            factor = np.clip(factor, 0, 1)
            factor = factor ** 2  # 平滑過渡
            
            # 使用effect_strength控制強(qiáng)度
            scale = 1.0 - self.effect_strength * factor * mask
            new_x = cx + dx * scale
            new_y = cy + dy * scale
            
        elif self.current_tool == 'shrink':
            # 縮小效果：像素向外擴(kuò)展（修正：原來的enlarge邏輯）
            factor = 1.0 - (distances / self.brush_radius)
            factor = np.clip(factor, 0, 1)
            factor = factor ** 2
            
            # 使用effect_strength控制強(qiáng)度
            scale = 1.0 + self.effect_strength * factor * mask
            new_x = cx + dx * scale
            new_y = cy + dy * scale
            
        elif self.current_tool == 'rotate':
            # 旋轉(zhuǎn)效果：像素螺旋旋轉(zhuǎn)
            # rotate_direction: 1為順時針，-1為逆時針
            angle = np.where(mask, (1.0 - distances / self.brush_radius) * np.pi * self.effect_strength * self.rotate_direction, 0)
            
            cos_angle = np.cos(angle)
            sin_angle = np.sin(angle)
            
            new_x = cx + dx * cos_angle - dy * sin_angle
            new_y = cy + dx * sin_angle + dy * cos_angle
        else:
            return
            
        # 限制坐標(biāo)范圍
        new_x = np.clip(new_x, 0, w - 1)
        new_y = np.clip(new_y, 0, h - 1)
        
        # 使用雙線性插值進(jìn)行重映射
        new_image = cv2.remap(self.image, new_x.astype(np.float32), 
                              new_y.astype(np.float32), cv2.INTER_LINEAR)
        
        self.image = new_image
        self.update_display()
        
    def apply_eraser(self, center, update_display=True):
        """應(yīng)用橡皮擦效果（恢復(fù)原始圖像）- 使用NumPy向量化優(yōu)化"""
        if self.image is None or self.original_image is None:
            return
            
        h, w = self.image.shape[:2]
        cx, cy = center.x(), center.y()
        
        # 確保中心點(diǎn)在圖像范圍內(nèi)
        if cx < 0 or cy < 0 or cx >= w or cy >= h:
            return
        
        # 計算畫筆范圍
        x1 = max(0, cx - self.brush_radius)
        y1 = max(0, cy - self.brush_radius)
        x2 = min(w, cx + self.brush_radius)
        y2 = min(h, cy + self.brush_radius)
        
        # 使用NumPy向量化操作代替雙重循環(huán)
        y_coords, x_coords = np.ogrid[y1:y2, x1:x2]
        
        # 計算距離矩陣
        distances = np.sqrt((x_coords - cx)**2 + (y_coords - cy)**2)
        
        # 創(chuàng)建圓形遮罩
        mask = distances <= self.brush_radius
        
        if not mask.any():
            return
        
        # 計算混合因子（邊緣羽化）
        factor = np.zeros_like(distances)
        factor[mask] = 1.0 - (distances[mask] / self.brush_radius)
        factor = factor ** 0.5  # 平滑過渡曲線
        
        # 擴(kuò)展factor到3通道
        factor_3d = factor[:, :, np.newaxis]
        
        # 向量化混合操作
        region = self.image[y1:y2, x1:x2]
        original_region = self.original_image[y1:y2, x1:x2]
        
        # 只混合mask為True的區(qū)域
        mask_3d = mask[:, :, np.newaxis]
        blended = region * (1 - factor_3d) + original_region * factor_3d
        self.image[y1:y2, x1:x2] = np.where(mask_3d, blended, region).astype(np.uint8)
        
        if update_display:
            self.update_display()
    
    def apply_eraser_path(self, start_pos, end_pos):
        """沿路徑應(yīng)用橡皮擦效果（優(yōu)化版）"""
        if self.image is None or self.original_image is None or start_pos is None:
            return
        
        # 計算路徑上的點(diǎn)
        sx, sy = start_pos.x(), start_pos.y()
        ex, ey = end_pos.x(), end_pos.y()
        
        # 計算距離和步數(shù)
        dist = np.sqrt((ex - sx)**2 + (ey - sy)**2)
        if dist < 1:
            return
        
        # 根據(jù)畫筆半徑調(diào)整步數(shù)，大畫筆可以用更少的步數(shù)
        step_size = max(self.brush_radius // 4, 3)
        steps = max(int(dist / step_size), 1)
        
        # 沿路徑插值多個點(diǎn)，批量處理，不每次都刷新
        for i in range(steps + 1):
            t = i / steps if steps > 0 else 0
            px = int(sx + (ex - sx) * t)
            py = int(sy + (ey - sy) * t)
            # 只在最后一個點(diǎn)才刷新顯示
            self.apply_eraser(QPoint(px, py), update_display=(i == steps))
    
    
    def apply_drag_effect(self, start_pos, end_pos):
        """應(yīng)用拖拽扭曲效果"""
        if self.image is None or start_pos is None:
            return
            
        h, w = self.image.shape[:2]
        sx, sy = start_pos.x(), start_pos.y()
        ex, ey = end_pos.x(), end_pos.y()
        
        # 計算拖拽向量
        drag_x = ex - sx
        drag_y = ey - sy
        
        if drag_x == 0 and drag_y == 0:
            return
            
        # 創(chuàng)建網(wǎng)格
        y_indices, x_indices = np.mgrid[0:h, 0:w]
        
        # 計算到起始點(diǎn)的距離
        dx = x_indices - sx
        dy = y_indices - sy
        distances = np.sqrt(dx**2 + dy**2)
        
        # 創(chuàng)建影響掩碼
        mask = distances <= self.brush_radius
        
        # 計算影響因子（距離越近影響越大）
        factor = np.where(distances < self.brush_radius,
                         1.0 - (distances / self.brush_radius),
                         0)
        factor = factor ** 2  # 平滑過渡
        
        # 應(yīng)用拖拽位移，使用effect_strength控制強(qiáng)度
        new_x = x_indices - drag_x * factor * mask * self.effect_strength
        new_y = y_indices - drag_y * factor * mask * self.effect_strength
        
        # 限制坐標(biāo)范圍
        new_x = np.clip(new_x, 0, w - 1)
        new_y = np.clip(new_y, 0, h - 1)
        
        # 重映射
        new_image = cv2.remap(self.image, new_x.astype(np.float32),
                              new_y.astype(np.float32), cv2.INTER_LINEAR)
        
        self.image = new_image
        self.update_display()
        
    def reset_image(self):
        """重置圖像到原始狀態(tài)"""
        if self.original_image is not None:
            self.image = self.original_image.copy()
            # 重置縮放和偏移
            self.zoom_scale = 1.0
            self.offset_x = 0
            self.offset_y = 0
            self.update_display()
            
    def wheelEvent(self, event):
        """鼠標(biāo)滾輪事件（Ctrl+滾輪縮放）"""
        if self.image is None:
            return
            
        # 檢測Ctrl鍵
        modifiers = QApplication.keyboardModifiers()
        if modifiers == Qt.ControlModifier:
            # 獲取鼠標(biāo)位置對應(yīng)的圖像坐標(biāo)
            mouse_pos = event.pos()
            old_image_pos = self.get_image_pos(mouse_pos)
            
            # 計算縮放增量
            delta = event.angleDelta().y()
            zoom_factor = 1.1 if delta > 0 else 0.9
            
            # 更新縮放比例
            old_zoom = self.zoom_scale
            self.zoom_scale *= zoom_factor
            
            # 限制縮放范圍
            self.zoom_scale = max(0.1, min(10.0, self.zoom_scale))
            
            # 如果縮放真的改變了，調(diào)整偏移以保持鼠標(biāo)位置下的圖像點(diǎn)不變
            if old_zoom != self.zoom_scale and old_image_pos:
                # 計算新的顯示尺寸
                h, w = self.image.shape[:2]
                widget_aspect = self.width() / self.height()
                image_aspect = w / h
                
                if widget_aspect > image_aspect:
                    base_height = self.height()
                    base_width = int(base_height * image_aspect)
                else:
                    base_width = self.width()
                    base_height = int(base_width / image_aspect)
                
                old_display_width = int(base_width * old_zoom)
                old_display_height = int(base_height * old_zoom)
                new_display_width = int(base_width * self.zoom_scale)
                new_display_height = int(base_height * self.zoom_scale)
                
                # 計算鼠標(biāo)在顯示圖像中的相對位置
                if old_display_width <= self.width():
                    old_x_offset = (self.width() - old_display_width) // 2
                else:
                    old_x_offset = self.offset_x
                    
                if old_display_height <= self.height():
                    old_y_offset = (self.height() - old_display_height) // 2
                else:
                    old_y_offset = self.offset_y
                
                img_x_in_display = mouse_pos.x() - old_x_offset
                img_y_in_display = mouse_pos.y() - old_y_offset
                
                # 計算新的偏移以保持鼠標(biāo)下的點(diǎn)不變
                ratio_x = img_x_in_display / old_display_width if old_display_width > 0 else 0.5
                ratio_y = img_y_in_display / old_display_height if old_display_height > 0 else 0.5
                
                new_x_in_display = ratio_x * new_display_width
                new_y_in_display = ratio_y * new_display_height
                
                if new_display_width > self.width():
                    self.offset_x = mouse_pos.x() - new_x_in_display
                else:
                    self.offset_x = 0
                    
                if new_display_height > self.height():
                    self.offset_y = mouse_pos.y() - new_y_in_display
                else:
                    self.offset_y = 0
                
                # 限制偏移范圍
                max_offset_x = max(0, new_display_width - self.width())
                max_offset_y = max(0, new_display_height - self.height())
                
                self.offset_x = max(-max_offset_x, min(0, self.offset_x))
                self.offset_y = max(-max_offset_y, min(0, self.offset_y))
            
            self.update_display()
            
            # 更新狀態(tài)欄顯示縮放比例
            if self.parent_window:
                self.parent_window.statusBar().showMessage(f"縮放: {self.zoom_scale:.1f}x")
            
            event.accept()
        else:
            event.ignore()
            
    def dragEnterEvent(self, event):
        """拖拽進(jìn)入事件"""
        if event.mimeData().hasUrls():
            # 檢查是否是圖片文件
            urls = event.mimeData().urls()
            if urls:
                file_path = urls[0].toLocalFile()
                if file_path.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
                    event.acceptProposedAction()
                    # 顯示拖拽提示
                    self.setStyleSheet("""
                        QLabel { 
                            background-color: #1a4d2e; 
                            color: #4CAF50;
                            font-size: 24px;
                            font-weight: bold;
                            border: 3px dashed #4CAF50;
                            border-radius: 10px;
                        }
                    """)
                    if self.image is None:
                        self.setText('? 松開鼠標(biāo)即可上傳圖片')
                        
    def dragLeaveEvent(self, event):
        """拖拽離開事件"""
        if self.image is None:
            # 恢復(fù)原始樣式
            self.setStyleSheet("""
                QLabel { 
                    background-color: #2b2b2b; 
                    color: #9E9E9E;
                    font-size: 24px;
                    font-weight: bold;
                    border: 3px dashed #555;
                    border-radius: 10px;
                }
            """)
            self.setText('?? 點(diǎn)擊"上傳圖片"按鈕\n或\n拖拽圖片到此處')
            
    def dropEvent(self, event):
        """拖拽放下事件"""
        if event.mimeData().hasUrls():
            urls = event.mimeData().urls()
            if urls:
                file_path = urls[0].toLocalFile()
                if file_path.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
                    # 加載圖片
                    if self.load_image(file_path):
                        if self.parent_window:
                            self.parent_window.statusBar().showMessage(f"已加載: {file_path}")
                        event.acceptProposedAction()
                    else:
                        if self.parent_window:
                            self.parent_window.statusBar().showMessage("加載圖片失?。?)
                        # 恢復(fù)提示
                        self.setStyleSheet("""
                            QLabel { 
                                background-color: #2b2b2b; 
                                color: #9E9E9E;
                                font-size: 24px;
                                font-weight: bold;
                                border: 3px dashed #555;
                                border-radius: 10px;
                            }
                        """)
                        self.setText('?? 點(diǎn)擊"上傳圖片"按鈕\n或\n拖拽圖片到此處')
    
    def resizeEvent(self, event):
        """窗口大小改變時重新顯示圖像"""
        super().resizeEvent(event)
        self.update_display()


class FaceWarpApp(QMainWindow):
    """捏臉APP主窗口"""
    
    def __init__(self):
        super().__init__()
        self.init_ui()
        
    def init_ui(self):
        """初始化用戶界面"""
        self.setWindowTitle("捏臉APP - 圖像變形工具")
        self.setGeometry(100, 100, 1600, 900)
        self.setMinimumSize(1600, 800)  # 設(shè)置最小窗口尺寸，確保所有按鈕可見
        
        # 創(chuàng)建中心部件
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # 主布局
        main_layout = QVBoxLayout(central_widget)
        main_layout.setSpacing(15)
        main_layout.setContentsMargins(15, 15, 15, 15)
        
        # 創(chuàng)建工具欄
        self.create_toolbar()
        
        # 創(chuàng)建圖像畫布
        self.canvas = ImageCanvas(self)
        main_layout.addWidget(self.canvas)
        
        # 創(chuàng)建控制面板
        control_panel = self.create_control_panel()
        main_layout.addLayout(control_panel)
        
        # 設(shè)置樣式
        self.setStyleSheet("""
            QMainWindow {
                background-color: #1a1a1a;
            }
            QWidget {
                font-family: "Microsoft YaHei UI", "Segoe UI", Arial;
            }
            QPushButton {
                background-color: #2196F3;
                color: white;
                border: none;
                padding: 10px 20px;
                border-radius: 6px;
                font-size: 15px;
                font-weight: bold;
                min-width: 100px;
                min-height: 42px;
            }
            QPushButton:hover {
                background-color: #42A5F5;
            }
            QPushButton:pressed {
                background-color: #1976D2;
            }
            QPushButton:checked {
                background-color: #4CAF50;
            }
            QLabel {
                color: #E0E0E0;
                font-size: 16px;
                font-weight: bold;
            }
            QSlider::groove:horizontal {
                height: 10px;
                background: #424242;
                border-radius: 5px;
            }
            QSlider::handle:horizontal {
                background: #2196F3;
                width: 22px;
                height: 22px;
                margin: -6px 0;
                border-radius: 11px;
            }
            QSlider::handle:horizontal:hover {
                background: #42A5F5;
            }
            QToolBar {
                background-color: #2d2d2d;
                border: none;
                spacing: 10px;
                padding: 10px;
            }
            QToolButton {
                background-color: #2196F3;
                color: white;
                border: none;
                padding: 10px 18px;
                border-radius: 6px;
                font-size: 15px;
                font-weight: bold;
                min-width: 95px;
                min-height: 42px;
            }
            QToolButton:hover {
                background-color: #42A5F5;
            }
            QToolButton:pressed {
                background-color: #1976D2;
            }
            QToolButton:checked {
                background-color: #4CAF50;
            }
            QStatusBar {
                background-color: #2d2d2d;
                color: #E0E0E0;
                font-size: 14px;
            }
        """)
        
    def create_toolbar(self):
        """創(chuàng)建工具欄"""
        from PyQt5.QtCore import QSize
        
        toolbar = QToolBar()
        toolbar.setMovable(False)
        toolbar.setIconSize(QSize(28, 28))
        toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
        toolbar.setStyleSheet("""
            QToolBar {
                spacing: 8px;
            }
        """)
        self.addToolBar(toolbar)
        
        # 上傳圖片按鈕
        upload_action = QAction("?? 上傳圖片", self)
        upload_action.triggered.connect(self.load_image)
        toolbar.addAction(upload_action)
        
        toolbar.addSeparator()
        
        # 工具按鈕
        self.enlarge_btn = QAction("?? 放大", self)
        self.enlarge_btn.setCheckable(True)
        self.enlarge_btn.triggered.connect(lambda: self.set_tool('enlarge'))
        toolbar.addAction(self.enlarge_btn)
        
        self.shrink_btn = QAction("?? 縮小", self)
        self.shrink_btn.setCheckable(True)
        self.shrink_btn.triggered.connect(lambda: self.set_tool('shrink'))
        toolbar.addAction(self.shrink_btn)
        
        self.drag_btn = QAction("? 拖拽扭曲", self)
        self.drag_btn.setCheckable(True)
        self.drag_btn.triggered.connect(lambda: self.set_tool('drag'))
        toolbar.addAction(self.drag_btn)
        
        self.rotate_btn = QAction("?? 旋轉(zhuǎn)", self)
        self.rotate_btn.setCheckable(True)
        self.rotate_btn.triggered.connect(lambda: self.set_tool('rotate'))
        toolbar.addAction(self.rotate_btn)
        
        self.eraser_btn = QAction("?? 橡皮擦", self)
        self.eraser_btn.setCheckable(True)
        self.eraser_btn.triggered.connect(lambda: self.set_tool('eraser'))
        toolbar.addAction(self.eraser_btn)
        
        toolbar.addSeparator()
        
        # 重置按鈕
        reset_action = QAction("? 重置", self)
        reset_action.triggered.connect(self.reset_image)
        toolbar.addAction(reset_action)
        
        # 保存按鈕
        save_action = QAction("?? 保存", self)
        save_action.triggered.connect(self.save_image)
        toolbar.addAction(save_action)
        
        self.tool_buttons = [self.enlarge_btn, self.shrink_btn, self.drag_btn, self.rotate_btn, self.eraser_btn]
        
    def create_control_panel(self):
        """創(chuàng)建控制面板"""
        from PyQt5.QtWidgets import QButtonGroup, QRadioButton, QGroupBox, QLineEdit
        from PyQt5.QtGui import QIntValidator, QDoubleValidator
        
        layout = QHBoxLayout()
        layout.setSpacing(20)
        
        # 畫筆半徑控制
        radius_label = QLabel("畫筆半徑:")
        layout.addWidget(radius_label)
        
        self.radius_slider = QSlider(Qt.Horizontal)
        self.radius_slider.setMinimum(10)
        self.radius_slider.setMaximum(800)  # 提高到800
        self.radius_slider.setValue(170)  # 默認(rèn)170
        self.radius_slider.setMinimumWidth(250)
        self.radius_slider.valueChanged.connect(self.update_brush_radius_from_slider)
        layout.addWidget(self.radius_slider)
        
        self.radius_value_label = QLabel("170 px")
        self.radius_value_label.setMinimumWidth(70)
        layout.addWidget(self.radius_value_label)
        
        # 畫筆半徑輸入框
        self.radius_input = QLineEdit()
        self.radius_input.setText("170")
        self.radius_input.setMaximumWidth(60)
        self.radius_input.setValidator(QIntValidator(10, 800))
        self.radius_input.setStyleSheet("""
            QLineEdit {
                background-color: #3d3d3d;
                color: #E0E0E0;
                border: 2px solid #555;
                border-radius: 4px;
                padding: 5px;
                font-size: 15px;
            }
            QLineEdit:focus {
                border: 2px solid #2196F3;
            }
        """)
        self.radius_input.returnPressed.connect(self.update_brush_radius_from_input)
        self.radius_input.editingFinished.connect(self.update_brush_radius_from_input)
        layout.addWidget(self.radius_input)
        
        layout.addSpacing(30)
        
        # 變化強(qiáng)度控制
        strength_label = QLabel("變化強(qiáng)度:")
        layout.addWidget(strength_label)
        
        self.strength_slider = QSlider(Qt.Horizontal)
        self.strength_slider.setMinimum(1)  # 0.01
        self.strength_slider.setMaximum(100)  # 1.0
        self.strength_slider.setValue(20)  # 默認(rèn)0.20
        self.strength_slider.setMinimumWidth(250)
        self.strength_slider.valueChanged.connect(self.update_effect_strength_from_slider)
        layout.addWidget(self.strength_slider)
        
        self.strength_value_label = QLabel("0.20")
        self.strength_value_label.setMinimumWidth(50)
        layout.addWidget(self.strength_value_label)
        
        # 變化強(qiáng)度輸入框
        self.strength_input = QLineEdit()
        self.strength_input.setText("0.20")
        self.strength_input.setMaximumWidth(60)
        # 允許輸入0.01-1.0，最多3位小數(shù)（如0.001）
        strength_validator = QDoubleValidator(0.01, 1.0, 3)
        strength_validator.setNotation(QDoubleValidator.StandardNotation)
        self.strength_input.setValidator(strength_validator)
        self.strength_input.setStyleSheet("""
            QLineEdit {
                background-color: #3d3d3d;
                color: #E0E0E0;
                border: 2px solid #555;
                border-radius: 4px;
                padding: 5px;
                font-size: 15px;
            }
            QLineEdit:focus {
                border: 2px solid #2196F3;
            }
        """)
        self.strength_input.returnPressed.connect(self.update_effect_strength_from_input)
        self.strength_input.editingFinished.connect(self.update_effect_strength_from_input)
        layout.addWidget(self.strength_input)
        
        layout.addSpacing(30)
        
        # 旋轉(zhuǎn)方向控制
        rotate_group_box = QGroupBox("旋轉(zhuǎn)方向")
        rotate_group_box.setStyleSheet("""
            QGroupBox {
                color: #E0E0E0;
                font-size: 16px;
                font-weight: bold;
                border: 2px solid #424242;
                border-radius: 8px;
                margin-top: 10px;
                padding-top: 10px;
            }
            QGroupBox::title {
                subcontrol-origin: margin;
                left: 15px;
                padding: 0 5px;
            }
            QRadioButton {
                color: #E0E0E0;
                font-size: 15px;
                spacing: 8px;
            }
            QRadioButton::indicator {
                width: 20px;
                height: 20px;
            }
            QRadioButton::indicator:unchecked {
                border: 2px solid #666;
                border-radius: 10px;
                background: #2d2d2d;
            }
            QRadioButton::indicator:checked {
                border: 2px solid #2196F3;
                border-radius: 10px;
                background: #2196F3;
            }
        """)
        
        rotate_layout = QHBoxLayout()
        rotate_layout.setSpacing(15)
        
        self.clockwise_radio = QRadioButton("? 順時針")
        self.clockwise_radio.setChecked(True)
        self.clockwise_radio.toggled.connect(lambda: self.set_rotate_direction(1))
        
        self.counterclockwise_radio = QRadioButton("? 逆時針")
        self.counterclockwise_radio.toggled.connect(lambda: self.set_rotate_direction(-1))
        
        rotate_layout.addWidget(self.clockwise_radio)
        rotate_layout.addWidget(self.counterclockwise_radio)
        rotate_group_box.setLayout(rotate_layout)
        
        layout.addWidget(rotate_group_box)
        
        layout.addStretch()
        
        return layout
        
    def set_tool(self, tool_name):
        """設(shè)置當(dāng)前工具"""
        # 取消其他工具的選中狀態(tài)
        for btn in self.tool_buttons:
            btn.setChecked(False)
            
        # 設(shè)置當(dāng)前工具
        if tool_name == 'enlarge':
            self.enlarge_btn.setChecked(True)
        elif tool_name == 'shrink':
            self.shrink_btn.setChecked(True)
        elif tool_name == 'drag':
            self.drag_btn.setChecked(True)
        elif tool_name == 'rotate':
            self.rotate_btn.setChecked(True)
        elif tool_name == 'eraser':
            self.eraser_btn.setChecked(True)
            
        self.canvas.current_tool = tool_name
        
    def update_brush_radius_from_slider(self, value):
        """從滑塊更新畫筆半徑"""
        self.canvas.brush_radius = value
        self.radius_value_label.setText(f"{value} px")
        self.radius_input.setText(str(value))
        
    def update_brush_radius_from_input(self):
        """從輸入框更新畫筆半徑"""
        try:
            value = int(self.radius_input.text())
            value = max(10, min(800, value))  # 限制范圍
            self.canvas.brush_radius = value
            self.radius_slider.setValue(value)
            self.radius_value_label.setText(f"{value} px")
            self.radius_input.setText(str(value))
        except ValueError:
            # 輸入無效，恢復(fù)當(dāng)前值
            self.radius_input.setText(str(self.canvas.brush_radius))
        
    def update_effect_strength_from_slider(self, value):
        """從滑塊更新變化強(qiáng)度"""
        strength = value / 100.0  # 轉(zhuǎn)換為0.01-1.0
        self.canvas.effect_strength = strength
        self.strength_value_label.setText(f"{strength:.2f}")
        self.strength_input.setText(f"{strength:.2f}")
        
    def update_effect_strength_from_input(self):
        """從輸入框更新變化強(qiáng)度"""
        try:
            value = float(self.strength_input.text())
            value = max(0.01, min(1.0, value))  # 限制范圍
            self.canvas.effect_strength = value
            self.strength_slider.setValue(int(value * 100))
            self.strength_value_label.setText(f"{value:.2f}")
            self.strength_input.setText(f"{value:.2f}")
        except ValueError:
            # 輸入無效，恢復(fù)當(dāng)前值
            self.strength_input.setText(f"{self.canvas.effect_strength:.2f}")
        
    def set_rotate_direction(self, direction):
        """設(shè)置旋轉(zhuǎn)方向"""
        self.canvas.rotate_direction = direction
        
    def load_image(self):
        """加載圖像"""
        file_path, _ = QFileDialog.getOpenFileName(
            self, "選擇圖片", "", 
            "圖片文件 (*.png *.jpg *.jpeg *.bmp);;所有文件 (*.*)"
        )
        
        if file_path:
            if self.canvas.load_image(file_path):
                self.statusBar().showMessage(f"已加載: {file_path}")
            else:
                self.statusBar().showMessage("加載圖片失??！")
                
    def reset_image(self):
        """重置圖像"""
        self.canvas.reset_image()
        self.statusBar().showMessage("已重置圖像")
        
    def save_image(self):
        """保存圖像（支持中文路徑）"""
        if self.canvas.image is None:
            self.statusBar().showMessage("沒有可保存的圖像！")
            return
            
        file_path, _ = QFileDialog.getSaveFileName(
            self, "保存圖片", "", 
            "PNG文件 (*.png);;JPEG文件 (*.jpg);;所有文件 (*.*)"
        )
        
        if file_path:
            try:
                # RGB轉(zhuǎn)BGR
                image_bgr = cv2.cvtColor(self.canvas.image, cv2.COLOR_RGB2BGR)
                
                # 使用cv2.imencode()和tofile()保存，支持中文路徑
                # 根據(jù)文件擴(kuò)展名確定編碼格式
                ext = file_path.lower().split('.')[-1]
                if ext in ['jpg', 'jpeg']:
                    encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 95]
                    _, encoded_img = cv2.imencode('.jpg', image_bgr, encode_param)
                else:
                    _, encoded_img = cv2.imencode('.png', image_bgr)
                
                encoded_img.tofile(file_path)
                self.statusBar().showMessage(f"已保存: {file_path}")
            except Exception as e:
                self.statusBar().showMessage(f"保存失敗: {str(e)}")


def main():
    app = QApplication(sys.argv)
    window = FaceWarpApp()
    window.show()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple PyQt5

# 重新安裝opencv-python
pip uninstall opencv-python
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple opencv-python

PyQt5>=5.15.0
opencv-python>=4.5.0
numpy>=1.19.0

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple PyQt5>=5.15.0
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple opencv-python>=4.5.0
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple numpy>=1.19.0