feat(v1.6.6): 添加画布拖动、日志显示和MOCR镜像下载

Author: hgmzhn

README.md

@@ -1 +1 @@
-1.6.5
+1.6.6

VERSION

@@ -499,9 +499,28 @@ def start_backend_task(self):
             self.logger.warning("一个任务已经在运行中。")
             return
 
+        # 检查文件列表是否为空
         files_to_process = self._resolve_input_files()
         if not files_to_process:
             self.logger.warning("没有找到有效的图片文件，任务中止")
+            from PyQt6.QtWidgets import QMessageBox
+            QMessageBox.warning(
+                None,
+                "文件列表为空",
+                "请先添加要翻译的图片文件！\n\n可以通过以下方式添加：\n• 点击「添加文件」按钮\n• 点击「添加文件夹」按钮\n• 直接拖拽文件到文件列表"
+            )
+            return
+
+        # 检查输出目录是否合法
+        output_path = self.config_service.get_config().app.last_output_path
+        if not output_path or not os.path.isdir(output_path):
+            self.logger.warning(f"输出目录不合法: {output_path}")
+            from PyQt6.QtWidgets import QMessageBox
+            QMessageBox.warning(
+                None,
+                "输出目录不合法",
+                "请先设置有效的输出目录！\n\n可以通过以下方式设置：\n• 点击「浏览...」按钮选择输出目录\n• 直接在输出目录输入框中输入路径"
+            )
             return
 
         self.saved_files_count = 0
@@ -644,20 +663,40 @@ def stop_task(self) -> bool:
             self.state_manager.set_translating(False)
             self.state_manager.set_status_message("正在停止翻译...")
 
+            # 1. 先通知 worker 停止
             if self.worker:
                 self.worker.stop()
+
+            # 2. 请求线程退出
             self.thread.quit()
 
             # 保存线程引用，避免在等待过程中被清空
             thread_ref = self.thread
+            worker_ref = self.worker
 
             # 在后台等待线程停止，不阻塞UI
             from PyQt6.QtCore import QTimer
+            timeout_counter = [0]  # 使用列表以便在闭包中修改
+
             def wait_for_thread():
                 try:
                     if thread_ref and not thread_ref.wait(100):  # 等待100ms
-                        # 如果还没停止，继续等待
-                        QTimer.singleShot(100, wait_for_thread)
+                        timeout_counter[0] += 100
+
+                        # 如果超过5秒还没停止，强制终止
+                        if timeout_counter[0] >= 5000:
+                            self.logger.warning("线程5秒内未停止，强制终止...")
+                            try:
+                                thread_ref.terminate()
+                                thread_ref.wait(1000)  # 等待1秒
+                                self.logger.info("翻译线程已被强制终止。")
+                                self.state_manager.set_status_message("任务已强制停止")
+                            except Exception as e:
+                                self.logger.error(f"强制终止线程失败: {e}")
+                                self.state_manager.set_status_message("停止失败")
+                        else:
+                            # 继续等待
+                            QTimer.singleShot(100, wait_for_thread)
                     else:
                         # 线程已停止
                         self.logger.info("翻译线程已成功停止。")
@@ -839,9 +878,32 @@ async def _do_processing(self):
                 'input_folders': input_folders
             }
 
+            # 确定翻译流程模式
+            workflow_mode = "正常翻译流程"
+            workflow_tip = ""
+            cli_config = self.config_dict.get('cli', {})
+            if cli_config.get('generate_and_export', False):
+                workflow_mode = "导出翻译"
+                workflow_tip = "💡 提示：导出翻译后，可在 manga_translator_work/translations/ 目录查看 图片名_translated.txt 文件"
+            elif cli_config.get('template', False):
+                workflow_mode = "导出原文"
+                workflow_tip = "💡 提示：导出原文后，可在 manga_translator_work/originals/ 目录手动翻译 图片名_original.txt 文件，然后使用「导入翻译并渲染」模式"
+            elif cli_config.get('load_text', False):
+                workflow_mode = "导入翻译并渲染"
+                workflow_tip = "💡 提示：将从 manga_translator_work/originals/ 或 translations/ 目录读取 TXT 文件并渲染（优先使用 _original.txt）"
+
             if is_hq or (len(self.files) > 1 and batch_size > 1):
                 self.log_received.emit(f"--- [12] THREAD: Starting batch processing ({'HQ mode' if is_hq else 'Batch mode'})...")
 
+                # 输出批量处理信息
+                total_images = len(self.files)
+                total_batches = (total_images + batch_size - 1) // batch_size if batch_size > 0 else 1
+                self.log_received.emit(f"📊 批量处理模式：共 {total_images} 张图片，分 {total_batches} 个批次处理")
+                self.log_received.emit(f"🔧 翻译流程：{workflow_mode}")
+                self.log_received.emit(f"📁 输出目录：{self.output_folder}")
+                if workflow_tip:
+                    self.log_received.emit(workflow_tip)
+
                 images_with_configs = []
                 for file_path in self.files:
                     if not self._is_running: raise asyncio.CancelledError("Task stopped by user.")
@@ -850,39 +912,62 @@ async def _do_processing(self):
                     image.name = file_path
                     images_with_configs.append((image, config))
 
+                self.log_received.emit(f"🚀 开始翻译...")
                 contexts = await translator.translate_batch(images_with_configs, save_info=save_info)
 
                 # The backend now handles saving for batch jobs. We just need to collect the paths/status.
+                success_count = 0
                 for ctx in contexts:
                     if not self._is_running: raise asyncio.CancelledError("Task stopped by user.")
                     if ctx:
                         results.append({'success': True, 'original_path': ctx.image_name, 'image_data': None})
+                        success_count += 1
                     else:
                         results.append({'success': False, 'original_path': 'Unknown', 'error': 'Batch translation returned no context'})
 
-            else: 
+                self.log_received.emit(f"✅ 批量翻译完成：成功 {success_count}/{total_images} 张")
+                self.log_received.emit(f"💾 文件已保存到：{self.output_folder}")
+
+            else:
                 self.log_received.emit("--- [12] THREAD: Starting sequential processing...")
                 total_files = len(self.files)
+
+                # 输出顺序处理信息
+                self.log_received.emit(f"📊 顺序处理模式：共 {total_files} 张图片")
+                self.log_received.emit(f"🔧 翻译流程：{workflow_mode}")
+                self.log_received.emit(f"📁 输出目录：{self.output_folder}")
+                if workflow_tip:
+                    self.log_received.emit(workflow_tip)
+
+                success_count = 0
                 for i, file_path in enumerate(self.files):
                     if not self._is_running:
                         raise asyncio.CancelledError("Task stopped by user.")
 
+                    current_num = i + 1
                     self.progress.emit(i, total_files, f"Processing: {os.path.basename(file_path)}")
-                    
+                    self.log_received.emit(f"🔄 [{current_num}/{total_files}] 正在处理：{os.path.basename(file_path)}")
+
                     try:
                         image = Image.open(file_path)
                         image.name = file_path
-                        
+
                         ctx = await translator.translate(image, config, image_name=image.name)
-                        
+
                         if ctx and ctx.result:
                             self.file_processed.emit({'success': True, 'original_path': file_path, 'image_data': ctx.result})
+                            success_count += 1
+                            self.log_received.emit(f"✅ [{current_num}/{total_files}] 完成：{os.path.basename(file_path)}")
                         else:
                             self.file_processed.emit({'success': False, 'original_path': file_path, 'error': 'Translation returned no result or image'})
+                            self.log_received.emit(f"❌ [{current_num}/{total_files}] 失败：{os.path.basename(file_path)}")
 
                     except Exception as e:
-                        self.log_received.emit(f"Error processing file {os.path.basename(file_path)}: {e}")
+                        self.log_received.emit(f"❌ [{current_num}/{total_files}] 错误：{os.path.basename(file_path)} - {e}")
                         self.file_processed.emit({'success': False, 'original_path': file_path, 'error': str(e)})
+
+                self.log_received.emit(f"✅ 顺序翻译完成：成功 {success_count}/{total_files} 张")
+                self.log_received.emit(f"💾 文件已保存到：{self.output_folder}")
 
             self.finished.emit(results)
 

desktop_qt_ui/app_logic.py

@@ -921,7 +921,17 @@ def mousePressEvent(self, event):
             dummy_event = event.clone()
             dummy_event.setButton(Qt.MouseButton.LeftButton)
             super().mousePressEvent(dummy_event)
-        else:
+        elif event.button() == Qt.MouseButton.LeftButton:
+            # 检查是否点击在空白区域
+            item_at_pos = self.itemAt(event.pos())
+
+            # 如果点击在空白区域（没有 item 或只有图片），启用拖动模式
+            if item_at_pos is None or item_at_pos == self._image_item:
+                self.setDragMode(QGraphicsView.DragMode.ScrollHandDrag)
+                dummy_event = event.clone()
+                super().mousePressEvent(dummy_event)
+                return
+
             # 先记录当前选择
             old_selection = self.model.get_selection().copy()
 
@@ -934,6 +944,8 @@ def mousePressEvent(self, event):
                 # 只有真正点击空白时，event 才不会被 accept
                 if not event.isAccepted():
                     self.model.set_selection([])
+        else:
+            super().mousePressEvent(event)
 
     def mouseMoveEvent(self, event):
         """Handle mouse move for drawing."""
@@ -1007,7 +1019,7 @@ def mouseReleaseEvent(self, event):
         if self._is_drawing and event.button() == Qt.MouseButton.LeftButton:
             self._finish_drawing()
 
-        if event.button() == Qt.MouseButton.MiddleButton:
+        if event.button() == Qt.MouseButton.MiddleButton or event.button() == Qt.MouseButton.LeftButton:
             self.setDragMode(QGraphicsView.DragMode.NoDrag)
         super().mouseReleaseEvent(event)
 

desktop_qt_ui/editor/graphics_view.py

@@ -3,6 +3,9 @@
 import logging
 import warnings
 
+# 设置 Hugging Face 镜像站（国内用户加速下载）
+os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'
+
 # 修复PyInstaller打包后onnxruntime的DLL加载问题
 if getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS'):
     # 运行在PyInstaller打包环境中

desktop_qt_ui/main.py

@@ -84,6 +84,7 @@ def _connect_signals(self):
         self.app_logic.file_removed.connect(self.main_view.file_list.remove_file)
         self.app_logic.output_path_updated.connect(self.main_view.update_output_path_display)
         self.app_logic.task_completed.connect(self.on_task_completed, type=Qt.ConnectionType.QueuedConnection)
+        self.app_logic.log_message.connect(self.main_view.append_log)
 
         # --- View to Logic Connections ---
         self.main_view.setting_changed.connect(self.app_logic.update_single_config)

desktop_qt_ui/main_window.py

@@ -1,21 +1,21 @@
 {
   "app": {
-    "last_open_dir": "",
-    "last_output_path": ""
+    "last_open_dir": "D:/xiazai/图片助手(ImageAssistant)_批量图片下载器/午夜心旋律",
+    "last_output_path": "D:/xiazai/图片助手(ImageAssistant)_批量图片下载器/output"
   },
   "filter_text": null,
   "kernel_size": 3,
   "mask_dilation_offset": 70,
   "translator": {
-    "translator": "gemini",
+    "translator": "gemini_hq",
     "target_lang": "CHS",
     "no_text_lang_skip": false,
     "gpt_config": "../examples/gpt_config-example.yaml",
     "high_quality_prompt_path": "dict/prompt_example.json"
   },
   "ocr": {
     "use_mocr_merge": false,
-    "ocr": "paddleocr",
+    "ocr": "mocr",
     "use_hybrid_ocr": false,
     "secondary_ocr": "48px",
     "min_text_length": 0,

examples/config-example.json

@@ -22,9 +22,11 @@
 def get_ocr(key: Ocr, *args, **kwargs) -> CommonOCR:
     if key not in OCRS:
         raise ValueError(f'Could not find OCR for: "{key}". Choose from the following: %s' % ','.join(OCRS))
-    # Always create a new instance to avoid caching issues in editor mode
-    ocr = OCRS[key]
-    return ocr(*args, **kwargs)
+    # Use cache to avoid reloading models in the same translation session
+    if key not in ocr_cache:
+        ocr = OCRS[key]
+        ocr_cache[key] = ocr(*args, **kwargs)
+    return ocr_cache[key]
 
 async def prepare(ocr_key: Ocr, device: str = 'cpu'):
     ocr = get_ocr(ocr_key)

manga_translator/ocr/__init__.py

@@ -256,7 +256,7 @@ def _decode_ctc(self, pred: np.ndarray):
         return text, confidence
 
     def _estimate_colors(self, region: np.ndarray, textline: Quadrilateral):
-        """Estimate foreground/background colors using Otsu thresholding"""
+        """Estimate foreground/background colors using improved Otsu thresholding"""
         try:
             if len(region.shape) == 3:
                 gray = cv2.cvtColor(region, cv2.COLOR_BGR2GRAY)
@@ -281,17 +281,43 @@ def _estimate_colors(self, region: np.ndarray, textline: Quadrilateral):
 
                 if np.any(fg_mask):
                     fg_pixels = region_rgb[fg_mask]
-                    textline.fg_r = int(np.mean(fg_pixels[:, 0]))
-                    textline.fg_g = int(np.mean(fg_pixels[:, 1]))
-                    textline.fg_b = int(np.mean(fg_pixels[:, 2]))
+
+                    # 改进：使用中位数代替平均值，减少抗锯齿像素的影响
+                    fg_r = int(np.median(fg_pixels[:, 0]))
+                    fg_g = int(np.median(fg_pixels[:, 1]))
+                    fg_b = int(np.median(fg_pixels[:, 2]))
+
+                    # 颜色量化：如果接近黑色（RGB < 40），强制设为纯黑
+                    if fg_r < 40 and fg_g < 40 and fg_b < 40:
+                        textline.fg_r = textline.fg_g = textline.fg_b = 0
+                    # 如果接近白色（RGB > 215），强制设为纯白
+                    elif fg_r > 215 and fg_g > 215 and fg_b > 215:
+                        textline.fg_r = textline.fg_g = textline.fg_b = 255
+                    else:
+                        textline.fg_r = fg_r
+                        textline.fg_g = fg_g
+                        textline.fg_b = fg_b
                 else:
                     textline.fg_r = textline.fg_g = textline.fg_b = 0
 
                 if np.any(bg_mask):
                     bg_pixels = region_rgb[bg_mask]
-                    textline.bg_r = int(np.mean(bg_pixels[:, 0]))
-                    textline.bg_g = int(np.mean(bg_pixels[:, 1]))
-                    textline.bg_b = int(np.mean(bg_pixels[:, 2]))
+
+                    # 改进：使用中位数代替平均值
+                    bg_r = int(np.median(bg_pixels[:, 0]))
+                    bg_g = int(np.median(bg_pixels[:, 1]))
+                    bg_b = int(np.median(bg_pixels[:, 2]))
+
+                    # 颜色量化：如果接近白色（RGB > 215），强制设为纯白
+                    if bg_r > 215 and bg_g > 215 and bg_b > 215:
+                        textline.bg_r = textline.bg_g = textline.bg_b = 255
+                    # 如果接近黑色（RGB < 40），强制设为纯黑
+                    elif bg_r < 40 and bg_g < 40 and bg_b < 40:
+                        textline.bg_r = textline.bg_g = textline.bg_b = 0
+                    else:
+                        textline.bg_r = bg_r
+                        textline.bg_g = bg_g
+                        textline.bg_b = bg_b
                 else:
                     textline.bg_r = textline.bg_g = textline.bg_b = 255
             else:

manga_translator/ocr/model_paddleocr.py

@@ -67,9 +67,11 @@
 def get_translator(key: Translator, *args, **kwargs) -> CommonTranslator:
     if key not in TRANSLATORS:
         raise ValueError(f'Could not find translator for: "{key}". Choose from the following: %s' % ','.join(TRANSLATORS))
-    # Always create a new instance to avoid caching issues in editor mode
-    translator = TRANSLATORS[key]
-    return translator(*args, **kwargs)
+    # Use cache to avoid reloading models in the same translation session
+    if key not in translator_cache:
+        translator = TRANSLATORS[key]
+        translator_cache[key] = translator(*args, **kwargs)
+    return translator_cache[key]
 
 prepare_selective_translator(get_translator)