Files
templates/tools/pdf-scan-to-vector/gui.py
T
Andrey afdf62cfa4 Добавить проверку Flash SCI, системные диалоги и векторизацию PDF
Расширить протокол SCI проверкой содержимого Flash и комплектом RAM-ядер.
Добавить утилиту векторизации PDF с OCR, общие диалоги DSView и проверки.
2026-11-18 16:03:53 +03:00

591 lines
88 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
from dataclasses import asdict # Преобразуем настройки обработки в словарь для сохранения пользовательского профиля.
from pathlib import Path # Поддерживаем русские имена файлов и папок во всех диалогах.
import multiprocessing as mp # Изолируем тяжёлую обработку MuPDF от процесса графического интерфейса.
import queue as queue_module # Обрабатываем отсутствие сообщений без блокировки событий Qt.
import tempfile # Храним внутренние результаты и демонстрационный документ до закрытия приложения.
import time # Измеряем длительность операции независимо от изменения системных часов.
import os # Атомарно сохраняем выбранные пользователем результаты.
import shutil # Переносим проверенный внутренний результат в выбранную папку.
import zipfile # Экспортируем многостраничный набор SVG одним переносимым архивом.
import pymupdf as fitz # Рендерим исходный документ и фактически созданный PDF результата.
from PySide6 import QtCore as C, QtGui as G, QtWidgets as W # Используем родной настольный Qt-интерфейс как в SETGUI.
from engine import Options, asset_path, parse_pages, worker # Разделяем интерфейс и независимо проверяемый движок преобразования.
from theme import STYLE # Подключаем самостоятельную тему с палитрой SETGUI.
def label(text, name="muted"): # Создаём подписи с общим способом назначения визуальной роли.
widget = W.QLabel(text) # Сохраняем Unicode-текст интерфейса без HTML-разметки.
widget.setObjectName(name) # Таблица стилей выбирает оформление по назначению подписи.
widget.setWordWrap(True) # Длинные русские названия не обрезаются в узкой панели.
return widget # Возвращаем готовую подпись для размещения в любом контейнере.
def button(text, callback, name=""): # Объединяем создание кнопок и подключение действий.
widget = W.QPushButton(text) # Все основные команды имеют видимую текстовую подпись.
widget.setObjectName(name) # Главную команду выделяем акцентным стилем.
widget.clicked.connect(callback) # Qt вызывает переданное действие при нажатии кнопки.
return widget # Возвращаем кнопку для изменения доступности во время обработки.
def atomic_copy(source, target): # Сохраняем экспорт без повреждения существующего файла при ошибке копирования.
target = Path(target) # Нормализуем назначение перед созданием файла на том же диске.
handle, temporary = tempfile.mkstemp(prefix=".pdf-export-", suffix=target.suffix, dir=target.parent) # Временный файл исключает публикацию частичной копии.
os.close(handle) # Освобождаем дескриптор для повторного открытия в Windows.
try: # Обязательно удаляем промежуточный файл при ошибке записи.
shutil.copyfile(source, temporary) # Копируем уже завершённый внутренний результат.
os.replace(temporary, target) # Атомарно заменяем назначение только после успешного копирования.
finally: # Уборка нужна также при отказе в доступе или переполнении диска.
Path(temporary).unlink(missing_ok=True) # После успешного переноса путь отсутствует, что не считается ошибкой.
class Preview(W.QGraphicsView): # Показываем белый лист на тёмном рабочем столе с масштабированием и перемещением.
def __init__(self): # Подготавливаем сцену предпросмотра без открытия PDF.
super().__init__() # Инициализируем стандартную графическую область Qt.
self.setScene(W.QGraphicsScene(self)) # Сцена владеет изображением текущей страницы.
self.setDragMode(W.QGraphicsView.DragMode.ScrollHandDrag) # Лист перемещается мышью при увеличении.
self.setRenderHint(G.QPainter.RenderHint.SmoothPixmapTransform) # Сглаживаем изображение при дробном масштабе.
self.setTransformationAnchor(W.QGraphicsView.ViewportAnchor.AnchorUnderMouse) # Увеличиваем область под указателем, сохраняя контекст просмотра.
self.fitted = True # Первоначально подбираем масштаб по доступной области окна.
def show_page(self, page): # Перерисовываем предпросмотр из выбранного документа.
scale = min(3.0, 1800 / max(page.rect.width, page.rect.height)) # Ограничиваем длинную сторону предпросмотра 1800 пикселями для отзывчивого интерфейса.
pix = page.get_pixmap(matrix=fitz.Matrix(scale, scale), alpha=False, colorspace=fitz.csRGB) # Отображаем действительное содержимое страницы, включая контуры результата.
image = G.QImage(pix.samples, pix.width, pix.height, pix.stride, G.QImage.Format.Format_RGB888).copy() # Копируем данные, чтобы Qt не ссылался на освобождённую память MuPDF.
self.scene().clear() # Освобождаем изображение предыдущей страницы.
self.scene().addPixmap(G.QPixmap.fromImage(image)) # Передаём изображение текущего листа графической сцене.
self.scene().setSceneRect(self.scene().itemsBoundingRect()) # Устанавливаем границы прокрутки по размеру листа.
self.fit_page() # Новая страница целиком помещается в окно предпросмотра.
def fit_page(self): # Возвращаем масштаб, при котором виден весь лист.
self.fitInView(self.sceneRect(), C.Qt.AspectRatioMode.KeepAspectRatio) # Сохраняем пропорции листа при подборе масштаба.
self.fitted = True # При изменении размера окна продолжаем показывать лист целиком.
def zoom(self, factor): # Применяем ограниченный пользовательский масштаб предпросмотра.
current = self.transform().m11() # Получаем текущий коэффициент преобразования сцены Qt.
if 0.03 <= current * factor <= 8: # Ограничиваем масштаб разумным диапазоном, исключая исчезновение листа.
self.scale(factor, factor) # Увеличиваем обе оси одинаково, не искажая геометрию документа.
self.fitted = False # Ручное увеличение сохраняется при изменении размеров окна.
def wheelEvent(self, event): # Добавляем привычное увеличение Ctrl+колесо, оставляя обычную прокрутку.
if event.modifiers() & C.Qt.KeyboardModifier.ControlModifier: # Масштабирование включается только с зажатой клавишей Ctrl.
self.zoom(1.2 if event.angleDelta().y() > 0 else 1 / 1.2) # Каждый шаг колеса меняет масштаб на двадцать процентов.
event.accept() # Не передаём событие обычной прокрутке после изменения масштаба.
else: # Без Ctrl пользователь перемещается по увеличенной странице.
super().wheelEvent(event) # Сохраняем стандартное поведение графической области Qt.
def resizeEvent(self, event): # Поддерживаем удобный размер страницы при изменении геометрии окна.
super().resizeEvent(event) # Сначала Qt обновляет размеры видимой области.
if self.fitted: # Автоподбор не должен сбрасывать ручное увеличение.
self.fit_page() # Повторно вписываем лист в новую область просмотра.
class MainWindow(W.QMainWindow): # Объединяем выбор документа, настройки, предпросмотр, OCR и экспорт.
def __init__(self, settings_path=None): # Необязательный INI изолирует автоматические проверки и переносимые профили.
super().__init__() # Инициализируем главное окно Qt.
self.setWindowTitle("PDF Scan to Vector · SET") # Название помогает отличить приложение в панели задач.
self.setMinimumSize(1080, 700) # Защищаем компоновку от взаимного перекрытия основных панелей.
self.resize(1440, 920) # Начальный размер рассчитан на обычный монитор Full HD с масштабом Windows.
self.setAcceptDrops(True) # Разрешаем открыть PDF перетаскиванием из Проводника.
self.temp = tempfile.TemporaryDirectory(prefix="pdf-scan-vector-") # Временная папка принадлежит только текущему окну.
self.settings = C.QSettings(str(settings_path), C.QSettings.IniFormat) if settings_path else C.QSettings("SET", "PDFScanToVector") # Отдельный профиль сохраняет те же параметры без вмешательства в рабочие настройки.
self.result_saved = False # SETGUI использует признак успешного экспорта для защиты результата перед выходом.
self.source, self.result, self.report = None, None, None # Не смешиваем открытый оригинал, результат и отчёт OCR.
self.source_path, self.password = None, "" # Пароль защищённого PDF хранится только в памяти текущего сеанса.
self.process, self.messages, self.cancel_event = None, None, None # Процесс обработки создаём только по команде пользователя.
self.terminal_message = False # Отмечаем получение окончательного статуса до завершения рабочего процесса.
self.started = 0.0 # Начальное время используется для длительности успешной обработки.
self.thumbnail_row = 0 # Миниатюры формируются постепенно, не задерживая открытие большого документа.
self.context = mp.get_context("spawn") # Явный spawn одинаково работает в исходниках и автономном EXE Windows.
self.build_ui() # Создаём все элементы до восстановления сохранённых параметров.
self.restore_settings() # Возвращаем последний профиль обработки и положение окна.
self.poll_timer = C.QTimer(self) # Таймер читает очередь, не блокируя обработку событий GUI.
self.poll_timer.setInterval(120) # Обновляем статус примерно восемь раз в секунду без лишней нагрузки.
self.poll_timer.timeout.connect(self.poll_worker) # Обрабатываем уведомления отдельного процесса в главном потоке Qt.
self.thumbnails = C.QTimer(self) # Отдельный таймер постепенно добавляет изображения страниц.
self.thumbnails.setInterval(35) # Между миниатюрами оставляем время для отрисовки и нажатий.
self.thumbnails.timeout.connect(self.next_thumbnail) # Рендерим по одной небольшой странице за такт.
self.set_busy(False) # Назначаем исходную доступность команд без загруженного документа.
def build_ui(self): # Строим компоновку в стиле SETGUI: заголовок, страницы, рабочая область и настройки.
root = W.QWidget() # Центральный контейнер хранит вертикальную структуру всего окна.
self.setCentralWidget(root) # Назначаем контейнер основной областью QMainWindow.
layout = W.QVBoxLayout(root) # Располагаем шапку, инструменты и рабочее пространство сверху вниз.
layout.setContentsMargins(0, 0, 0, 12) # Шапка доходит до краёв окна, снизу оставляем отступ.
header = W.QFrame() # Выделяем верхнюю полосу отдельной рамкой с фоном SETGUI.
header.setObjectName("header") # Назначаем тёмный фон и нижнюю разделительную линию.
heading = W.QHBoxLayout(header) # Размещаем знак, название и описание обработки в одной строке.
heading.setContentsMargins(20, 14, 20, 14) # Оставляем одинаковые поля вокруг названия приложения.
heading.addWidget(label("SET", "brand")) # Используем текстовый акцент без зависимости от чужих ресурсов значков.
heading.addSpacing(16) # Визуально отделяем короткий знак от назначения программы.
titles = W.QVBoxLayout() # Заголовок и пояснение образуют единый блок.
titles.addWidget(label("PDF Scan to Vector", "title")) # Основное название остаётся коротким и узнаваемым.
titles.addWidget(label("Векторизация сканов и распознавание текста")) # Русское пояснение раскрывает назначение приложения.
heading.addLayout(titles, 1) # Отдаём заголовку свободную ширину, чтобы описание не переносилось без необходимости.
badge = label("ЛОКАЛЬНО · RU / EN") # Правый статус обозначает обработку на компьютере и включённые языки.
badge.setWordWrap(False) # Короткая служебная подпись должна оставаться одной строкой.
heading.addWidget(badge) # Прижимаем индикатор автономной работы к правому краю шапки.
layout.addWidget(header) # Размещаем шапку над рабочими инструментами.
toolbar = W.QHBoxLayout() # Основные команды доступны в постоянной верхней строке.
toolbar.setContentsMargins(16, 6, 16, 4) # Отделяем кнопки от краёв и шапки.
self.open_button = button("Открыть PDF…", self.choose_source) # Диалог открытия является основным способом загрузки.
toolbar.addWidget(self.open_button) # Ставим открытие первым в порядке чтения.
self.demo_button = button("Пример", self.open_demo) # Демонстрационный скан позволяет проверить приложение без своего файла.
toolbar.addWidget(self.demo_button) # Пример доступен рядом с открытием документа.
self.file_label = label("Перетащите PDF в окно или выберите файл") # До загрузки поясняем два доступных способа открытия.
toolbar.addWidget(self.file_label, 1) # Длинное имя файла использует свободную ширину панели.
self.save_pdf_button = button("Сохранить PDF…", self.save_pdf) # Сохраняем только фактически готовый результат обработки.
toolbar.addWidget(self.save_pdf_button) # PDF является главным выходным форматом.
layout.addLayout(toolbar) # Инструменты остаются над всеми тремя рабочими колонками.
columns = W.QHBoxLayout() # Делим рабочую область на изменяемый предпросмотр и постоянные настройки.
columns.setContentsMargins(16, 0, 16, 0) # Выравниваем рабочие колонки по краям панели инструментов.
splitter = W.QSplitter(C.Qt.Orientation.Horizontal) # Позволяем расширять список страниц относительно документа.
self.page_list = W.QListWidget() # Список хранит миниатюры и исходные номера страниц.
self.page_list.setMinimumWidth(138) # Даже при сужении видны номер страницы и уменьшенный лист.
self.page_list.setMaximumWidth(300) # Миниатюры не занимают неоправданно большую часть окна.
self.page_list.setIconSize(C.QSize(98, 132)) # Устанавливаем размер миниатюр в логических пикселях Qt.
self.page_list.setViewMode(W.QListView.ViewMode.IconMode) # Располагаем подпись под миниатюрой, чтобы номер страницы не обрезался сбоку.
self.page_list.setFlow(W.QListView.Flow.TopToBottom) # Страницы образуют одну вертикальную колонку.
self.page_list.setWrapping(False) # При изменении высоты окна не переносим миниатюры во вторую колонку.
self.page_list.setMovement(W.QListView.Movement.Static) # Перетаскивание карточки не должно менять исходный порядок страниц.
self.page_list.currentRowChanged.connect(self.refresh_page) # Выбор строки синхронно обновляет оригинал, результат и текст.
splitter.addWidget(self.page_list) # Левая часть разделителя показывает страницы документа.
workspace = W.QWidget() # Средняя колонка объединяет навигацию и вкладки просмотра.
middle = W.QVBoxLayout(workspace) # Располагаем номер страницы над областью предпросмотра.
middle.setContentsMargins(8, 0, 0, 0) # Оставляем небольшой зазор после разделителя миниатюр.
navigation = W.QHBoxLayout() # Навигация по страницам и масштабу располагается в одной строке.
navigation.addWidget(button("‹", lambda: self.move_page(-1))) # Переходим на предыдущую страницу без возврата к списку.
self.page_label = label("Документ не открыт") # Показываем текущую страницу и общее количество листов.
navigation.addWidget(self.page_label, 1) # Подпись занимает свободное пространство между командами.
navigation.addWidget(button("›", lambda: self.move_page(1))) # Переходим на следующий лист с теми же настройками просмотра.
navigation.addWidget(button("−", lambda: self.current_preview().zoom(1 / 1.25))) # Уменьшаем предпросмотр на один шаг.
navigation.addWidget(button("+", lambda: self.current_preview().zoom(1.25))) # Увеличиваем предпросмотр на двадцать пять процентов.
navigation.addWidget(button("По размеру", lambda: self.current_preview().fit_page())) # Возвращаем показ листа целиком.
middle.addLayout(navigation) # Закрепляем навигацию над вкладками.
self.tabs = W.QTabWidget() # Разделяем исходное изображение, реальный результат, текст и диагностику.
self.original_preview, self.result_preview = Preview(), Preview() # Каждая PDF-вкладка сохраняет собственную сцену и масштаб.
self.tabs.addTab(self.original_preview, "Оригинал") # Первый просмотр всегда относится к исходному PDF.
self.tabs.addTab(self.result_preview, "Результат") # Вторая вкладка рендерит уже обработанный документ.
self.text = W.QPlainTextEdit() # OCR-текст можно выделять и копировать стандартными средствами Qt.
self.text.setReadOnly(True) # Текст соответствует PDF; случайная правка не должна создавать расхождение.
self.text.setPlaceholderText("После обработки здесь появится распознанный текст выбранной страницы.") # Поясняем состояние до запуска OCR.
self.tabs.addTab(self.text, "Текст OCR") # Отдельная вкладка облегчает проверку качества распознавания.
self.log = W.QPlainTextEdit() # Журнал хранит подробности этапов и возможных ошибок.
self.log.setReadOnly(True) # Диагностические сообщения нельзя случайно изменить.
self.log.setMaximumBlockCount(2500) # Ограничиваем память при обработке очень длинных документов.
self.tabs.addTab(self.log, "Журнал") # Подробности доступны без загромождения главного предпросмотра.
self.tabs.setTabEnabled(1, False) # Результат станет доступен только после успешной конвертации.
middle.addWidget(self.tabs, 1) # Отдаём вкладкам всё оставшееся вертикальное пространство.
splitter.addWidget(workspace) # Средняя часть разделителя показывает документ и текст.
splitter.setStretchFactor(1, 1) # При расширении окна увеличиваем преимущественно предпросмотр.
splitter.setSizes([160, 900]) # Начальная ширина миниатюр меньше рабочей области документа.
columns.addWidget(splitter, 1) # Разделитель занимает всю ширину за вычетом настроек.
panel = W.QFrame() # Настройки обработки группируем в отдельной панели SETGUI.
panel.setObjectName("panel") # Применяем скругление и фон боковой панели.
panel.setFixedWidth(302) # Постоянная ширина сохраняет читаемость подписей и полей.
sidebar = W.QVBoxLayout(panel) # Строим настройки сверху вниз в порядке принятия решений.
sidebar.setContentsMargins(16, 16, 16, 16) # Обеспечиваем поля внутри границы панели.
sidebar.addWidget(label("Параметры обработки", "section")) # Название связывает режим и настройки изображения.
scroll = W.QScrollArea() # На низком экране настройки доступны через прокрутку.
scroll.setWidgetResizable(True) # Внутренняя форма принимает ширину боковой панели.
content = W.QWidget() # Контейнер параметров не включает кнопки запуска и отмены.
form = W.QVBoxLayout(content) # Каждый параметр размещаем после его подписи.
form.setSpacing(4) # Уменьшаем вертикальные промежутки, сохраняя больше настроек на обычном экране.
form.setContentsMargins(0, 8, 4, 4) # Полоса прокрутки не перекрывает поля ввода.
self.mode = W.QComboBox() # Режим определяет состав выходного PDF.
self.mode.addItem("Вектор + распознанный текст", "vector_ocr") # Совмещённый режим сохраняет графику контурами и добавляет поисковый слой.
self.mode.addItem("Вектор + обычный текст", "vector_text") # Заменяем отделимые распознанные буквы видимым шрифтом с кириллицей, сохраняя графику векторной.
self.mode.addItem("Только векторизация", "vector") # Этот режим не расходует время на распознавание текста.
self.mode.addItem("Скан + распознанный текст", "ocr") # Режим OCR сохраняет цветное изображение вместо монохромной трассировки.
self.language = W.QComboBox() # Пользователь выбирает модели языка своего документа.
self.language.addItem("Русский + английский", "rus+eng") # Совмещённая модель подходит для схем с латинскими обозначениями.
self.language.addItem("Русский", "rus") # Одноязычный профиль уменьшает неоднозначность русских документов.
self.language.addItem("Английский", "eng") # Английский профиль подходит для технической документации.
self.recognition = W.QComboBox() # Профиль определяет подготовку копии изображения перед OCR.
self.recognition.addItem("Улучшенное · схемы и сканы", "enhanced") # Выравниваем фон и убираем длинные линии только из изображения для распознавания.
self.recognition.addItem("Исходное · без подготовки", "original") # Позволяем сравнить распознавание исходных пикселей для необычных документов.
self.recognition.setToolTip("Улучшенное OCR выравнивает фон и убирает длинные линии таблиц из копии для распознавания. На мелком тексте сравните 400 и 600 DPI.") # Объясняем смысл профиля и практический выбор разрешения.
self.dpi = W.QComboBox() # Фиксированные разрешения предотвращают случайные экстремальные настройки.
for value in (150, 200, 300, 400, 600): # Разрешения заданы в точках на дюйм и покрывают черновой и подробный режимы.
self.dpi.addItem(f"{value} DPI", value) # Храним числовое значение отдельно от подписи.
self.dpi.setCurrentIndex(2) # Выбираем стандартные 300 DPI для печатных сканов.
self.range = W.QLineEdit() # Диапазон позволяет обрабатывать отдельные страницы большого файла.
self.range.setPlaceholderText("Все страницы · пример: 1-3, 5") # Показываем синтаксис рядом с местом ввода.
self.rotate = W.QComboBox() # Поворот исправляет документы, отсканированные боком или вверх ногами.
for value in (0, 90, 180, 270): # Разрешаем четыре ориентации, не внося интерполяционных искажений.
self.rotate.addItem(f"{value}°", value) # Единица измерения явно указана в интерфейсе.
self.threshold = W.QSpinBox() # Ручной порог помогает при бледных или слишком тёмных сканах.
self.threshold.setRange(0, 254) # Ноль зарезервирован для автоматического метода Оцу, остальные числа являются уровнями серого.
self.threshold.setSpecialValueText("Авто · метод Оцу") # Автоматический режим понятен без знания числового служебного значения.
self.threshold.setToolTip("0 — автоматический порог. 1–254 — уровень серого; большее значение сохраняет больше бледных линий.") # Объясняем влияние порога на детализацию трассировки.
self.noise = W.QDoubleSpinBox() # Минимальная площадь компонента регулирует удаление пыли.
self.noise.setRange(0, 100) # Площадь в квадратных пикселях при 300 DPI допускает отключение фильтра нулём.
self.noise.setValue(2) # Небольшой порог удаляет точки пыли, сохраняя печатные знаки.
self.noise.setSuffix(" px²") # Отображаем единицу площади, чтобы её не путали с длиной.
self.noise.setToolTip("Удалять внешние пятна меньше указанной площади при 300 DPI. 0 — сохранить все детали.") # Поясняем пересчёт настройки при другом разрешении.
self.simplify = W.QDoubleSpinBox() # Допуск упрощения управляет числом углов и размером векторного PDF.
self.simplify.setRange(0, 3) # Ограничиваем отклонение контура тремя пикселями при базовых 300 DPI.
self.simplify.setSingleStep(0.05) # Небольшой шаг позволяет точно подбирать детализацию мелкого текста.
self.simplify.setValue(0.45) # Сохраняем форму печатных букв с умеренным сокращением числа узлов.
self.simplify.setSuffix(" px") # Допуск является длиной в пикселях, а не площадью.
controls = [("Результат", self.mode), ("Язык OCR", self.language), ("Распознавание", self.recognition), ("Разрешение", self.dpi), ("Страницы", self.range), ("Поворот по часовой стрелке", self.rotate), ("Порог чёрного", self.threshold), ("Удаление пыли · при 300 DPI", self.noise), ("Упрощение · при 300 DPI", self.simplify)] # Профиль OCR располагаем рядом с языком, а параметры трассировки — ниже разрешения.
for title, control in controls: # Используем одинаковые подписи и интервалы для всех полей.
form.addWidget(label(title)) # Название параметра располагаем непосредственно над его значением.
form.addWidget(control) # Поле занимает всю ширину доступной формы.
form.addSpacing(3) # Отделяем связанные пары без лишних горизонтальных линий.
form.addWidget(label("«Вектор + обычный текст» заменяет распознанные буквы шрифтом. Неотделимые подписи остаются контурами. Проверьте текст OCR перед сохранением.")) # Поясняем отличие видимого текста и необходимость проверки ошибок распознавания.
form.addStretch() # При высоком окне параметры остаются прижаты к верхнему краю.
scroll.setWidget(content) # Передаём форму в прокручиваемую область.
sidebar.addWidget(scroll, 1) # Кнопки управления остаются видимыми даже при прокрутке настроек.
self.parameters = content # Одним действием блокируем изменение параметров запущенной операции.
self.run_button = button("Преобразовать документ", self.start_conversion, "primary") # Главная команда запускает обработку выбранных страниц.
sidebar.addWidget(self.run_button) # Основное действие располагаем под параметрами.
self.cancel_button = button("Отменить обработку", self.cancel_conversion) # Отмена передаётся процессу через межпроцессное событие.
sidebar.addWidget(self.cancel_button) # Кнопка отмены находится рядом с командой запуска.
self.save_text_button = button("Сохранить текст TXT…", self.save_text) # Даём отдельный экспорт распознанного текста в UTF-8.
sidebar.addWidget(self.save_text_button) # Текстовый экспорт доступен для всего обработанного диапазона.
self.svg_button = button("Экспорт страниц SVG…", self.save_svg) # Многостраничную векторную графику можно использовать во внешнем редакторе.
sidebar.addWidget(self.svg_button) # SVG является дополнительным выходным форматом после PDF.
columns.addWidget(panel) # Боковая панель завершает рабочую строку справа.
layout.addLayout(columns, 1) # Основная область растягивается вместе с окном.
bottom = W.QHBoxLayout() # Объединяем текущий этап и индикатор прогресса.
bottom.setContentsMargins(20, 6, 20, 0) # Выравниваем нижние данные с полями рабочей области.
self.state_label = label("Готово к работе") # Исходное состояние не создаёт впечатления незавершённой операции.
bottom.addWidget(self.state_label, 1) # Название этапа использует свободную ширину.
self.progress = W.QProgressBar() # Прогресс отражает количество завершённых выбранных страниц.
self.progress.setFixedWidth(270) # Постоянная ширина не меняет компоновку при обновлении текста.
self.progress.setValue(0) # Начальное значение соответствует отсутствию обработки.
bottom.addWidget(self.progress) # Индикатор располагаем в правой части нижней строки.
layout.addLayout(bottom) # Состояние всегда доступно под документом.
self.statusBar().showMessage("PDF и OCR обрабатываются на этом компьютере · Ctrl+O — открыть · Ctrl+S — сохранить PDF · Ctrl+колесо — масштаб") # Даём полезные сочетания клавиш без отдельной справки.
open_action = G.QAction(self) # Создаём команду открытия для стандартного сочетания клавиш.
open_action.setShortcut(G.QKeySequence.StandardKey.Open) # Ctrl+O соответствует привычному поведению Windows.
open_action.triggered.connect(self.choose_source) # Горячая клавиша использует тот же диалог открытия.
self.addAction(open_action) # Регистрируем действие в области главного окна.
save_action = G.QAction(self) # Создаём независимую команду сохранения результата.
save_action.setShortcut(G.QKeySequence.StandardKey.Save) # Ctrl+S сохраняет обработанный PDF.
save_action.triggered.connect(self.save_pdf) # Проверка готовности выполняется самим обработчиком сохранения.
self.addAction(save_action) # Делаем горячую клавишу доступной во всех вкладках.
self.mode.currentIndexChanged.connect(self.update_mode) # Настройки отражают выбранный тип обработки.
def current_preview(self): # Определяем PDF-область для кнопок изменения масштаба.
return self.result_preview if self.tabs.currentIndex() == 1 else self.original_preview # Для текстовых вкладок сохраняем управление оригиналом.
def restore_settings(self): # Восстанавливаем устойчивые настройки без паролей и документов пользователя.
for name in ("mode", "language", "recognition", "dpi", "rotate"): # Восстанавливаем профиль OCR вместе с остальными устойчивыми значениями списков.
control = getattr(self, name) # Получаем поле соответствующего параметра.
index = control.findData(self.settings.value(name, control.currentData())) # Сопоставляем сохранённое значение с доступными вариантами.
if index >= 0: # Неизвестные значения старой версии заменяются текущими значениями по умолчанию.
control.setCurrentIndex(index) # Восстанавливаем найденный пользовательский выбор.
for name in ("threshold", "noise", "simplify"): # Числовые настройки приводим к типу соответствующего поля.
control = getattr(self, name) # Обращаемся к нужному редактору числа.
try: # Повреждённые настройки не должны препятствовать запуску приложения.
control.setValue(type(control.value())(self.settings.value(name, control.value()))) # Сохраняем различие целого порога и дробных допусков.
except (ValueError, TypeError): # Игнорируем некорректное сохранённое значение.
pass # Оставляем проверенное значение по умолчанию.
geometry = self.settings.value("geometry") # Получаем прежнее положение и размер окна.
if geometry: # При первом запуске запись геометрии ещё отсутствует.
self.restoreGeometry(geometry) # Qt проверяет доступность экрана и возвращает окно в видимую область.
self.update_mode() # Применяем доступность параметров после восстановления режима.
def update_mode(self): # Скрываем смысловую неоднозначность параметров разных типов обработки.
vector = self.mode.currentData() != "ocr" # Бинаризация относится только к восстановлению контуров.
for control in (self.threshold, self.noise, self.simplify): # Порог, фильтр пыли и упрощение не влияют на сохранение цветного скана.
control.setEnabled(vector) # Отключаем нерелевантные поля, сохраняя выбранные значения.
self.language.setEnabled(self.mode.currentData() != "vector") # Язык не нужен, когда OCR отключён.
self.recognition.setEnabled(self.mode.currentData() != "vector") # Подготовка изображения применяется только к режимам распознавания.
def options(self): # Фиксируем текущие параметры одной будущей операции.
return Options(dpi=self.dpi.currentData(), mode=self.mode.currentData(), language=self.language.currentData(), threshold=self.threshold.value(), noise=self.noise.value(), simplify=self.simplify.value(), pages=self.range.text(), rotate=self.rotate.currentData(), recognition=self.recognition.currentData()) # Передаём профиль OCR и параметры обработки рабочему процессу без ссылок на виджеты.
def choose_source(self): # Открываем диалог выбора исходного документа.
if self.process: # Защищаем запущенную операцию от замены связанного исходного документа.
return # Пользователь сможет открыть следующий файл после завершения или отмены.
filename, _ = W.QFileDialog.getOpenFileName(self, "Открыть скан PDF", self.settings.value("last_directory", ""), "Документы PDF (*.pdf)") # Ограничиваем видимые входные форматы поддерживаемым типом.
if filename: # Закрытие диалога без выбора ничего не меняет в текущем документе.
self.load_pdf(filename) # Проверяем документ и отображаем первую страницу.
def load_pdf(self, filename, supplied_password=None): # Открываем новый PDF только после успешной проверки и разблокировки.
if self.process: # Текущие данные нельзя менять до получения окончательного статуса обработки.
return False # Отклоняем также перетаскивание файла во время операции.
document = None # Контролируем владение документом при исключении на любом этапе открытия.
try: # Повреждённый файл должен оставить прежний документ доступным.
document = fitz.open(filename) # MuPDF определяет действительный формат по содержимому.
if not document.is_pdf or not len(document): # Разрешаем только непустые PDF, а не изображения с изменённым расширением.
raise ValueError("Выберите непустой документ PDF.") # Даём понятное объяснение неподдерживаемого входного файла.
password = supplied_password or "" # Автотест может передать пароль без интерактивного диалога.
if document.needs_pass: # Запрашиваем секрет только для защищённых документов.
if supplied_password is None: # Обычный пользователь вводит пароль в скрытом поле.
password, accepted = W.QInputDialog.getText(self, "Защищённый PDF", "Пароль документа:", W.QLineEdit.EchoMode.Password) # Не показываем введённый пароль открытым текстом.
if not accepted: # Отмена ввода не считается ошибкой исходного документа.
document.close() # Освобождаем только новую попытку открытия.
return False # Сохраняем прежний документ и его результат.
if not document.authenticate(password): # Проверяем введённый пароль до замены текущего состояния.
raise ValueError("Неверный пароль PDF.") # Возвращаем понятное сообщение без раскрытия секрета.
document[0].get_pixmap(matrix=fitz.Matrix(0.1, 0.1)) # Проверяем рендеринг до закрытия прежнего документа.
self.thumbnails.stop() # Не допускаем обращения отложенного таймера к закрываемому PDF.
self.clear_result() # Убираем результат, принадлежащий предыдущему входному файлу.
if self.source: # Старый документ закрываем только после успешной проверки нового.
self.source.close() # Освобождаем его страницы и файловые ресурсы.
self.source, document = document, None # Передаём владение проверенным документом окну.
self.source_path, self.password = Path(filename).resolve(), password # Сохраняем исходный путь и пароль для отдельного процесса.
self.settings.setValue("last_directory", str(self.source_path.parent)) # Следующий диалог начинается в последней использованной папке.
self.file_label.setText(self.source_path.name) # В верхней строке показываем выбранное имя файла.
self.file_label.setToolTip(str(self.source_path)) # Полный путь доступен при наведении, не занимая всю ширину окна.
self.range.clear() # Диапазон предыдущего документа не переносим на новый файл.
self.page_list.clear() # Удаляем миниатюры прежнего документа.
for index in range(len(self.source)): # Создаём лёгкие элементы списка без немедленного рендеринга всех страниц.
item = W.QListWidgetItem(f"Страница {index + 1}") # Пользовательские номера начинаются с единицы.
item.setSizeHint(C.QSize(124, 158)) # Размер карточек остаётся постоянным во время подгрузки изображений.
self.page_list.addItem(item) # Добавляем лист в порядке исходного PDF.
self.page_list.setCurrentRow(0) # Сразу показываем первую страницу после открытия.
self.thumbnail_row = 0 # Начинаем постепенное заполнение миниатюр с первого листа.
self.thumbnails.start() # Передаём дальнейшую генерацию маленьких изображений таймеру.
self.log.appendPlainText(f"Открыт: {self.source_path.name} · страниц: {len(self.source)}") # Журнал фиксирует документ без пароля.
self.tabs.setCurrentIndex(0) # После открытия показываем оригинал.
self.state_label.setText("Документ открыт · выберите параметры и начните обработку") # Подсказываем следующее действие.
self.progress.setValue(0) # Старый прогресс не относится к новому документу.
self.set_busy(False) # Разрешаем запуск обработки нового PDF.
return True # Сообщаем вызывающему коду об успешном открытии.
except Exception as error: # Изолируем ошибки чтения, пароля и отображения.
if document is not None: # Не закрываем документ, владение которым уже передано окну.
document.close() # Освобождаем неудачную попытку открытия.
W.QMessageBox.warning(self, "Не удалось открыть PDF", str(error)) # Показываем причину без аварийного завершения приложения.
return False # Автотесты и обработчик перетаскивания могут проверить результат открытия.
def next_thumbnail(self): # Рендерим одну миниатюру за такт, сохраняя отзывчивость окна.
if self.source is None or self.thumbnail_row >= len(self.source): # Завершаем таймер после последней страницы или закрытия документа.
self.thumbnails.stop() # Не тратим процессор на пустую очередь миниатюр.
return # Последующая работа возобновится при открытии нового файла.
try: # Повреждение отдельного листа не должно мешать просмотру остальных.
page = self.source[self.thumbnail_row] # Выбираем страницу, ещё не получившую миниатюру.
pix = page.get_pixmap(matrix=fitz.Matrix(104 / max(page.rect.width, page.rect.height), 104 / max(page.rect.width, page.rect.height)), alpha=False, colorspace=fitz.csRGB) # Длинная сторона миниатюры ограничена 104 пикселями для экономии памяти.
image = G.QImage(pix.samples, pix.width, pix.height, pix.stride, G.QImage.Format.Format_RGB888).copy() # Изображение Qt получает независимые данные.
self.page_list.item(self.thumbnail_row).setIcon(G.QIcon(G.QPixmap.fromImage(image))) # Заменяем пустую карточку реальным изображением страницы.
except Exception as error: # Отчёт об ошибке миниатюры оставляем в диагностическом журнале.
self.log.appendPlainText(f"Миниатюра {self.thumbnail_row + 1}: {error}") # Сохраняем номер проблемного исходного листа.
self.thumbnail_row += 1 # Продолжаем со следующей страницей при очередном событии таймера.
def clear_result(self): # Сбрасываем зависимые данные при открытии нового файла или запуске новой обработки.
if self.result: # Предыдущий результат может держать временный PDF открытым в Windows.
self.result.close() # Освобождаем файл до его повторной записи.
self.result, self.report = None, None # Отмечаем отсутствие актуального результата и текста.
self.result_saved = False # Предыдущее сохранение не относится к следующему преобразованию.
self.result_preview.scene().clear() # Убираем изображение прежнего обработанного листа.
self.text.clear() # Старый OCR не должен выглядеть относящимся к новому документу.
self.tabs.setTabEnabled(1, False) # Вкладка результата снова ждёт завершения операции.
def refresh_page(self, row): # Синхронизируем оригинал, результат и OCR по исходному номеру страницы.
if self.source is None or row < 0 or row >= len(self.source): # Игнорируем временное отсутствие выбора при очистке списка.
return # Не обращаемся к несуществующему листу.
try: # Ошибка рендеринга отдельной страницы не должна закрывать приложение.
self.original_preview.show_page(self.source[row]) # Показываем исходный лист независимо от выбранного диапазона обработки.
self.page_label.setText(f"Страница {row + 1} из {len(self.source)}") # Нумерация соответствует миниатюрам и исходному PDF.
self.result_preview.scene().clear() # Сначала убираем результат предыдущего номера.
self.text.clear() # Текст обновляется только при наличии обработанного соответствия.
if self.report and self.result: # После обработки ищем страницу в выбранном диапазоне.
numbers = [item["source_page"] - 1 for item in self.report["pages"]] # Отчёт связывает индексы результата с исходными страницами.
if row in numbers: # Страница могла быть исключена пользовательским диапазоном.
index = numbers.index(row) # Определяем фактический индекс в сокращённом результирующем документе.
self.result_preview.show_page(self.result[index]) # Рендерим настоящую обработанную страницу.
self.text.setPlainText(self.report["text"][index]) # Показываем именно её Unicode-текст OCR.
else: # Для пропущенной страницы даём явное объяснение пустого результата.
self.text.setPlainText("Эта страница не входила в выбранный диапазон обработки.") # Не показываем текст другого листа по совпавшему индексу.
except Exception as error: # Ошибку визуализации помещаем в журнал для диагностики.
self.log.appendPlainText(f"Предпросмотр: {error}") # Оставляем возможность перейти на другую страницу.
def move_page(self, step): # Кнопки перехода используют то же состояние, что и список миниатюр.
row = self.page_list.currentRow() + step # Смещаем исходный номер страницы на один шаг.
if 0 <= row < self.page_list.count(): # Не выходим за границы документа.
self.page_list.setCurrentRow(row) # Сигнал списка автоматически обновит все связанные вкладки.
def set_busy(self, busy): # Централизованно задаём доступность действий при изменении состояния операции.
self.open_button.setEnabled(not busy) # Новый документ можно открыть после завершения текущей обработки.
self.demo_button.setEnabled(not busy) # Демонстрационный файл также не должен менять активную операцию.
self.parameters.setEnabled(not busy) # Параметры фиксируются на время работы процесса.
self.run_button.setEnabled(not busy and self.source is not None) # Запуск возможен только с открытым PDF и свободным обработчиком.
self.cancel_button.setEnabled(busy) # Отмена имеет смысл только во время выполнения задачи.
self.save_pdf_button.setEnabled(not busy and self.report is not None) # Экспорт PDF доступен после подтверждённого успеха.
self.save_text_button.setEnabled(not busy and bool(self.report and any(self.report["text"]))) # Не предлагаем сохранить пустой OCR для режима только векторизации.
self.svg_button.setEnabled(not busy and bool(self.report and self.report.get("mode") != "ocr")) # Экспорт SVG относим только к настоящим векторным результатам.
def start_conversion(self): # Запускаем отдельный процесс после проверки входного документа и диапазона.
if self.source is None or self.process: # Защищаем обработчик также от повторного вызова горячими клавишами.
return # Не создаём несколько обработчиков для одного окна.
try: # Ошибки ввода сообщаем до очистки существующего результата.
options = self.options() # Фиксируем весь профиль текущей операции.
parse_pages(options.pages, len(self.source)) # Раннее уточнение диапазона не запускает дорогую обработку.
self.clear_result() # Освобождаем предыдущий временный PDF до новой записи.
self.progress.setValue(0) # Каждая операция начинает счётчик завершённых страниц заново.
self.messages, self.cancel_event = self.context.Queue(), self.context.Event() # Передаём прогресс и отмену штатными средствами multiprocessing.
destination = str(Path(self.temp.name) / "result.pdf") # Рабочий результат хранится отдельно от пользовательского оригинала.
self.process = self.context.Process(target=worker, args=(str(self.source_path), destination, options, self.messages, self.cancel_event, self.password), daemon=True) # MuPDF и OCR исполняются в изолированном процессе.
self.terminal_message = False # Перед стартом ещё не получено окончательное сообщение обработчика.
self.started = time.monotonic() # Начинаем измерение реальной длительности операции.
self.active_mode = options.mode # Экспорт результата определяется использованным режимом, а не последующим выбором списка.
self.process.start() # Windows создаёт независимый процесс без блокировки Qt.
self.poll_timer.start() # Начинаем регулярное чтение сообщений прогресса.
self.set_busy(True) # Блокируем повторный старт и разрешаем безопасную отмену.
self.state_label.setText("Запуск обработки…") # Показываем начало работы до первого сообщения процесса.
self.log.appendPlainText(f"Обработка: {options.dpi} DPI · {options.mode} · {options.language}") # Запоминаем профиль для сравнения результатов.
except Exception as error: # Ошибки запуска не оставляют интерфейс навсегда заблокированным.
if self.process is not None and not self.process.is_alive(): # Очищаем только неработающий объект процесса.
self.process = None # Возвращаем возможность повторить запуск.
self.set_busy(bool(self.process)) # Восстанавливаем доступность действий по фактическому состоянию.
W.QMessageBox.warning(self, "Не удалось начать обработку", str(error)) # Объясняем ошибку диапазона или запуска Windows.
def cancel_conversion(self): # Отмена выполняется на безопасной границе текущего этапа.
if self.cancel_event is not None: # Событие существует только после подготовки рабочего процесса.
self.cancel_event.set() # Рабочий процесс проверяет флаг между страницами и этапами трассировки.
self.cancel_button.setEnabled(False) # Повторное нажатие не создаёт дополнительных действий.
self.state_label.setText("Отмена… ожидаем завершения текущего этапа OCR") # Честно поясняем возможную задержку внутри встроенного Tesseract.
def poll_worker(self): # Читаем накопившиеся уведомления без ожидания в главном потоке Qt.
if self.messages is None: # Таймер может получить последнее событие после завершения очистки.
return # Не обращаемся к закрытой межпроцессной очереди.
for _ in range(100): # Ограничиваем обработку пачки, чтобы журнал не вытеснял события интерфейса.
try: # Пустая очередь означает, что на этом такте новых данных больше нет.
message = self.messages.get_nowait() # Получаем только уже доставленные сообщения рабочего процесса.
except queue_module.Empty: # Не блокируем окно ожиданием очередного этапа.
break # Продолжим чтение после следующего сигнала таймера.
kind = message["kind"] # Тип сообщения определяет обновление прогресса или окончательный статус.
if kind in {"progress", "log"}: # Оба вида содержат понятное описание текущего этапа.
self.log.appendPlainText(message["message"]) # Записываем ход работы в диагностическую вкладку.
if not self.cancel_event.is_set(): # Не заменяем пояснение об отмене обычным названием этапа.
self.state_label.setText(message["message"]) # Состояние видно даже при просмотре документа.
if kind == "progress": # Числовое значение присутствует только у обновления прогресса.
self.progress.setValue(message["value"]) # Отражаем долю завершённых выбранных страниц.
elif kind == "done": # Окончательное подтверждение приходит после атомарной записи внутреннего PDF.
self.terminal_message = True # Отличаем штатное завершение от аварии процесса без сообщения.
try: # Проверяем доступность результата до включения экспорта.
self.report = message["report"] # Получаем текст и связь выходных страниц с исходными.
self.report["mode"] = self.active_mode # Сохраняем фактический режим вместе с результатом.
self.result = fitz.open(self.report["path"]) # Предпросмотр будет читать сохранённый PDF, а не исходный растр.
self.tabs.setTabEnabled(1, True) # Активируем результат только после успешного открытия.
first = self.report["pages"][0]["source_page"] - 1 # Выбираем первую обработанную страницу, даже если диапазон начинается не с единицы.
self.page_list.setCurrentRow(first) # Синхронизируем выбранную миниатюру с новым результатом.
self.refresh_page(first) # Обновляем вкладки также при неизменившемся выборе списка.
self.tabs.setCurrentIndex(1) # После успеха сразу показываем действительный результат обработки.
elapsed = time.monotonic() - self.started # Измеряем длительность без влияния переводов системных часов.
contours = sum(item["contours"] for item in self.report["pages"]) # Суммируем число восстановленных замкнутых контуров.
self.state_label.setText(f"Готово · страниц: {len(self.result)} · контуров: {contours:,} · {elapsed:.1f} с") # Подтверждаем результат конкретной статистикой.
self.log.appendPlainText(self.state_label.text()) # Сохраняем итоговый статус рядом с этапами обработки.
except Exception as error: # Повреждённый внутренний результат нельзя предлагать для экспорта.
self.clear_result() # Убираем непроверенный отчёт и закрываем возможный документ.
self.state_label.setText(f"Ошибка открытия результата: {error}") # Сообщаем точную причину сбоя проверки.
elif kind in {"error", "cancelled"}: # Оба варианта завершают операцию без готового результата.
self.terminal_message = True # Процесс сообщил причину завершения штатным протоколом.
self.state_label.setText(message["message"]) # Краткое пояснение доступно вне вкладки журнала.
self.log.appendPlainText(message.get("detail", message["message"])) # Подробный стек ошибки оставляем только в журнале.
if kind == "error": # Пользовательская отмена не требует модального окна предупреждения.
W.QMessageBox.warning(self, "Ошибка обработки PDF", message["message"]) # Ошибка обработки явно видна пользователю.
if self.process is not None and not self.process.is_alive(): # Освобождаем ресурсы только после выхода рабочего процесса.
self.process.join(timeout=0) # Забираем код завершения без ожидания в интерфейсе.
if not self.terminal_message: # Авария нативной библиотеки может не отправить сообщение об ошибке.
self.state_label.setText(f"Процесс обработки завершился с кодом {self.process.exitcode}. См. журнал.") # Не оставляем интерфейс в бесконечном состоянии обработки.
self.log.appendPlainText(self.state_label.text()) # Фиксируем аварийное завершение для последующей диагностики.
self.process.close() # Освобождаем дескрипторы процесса Windows.
self.process = None # Разрешаем следующий запуск после полной уборки.
self.messages.close() # Закрываем очередь, когда дочерний процесс уже завершил отправку сообщений.
self.messages = None # Последующие такты таймера не должны читать закрытую очередь.
self.poll_timer.stop() # Прекращаем опрос до следующей операции.
self.set_busy(False) # Возвращаем доступность кнопок по наличию готового результата.
def save_pdf(self): # Экспортируем завершённый документ в выбранную пользователем папку.
if self.report is None or self.process: # Не сохраняем промежуточные данные во время работы.
return # Горячая клавиша безопасна также до первой конвертации.
target, _ = W.QFileDialog.getSaveFileName(self, "Сохранить обработанный PDF", str(self.source_path.with_name(self.source_path.stem + "_vector.pdf")), "Документы PDF (*.pdf)") # Предлагаем отдельное имя рядом с оригиналом.
if not target: # Закрытие диалога не меняет внутренний результат.
return # Пользователь сможет повторить экспорт позднее.
try: # Отказы файловой системы показываем без потери результата в памяти приложения.
if Path(target).resolve() == self.source_path: # Защищаем исходный скан от случайного выбора в диалоге сохранения.
raise ValueError("Сохраните результат под другим именем, чтобы сохранить исходный скан.") # Даём прямое объяснение требуемого имени.
atomic_copy(self.report["path"], target) # Публикуем только полностью скопированный PDF.
self.result_saved = True # Считаем результат сохранённым только после успешной публикации PDF.
self.state_label.setText(f"PDF сохранён: {target}") # Подтверждаем фактическое расположение результата.
except Exception as error: # Обрабатываем блокировку файла, отказ доступа и отсутствие места.
W.QMessageBox.warning(self, "Не удалось сохранить PDF", str(error)) # Пользователь может выбрать другое назначение без повторного OCR.
def save_text(self): # Записываем распознанный текст всех обработанных страниц в UTF-8.
if self.report is None or self.process: # Текст доступен только у полностью готового результата.
return # Не экспортируем частично распознанный документ.
target, _ = W.QFileDialog.getSaveFileName(self, "Сохранить распознанный текст", str(self.source_path.with_suffix(".txt")), "Текст UTF-8 (*.txt)") # Предлагаем формат, который открывается в стандартных редакторах Windows.
if target: # Отмена диалога не требует сообщения об ошибке.
try: # Ошибку текстового экспорта показываем отдельно от состояния готового PDF.
sections = [f"Страница {stats['source_page']}\n{text}" for stats, text in zip(self.report["pages"], self.report["text"])] # Сохраняем исходные номера страниц рядом с соответствующим OCR.
staging = Path(self.temp.name) / "recognized.txt" # Сначала создаём внутренний текстовый файл.
staging.write_text("\n\n".join(sections), encoding="utf-8") # Явная кодировка сохраняет кириллицу независимо от системной локали.
atomic_copy(staging, target) # Защищаем существующий текстовый файл от частичной перезаписи.
self.state_label.setText(f"Текст сохранён: {target}") # Подтверждаем успешную запись выбранного файла.
except Exception as error: # Обрабатываем недоступность каталога и другие ошибки записи.
W.QMessageBox.warning(self, "Не удалось сохранить текст", str(error)) # Готовый OCR остаётся доступен в приложении.
def save_svg(self): # Экспортируем страницы настоящего векторного результата в архив SVG.
if self.result is None or self.process or self.report.get("mode") == "ocr": # Исключаем экспорт изображения под видом вектора.
return # Этот формат доступен только для двух режимов трассировки.
target, _ = W.QFileDialog.getSaveFileName(self, "Сохранить страницы SVG в ZIP", str(self.source_path.with_name(self.source_path.stem + "_svg.zip")), "Архив страниц SVG (*.zip)") # Один архив удобен для любого числа листов.
if target: # При отмене оставляем готовый PDF и настройки без изменений.
try: # Ошибки внешнего экспорта не должны разрушать внутренний результат.
staging = Path(self.temp.name) / "pages.zip" # Архив сначала создаём в собственном временном каталоге приложения.
with zipfile.ZipFile(staging, "w", compression=zipfile.ZIP_DEFLATED) as archive: # Сжимаем текстовую геометрию стандартным форматом ZIP.
for index, page in enumerate(self.result): # Экспортируем все обработанные страницы, сохраняя их порядок.
number = self.report["pages"][index]["source_page"] # Имя каждого SVG содержит номер исходного листа.
archive.writestr(f"page_{number:04}.svg", page.get_svg_image(text_as_path=True).encode("utf-8")) # Формируем самостоятельный векторный SVG без внешних шрифтов.
atomic_copy(staging, target) # Публикуем только полностью завершённый архив.
self.state_label.setText(f"SVG сохранены: {target}") # Подтверждаем назначение экспортированной графики.
except Exception as error: # Показываем ошибку записи или преобразования отдельной страницы.
W.QMessageBox.warning(self, "Не удалось сохранить SVG", str(error)) # Пользователь сохраняет возможность повторить экспорт.
def open_demo(self): # Создаём демонстрационный скан без сетевой загрузки или пользовательских документов.
from sample import create_sample # Загружаем генератор примера только по запросу пользователя.
try: # Обрабатываем редкие ошибки временной папки или рендеринга примера.
filename = Path(self.temp.name) / "Пример скана.pdf" # Кириллическое имя одновременно проверяет поддержку русских путей.
create_sample(filename) # Пример содержит только растровые страницы, а не готовый поисковый текст.
self.load_pdf(filename) # Открываем его обычным путём проверки и предпросмотра PDF.
except Exception as error: # Не прерываем работу интерфейса, если пример не удалось сформировать.
W.QMessageBox.warning(self, "Не удалось открыть пример", str(error)) # Показываем конкретную причину сбоя.
def dragEnterEvent(self, event): # Принимаем перетаскивание локального PDF из Проводника.
if not self.process and event.mimeData().hasUrls(): # Открытие перетаскиванием запрещено только во время обработки.
urls = event.mimeData().urls() # Получаем список перетаскиваемых объектов операционной системы.
if len(urls) == 1 and urls[0].isLocalFile() and urls[0].toLocalFile().lower().endswith(".pdf"): # Разрешаем ровно один локальный PDF вместо неоднозначной группы файлов.
event.acceptProposedAction() # Windows показывает, что документ можно отпустить в окне.
def dropEvent(self, event): # Используем общий проверяемый путь открытия после отпускания файла.
urls = event.mimeData().urls() # Читаем URL из события переноса.
if urls and not self.process: # Повторно проверяем состояние, которое могло измениться после входа указателя.
self.load_pdf(urls[0].toLocalFile()) # Защита от неверного формата находится внутри общего обработчика.
def closeEvent(self, event): # Завершаем фоновые операции и сохраняем профиль перед закрытием окна.
self.poll_timer.stop() # Прекращаем получение сообщений до освобождения документов и временной папки.
self.thumbnails.stop() # Отложенный рендер миниатюр больше не должен обращаться к исходному PDF.
if self.process is not None: # Закрытие окна разрешено также во время длительного распознавания.
self.cancel_event.set() # Сначала предлагаем процессу штатную отмену.
self.process.join(timeout=0.2) # Даём короткое время на выход, не задерживая закрытие интерфейса.
if self.process.is_alive(): # Встроенный OCR может ещё находиться внутри долгого нативного вызова.
self.process.terminate() # Завершаем только принадлежащий окну процесс, который пишет во внутреннюю временную папку.
self.process.join(timeout=2) # Дожидаемся освобождения Windows-дескрипторов внутреннего PDF.
self.process.close() # Освобождаем объект завершённого процесса.
if self.messages is not None: # Очередь может остаться открытой при закрытии окна во время обработки.
self.messages.cancel_join_thread() # Не ждём служебный поток очереди принудительно остановленного процесса.
self.messages.close() # Освобождаем межпроцессный канал.
for name, value in asdict(self.options()).items(): # Сохраняем только параметры обработки текущего окна.
if name != "pages": # Диапазон зависит от документа и не переносится между запусками.
self.settings.setValue(name, value) # Qt записывает профиль без пароля и содержимого документов.
self.settings.setValue("geometry", self.saveGeometry()) # Восстанавливаем удобный размер окна при следующем запуске.
if self.source: # Закрываем исходный документ перед очисткой примера из временной папки.
self.source.close() # Освобождаем удерживаемый файловый дескриптор Windows.
if self.result: # Результат предпросмотра также может находиться во временном каталоге.
self.result.close() # Разрешаем удалить внутренний PDF после закрытия окна.
self.temp.cleanup() # Удаляем только принадлежащие текущему сеансу промежуточные файлы.
event.accept() # Разрешаем Qt завершить закрытие приложения.
def application(): # Создаём единый экземпляр приложения с темой SETGUI.
app = W.QApplication.instance() or W.QApplication([]) # Автотесты могут повторно использовать уже созданный объект Qt.
app.setStyle("Fusion") # Одинаковая геометрия виджетов не зависит от светлой системной темы Windows.
app.setStyleSheet(STYLE) # Применяем самостоятельную тёмную таблицу оформления.
app.setApplicationName("PDF Scan to Vector") # Название используется в системных диалогах и панели задач.
if asset_path("app.ico").exists(): # Иконка входит в сборку, но исходники могут работать и до её генерации.
app.setWindowIcon(G.QIcon(str(asset_path("app.ico")))) # Назначаем единый значок окна и диалогов.
return app # Возвращаем приложение точке входа и автоматической проверке GUI.