diff --git a/.gitignore b/.gitignore index 1757a1c..1010999 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,8 @@ cmake-build-*/ *.a *.elf *.bin +# Встроенные ядра F28335 являются ресурсами поставки, а не промежуточными результатами пользовательской сборки. +!python/set_devices/sci_kernels/*.bin *.hex *.map *.lst diff --git a/c/firmware-info/tests/test_c2000_sci_build.py b/c/firmware-info/tests/test_c2000_sci_build.py index 831fb6f..8b16c8a 100644 --- a/c/firmware-info/tests/test_c2000_sci_build.py +++ b/c/firmware-info/tests/test_c2000_sci_build.py @@ -20,6 +20,7 @@ class SciKernelBuildTests(unittest.TestCase): # Фиксирует несовм image = sci.build_kernel(compiler, Path(temporary) / 'f28335_sci_kernel.bin', 30000000, 0x0080, ware) # Плата использует кварц 30 МГц; маска 0x80 выбирает сектор H из комплекта, вызвавшего ошибку. data = image.read_bytes() # Проверяет конечный транспортный BIN после настоящего hex2000. self.assertEqual(data[:2], b'\xAA\x08') # Действующий приёмник ожидает ключ SCI8 0x08AA в порядке младшего байта вперёд. + self.assertEqual(data[2:6], b'VR\x01\x00') # Реально собранное ядро объявляет VR1 в резерве SCI8; entry и адреса блоков остаются на штатных смещениях. self.assertEqual(struct.unpack_from(' 0 && reserved <= 0xFF ? reserved : 0; // Маска охватывает только восемь секторов A–H.\n\1if (i == 5) SetSciSectorMask = SetSciSectorMask && reserved == (SetSciSectorMask ^ 0xFF) ? SetSciSectorMask : 0; // Инверсия маски запрещает стирание при повреждении параметров.' # Первичная инициализация выполняется потоком заголовка и не зависит от C runtime. + text = text.replace('status = Flash_Erase(', 'if (!SetSciSectorMask || (SetSciSectorMask & 0xFF00)) return; // Без корректного SM1 заголовка стирание запрещено.\n status = Flash_Erase(', 1) # Отсутствующий или повреждённый запрос заканчивается до первого аппаратного изменения Flash. + text, replaced = re.subn(r'(?m)^(\s*)GetOnlyWordData\(\);', reserved_patch, text) # Все восемь резервных слов по-прежнему участвуют в штатной checksum TI. + if replaced != 1: raise ValueError("Неподдержанная версия TI Kernel A: изменено чтение резерва SCI8") # Без явного распознавания VR1 host не должен ожидать дополнительные байты. + shutil.copyfile(Path(__file__).with_name('c2000_sci_readback.h'), source / 'c2000_sci_readback.h') # Компилирует сопровождающий исходник reader из той же версии templates, что сборщик. shared.write_text(text, encoding="utf-8") # Временный исходник остаётся UTF-8 с сохранённой лицензией TI. cpu_rate = 1000000000 / (oscillator_hz * 5) # Штатный PLLCR=10 и DIVSEL=/2 дают SYSCLKOUT=5×частота кварца; CPU_RATE выражен наносекундами. config = source / "Flash2833x_API_Config.h"; text = config.read_text(encoding="utf-8-sig") # Масштабирование Flash API должно соответствовать реальной частоте CPU. @@ -73,6 +85,10 @@ def build_kernel(compiler, output, oscillator_hz, sectors, ware=None): # Соб subprocess.run(link_args, check=True, cwd=source) # Неполная RAM-компоновка не допускается к упаковке. subprocess.run([str(compiler / "bin/hex2000.exe"), str(out), "-boot", "-sci8", "--entrypoint=0", "-b", "-o", str(output)], check=True) # SCI8 входит через адрес 0x000000, где codestart передаёт управление _InitBoot; COFF сохраняет символическую точку входа. if not output.is_file() or not output.stat().st_size: raise ValueError("TI hex2000 не создал RAM-ядро SCI") # Ложный успех процесса не оставляет неполный комплект. + data = bytearray(output.read_bytes()) # Метка возможностей добавляется только к уже скомпилированному RAM-ядру. + if len(data) < 24 or data[:2] != b'\xAA\x08': raise ValueError('Неверный заголовок RAM-ядра SCI8') # Не заменяет байты неизвестного выходного формата hex2000. + data[2:6] = b'VR\x01\x00'; output.write_bytes(data) # Первичный SCI-загрузчик игнорирует восемь резервных слов; host узнаёт поддержку VR1 по первым двум, не меняя entry и LOAD-адресов. + if sectors is None: data[6:10] = b'SM\x01\x00'; output.write_bytes(data) # Метка SM1 разрешает host передавать точную маску секторов через резерв заголовка приложения. return output # Ядро проверяется host C-ядром до первого байта COM-передачи. @@ -87,7 +103,7 @@ def publish(build, project, compiler, build_dir, artifact, metadata, output, exp build_kernel(compiler, kernel, settings.get("oscillator_hz", 30000000), sectors) # Подготовка Flash больше не требует проектного build_flash.py. subprocess.run([str(compiler / "bin/hex2000.exe"), str(source), "-boot", "-sci8", "-b", "-map", str(image.with_suffix(".bin.map")), "-o", str(image)], check=True) # BIN содержит LOAD-адреса исходной Flash-компоновки, без переименования RAM-образа. build.verify_embedded(image, metadata) # Подтверждает полноту SCI8 и встроенный паспорт именно текущего prebuild. - kernel_info = {"file": kernel.name, "size_bytes": kernel.stat().st_size, "sha256": hashlib.sha256(kernel.read_bytes()).hexdigest(), "oscillator_hz": settings.get("oscillator_hz", 30000000), "sector_mask": sectors, "protocol": "TI Flash Kernel A"} # GUI проверяет точный RAM-бинарник перед отправкой первичному загрузчику. + kernel_info = {"file": kernel.name, "size_bytes": kernel.stat().st_size, "sha256": hashlib.sha256(kernel.read_bytes()).hexdigest(), "oscillator_hz": settings.get("oscillator_hz", 30000000), "sector_mask": sectors, "protocol": "TI Flash Kernel A", "verify": "readback-v1"} # SHA-256 включает метку VR1 и привязывает возможность физического чтения к точному RAM-ядру комплекта. specific = dict(metadata, execution="FLASH", image_format="SCI8-FLASH-SCI", protocol="TI SCI Flash Kernel A", transport="tms", flash_kernel=kernel_info) # Паспорт не объявляет совместимость с отдельным BIOS ПМ35 и FAB1. passport = stage / "firmware_identity.json"; passport.write_text(json.dumps(specific, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") # Сохраняет все исходные настройки, версию и точное назначение комплекта. identity.seal(image, passport); build.verify_package(image, specific) # Подтверждает SHA-256 транспортного Flash BIN до архивирования. diff --git a/c/firmware-info/tools/c2000_sci_readback.h b/c/firmware-info/tools/c2000_sci_readback.h new file mode 100644 index 0000000..33d60c1 --- /dev/null +++ b/c/firmware-info/tools/c2000_sci_readback.h @@ -0,0 +1,20 @@ +#ifndef SET_SCI_READBACK_H /* Дополнение подключается к одной копии Shared_Boot.c официального RAM-ядра TI. */ +#define SET_SCI_READBACK_H /* Защищает определения от повторного включения в исходник ядра. */ +static Uint16 SetSciVerify; /* ReadReservedFn явно устанавливает режим до стирания, поэтому инициализация C runtime не требуется. */ +static Uint16 SetSciSectorMask; /* Встроенное ядро получает маску A–H из проверенного host-заголовка SM1 до первого вызова Flash_Erase. */ +static void SetSciSendWord(Uint16 value) { /* Передаёт физически прочитанное слово в том же little-endian порядке, что полезные данные SCI8. */ + while (!SciaRegs.SCICTL2.bit.TXRDY) {} /* Ожидает освобождения передатчика SCI-A перед младшими восемью битами слова. */ + SciaRegs.SCITXBUF = value & 0xFF; /* Маска 0xFF выделяет младший октет 16-битного слова C28x для линии 8N1. */ + while (!SciaRegs.SCICTL2.bit.TXRDY) {} /* Старший октет не должен перезаписать ещё не переданный младший октет. */ + SciaRegs.SCITXBUF = (value >> 8) & 0xFF; /* Сдвиг на восемь бит выделяет старшую половину считанного слова Flash. */ +} /* Заканчивает передачу одного считанного слова без изменения штатной checksum входящего потока. */ +static Uint16 SetSciProgram(Uint16 *destination, Uint16 *buffer, Uint32 count, FLASH_ST *status) { /* Оборачивает штатный Flash API, сохраняя адреса, число слов и результат программирования TI. */ + Uint16 result = Flash_Program(destination, buffer, count, status); /* Записывает принятую порцию до любого чтения; ошибку TI обработает исходный CopyData. */ + Uint32 index; /* 32-битный индекс согласован с единицами длины официального Flash API. */ + volatile Uint16 *flash = destination; /* Volatile заставляет читать реальные ячейки Flash, исключая повторную выдачу staging-буфера RAM. */ + if (result == STATUS_SUCCESS && SetSciVerify) { /* Чтение выполняется только после успешной записи и явного запроса VR1 от host. */ + for (index = 0; index < count; ++index) SetSciSendWord(flash[index]); /* Передаёт каждое физическое слово; нулевой остаток TI не добавляет байты перед checksum. */ + } /* После чтения исходный CopyData отправит свою checksum, которую host проверит отдельно от содержимого Flash. */ + return result; /* Исходные ветви отказа Flash API остаются обязательными и не подтверждают неудачную запись. */ +} /* Заканчивает необязательное чтение порции до разрешения следующей записи или перехода к entry приложения. */ +#endif /* Заканчивает дополнение VR1 к официальному TI Flash Kernel A. */ diff --git a/c/set-protocol/include/c2000_sci.h b/c/set-protocol/include/c2000_sci.h index 62f92c2..604c7d0 100644 --- a/c/set-protocol/include/c2000_sci.h +++ b/c/set-protocol/include/c2000_sci.h @@ -4,10 +4,12 @@ #ifdef __cplusplus /* C++-потребители используют тот же ABI без изменения имён функций. */ extern "C" { /* Открывает C-связность публичных функций. */ #endif /* Завершает условное начало C-связности. */ -PCAN_ABI_API int c2000_sci_decode(const uint8_t *source, size_t size, uint8_t *output, size_t capacity, size_t *written); /* Принимает бинарный SCI8 либо ASCII SCI8 TI со STX/ETX; не принимает Intel HEX. */ +PCAN_ABI_API int c2000_sci_decode(const uint8_t *source, size_t size, uint8_t *output, size_t capacity, size_t *written); /* Принимает бинарный/ASCII SCI8 и прежний Intel HEX C2Prog со словными адресами C28x; байтовый HEX других MCU остаётся отдельным форматом. */ PCAN_ABI_API int c2000_sci_validate(const uint8_t *data, size_t size, int flash, uint32_t *entry, uint16_t *sectors); /* Проверяет таблицу, адреса слов C28x, перекрытия и присутствие точки входа до передачи. */ PCAN_ABI_API size_t c2000_sci_session_size(void); /* Возвращает размер хранилища, принадлежащего вызывающему приложению. */ PCAN_ABI_API int c2000_sci_begin(void *storage, size_t size, const uint8_t *kernel, size_t kernel_size, const uint8_t *image, size_t image_size); /* Сохраняет указатели на неизменяемые буферы и проверяет оба образа до autobaud. */ +PCAN_ABI_API int c2000_sci_verify(void *storage); /* До autobaud включает чтение каждой записанной порции; требует метку VR версии 1 в резерве RAM-ядра. */ +PCAN_ABI_API uint32_t c2000_sci_error_address(const void *storage); /* Возвращает словный адрес первого несовпадения Flash для диагностики Verify. */ PCAN_ABI_API int c2000_sci_next(void *storage, uint8_t *tx, size_t capacity, size_t *tx_size, size_t *rx_size, uint32_t *delay_ms); /* Возвращает 1 для обмена, 2 для паузы, 0 после терминатора и отрицательное число при ошибке состояния. */ PCAN_ABI_API int c2000_sci_accept(void *storage, const uint8_t *rx, size_t size); /* Сверяет эхо ROM либо checksum TI Kernel A, затем разрешает следующий шаг. */ PCAN_ABI_API unsigned c2000_sci_progress(const void *storage); /* Возвращает завершённую долю передачи 0..100 без доступа к системным часам. */ diff --git a/c/set-protocol/src/c2000_sci.c b/c/set-protocol/src/c2000_sci.c index 4f03e6f..3996990 100644 --- a/c/set-protocol/src/c2000_sci.c +++ b/c/set-protocol/src/c2000_sci.c @@ -6,17 +6,56 @@ typedef struct { /* Контекст не владеет образами и н size_t kernel_size, image_size, kernel_at, image_at, pending_bytes; /* Позиции и длины измеряются физическими октетами файлов. */ unsigned phase, wait, remaining, block_words, extra_zero; /* Отделяет autobaud, байтовое эхо ROM и порционные подтверждения Flash. */ uint16_t expected; /* Хранит ожидаемое эхо либо сумму октетов по контракту TI Kernel A. */ + uint16_t sector_mask; /* Маска TI вычисляется по проверенным Flash-блокам; сектор A соответствует младшему биту. */ + unsigned verify; /* Режим VR1 запрашивает физическое чтение Flash перед checksum каждой непустой порции. */ + size_t readback_at, readback_size; /* Ожидаемые октеты берутся только из полезной части текущей секции SCI8, без её заголовка. */ + uint32_t block_address, error_address; /* Адреса выражены 16-битными словами C28x, как адреса LOAD в таблице TI. */ } sci_session_t; /* Размер структуры скрыт за функцией session_size для стабильного ABI. */ static uint16_t word(const uint8_t *p) { return (uint16_t)((uint16_t)p[0] | ((uint16_t)p[1] << 8)); } /* SCI8 передаёт каждый 16-битный элемент младшей октетой вперёд. */ static uint32_t address(const uint8_t *p) { return ((uint32_t)word(p) << 16) | word(p + 2); } /* Адрес состоит из старшего слова C28x, затем младшего слова. */ static int white(uint8_t c) { return c == ' ' || c == '\t' || c == '\r' || c == '\n'; } /* ASCII SCI8 допускает стандартные разделители между октетами. */ static int digit(uint8_t c) { return c >= '0' && c <= '9' ? c - '0' : c >= 'A' && c <= 'F' ? c - 'A' + 10 : c >= 'a' && c <= 'f' ? c - 'a' + 10 : -1; } /* Декодирует только шестнадцатеричные цифры TI ASCII. */ -int c2000_sci_decode(const uint8_t *source, size_t size, uint8_t *output, size_t capacity, size_t *written) { /* Приводит оба поддержанных формата к одному бинарному буферу SCI8. */ +static void put_word(uint8_t *p, uint16_t value) { p[0] = (uint8_t)value; p[1] = (uint8_t)(value >> 8); } /* SCI8 хранит каждое слово младшим октетом вперёд независимо от порядка байтов Intel HEX. */ +static void put_address(uint8_t *p, uint32_t value) { put_word(p, (uint16_t)(value >> 16)); put_word(p + 2, (uint16_t)value); } /* Адрес SCI8 передаётся старшим словом вперёд, сохраняя little endian внутри обоих слов. */ +static int decode_word_hex(const uint8_t *source, size_t size, uint8_t *output, size_t capacity, size_t *written) { /* Читает прежний HEX C2Prog: адреса обозначают слова C28x, а пары октетов записаны старшим байтом вперёд. */ + size_t at = 0, count = 22, block_at = 0, index, length; uint32_t base = 0, start, next_address = 0, target = 0x33FFF6UL; unsigned eof = 0, sum, type; uint8_t record[260]; /* Аппаратный codestart F28335 занимает слова 33FFF6–33FFF7; явная запись entry имеет приоритет. */ + if (capacity < 24) return -2; memset(output, 0, 22); output[0] = 0xAA; output[1] = 0x08; /* Формирует заголовок SCI8 без изменения адресов будущих Flash-блоков. */ + while (at < size) { /* Каждая запись полностью проверяется до добавления её данных в результат. */ + while (at < size && white(source[at])) ++at; if (at == size) break; /* Разрешает CRLF, LF и пустые строки между записями. */ + if (eof || source[at++] != ':' || size - at < 2 || digit(source[at]) < 0 || digit(source[at + 1]) < 0) return -12; /* Запрещает скрытые записи после EOF и повреждённое начало строки. */ + length = (size_t)((digit(source[at]) << 4) | digit(source[at + 1])); sum = 0; /* Поле длины Intel HEX измеряет октеты данных даже при словной адресации TI. */ + if (size - at < (length + 5) * 2) return -12; /* До чтения ограничивает длину полного заголовка, данных и checksum. */ + for (index = 0; index < length + 5; ++index) { /* Контрольная сумма включает длину, адрес, тип и каждый октет полезных данных. */ + int high = digit(source[at++]), low = digit(source[at++]); if (high < 0 || low < 0) return -12; /* Не принимает нечётные пары или символы вне шестнадцатеричного алфавита. */ + record[index] = (uint8_t)((high << 4) | low); sum += record[index]; /* Сохраняет не более 255 октетов данных в ограниченном локальном буфере. */ + } /* Завершает разбор одной Intel HEX-записи без heap. */ + if ((sum & 0xFFU) || (at < size && !white(source[at]))) return -12; type = record[3]; /* Дополнение checksum обязано давать ноль по модулю 256, а строка должна закончиться. */ + if (type == 0) { /* Адреса данных интерпретируются только по контракту C2000, а не как байтовые адреса STM32. */ + uint32_t offset = ((uint32_t)record[1] << 8) | record[2]; if (!length) continue; /* Пустая запись не создаёт нулевой блок, который в SCI8 обозначает конец образа. */ + if (length % 2 || base > UINT32_MAX - offset) return -12; start = base + offset; /* Каждая пара октетов должна составлять полное слово без переполнения адреса. */ + if (!block_at || start != next_address || (size_t)word(output + block_at) + length / 2 > 0xFFFFU) { /* Сливает соседние записи в секцию SCI8 вместо создания тысяч мелких Flash-блоков. */ + if (count > capacity || capacity - count < 6 + length + 2) return -2; block_at = count; memset(output + count, 0, 6); put_address(output + count + 2, start); count += 6; /* Новый заголовок содержит число слов и исходный словный адрес TI; резервирует место терминатора. */ + } else if (count > capacity || capacity - count < length + 2) return -2; /* Продолжение секции также оставляет два октета для конечного нулевого размера. */ + for (index = 0; index < length; index += 2) { output[count + index] = record[5 + index]; output[count + index + 1] = record[4 + index]; } /* HEX romwidth=16 хранит старший октет первым; SCI8 и COFF используют младший первым. */ + put_word(output + block_at, (uint16_t)(word(output + block_at) + length / 2)); count += length; /* В SCI8 размер блока измеряется 16-битными словами, а длина буфера — октетами. */ + if (start > UINT32_MAX - length / 2) return -6; next_address = start + (uint32_t)(length / 2); /* Следующая запись может продолжить блок только с точного следующего словного адреса. */ + } else if (type == 1) { if (length || record[1] || record[2]) return -12; eof = 1; } /* EOF не содержит данных и запрещает дальнейшие записи. */ + else if (type == 2 || type == 4) { if (length != 2 || record[1] || record[2]) return -12; base = (((uint32_t)record[4] << 8) | record[5]) << (type == 2 ? 4 : 16); } /* Поддерживает расширенный сегментный и линейный адрес без удвоения адресов C28x. */ + else if (type == 3 || type == 5) { /* Явная точка входа поддерживается обоими стандартными типами стартовой записи Intel HEX. */ + if (length != 4 || record[1] || record[2]) return -12; target = type == 3 ? ((((uint32_t)record[4] << 8) | record[5]) << 4) + (((uint32_t)record[6] << 8) | record[7]) : ((uint32_t)record[4] << 24) | ((uint32_t)record[5] << 16) | ((uint32_t)record[6] << 8) | record[7]; /* Стартовый адрес сохраняет те же словные единицы, что адреса данных текущего HEX. */ + } else return -12; /* Неизвестный тип записи нельзя молча пропускать в файле для программирования Flash. */ + } /* После полного разбора адресная таблица проходит общую проверку Flash и области CSM. */ + if (!eof || !block_at || capacity - count < 2) return -12; put_word(output + count, 0); count += 2; put_address(output + 18, target); /* Сохраняет точку входа и добавляет единственный терминатор SCI8. */ + { int status = c2000_sci_validate(output, count, 1, NULL, NULL); if (status) return status; } /* Отвергает реальные словные пересечения, отсутствующий codestart и защищённые адреса. */ + *written = count; return 0; /* Публикует только полностью проверенный образ, готовый для существующего SCI-автомата. */ +} /* Завершает преобразование прежнего HEX без зависимости от установленного hex2000. */ +int c2000_sci_decode(const uint8_t *source, size_t size, uint8_t *output, size_t capacity, size_t *written) { /* Приводит бинарный SCI8, ASCII SCI8 TI и прежний словный Intel HEX к единому проверяемому буферу SCI8. */ size_t at = 0, count = 0; int high, low; /* Хранит позиции отдельно от результата до полного завершения разбора. */ if (written) *written = 0; /* Ошибка никогда не оставляет длину частично принятого файла. */ if (!source || !output || !written || size < 2) return -1; /* Проверяет указатели и минимальный ключ до чтения данных. */ if (source[0] == 0xAA && source[1] == 0x08) { if (size > capacity) return -2; memmove(output, source, size); *written = size; return 0; } /* Бинарный SCI8 сохраняется побайтно. */ while (at < size && white(source[at])) ++at; /* Пропускает пустые строки перед STX. */ + if (at < size && source[at] == ':') return decode_word_hex(source + at, size - at, output, capacity, written); /* В явном SCI-маршруте старый Intel HEX TI разбирается словным кодеком, сохраняя общий байтовый парсер других MCU. */ if (at == size || source[at++] != 2) return -3; /* ASCII TI начинается управляющим STX, а не Intel HEX-двоеточием. */ for (;;) { /* Принимает только завершённый ETX поток двухзначных октетов. */ while (at < size && white(source[at])) ++at; /* Разделители не входят в передаваемые байты. */ @@ -59,13 +98,22 @@ int c2000_sci_begin(void *storage, size_t size, const uint8_t *kernel, size_t ke sci_session_t *s = (sci_session_t *)storage; int status; /* Контекст размещён в памяти вызывающего порта. */ if (!s || size < sizeof(*s)) return -1; memset(s, 0, sizeof(*s)); /* Не оставляет состояние предыдущей передачи. */ status = c2000_sci_validate(kernel, kernel_size, 0, NULL, NULL); if (status) return status; /* В RAM можно передать только корректное ядро. */ - status = c2000_sci_validate(image, image_size, 1, NULL, NULL); if (status) return status; /* Ошибочный Flash-образ не должен даже запускать загрузку ядра. */ + status = c2000_sci_validate(image, image_size, 1, NULL, &s->sector_mask); if (status) return status; /* Проверка приложения одновременно вычисляет точную маску стирания для встроенного ядра. */ s->kernel = kernel; s->kernel_size = kernel_size; s->image = image; s->image_size = image_size; return 0; /* Срок жизни буферов остаётся обязанностью порта. */ } /* Завершает инициализацию сеанса. */ +int c2000_sci_verify(void *storage) { /* Явный запрос Verify не меняет поведение прежней функции begin и старых клиентов. */ + sci_session_t *s = (sci_session_t *)storage; /* Режим устанавливается в уже проверенном контексте до первого аппаратного обмена. */ + if (!s || !s->kernel || s->phase || s->wait || s->kernel_at) return -8; /* Нельзя включать чтение после начала передачи или при отсутствии подготовленного ядра. */ + if (memcmp(s->kernel + 2, "VR\1\0", 4)) return -11; /* Резерв SCI8 RAM-ядра содержит сигнатуру VR и 16-битную версию 1 только у расширенного сборщика. */ + s->verify = 1; return 0; /* Реальная проверка будет обязательной для каждой программируемой порции до передачи терминатора. */ +} /* Завершает включение аппаратного чтения Flash. */ +uint32_t c2000_sci_error_address(const void *storage) { /* Предоставляет диагностический адрес без раскрытия структуры C-контекста. */ + const sci_session_t *s = (const sci_session_t *)storage; return s ? s->error_address : 0; /* Нулевой адрес для отсутствующего контекста не может совпасть с разрешённой внутренней Flash. */ +} /* Завершает получение адреса ошибки Verify. */ int c2000_sci_next(void *storage, uint8_t *tx, size_t capacity, size_t *tx_size, size_t *rx_size, uint32_t *delay_ms) { /* Планирует ровно один обмен либо обязательную паузу TI. */ sci_session_t *s = (sci_session_t *)storage; size_t count, i; /* Длины считаются октетами, кроме remaining в словах Flash. */ if (!s || !tx || !tx_size || !rx_size || !delay_ms || s->wait || !s->kernel) return -8; *tx_size = *rx_size = 0; *delay_ms = 0; /* Запрещает новый пакет до проверки ответа на предыдущий. */ - if (s->phase == 9) return 0; /* Нулевой терминатор уже передан; аппаратная проверка чтением не заявляется. */ + if (s->phase == 9) return 0; /* Терминатор разрешён только после подтверждения всех порций, включая чтение Flash при включённом Verify. */ if (s->phase == 2 || s->phase == 4) { ++s->phase; *delay_ms = 3000; return 2; } /* TI f05_DownloadImage выдерживает три секунды после ядра и после его autobaud. */ if (!capacity) return -2; /* Даже одиночный символ синхронизации должен помещаться в буфер. */ if (s->phase == 0 || s->phase == 3) { tx[0] = 'A'; *tx_size = *rx_size = 1; s->expected = 'A'; } /* ROM и Kernel A независимо определяют скорость по эху ASCII A. */ @@ -74,20 +122,26 @@ int c2000_sci_next(void *storage, uint8_t *tx, size_t capacity, size_t *tx_size, else { /* Прикладной поток подтверждается суммой порций после успешного вызова Flash API. */ if (s->phase == 5) { count = 22; s->image_at = 0; } /* Заголовок подтверждается после стирания выбранных ядром секторов. */ else { /* Обрабатывает полный SCI8-блок без передачи следующего до подтверждения текущего. */ - if (!s->remaining) { s->block_words = s->remaining = word(s->image + s->image_at); s->extra_zero = s->block_words > SCI_CHUNK_WORDS && s->block_words % SCI_CHUNK_WORDS == 0; } /* Учитывает точный размер порции TI и его особый пустой остаток. */ + if (!s->remaining) { s->block_words = s->remaining = word(s->image + s->image_at); s->extra_zero = s->block_words > SCI_CHUNK_WORDS && s->block_words % SCI_CHUNK_WORDS == 0; if (s->remaining) s->block_address = address(s->image + s->image_at + 2); } /* Читает адрес только непустой секции и учитывает дополнительный ACK пустого остатка TI. */ if (!s->remaining) { if (capacity < 2) return -2; memcpy(tx, s->image + s->image_at, 2); *tx_size = 2; s->image_at += 2; s->phase = 9; return 1; } /* Терминатор завершает программирование и передаёт управление entry приложения. */ count = (size_t)(s->remaining > SCI_CHUNK_WORDS ? SCI_CHUNK_WORDS : s->remaining) * 2; /* Полезная часть порции не превышает RAM-буфер TI. */ if (s->remaining == s->block_words) count += 6; /* Первая порция включает размер секции и 32-битный словный адрес. */ } /* Получена длина заголовка либо одной порции приложения. */ if (capacity < count) return -2; memcpy(tx, s->image + s->image_at, count); *tx_size = count; *rx_size = 2; s->expected = 0; /* Копирует готовые байты без повторной сборки таблицы в порту GUI. */ + s->readback_size = 0; /* Заголовок erase и служебные подтверждения не представляют содержимое Flash. */ + if (s->verify && s->phase == 5) { tx[2] = 'V'; tx[3] = 'R'; tx[4] = 1; tx[5] = 0; } /* Первые два резервных слова заголовка включают VR1; исходный BIN и его SHA-256 остаются неизменными. */ + if (s->phase == 5 && !memcmp(s->kernel + 6, "SM\1\0", 4)) { if (!s->verify) memset(tx + 2, 0, 4); tx[6] = 'S'; tx[7] = 'M'; tx[8] = (uint8_t)s->sector_mask; tx[9] = 0; tx[10] = (uint8_t)(s->sector_mask ^ 0xFFU); tx[11] = 0; } /* SM1 передаёт точную маску и инверсию; при выключенном Verify резерв исходного BIN не может самовольно включить чтение в ядре. */ + if (s->verify && s->phase == 6) { s->readback_at = s->image_at + (s->remaining == s->block_words ? 6 : 0); s->readback_size = count - (s->readback_at - s->image_at); *rx_size += s->readback_size; } /* Ожидает физические октеты текущей порции, затем штатную двухоктетную checksum TI. */ for (i = 0; i < count; ++i) s->expected = (uint16_t)(s->expected + tx[i]); s->pending_bytes = count; /* Сумма октетов по модулю 65536 совпадает с TI SendCheckSum. */ } /* Ответ на запланированный обмен должен быть принят до следующего шага. */ s->wait = (unsigned)*rx_size; return 1; /* Нулевой rx_size означает отправку терминатора без недостоверного ожидания ACK. */ } /* Завершает формирование следующего действия. */ int c2000_sci_accept(void *storage, const uint8_t *rx, size_t size) { /* Проверяет фактические ответы ROM и Flash Kernel A. */ - sci_session_t *s = (sci_session_t *)storage; unsigned words_sent; /* Состояние алгоритма меняется только после достоверного ответа. */ + sci_session_t *s = (sci_session_t *)storage; unsigned words_sent; size_t i; /* Индекс октета позволяет сообщить точный словный адрес первого несовпадения Flash. */ if (!s || !rx || !s->wait || size != s->wait) return -8; /* Не принимает пустое, лишнее или усечённое подтверждение. */ - if ((size == 1 ? rx[0] : word(rx)) != s->expected) return -9; s->wait = 0; /* Несовпадение эха или checksum останавливает передачу. */ + if ((size == 1 ? rx[0] : word(rx + size - 2)) != s->expected) return -9; /* Checksum завершает ответ как в исходном TI-протоколе, так и после физического чтения VR1. */ + if (s->verify && s->phase == 6) { for (i = 0; i < s->readback_size; ++i) if (rx[i] != s->image[s->readback_at + i]) { s->error_address = s->block_address + s->block_words - s->remaining + (uint32_t)(i / 2); return -10; } } /* Сравнивает каждый октет Flash с неизменяемым BIN и сохраняет адрес C28x; ошибка запрещает следующий блок и запуск приложения. */ + s->wait = 0; /* Следующий пакет разрешён только после успешной проверки checksum и всех запрошенных байтов Flash. */ if (s->phase == 0) s->phase = 1; /* После первого autobaud начинается байтовая передача RAM-ядра. */ else if (s->phase == 1) { if (++s->kernel_at == s->kernel_size) s->phase = 2; } /* Последний подтверждённый октет ядра запускает паузу его старта. */ else if (s->phase == 3) s->phase = 4; /* После autobaud ядра выдерживается пауза перед стиранием Flash. */ diff --git a/python/protocan/c2000_sci.py b/python/protocan/c2000_sci.py index 18e6db4..5c044d0 100644 --- a/python/protocan/c2000_sci.py +++ b/python/protocan/c2000_sci.py @@ -16,13 +16,13 @@ def _api(): # Настраивает только сигнатуры новых def _check(status): # Переводит детерминированные ошибки C в локализованное сообщение интерфейса. - messages = {-1: "Неверные параметры SCI", -2: "Недостаточный буфер SCI", -3: "Неверный ASCII SCI8 TI", -4: "Неверный заголовок SCI8", -5: "Обрезанная таблица SCI8 или отсутствующая точка входа", -6: "SCI8 содержит недопустимые адреса RAM/Flash или область CSM", -7: "SCI8 содержит пересекающиеся секции", -8: "Нарушена последовательность SCI Boot", -9: "Эхо или контрольная сумма загрузчика не совпали"} # Сообщения не повторяют проверку пакетов или вычисление checksum. + messages = {-1: "Неверные параметры SCI", -2: "Недостаточный буфер SCI", -3: "Неверный ASCII SCI8 TI", -4: "Неверный заголовок SCI8", -5: "Обрезанная таблица SCI8 или отсутствующая точка входа", -6: "Образ C2000 содержит недопустимые адреса RAM/Flash или область CSM", -7: "Образ C2000 содержит пересекающиеся секции", -8: "Нарушена последовательность SCI Boot", -9: "Эхо или контрольная сумма загрузчика не совпали", -12: "Неверная запись или контрольная сумма Intel HEX C2000"} # Ошибки старого HEX отличаются от ошибок транспорта; общий C-код остаётся единственным парсером. if status < 0: raise ValueError(messages.get(status, "Ошибка C2000 SCI: " + str(status))) # Любой отказ C останавливает передачу в аппаратном порту. def decode(data): # Преобразует представление SCI8 общим C-декодером до работы с COM. lib, raw = _api(), ctypes.create_string_buffer(data) # Сохраняет исходные байты на время вызова C. - output, written = ctypes.create_string_buffer(max(1, len(data))), ctypes.c_size_t() # Декодированный поток никогда не длиннее ASCII-источника. + output, written = ctypes.create_string_buffer(max(24, len(data) + 24)), ctypes.c_size_t() # Заголовок и терминатор SCI8 требуют 24 октета сверх минимального старого HEX; память ограничивается размером выбранного файла. _check(lib.c2000_sci_decode(raw, len(data), output, len(output), ctypes.byref(written))) # Проверку STX/ETX и шестнадцатеричных октетов выполняет общий модуль. return output.raw[:written.value] # Возвращает только опубликованную C длину полного результата. @@ -41,12 +41,19 @@ def ulitco_enter(): # Возвращает штатный пакет перех class Session: # Владеет C-контекстом и буферами двух образов на всё время прошивки. - def __init__(self, kernel, image): # Проверяет оба образа до первого аппаратного действия. + def __init__(self, kernel, image, verify=False): # Проверяет оба образа и поддержку выбранного чтения до первого аппаратного действия. self.lib = _api() # Одна библиотека обслуживает все шаги данного сеанса. self.kernel, self.image = ctypes.create_string_buffer(kernel), ctypes.create_string_buffer(image) # Буферы не перемещаются и не освобождаются до завершения сеанса. size = self.lib.c2000_sci_session_size() # Размер внутренней C-структуры не дублируется в ctypes. self.storage = (ctypes.c_uint64 * ((size + 7) // 8))() # Выравнивает непрозрачный контекст минимум на восемь октетов для указателей x64. _check(self.lib.c2000_sci_begin(self.storage, ctypes.sizeof(self.storage), self.kernel, len(kernel), self.image, len(image))) # Общая инициализация запрещает ошибочные таблицы до autobaud. + if verify: # Прежние сеансы совместимы со старой DLL, пока физическое чтение явно не запрошено. + try: function = self.lib.c2000_sci_verify # Проверяет наличие расширения в общей нативной библиотеке до открытия COM. + except AttributeError as error: raise RuntimeError('Обновите библиотеку setprotocol для Verify Flash') from error # Старый runtime не должен начать запись без выбранной проверки. + function.argtypes, function.restype = [ctypes.c_void_p], ctypes.c_int # Непрозрачный указатель контекста сохраняет разрядность ABI на x64. + status = function(self.storage) # Общий C-автомат проверит сигнатуру VR1 самого RAM-ядра и зафиксирует режим сеанса. + if status == -11: raise ValueError('RAM-ядро TI не поддерживает Verify: пересоберите комплект прошивки или снимите флажок Verify') # Старый комплект можно передавать только с явно выключенным чтением Flash. + _check(status) # Любой другой отказ подготовки также запрещает аппаратный старт. def next(self): # Получает готовое действие от детерминированного C-автомата. tx, tx_size, rx_size, delay = ctypes.create_string_buffer(2054), ctypes.c_size_t(), ctypes.c_size_t(), ctypes.c_uint32() # 1024 слова и шесть октетов заголовка секции покрывают максимальную порцию TI. @@ -56,7 +63,11 @@ class Session: # Владеет C-контекстом и буферами дв def accept(self, reply): # Передаёт полный ответ для проверки общему C-ядру. raw = ctypes.create_string_buffer(reply) # Сохраняет исходные октеты без преобразования в Python-число checksum. - _check(self.lib.c2000_sci_accept(self.storage, raw, len(reply))) # Успешная проверка разрешает следующий шаг автомата. + status = self.lib.c2000_sci_accept(self.storage, raw, len(reply)) # C сравнивает checksum и каждую прочитанную октету с исходным адресным блоком BIN. + if status == -10: # Проверка Flash должна сообщать точный физический адрес первого расхождения. + function = self.lib.c2000_sci_error_address; function.argtypes, function.restype = [ctypes.c_void_p], ctypes.c_uint32 # Словный адрес C28x имеет фиксированные 32 бита независимо от платформы host. + raise ValueError(f'Verify Flash: несовпадение по адресу слова 0x{function(self.storage):06X}; запуск приложения не выполнен') # Терминатор SCI8 не отправлен, поэтому ядро ещё ожидает следующий блок. + _check(status) # Только успешное чтение и проверка ответа разрешают следующий шаг автомата. @property # Прогресс отражает только подтверждённые этапы передачи. def progress(self): # Представление не повторяет состояния алгоритма в Python. diff --git a/python/pyproject.toml b/python/pyproject.toml index 4486f96..505325a 100644 --- a/python/pyproject.toml +++ b/python/pyproject.toml @@ -18,5 +18,5 @@ where = ["."] include = ["firmware_image*", "altera_logic*", "logic_analyzer*", "set_devices*", "protocan*", "setprotocol*", "pysetterminal*"] [tool.setuptools.package-data] -set_devices = ["gas_logger_maps/*.json"] +set_devices = ["gas_logger_maps/*.json", "sci_kernels/*.bin", "sci_kernels/*.json"] # Самостоятельный пакет templates также поставляет ядра F28335 с каталогом SHA-256 и лицензией TI. protocan = ["*.json", "native/*.dll", "native/*.so", "native/*.dylib"] diff --git a/python/set_devices/c2000_kernels.py b/python/set_devices/c2000_kernels.py new file mode 100644 index 0000000..1150162 --- /dev/null +++ b/python/set_devices/c2000_kernels.py @@ -0,0 +1,20 @@ +"""Встроенные RAM-ядра F28335, не требующие файлов проекта или установленного TI SDK.""" # Все аппаратные операции остаются в существующем SCI-автомате. +import hashlib # Сверяет двоичные ресурсы поставки с каталогом до открытия COM. +import json # Читает только локальный каталог ресурсов текущего Python-пакета. +from pathlib import Path # Ресурсы ищутся относительно модуля одинаково в исходниках, wheel и PyInstaller. +from protocan.c2000_sci import decode, validate # Проверка адресов и формата остаётся в общем C-ядре. + +def embedded_kernel(oscillator_hz): # Выбирает ядро под подтверждённую частоту платы, сохраняя согласование секторов в протоколе SM1. + directory = Path(__file__).with_name('sci_kernels') # Каталог входит в поставку SETGUI и не зависит от расположения прошиваемого проекта. + catalog = json.loads((directory / 'catalog.json').read_text(encoding='utf-8')) # Каталог не скачивается из сети во время подготовки аппаратной операции. + if catalog.get('schema') != 1 or catalog.get('target') != 'TMS320F28335': raise ValueError('Повреждён каталог встроенных ядер F28335') # Чужой формат или MCU не допускается к запуску в RAM. + rows = [row for row in catalog.get('kernels', []) if row.get('oscillator_hz') == oscillator_hz] # Частоты сравниваются в герцах без округления GUI. + if len(rows) != 1: raise ValueError('Встроенное ядро F28335 поддерживает кварц 20, 25 или 30 МГц') # Не заменяет неизвестную частоту ближайшим вариантом Flash API. + row = rows[0] # Единственное найденное ядро фиксируется до дальнейших проверок. + if not isinstance(row.get('file'), str) or Path(row['file']).name != row['file']: raise ValueError('Некорректное имя встроенного ядра F28335') # Каталог не может ссылаться на файл за пределами ресурсов приложения. + data = (directory / row['file']).read_bytes() # Встроенное ядро читается отдельным неизменяемым снимком для текущей попытки. + if len(data) != row.get('size_bytes') or hashlib.sha256(data).hexdigest() != row.get('sha256'): raise ValueError('Повреждено встроенное RAM-ядро F28335: переустановите SETGUI') # Совпадение имени ресурса не заменяет проверку его точных байтов. + data = decode(data) # Общий C-декодер проверяет контейнер SCI8 до обращения к его резерву. + entry, _ = validate(data, False) # Допускает только безопасные RAM-диапазоны без Flash и периферийных регистров. + if entry != 0 or data[2:10] != b'VR\x01\x00SM\x01\x00': raise ValueError('Встроенное ядро не поддерживает вход UlitCo, Verify или маску секторов SM1') # Старый первичный загрузчик выполняет переход на адрес 0; SM1 обязателен для точного стирания. + return data # Возвращает проверенное ядро; приложение и маску секторов дополнительно проверит Session. diff --git a/python/set_devices/firmware.py b/python/set_devices/firmware.py index 1dd655f..fdcc864 100644 --- a/python/set_devices/firmware.py +++ b/python/set_devices/firmware.py @@ -57,6 +57,16 @@ class FirmwareImage: raise FirmwareImageError(f"Размер образа превышает {maximum_size} байт") return cls(file_path, data, base) + @classmethod # Отдельный маршрут C2000 не меняет байтовую адресацию Intel HEX других микроконтроллеров. + def load_c2000(cls, path, maximum_size=1024 * 1024): # Принимает прежний HEX C2Prog и бинарный/ASCII SCI8 без соседнего manifest. + from protocan.c2000_sci import decode, validate # Единственный C-парсер проверяет checksum, словные адреса и порядок октетов TI. + file_path = Path(path) # Сохраняет исходный путь для SHA-256 и повторного чтения перед аппаратным подтверждением. + with file_path.open('rb') as stream: raw = stream.read(maximum_size + 1) # Ограничивает чтение старых файлов до одного МиБ, как подготовка SCI-панели. + if not raw or len(raw) > maximum_size: raise FirmwareImageError('Пустой или слишком большой образ C2000') # Не выделяет дополнительные буферы для неподходящего размера. + try: validate(decode(raw), True) # Проверяет весь результат до изменения выбранного образа или контролов основной формы. + except ValueError as error: raise FirmwareImageError(str(error)) from error # Обычный диалог файла показывает конкретную ошибку HEX или защищённого адреса. + return cls(file_path, raw, 0) # SHA и CRC относятся к исходному файлу; словные адреса передаются внутри проверенной SCI8-таблицы. + def _parse_intel_hex(text: str, maximum_size=2 * 1024 * 1024) -> tuple[bytes, int]: return contiguous_image(text, maximum_size) diff --git a/python/set_devices/qt_ports/c2000_sci_panel.py b/python/set_devices/qt_ports/c2000_sci_panel.py index 7364338..e1164eb 100644 --- a/python/set_devices/qt_ports/c2000_sci_panel.py +++ b/python/set_devices/qt_ports/c2000_sci_panel.py @@ -12,22 +12,25 @@ except ImportError: # Для Python 3.8/Windows 7 использует те ж from PySide2.QtWidgets import QWidget, QFormLayout, QLineEdit, QPushButton, QCheckBox, QSpinBox, QFileDialog, QLabel # Интерфейс не требует компонентов, доступных только Qt 6. from PySide2.QtSerialPort import QSerialPort # COM-порт остаётся локальной зависимостью адаптера. from protocan.c2000_sci import Session, decode, validate, ulitco_enter # Сборка, разбор, checksum и автомат обмена не повторяются в порту. +from set_devices.c2000_kernels import embedded_kernel # Старые проекты используют проверенные ядра поставки SETGUI без TI SDK и отдельного файла проекта. class SciWorker(QThread): # Один сеанс владеет COM-портом и неизменяемыми буферами до завершения. progress = Signal(int, str) # Штатная полоса GUI получает только подтверждённый прогресс C-автомата. result = Signal(bool, str) # Ошибка транспорта или checksum не выдаётся за успешную запись. - def __init__(self, kernel, image, port, baud, enter=False, timeout_ms=3000, parent=None): # Все параметры снимаются с GUI до запуска потока. + def __init__(self, kernel, image, port, baud, enter=False, timeout_ms=3000, parent=None, verify=False): # Режим чтения, буферы и параметры UART фиксируются до запуска потока. super().__init__(parent) # Время жизни потока связано с существующей панелью прошивки. self.kernel, self.image, self.port, self.baud = kernel, image, port, baud # Буферы не перечитываются с диска после аппаратного старта. self._stage, self._last_tx = "Подготовка SCI", b"" # Начальное состояние нужно также для самостоятельного создания SciWorker в проверках транспорта. self.enter, self.timeout_ms, self.stop = enter, timeout_ms, threading.Event() # Отмена проверяется во всех конечных ожиданиях. + self.verify = bool(verify) # Физическое чтение каждой порции запрашивается отдельно от транспортной checksum TI. - def configure(self, kernel, image, port, baud, enter=False, timeout_ms=3000): # Повторно использует готовый Qt-поток только после полного завершения предыдущего сеанса. + def configure(self, kernel, image, port, baud, enter=False, timeout_ms=3000, verify=False): # Фиксирует новый режим Verify только после полного завершения предыдущего сеанса. if self.isRunning(): raise ValueError('Прошивка SCI ещё выполняется') # Не меняем буферы, настройки UART и событие отмены во время аппаратного обмена. self.kernel, self.image, self.port, self.baud = kernel, image, port, baud # Фиксируем новый неизменяемый комплект и скорость UART в бодах до запуска run. self.enter, self.timeout_ms = enter, timeout_ms # Сохраняем явный вход Monitor и тайм-аут ответа в миллисекундах для нового сеанса. + self.verify = bool(verify) # Следующая попытка не наследует состояние Verify предыдущей записи. self.stop.clear() # Отмена предыдущей операции не должна автоматически отменять следующую явную попытку. self._stage, self._last_tx = 'Подготовка SCI', b'' # Диагностика нового сеанса не использует этап или последние байты предыдущей передачи. @@ -64,7 +67,7 @@ class SciWorker(QThread): # Один сеанс владеет COM-портом def run(self): # Qt вызывает метод в отдельном потоке, где создаётся и закрывается COM-порт. serial, started = None, time.monotonic() # COM открывается после проверки образа; монотонные часы измеряют полную длительность текущего сеанса, включая загрузку ядра и обязательные паузы. try: # Все исключения превращаются в конечный результат GUI. - session = Session(self.kernel, self.image) # Проверяет RAM-ядро и Flash-таблицу до любой управляющей команды. + session = Session(self.kernel, self.image, verify=self.verify) # Проверяет также поддержку VR1 до открытия порта и любой управляющей команды. self._stage = f"Открытие {self.port}" # Ошибка доступа к COM возникает до начала синхронизации с микроконтроллером. serial = QSerialPort(); serial.setPortName(self.port); serial.setBaudRate(468750 if self.enter else self.baud) # Штатный Monitor ИБП работает на 468750 бит/с (MONITOR_BRR=9, LSPCLK=37,5 МГц); при ручном входе сразу используется скорость загрузчика из manifest. serial.setDataBits(QSerialPort.DataBits.Data8); serial.setParity(QSerialPort.Parity.NoParity); serial.setStopBits(QSerialPort.StopBits.OneStop); serial.setFlowControl(QSerialPort.FlowControl.NoFlowControl) # TI SCI Boot и первичный загрузчик UlitCo используют 8N1 без аппаратного управления потоком. @@ -85,12 +88,13 @@ class SciWorker(QThread): # Один сеанс владеет COM-портом self._stage = "Первичная синхронизация SCI" if exchanges == 1 else f"Обмен SCI №{exchanges}" # Первая ошибка отделяется от последующей передачи ядра и программирования Flash. if exchanges == 1: self.progress.emit(0, f"{self._stage}: {self.port}, {self.baud} бод, TX {tx.hex(' ').upper()}") # До ожидания первого ответа журнал фиксирует скорость и настоящий символ синхронизации. self._write(serial, tx) # Отправляет готовый октет ROM либо порцию Flash Kernel A. - if expected: session.accept(self._read(serial, expected, 60000 if expected == 2 else self.timeout_ms)) # Erase/program получают минуту; эхо ROM использует точный тайм-аут из профиля JSON в миллисекундах. + if expected: session.accept(self._read(serial, expected, 60000 if expected >= 2 else self.timeout_ms)) # Erase/program и физическое чтение получают минуту; эхо ROM использует выбранный тайм-аут в миллисекундах. percent = session.progress # Подтверждённый процент по-прежнему вычисляется единственным C-автоматом после проверки ответа. if percent != last_percent: # Тысячи побайтовых подтверждений RAM-ядра не должны создавать одинаковые строки и queued-сигналы GUI. - self.progress.emit(percent, "Ядро TI / запись Flash…") # Публикуем каждое изменение процента, включая конечные 100 процентов, после успешного обмена. + self.progress.emit(percent, 'Ядро TI / запись и Verify Flash…' if self.verify else 'Ядро TI / запись Flash…') # Прогресс увеличивается лишь после checksum и побайтового сравнения прочитанной порции при включённом Verify. last_percent = percent # Следующий байт с тем же процентом продолжит аппаратный сеанс без повторной перерисовки и записи в журнал. - self.result.emit(True, f"Передача завершена за {time.monotonic() - started:.1f} с; ядро TI подтвердило порции Flash. Проверка чтением памяти отдельно не выполнялась.") # Сообщаем полное измеренное время сеанса и подтверждение ядра, сохраняя точное указание об отсутствии отдельной проверки чтением. + checked = 'Verify OK: все записанные слова Flash прочитаны и побайтно совпали с BIN.' if self.verify else 'Ядро TI подтвердило порции Flash. Проверка чтением памяти отдельно не выполнялась.' # Успех физического чтения заявляется только для полностью завершённого VR1-сеанса. + self.result.emit(True, f'Передача завершена за {time.monotonic() - started:.1f} с; {checked}') # Сохраняет полную длительность, включая запись, чтение и обязательные паузы ядра. except (OSError, ValueError, RuntimeError) as error: self.result.emit(False, str(error)) # Ошибка остановит GUI и сохранится в журнале текущей прошивки. finally: # Владение портом освобождается также после отмены или тайм-аута. if serial is not None: serial.close() # Закрывает только созданный этим потоком COM-сеанс. @@ -108,16 +112,23 @@ class C2000SciPanel(QWidget): # Общая панель используетс self._thread.result.connect(self._capture_result, Qt.QueuedConnection) # Обработка результата не изменяет состояние QWidget из рабочего потока. self._thread.finished.connect(self._released, Qt.QueuedConnection) # Освобождение активного сеанса начинается только после завершения run и закрытия собственного COM. form = QFormLayout(self) # Контролы не требуют дополнительного окна приложения. - self.kernel = QLineEdit(); form.addRow("RAM-ядро TI", self.kernel) # Готовый комплект заполняет путь автоматически. - button = QPushButton("Выбрать ядро…"); button.clicked.connect(self._choose); form.addRow(button) # Старые образы допускают явный выбор соответствующего ядра. + self.use_builtin = QCheckBox('Использовать встроенное RAM-ядро SETGUI'); self.use_builtin.setChecked(True); form.addRow(self.use_builtin) # Прежнему HEX/BIN достаточно выбранной частоты платы; внешний файл остаётся дополнительной возможностью. + self.kernel = QLineEdit(); self.kernel.setPlaceholderText('Встроенное ядро SETGUI'); form.addRow("RAM-ядро TI", self.kernel) # Пустое поле при встроенном режиме больше не означает отсутствующую обязательную зависимость. + self.kernel_button = QPushButton("Выбрать внешнее ядро…"); self.kernel_button.clicked.connect(self._choose); form.addRow(self.kernel_button) # Полные комплекты postbuild сохраняют возможность использовать собственное проверенное ядро. self.enter_monitor = QCheckBox("Перевести остановленный UlitCo в загрузчик через Monitor №93"); form.addRow(self.enter_monitor) # Управляющая команда отправляется только при явном выбранном режиме. - self.oscillator_hz = QSpinBox(); self.oscillator_hz.setRange(20000000, 30000000); self.oscillator_hz.setSingleStep(5000000); self.oscillator_hz.setValue(30000000); self.oscillator_hz.setReadOnly(True); form.addRow("Кварц ядра, Гц", self.oscillator_hz) # Частота зафиксирована при сборке ядра и не меняется настройкой COM. + self.verify_after_flash = QCheckBox('Verify — проверить Flash чтением после записи'); form.addRow(self.verify_after_flash) # Проверка каждой записанной порции доступна в той же форме UlitCo рядом с RAM-ядром. + self.verify_after_flash.setToolTip('Считать каждую записанную порцию из Flash и побайтно сравнить с BIN до запуска приложения. Требуется RAM-ядро TI с поддержкой Verify (VR1).') # Объясняет реальное действие и совместимость без смешения с SHA-256 транспортного файла. + self.oscillator_hz = QSpinBox(); self.oscillator_hz.setRange(20000000, 30000000); self.oscillator_hz.setSingleStep(5000000); self.oscillator_hz.setValue(30000000); form.addRow("Кварц платы, Гц", self.oscillator_hz) # Для встроенного режима выбирает вариант 20, 25 или 30 МГц; внешнее ядро сохраняет частоту своего manifest. self.timeout_ms = QSpinBox(); self.timeout_ms.setRange(50, 10000); self.timeout_ms.setValue(3000); form.addRow("Ожидание связи, мс", self.timeout_ms) # Отдельный erase/program получает обязательный бюджет до 60 секунд. label = QLabel("Штатный SCI Boot F28335: приложение UlitCo → RAM-ядро TI → Flash. Выберите порт SCI-A; при ручном входе предварительно включите загрузчик."); label.setWordWrap(True); form.addRow(label) # Оператор видит физический интерфейс и последовательность до начала записи. + self.use_builtin.toggled.connect(self._kernel_mode); self._kernel_mode(True); self.verify_after_flash.setChecked(True) # Начальное состояние готово для старого проекта и включает физическую проверку записанной Flash. + + def _kernel_mode(self, builtin): # Согласует элементы выбора с фактическим источником RAM-ядра. + self.kernel.setEnabled(not builtin); self.kernel_button.setEnabled(not builtin); self.oscillator_hz.setReadOnly(not builtin) # Встроенный вариант определяется частотой платы, а внешний — явно выбранным файлом. def _choose(self): # Выбор RAM-ядра сам по себе ничего не отправляет в устройство. path, _ = QFileDialog.getOpenFileName(self, "RAM-ядро F28335 SCI", self.kernel.text(), "SCI8 (*.bin *.txt)") # Принимает штатные бинарное и ASCII-представления TI. - if path: self.kernel.setText(path) # Отмена сохраняет текущий комплект. + if path: self.use_builtin.setChecked(False); self.kernel.setText(path) # Явный выбор внешнего файла отключает автоматическое ядро, не меняя активный сеанс. def set_manifest(self, image, metadata): # Подтягивает ядро и параметры из выбранного постсборочного комплекта. self.path, self.metadata = Path(image), metadata # Сохраняет принадлежность ядра конкретному Flash BIN. @@ -125,24 +136,29 @@ class C2000SciPanel(QWidget): # Общая панель используетс name = info.get("file", "") # Manifest хранит только исходное имя соседнего RAM-бинарника. if isinstance(name, str) and name and Path(name).name == name: self.kernel.setText(str(self.path.parent / name)) # Не разрешает metadata-путь за пределы папки образа. else: self.kernel.clear() # Новый образ не должен наследовать RAM-ядро предыдущей прошивки. - frequency = info.get("oscillator_hz", 30000000); self.oscillator_hz.setValue(frequency if type(frequency) is int and frequency in (20000000, 25000000, 30000000) else 30000000) # Показывает допустимую частоту без исключения setter на чужих metadata. + builtin = not bool(name and self.kernel.text() and Path(self.kernel.text()).is_file()); self.use_builtin.setChecked(builtin) # Manifest без доступного соседнего ядра и старые HEX/BIN используют ресурсы самого SETGUI. + self.verify_after_flash.setChecked(builtin or info.get('verify') == 'readback-v1') # Встроенные ядра поддерживают чтение Flash; совместимость старого внешнего ядра определяется его паспортом. + frequency = info.get("oscillator_hz", self.oscillator_hz.value()); self.oscillator_hz.setValue(frequency if type(frequency) is int and frequency in (20000000, 25000000, 30000000) else 30000000) # Старый проект без manifest сохраняет уже выбранный кварц платы; паспорт нового комплекта может явно задать свою частоту. def prepare(self, image): # Фиксирует и проверяет все байты до подтверждения аппаратной операции. with Path(image).open("rb") as stream: data = stream.read(1024 * 1024 + 1) # Ограничивает чтение Flash BIN до одного МиБ и одного контрольного октета. - with Path(self.kernel.text()).open("rb") as stream: kernel_raw = stream.read(1024 * 1024 + 1) # Worker получает ограниченный неизменяемый снимок RAM-ядра. + if self.use_builtin.isChecked(): kernel_raw = embedded_kernel(self.oscillator_hz.value()) # Выбирает проверенный ресурс поставки под реальную частоту платы без компилятора и файлов проекта. + else: # Пользовательский или постсборочный комплект сохраняет прежнюю проверку собственного ядра. + with Path(self.kernel.text()).open("rb") as stream: kernel_raw = stream.read(1024 * 1024 + 1) # Worker получает ограниченный неизменяемый снимок внешнего RAM-ядра. if len(data) > 1024 * 1024 or len(kernel_raw) > 1024 * 1024: raise ValueError("Слишком большой файл SCI8") # Ограничивает отдельные Flash и RAM-образы одним МиБ. if self.metadata and (len(data) != self.metadata.get("size_bytes") or hashlib.sha256(data).hexdigest() != self.metadata.get("sha256")): raise ValueError("Flash BIN изменён после выбора или не соответствует manifest") # Новый корректный SCI8 не должен незаметно заменить ранее подтверждённый образ. info = self.metadata.get("flash_kernel", {}) # При наличии паспорта зависимость должна совпадать побайтно. if not isinstance(info, dict): raise ValueError("В manifest требуется объект flash_kernel") # Неверный тип метаданных возвращается обычной ошибкой комплекта до доступа к COM. - if info and (len(kernel_raw) != info.get("size_bytes") or hashlib.sha256(kernel_raw).hexdigest() != info.get("sha256")): raise ValueError("RAM-ядро TI не соответствует manifest Flash BIN") # Чужая частота или маска erase не должны незаметно попасть в сеанс. + if info and not self.use_builtin.isChecked() and (len(kernel_raw) != info.get("size_bytes") or hashlib.sha256(kernel_raw).hexdigest() != info.get("sha256")): raise ValueError("RAM-ядро TI не соответствует manifest Flash BIN") # Внешний файл проверяется по паспорту проекта; встроенный уже проверен по каталогу самой программы. kernel, flash = decode(kernel_raw), decode(data) # Оба представления разбираются только общим C-декодером. validate(kernel, False); _, sectors = validate(flash, True) # Не открывает COM для повреждённых таблиц или адресов CSM; маску вычисляет единственный C-декодер. - if info and (info.get("sector_mask") != sectors or info.get("oscillator_hz") != self.oscillator_hz.value()): raise ValueError("RAM-ядро собрано для другой частоты или набора секторов Flash") # Комплект обязан соответствовать фактическим адресам приложения и выбранному при сборке кварцу. + if info and not self.use_builtin.isChecked() and (info.get("sector_mask") != sectors or info.get("oscillator_hz") != self.oscillator_hz.value()): raise ValueError("RAM-ядро собрано для другой частоты или набора секторов Flash") # Внешнее ядро имеет фиксированную маску; встроенное получает точную маску проверенного образа через SM1. + if self.verify_after_flash.isChecked(): Session(kernel, flash, verify=True) # Неподдерживаемое ядро или старый runtime выявляются до подтверждения записи и открытия COM. return kernel, flash # Возвращает готовые байты для неизменяемой аппаратной операции. def start(self, job, port, baud): # Основная форма вызывает метод после штатного подтверждения пользователя. if self.worker is not None: raise ValueError("Прошивка SCI уже выполняется") # Один виджет не может владеть двумя одновременными COM-сеансами. - self._thread.configure(*job, port, baud, self.enter_monitor.isChecked(), self.timeout_ms.value()) # Обновляем параметры уже существующего остановленного Qt-потока, не создавая новый метаобъект при каждой прошивке. + self._thread.configure(*job, port, baud, self.enter_monitor.isChecked(), self.timeout_ms.value(), verify=self.verify_after_flash.isChecked()) # Фиксирует checkbox вместе с буферами и UART до запуска уже существующего Qt-потока. self.worker, self._result = self._thread, None # Публичная ссылка обозначает только активный сеанс и сохраняет существующие проверки закрытия главного окна. self.worker.start() # Возобновляем готовый QThread; COM создаётся и закрывается только внутри его run. diff --git a/python/set_devices/qt_ports/uart_usb_terminal.py b/python/set_devices/qt_ports/uart_usb_terminal.py index aae738d..bdafda6 100644 --- a/python/set_devices/qt_ports/uart_usb_terminal.py +++ b/python/set_devices/qt_ports/uart_usb_terminal.py @@ -90,8 +90,8 @@ class UartUsbTerminal(QWidget): # Встраивается непосредст layout = QVBoxLayout(self) # Позволяет панели растягиваться внутри существующей MCU страницы. layout.addWidget(QLabel('USART → USB · RX1 PA3 / RX2 PB11 / RX3 PC11 / RX4 PD2 · TX1 PA2 · 8N1')) # Показывает проверенную разводку до подключения проводов. controls = QHBoxLayout(); self.devices = QComboBox(); self.devices.setMinimumContentsLength(35) # Делает выбор нескольких USB адаптеров читаемым в обычном окне. - self.refresh = QPushButton('Обновить USB'); self.connect = QPushButton('Запустить'); self.record = QPushButton('Запись RX…') # Разделяет поиск, начало захвата и выбор места бинарных журналов. - for widget in (self.devices, self.refresh, self.connect, self.record): controls.addWidget(widget) # Сохраняет основные действия в одной строке над потоками. + self.refresh = QPushButton('Обновить USB'); self.connect_button = QPushButton('Запустить'); self.record = QPushButton('Запись RX…') # Имя кнопки сохраняет метод QObject.connect, который PySide2 вызывает при подключении сигналов панели. + for widget in (self.devices, self.refresh, self.connect_button, self.record): controls.addWidget(widget) # Размещает выбор USB и три действия в одной строке, не перекрывая служебный метод Qt. layout.addLayout(controls); grid = QGridLayout(); layout.addLayout(grid) # Показывает четыре RX-экрана одновременно в сетке 2×2. for index, peripheral in enumerate(('USART2', 'USART3', 'UART4', 'UART5')): # Имена соответствуют единственному аппаратному порту G474 из templates. container = QWidget(); column = QVBoxLayout(container); row = QHBoxLayout(); rate = QComboBox(); rate.setEditable(True) # Каждому входу назначает независимый редактор скорости. @@ -105,7 +105,7 @@ class UartUsbTerminal(QWidget): # Встраивается непосредст layout.addLayout(sending); self.hex_view = QCheckBox('Показывать RX в HEX'); layout.addWidget(self.hex_view) # Позволяет читать двоичный поток без потери исходных байтов журнала. self.message = QLabel('Отключено. Для непрерывного потока выберите запись RX; экран показывает последние 8 КиБ каждого канала.'); self.message.setWordWrap(True); layout.addWidget(self.message) # Объясняет ограничение предпросмотра до начала длительного захвата. self.counts = [0] * 4; self.lost = [0] * 4; self.errors = [0] * 4 # Разделяет счётчики хоста и сообщённые прошивкой потери. - self.refresh.clicked.connect(self.refresh_devices); self.connect.clicked.connect(self.toggle); self.record.clicked.connect(self.choose_directory); self.send.clicked.connect(self.transmit); self.input.returnPressed.connect(self.transmit) # Связывает действия с общими обработчиками без открытия транспорта при создании UI. + self.refresh.clicked.connect(self.refresh_devices); self.connect_button.clicked.connect(self.toggle); self.record.clicked.connect(self.choose_directory); self.send.clicked.connect(self.transmit); self.input.returnPressed.connect(self.transmit) # Подключает кнопку запуска и остальные действия к обработчикам, сохраняя совместимость сигналов Qt 5 и Qt 6. self.hex_view.toggled.connect(self.render_all) # Меняет только представление уже принятых байтов. def refresh_devices(self): # Поиск выполняется только по явной кнопке пользователя. try: # Ошибка установки DLL должна быть видна на этой же странице. @@ -118,7 +118,7 @@ class UartUsbTerminal(QWidget): # Встраивается непосредст directory = QFileDialog.getExistingDirectory(self, 'Каталог бинарных журналов RX') # Пользователь явно определяет место длительной записи. if directory: self.directory = directory; self.record.setText('Запись RX: включена') # Отдельная подпапка и четыре bin файла создаются worker при START. def toggle(self): # Кнопка запуска меняет состояние только существующей сессии этой панели. - if self.worker and self.worker.isRunning(): self.worker.requestInterruption(); self.connect.setEnabled(False); return # Просит worker штатно завершить TX, STOP и закрытие файлов без блокирования GUI. + if self.worker and self.worker.isRunning(): self.worker.requestInterruption(); self.connect_button.setEnabled(False); return # Блокирует повторное отключение, пока worker штатно завершает TX, STOP и закрытие файлов без ожидания в GUI. if not self.devices.currentData(): self.refresh_devices() # Первый запуск помогает обнаружить устройство без дополнительного шага пользователя. if not self.devices.currentData(): return # Не создаёт worker с пустым либо выдуманным USB путём. try: rates = [int(rate.currentText()) for rate in self.rates] # Читает независимые скорости в битах в секунду перед фиксацией сессии. @@ -128,12 +128,12 @@ class UartUsbTerminal(QWidget): # Встраивается непосредст self.worker = UsbWorker(self.devices.currentData(), rates, self.directory, self) # Передаёт потоку неизменяемые параметры выбранного оборудования. self.worker.data_ready.connect(self.received); self.worker.stats_ready.connect(self.statistics); self.worker.status.connect(self.message.setText); self.worker.active.connect(self.started); self.worker.finished.connect(self.finished) # Все изменения виджетов выполняются через queued Qt сигналы GUI потока. for widget in [self.devices, self.refresh, self.record] + self.rates: widget.setEnabled(False) # Исключает изменение параметров уже открытого USB-сеанса. - self.connect.setText('Отключить'); self.message.setText('Подключение и настройка USART…'); self.worker.start() # Запускает ограниченные ожидания USB в фоне. + self.connect_button.setText('Отключить'); self.message.setText('Подключение и настройка USART…'); self.worker.start() # Переводит кнопку в режим отключения до начала фоновых ожиданий USB и подтверждений настройки. def started(self, channels): # Показывает возможности, которые реально подтвердила прошивка. self.send.setEnabled(True); self.message.setText('Захват активен: RX ' + str(channels) + ', TX только канал 1 / PA2') # Не разрешает TX до ACK команды START. for index, view in enumerate(self.views): view.setEnabled(index < channels) # Отражает сборки с двумя и тремя входами без ложного ожидания четырёх потоков. def finished(self): # Возвращает элементы управления только после закрытия USB и файлов worker. - self.send.setEnabled(False); self.connect.setEnabled(True); self.connect.setText('Запустить') # Завершённая сессия больше не принимает данные передатчика. + self.send.setEnabled(False); self.connect_button.setEnabled(True); self.connect_button.setText('Запустить') # После завершения сессии запрещает TX и возвращает доступную кнопку нового подключения. for widget in [self.devices, self.refresh, self.record] + self.rates: widget.setEnabled(True) # Разрешает выбор следующего устройства и независимых скоростей. self.worker.deleteLater(); self.worker = None # Освобождает завершённый QThread после обработки его последнего queued сигнала. def transmit(self): # Отправляет пользовательские данные только через единственный доступный TX. diff --git a/python/set_devices/sci_kernels/TI_LICENSE.json b/python/set_devices/sci_kernels/TI_LICENSE.json new file mode 100644 index 0000000..43b8e47 --- /dev/null +++ b/python/set_devices/sci_kernels/TI_LICENSE.json @@ -0,0 +1,4 @@ +{ + "source": "TI C2000Ware f28335_flash_kernel", + "license_notice": "//###########################################################################\n//\n// FILE:\tmain.c\n//\n// TITLE:\tF28335 Flash Kernel Example\n//\n//! \\addtogroup f2833x_example_list\n//!

F28335 Flash Kernel (f28335_flash_kernel)

\n//!\n//! This example is for use with the SerialLoader2000 utility. This\n//! application is intended to be loaded into the device's RAM via the\n//! SCI boot mode. After successfully loaded this program implements a\n//! modified version of the SCI boot protocol that allows a user application\n//! to be programmed into flash\n//\n//###########################################################################\n// $TI Release: $\n// $Release Date: $\n// $Copyright:\n// Copyright (C) 2009-2024 Texas Instruments Incorporated - http://www.ti.com/\n//\n// Redistribution and use in source and binary forms, with or without \n// modification, are permitted provided that the following conditions \n// are met:\n// \n// Redistributions of source code must retain the above copyright \n// notice, this list of conditions and the following disclaimer.\n// \n// Redistributions in binary form must reproduce the above copyright\n// notice, this list of conditions and the following disclaimer in the \n// documentation and/or other materials provided with the \n// distribution.\n// \n// Neither the name of Texas Instruments Incorporated nor the names of\n// its contributors may be used to endorse or promote products derived\n// from this software without specific prior written permission.\n// \n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \n// \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \n// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \n// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \n// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \n// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \n// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \n// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n// $" +} diff --git a/python/set_devices/sci_kernels/catalog.json b/python/set_devices/sci_kernels/catalog.json new file mode 100644 index 0000000..d832e52 --- /dev/null +++ b/python/set_devices/sci_kernels/catalog.json @@ -0,0 +1,30 @@ +{ + "schema": 1, + "target": "TMS320F28335", + "kernels": [ + { + "file": "f28335_20mhz.bin", + "oscillator_hz": 20000000, + "size_bytes": 5788, + "sha256": "5046fa4b2903974d73046d5e66c13a4cfdbdf16ac072cfbf8ba17e4c3f7b4143", + "verify": "readback-v1", + "sectors": "header-sm1" + }, + { + "file": "f28335_25mhz.bin", + "oscillator_hz": 25000000, + "size_bytes": 5788, + "sha256": "03e32cda9105b9a3d458dc2500b9a44807d8293fe46c2b7aef9400e4294d8f31", + "verify": "readback-v1", + "sectors": "header-sm1" + }, + { + "file": "f28335_30mhz.bin", + "oscillator_hz": 30000000, + "size_bytes": 5792, + "sha256": "fef8d88d96fe9d18b356dbddf10f5824b14ef45eae55d69ff74482e23a25f9a8", + "verify": "readback-v1", + "sectors": "header-sm1" + } + ] +} diff --git a/python/set_devices/sci_kernels/f28335_20mhz.bin b/python/set_devices/sci_kernels/f28335_20mhz.bin new file mode 100644 index 0000000..2d87b7d Binary files /dev/null and b/python/set_devices/sci_kernels/f28335_20mhz.bin differ diff --git a/python/set_devices/sci_kernels/f28335_25mhz.bin b/python/set_devices/sci_kernels/f28335_25mhz.bin new file mode 100644 index 0000000..e650c2c Binary files /dev/null and b/python/set_devices/sci_kernels/f28335_25mhz.bin differ diff --git a/python/set_devices/sci_kernels/f28335_30mhz.bin b/python/set_devices/sci_kernels/f28335_30mhz.bin new file mode 100644 index 0000000..e3a19eb Binary files /dev/null and b/python/set_devices/sci_kernels/f28335_30mhz.bin differ diff --git a/python/tests/test_c2000_sci.py b/python/tests/test_c2000_sci.py index 7921828..0834ce8 100644 --- a/python/tests/test_c2000_sci.py +++ b/python/tests/test_c2000_sci.py @@ -10,9 +10,11 @@ def sci8(address, words): # Готовит минимальную адресн @pytest.mark.parametrize("words", [1, 1024, 1025, 2048, 2050]) # Границы проверяют обычную порцию, остаток и дополнительный нулевой ACK официального TI kernel. -def test_complete_echo_and_checksum_transcript(words): # Фактические ответы подтверждают порядок и неизменность всего приложения. +@pytest.mark.parametrize('verify', [False, True]) # Каждый размер проверяется и в прежнем протоколе, и с обязательным чтением реальной Flash. +def test_complete_echo_and_checksum_transcript(words, verify): # Фактические ответы подтверждают полный порядок записи и выбранной проверки. kernel, image = sci8(0x9000, [0x1234, 0x5678]), sci8(0x328000, [0xA55A] * words) # RAM-ядро и Flash занимают разные разрешённые области. - session, received, pauses, zero_acks = Session(kernel, image), bytearray(), [], 0 # Наблюдения не используют внутреннюю структуру C-контекста. + if verify: kernel = kernel[:2] + b'VR\x01\x00' + kernel[6:] # Независимый эталон объявляет VR1 в резерве транспортного RAM-ядра. + session, received, pauses, zero_acks = Session(kernel, image, verify=verify), bytearray(), [], 0 # Использует настоящее C-ядро, включая проверку его возможностей до UART. for _ in range(len(kernel) + words + 100): # Конечный предел выявляет зацикливание автомата. state, tx, expected, delay = session.next() # Проверяет настоящий сформированный C-пакет. if state == 0: break # Успех допустим лишь после отправки нулевого терминатора приложения. @@ -20,10 +22,10 @@ def test_complete_echo_and_checksum_transcript(words): # Фактические if expected == 1: session.accept(tx) # ROM и autobaud должны вернуть точное эхо отправленного октета. else: # Kernel A подтверждает сумму октетов после erase/program, без побайтового эха приложения. received.extend(tx) # Снимок подтверждает отсутствие пропущенных, повторённых либо изменённых октетов SCI8. - if expected: session.accept(struct.pack(" 2 else b'') + struct.pack(" 1024 and words % 1024 == 0) # Обрабатывает особенность исходного TI Kernel A на кратной порции. @@ -49,3 +51,28 @@ def test_ascii_decode_memory_ranges_and_monitor_command(): # Проверяет with pytest.raises(ValueError): validate(sci8(0x33FFF8, [0x1234])) # Область CSM-паролей запрещена независимо от имени файла. with pytest.raises(ValueError): validate(sci8(0x8000, [0x1234])) # RAM-образ не может стать Flash-приложением из-за выбранного loader. assert ulitco_enter() == bytes([247, 213, 255, 93, 0, 0, 1, 0, 93, 1]) # Эталон совпадает с десятиоктетным Monitor-запросом FLASH_NUM=93 текущей прошивки UlitCo. + + +@pytest.mark.parametrize('fault', ['first', 'last', 'checksum', 'short']) # Повреждение данных, checksum и неполный ответ проверяются независимо друг от друга. +def test_verify_rejects_faults_in_later_noncontiguous_section(fault): # Адрес ошибки должен учитывать LOAD следующей секции и смещение после полного 1024-словного буфера. + kernel = sci8(0x9000, [1]); kernel = kernel[:2] + b'VR\x01\x00' + kernel[6:] # Минимальное ядро объявляет обязательный формат чтения VR1. + first, second = sci8(0x328000, [0x1234]), sci8(0x330100, [0xA55A] * 1025) # Разрыв между секциями выявляет ошибочное продолжение счётчика адресов первой секции. + session = Session(kernel, first[:-2] + second[22:], verify=True) # Оба блока проходят настоящую проверку Flash-адресов C-ядра. + while True: # Доходит до однословного остатка второй секции по публичному контракту обмена. + state, tx, expected, _ = session.next() # Размер ответа определяет физические данные и checksum без чтения структуры контекста. + if state == 2: continue # Обязательные паузы TI не требуют аппаратного ожидания в тесте. + if expected == 1: session.accept(tx); continue # ROM и autobaud возвращают точное эхо. + reply = (tx[-(expected - 2):] if expected > 2 else b'') + struct.pack('restore_dock(); +- PopupDlgList::SetCurrentScreen(QGuiApplication::primaryScreen()); ++ auto dialogs = new setgui::HostDialogPlacement(this, parent); // Диалоги получают владельца текущего плавающего окна вместо привязки к основному монитору. + QByteArray commandBuffer; +- auto fit = [this, parent, child, parentPid, commandBuffer]() mutable { ++ auto fit = [this, parent, child, parentPid, dialogs, commandBuffer]() mutable { // Существующий таймер также отслеживает смену монитора и владельца открытых настроек. + DWORD currentPid = 0; + GetWindowThreadProcessId(parent, ¤tPid); + if (!IsWindow(parent) || currentPid != parentPid) { +@@ -732,6 +733,7 @@ bool MainFrame::ShowEmbedded(quintptr parentId) + qApp->quit(); + return; + } ++ dialogs->refresh(); // Переносим открытые настройки только при фактической смене экрана или отделении DSView. + DWORD available = 0; + const HANDLE input = GetStdHandle(STD_INPUT_HANDLE); + if (PeekNamedPipe(input, NULL, 0, NULL, &available, NULL) && available) { diff --git a/tools/dsview/native/host_dialogs.h b/tools/dsview/native/host_dialogs.h new file mode 100644 index 0000000..401c43d --- /dev/null +++ b/tools/dsview/native/host_dialogs.h @@ -0,0 +1,93 @@ +#pragma once // Заголовок подключается один раз независимо от порядка включения исходников встроенного DSView. +#include // Фильтр видит только диалоги текущего процесса DSView. +#include // Настройки и сообщения отделяются от меню, осциллограмм и других самостоятельных окон. +#include // Первое размещение выполняется после события показа диалога. +#include // Отложенная операция не обращается к уже закрытому окну настроек. +#include // Видимые диалоги упорядочиваются от родительских настроек к вложенным подтверждениям. +#include // Геометрия сохраняет отрицательные координаты мониторов слева и сверху от основного. +#include // Нулевая задержка ждёт завершения автоматического размещения окна средствами Qt. +#include // Стабильная сортировка исключает зависимость размещения вложенных окон от порядка topLevelWidgets. +#ifdef Q_OS_WIN // Нативное встраивание DSView и владение окном SETGUI относятся к Windows. +#include // HWND, монитор и рабочая область определяются фактическим окном родителя другого процесса. +#endif // На остальных ОС заголовок не подключает функции WinAPI. + +namespace setgui { // Средства интеграции не меняют контракты самостоятельного приложения DSView. +inline QRect host_dialog_geometry(const QRect &anchor, const QRect &work, const QSize &requested) { // Один расчёт применяется к реальным окнам и проверкам нескольких мониторов. + const QSize size(qMin(requested.width(), work.width()), qMin(requested.height(), work.height())); // Диалог ограничивается доступной областью текущего монитора в физических пикселях Windows. + const QPoint center = anchor.center(); // Настройки появляются над анализатором, а не в центре основного экрана компьютера. + const int x = qBound(work.left(), center.x() - size.width() / 2, work.right() - size.width() + 1); // Горизонтальная граница учитывает отрицательные координаты и включительный правый край QRect. + const int y = qBound(work.top(), center.y() - size.height() / 2, work.bottom() - size.height() + 1); // Вертикальная граница оставляет заголовок над рабочей областью, не закрывая его панелью задач. + return QRect(QPoint(x, y), size); // Готовая область описывает положение и размер одного плавающего диалога. +} // Перенос не зависит от сохранённых координат и прежнего монитора DSView. + +#ifdef Q_OS_WIN // Владельцем диалогов становится верхнеуровневое окно SETGUI на текущем экране анализатора. +class HostDialogPlacement : public QObject { // QObject без Q_OBJECT не требует дополнительного шага moc при сборке рецепта. + HWND _surface; // Постоянный HWND области захвата сохраняется при отделении DSView и возврате во вкладку. + HWND _root = nullptr; // Верхнеуровневое окно меняется при переносе области в плавающую панель SETGUI. + HMONITOR _monitor = nullptr; // Монитор отслеживается по нативной иерархии, а не по устаревшему QWindow встроенного DSView. + QTimer _watch; // Отдельный таймер продолжает отслеживать экран во время модального exec, открытого внутри обработчика команд основного hostTimer. + + static int depth(QWidget *widget) { // Родительские диалоги должны перемещаться раньше вложенных подтверждений. + int count = 0; // Число предков описывает только глубину Qt-иерархии, не экран или размер окна. + for (; widget; widget = widget->parentWidget()) ++count; // Обычные QWidget между диалогами также сохраняют правильный порядок родителей и потомков. + return count; // Корневой диалог всегда расположен выше своего вложенного окна в порядке перемещения. + } // Расчёт выполняется только при смене монитора или нативного владельца. + + void place(QDialog *dialog) { // Вызывается только для реально видимого окна настроек текущего процесса DSView. + if (!dialog || !dialog->isVisible() || !_root || !IsWindow(_root)) return; // Закрытые диалоги и исчезнувший хост не получают новые нативные связи. + const HWND window = reinterpret_cast(dialog->winId()); // Получаем собственное верхнеуровневое окно Qt после его показа. + if (GetWindowLongPtr(window, GWL_STYLE) & WS_CHILD) return; // Встроенный QMessageBox внутри составного диалога не переносится отдельно от своего содержимого. + HWND anchor = _root; // Обычные настройки размещаются над текущим основным или отделённым окном анализатора. + for (QWidget *parent = dialog->parentWidget(); parent; parent = parent->parentWidget()) { // Вложенное подтверждение должно оставаться поверх уже открытых настроек. + if (qobject_cast(parent) && parent->isVisible()) { anchor = reinterpret_cast(parent->winId()); break; } // Ближайший видимый диалог сохраняет естественную цепочку модальных окон. + } // Обычные QWidget между диалогом и DSView не подменяют владельца плавающего окна. + SetWindowLongPtr(window, GWLP_HWNDPARENT, reinterpret_cast(anchor)); // Связь владельца удерживает настройки над анализатором, не превращая их в дочернюю вкладку или глобально верхнее окно. + RECT host_rect, dialog_rect; // WinAPI возвращает физические координаты обоих окон в одном пространстве нескольких мониторов. + MONITORINFO info = {}; info.cbSize = sizeof(info); // Размер структуры обязателен для чтения рабочей области без панели задач. + const HMONITOR monitor = MonitorFromWindow(_root, MONITOR_DEFAULTTONEAREST); // Экран выбирается по текущему положению анализатора даже после перемещения между мониторами. + if (!GetMonitorInfo(monitor, &info) || !GetWindowRect(anchor, &host_rect) || !GetWindowRect(window, &dialog_rect)) return; // При недоступной геометрии сохраняем безопасную связь владельца без произвольного переноса. + const QRect host(host_rect.left, host_rect.top, host_rect.right - host_rect.left, host_rect.bottom - host_rect.top); // Область владельца используется как центр размещения настроек. + const QRect work(info.rcWork.left, info.rcWork.top, info.rcWork.right - info.rcWork.left, info.rcWork.bottom - info.rcWork.top); // Доступная область относится к фактическому монитору SETGUI или отделённого DSView. + const QRect bounds = host_dialog_geometry(host, work, QSize(dialog_rect.right - dialog_rect.left, dialog_rect.bottom - dialog_rect.top)); // Единый расчёт ограничивает окно целиком текущим монитором. + SetWindowPos(window, nullptr, bounds.x(), bounds.y(), bounds.width(), bounds.height(), SWP_NOZORDER | SWP_NOACTIVATE); // Перемещаем диалог после автоматического центрирования Qt, не перехватывая фокус и не делая его глобально верхним. + } // Пользователь может перемещать плавающее окно вручную после начального размещения. + +public: // Родитель-владелец задаётся существующим MainFrame встроенного DSView. + HostDialogPlacement(QObject *parent, HWND surface) : QObject(parent), _surface(surface), _watch(this) { // Область SETGUI уже проверена ShowEmbedded перед установкой фильтра. + _watch.setInterval(100); // Проверка каждые 100 миллисекунд работает только при открытых диалогах и сохраняет отзывчивость при переносе между экранами. + connect(&_watch, &QTimer::timeout, this, [this]() { // Модальный цикл Qt блокирует повторный timeout открывшего его hostTimer, поэтому здесь требуется независимый источник событий. + for (QWidget *widget : QApplication::topLevelWidgets()) { // Наличие видимых настроек проверяется без перечисления всех дочерних контролов DSView. + if (qobject_cast(widget) && widget->isVisible()) { refresh(); return; } // Пока настройки открыты, следим за реальным монитором и владельцем анализатора. + } // После закрытия последнего окна настроек дополнительное наблюдение больше не требуется. + _watch.stop(); // В обычной работе без диалогов новый периодический опрос отсутствует. + }); // Родитель MainFrame отменяет таймер вместе с фильтром при завершении встроенного DSView. + qApp->installEventFilter(this); // Все настройки DSView обрабатываются одним правилом независимо от конкретного анализатора. + refresh(); // Запоминаем текущего владельца и монитор до первого открытия настроек. + } // Уничтожение QObject автоматически снимает фильтр приложения и отменяет отложенные действия. + + void refresh() { // Существующий hostTimer и наблюдение открытых настроек используют один проверяемый маршрут обновления. + const HWND root = IsWindow(_surface) ? GetAncestor(_surface, GA_ROOT) : nullptr; // Корневой HWND следует за отделением, закреплением и переносом SETGUI. + const HMONITOR monitor = root ? MonitorFromWindow(root, MONITOR_DEFAULTTONEAREST) : nullptr; // Один дескриптор монитора обнаруживает реальную смену экрана. + if (root == _root && monitor == _monitor) return; // Ручное перемещение настроек не отменяется каждым тактом таймера. + _root = root; _monitor = monitor; // Обновляем положение владельца до переноса уже открытых диалогов. + QList> dialogs; // Безопасные указатели исключают обращение к подтверждению, которое могло закрыться при перемещении родителя. + for (QWidget *widget : QApplication::topLevelWidgets()) { // Просматриваем только окна собственного процесса DSView. + if (auto dialog = qobject_cast(widget)) dialogs.append(QPointer(dialog)); // Осциллограммы, меню и окна других приложений не участвуют в перемещении. + } // Порядок topLevelWidgets сам по себе не определяет отношения между родителями и потомками. + std::stable_sort(dialogs.begin(), dialogs.end(), [](const QPointer &left, const QPointer &right) { return depth(left.data()) < depth(right.data()); }); // Сначала переносим настройки, затем центрируем вложенные подтверждения над их новым положением. + for (const auto &dialog : dialogs) place(dialog.data()); // При фактической смене экрана все открытые настройки получают согласованные координаты. + } // Встроенный MainFrame больше не должен ошибочно считать основным монитором экран компьютера по умолчанию. + + bool eventFilter(QObject *watched, QEvent *event) override { // После первого показа Qt мог использовать координаты невидимого встроенного MainFrame. + if (event->type() == QEvent::Show) { // Переразмещение выполняется один раз на показ, а не при каждом движении пользователя. + if (auto dialog = qobject_cast(watched)) { // Фильтр не затрагивает раскрывающиеся меню и самостоятельные графики DSView. + _watch.start(); // С этого показа перенос между экранами обслуживается также внутри модального exec диалога. + const QPointer guarded(dialog); // Диалог может закрыться раньше выполнения отложенного события. + QTimer::singleShot(0, this, [this, guarded]() { if (guarded) { refresh(); place(guarded.data()); } }); // Сначала обновляем экран хоста, затем исправляем окончательное положение показанного окна. + } // Вложенные подтверждения получают своего видимого родителя тем же способом. + } // Все обычные события ввода и обработки диалогов остаются у Qt. + return false; // Фильтр меняет только размещение и никогда не подавляет модальный цикл, сохранение или закрытие настроек. + } // Правило применяется только к экземпляру, запущенному через --embed-parent. +}; // MainFrame владеет фильтром на протяжении одной встроенной сессии DSView. +#endif // Самостоятельный DSView на других платформах сохраняет исходное поведение своих диалогов. +} // Пространство имён отделяет интеграцию SETGUI от библиотек и диалогов DSView. diff --git a/tools/dsview/tests/check_host_dialogs.cpp b/tools/dsview/tests/check_host_dialogs.cpp new file mode 100644 index 0000000..7b252d8 --- /dev/null +++ b/tools/dsview/tests/check_host_dialogs.cpp @@ -0,0 +1,49 @@ +#include // Проверка использует тот же Qt 5, которым собран встроенный DSView. +#include // Настройки моделируются настоящими верхнеуровневыми окнами Qt. +#include // Доступные мониторы позволяют проверить реальный перенос, если компьютер имеет несколько экранов. +#include // Короткие интервалы дают завершиться отложенному размещению окна. +#include // Результат геометрических и нативных проверок выводится без графических предупреждений. +#include "../native/host_dialogs.h" // Подключаем каноническую реализацию, которая копируется в MainFrame при сборке DSView. + +static void events() { // Отложенный Show обрабатывается тем же циклом событий, что в настоящем приложении. + for (int i = 0; i < 40; ++i) { QApplication::processEvents(); QThread::msleep(5); } // Сорок интервалов по 5 миллисекунд дают отработать наблюдению открытых диалогов с периодом 100 миллисекунд. +} // Проверка не запускает аппаратные драйверы или захват DSView. + +static bool placed(QDialog &dialog, HWND anchor, HWND host) { // Фактические HWND проверяют владельца, рабочую область и положение диалога. + const HWND window = reinterpret_cast(dialog.winId()); // Дескриптор принадлежит только окну, созданному текущей проверкой. + if (GetWindow(window, GW_OWNER) != anchor) return false; // Настройки должны оставаться поверх своего анализатора или родительского диалога. + RECT rect, owner; MONITORINFO info = {}; info.cbSize = sizeof(info); // Геометрия WinAPI задаётся в одной системе физических пикселей. + if (!GetWindowRect(window, &rect) || !GetWindowRect(anchor, &owner) || !GetMonitorInfo(MonitorFromWindow(host, MONITOR_DEFAULTTONEAREST), &info)) return false; // Недоступные дескрипторы считаются неуспешным результатом проверки. + const QRect bounds(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top); // Фиксируем окончательное положение уже показанного диалога. + const QRect work(info.rcWork.left, info.rcWork.top, info.rcWork.right - info.rcWork.left, info.rcWork.bottom - info.rcWork.top); // Панель задач исключена из допустимой области настроек. + const QRect expected = setgui::host_dialog_geometry(QRect(owner.left, owner.top, owner.right - owner.left, owner.bottom - owner.top), work, bounds.size()); // Проверяем центрирование относительно фактического владельца. + return work.contains(bounds) && (bounds.topLeft() - expected.topLeft()).manhattanLength() <= 2; // Погрешность до двух физических пикселей допускает округление рамки Windows. +} // Произвольный перенос на основной экран вместо монитора хоста не удовлетворяет этому контракту. + +int main(int argc, char **argv) { // Один самостоятельный процесс проверяет реальную интеграцию окон без открытого SETGUI. + QApplication app(argc, argv); // Нативные Qt-окна доступны только после создания приложения. + const QRect work(-1920, -1080, 1920, 1040); // Синтетический экран расположен слева и сверху от основного, а нижние 40 пикселей зарезервированы под панель задач. + const QRect negative = setgui::host_dialog_geometry(QRect(-1800, -980, 1100, 700), work, QSize(640, 480)); // Расчёт не должен ошибочно ограничивать координаты нулём. + if (!work.contains(negative) || negative.x() >= 0 || negative.y() >= 0) return 1; // Диалог обязан остаться внутри текущего экрана с отрицательными координатами. + if (setgui::host_dialog_geometry(QRect(-100, -100, 200, 200), work, QSize(4000, 3000)) != work) return 2; // Слишком большое окно ограничивается рабочей областью того же монитора. + QWidget host; host.resize(1000, 700); host.move(QApplication::primaryScreen()->availableGeometry().topLeft() + QPoint(50, 50)); host.show(); // Собственное окно моделирует основное или отделённое окно SETGUI. + QWidget surface(&host); surface.resize(900, 600); surface.show(); // Постоянная нативная область соответствует DSViewTab.surface. + QWidget frame(nullptr, Qt::Tool | Qt::FramelessWindowHint); frame.resize(900, 600); frame.show(); // Отдельный Qt-процесс DSView также изначально создаёт собственное верхнеуровневое окно. + const HWND child = reinterpret_cast(frame.winId()), parent = reinterpret_cast(surface.winId()); // Оба дескриптора принадлежат только текущему проверочному процессу. + SetWindowLongPtr(child, GWL_STYLE, WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS); SetParent(child, parent); // Воспроизводим нативное встраивание ShowEmbedded без изменения QObject-иерархии Qt. + setgui::HostDialogPlacement placement(&frame, parent); // Используем реальный фильтр будущей сборки DSView. + QDialog dialog(&frame, Qt::Dialog | Qt::FramelessWindowHint); dialog.resize(460, 320); dialog.show(); events(); // Настройки автоматически получают нового владельца после исходного размещения Qt. + const HWND root = GetAncestor(parent, GA_ROOT); // Владельцем настроек должен стать верхний HWND текущего окна SETGUI. + if (!placed(dialog, root, root)) return 3; // Проверяем фактическое владение и видимую геометрию первого диалога. + QDialog nested(&dialog, Qt::Dialog | Qt::FramelessWindowHint); nested.resize(300, 180); nested.show(); events(); // Подтверждение поверх настроек не должно уходить за главное окно. + if (!placed(nested, reinterpret_cast(dialog.winId()), root)) return 4; // Ближайший открытый диалог сохраняет естественную цепочку владельцев. + const auto screens = QApplication::screens(); // Реальный многомониторный сценарий включается, если оборудование его поддерживает. + if (screens.size() > 1) { // Одномониторный компьютер по-прежнему проверяет синтетические отрицательные координаты выше. + host.move(screens.last()->availableGeometry().topLeft() + QPoint(50, 50)); events(); // Уже открытые настройки должны следовать за фактическим монитором владельца без ручного вызова refresh из проверки. + if (!placed(dialog, GetAncestor(parent, GA_ROOT), GetAncestor(parent, GA_ROOT))) return 5; // После переноса проверяем новые физические координаты и прежнее отношение владения. + if (!placed(nested, reinterpret_cast(dialog.winId()), GetAncestor(parent, GA_ROOT))) return 6; // Уже открытое вложенное подтверждение также остаётся над перемещёнными настройками на новом экране. + } // Пользовательское перемещение диалога внутри одного экрана не отменяется регулярным опросом. + nested.close(); dialog.close(); frame.hide(); host.close(); // Закрываем только собственные окна и освобождаем фильтр после завершения всех проверок. + std::printf("PASS host dialogs; screens=%d; negative coordinates and nested ownership checked\n", screens.size()); // Число экранов делает границы нативной проверки явными в журнале. + return 0; // Успех означает корректное размещение, владение и сохранение экранных границ. +} // Внешние приложения, приборы и пользовательские записи во время проверки не затрагиваются. diff --git a/tools/dsview/zynq-ethernet/build.py b/tools/dsview/zynq-ethernet/build.py index 01f866d..79838e4 100644 --- a/tools/dsview/zynq-ethernet/build.py +++ b/tools/dsview/zynq-ethernet/build.py @@ -13,6 +13,8 @@ def main(): parser.add_argument('--output', type=Path, required=True) parser.add_argument('--msys-root', type=Path, required=True) parser.add_argument('--recipe', type=Path, default=HERE.parent) + parser.add_argument('--win7', action='store_true') # Вариант Ethernet должен сохранить тот же совместимый Python, что базовый компонент DSView. + parser.add_argument('--python-root', type=Path) # Явная установка Python 3.8 передаётся каноническому рецепту без подмены ABI. args = parser.parse_args() source, output, recipe = (p.resolve() for p in (args.source, args.output, args.recipe)) @@ -32,7 +34,7 @@ def main(): subprocess.run([sys.executable, str(recipe / 'build.py'), '--source', str(source), '--extra-patch', str(HERE / 'ethernet.patch'), - '--output', str(output), '--msys-root', str(args.msys_root.resolve())], check=True) + '--output', str(output), '--msys-root', str(args.msys_root.resolve()), *(['--win7', '--python-root', str(args.python_root.resolve())] if args.win7 and args.python_root else [])], check=True) # Современная сборка сохраняет прежнюю команду, Win7 получает отдельный набор параметров. source_files = output / 'zynq-source' source_files.mkdir(exist_ok=True) for path in (*inputs, HERE / 'ethernet.patch'): diff --git a/tools/pdf-scan-to-vector/.gitignore b/tools/pdf-scan-to-vector/.gitignore new file mode 100644 index 0000000..832b1b0 --- /dev/null +++ b/tools/pdf-scan-to-vector/.gitignore @@ -0,0 +1,9 @@ +.venv/ +build/ +dist/ +__pycache__/ +*.py[cod] +.pytest_cache/ +verification-output/ +tmp/ +*.log diff --git a/tools/pdf-scan-to-vector/PDFScanToVector.spec b/tools/pdf-scan-to-vector/PDFScanToVector.spec new file mode 100644 index 0000000..8db2bbd --- /dev/null +++ b/tools/pdf-scan-to-vector/PDFScanToVector.spec @@ -0,0 +1,39 @@ +from pathlib import PureWindowsPath # Сравниваем имена DLL независимо от разделителей путей в таблице сборки. +import os # Отдельный вариант компонента сохраняет исходную автономную сборку одним EXE. +component = os.environ.get("PDF_SCAN_COMPONENT") == "1" # Onedir запускает один процесс с HWND, чей PID совпадает с QProcess SETGUI. + +analysis = Analysis( # Собираем зависимости единственной точки входа приложения. + ["app.py"], # Точка входа поддерживает GUI, дочерний обработчик и встроенную самопроверку. + pathex=[], # Импортируем модули из проекта без внешних дополнительных каталогов. + binaries=[], # Нативные библиотеки Qt, OpenCV и MuPDF собираются штатными хуками PyInstaller. + datas=[("assets", "assets")], # Языковые модели OCR, их лицензия и значок входят в автономный EXE. + hiddenimports=[], # Рабочие модули импортируются явно и доступны обычному анализу зависимостей. + hookspath=[], # Не используем локальные подмены стандартных правил упаковки библиотек. + hooksconfig={}, # Оставляем стандартную конфигурацию поддерживаемых PyInstaller компонентов. + runtime_hooks=[], # Инициализация Qt и multiprocessing выполняется штатными хуками упаковщика. + excludes=["tkinter", "matplotlib", "pandas", "scipy", "IPython"], # Исключаем необязательные пакеты системного Python, не используемые приложением. + noarchive=False, # Упаковываем Python-модули в сжатый внутренний архив. + optimize=0, # Сохраняем проверки assert встроенного сценария самопроверки EXE. +) # Завершаем анализ Python-модулей, ресурсов и связанных DLL. +system_icu = {"icuuc.dll", "icudt78.dll"} # Qt использует системный ICU Windows; одноимённый ICU 78 из Poppler имеет несовместимые имена экспортируемых функций. +analysis.binaries = [entry for entry in analysis.binaries if PureWindowsPath(entry[0]).name.lower() not in system_icu] # Не включаем посторонний ICU из PATH: приложение использует штатную библиотеку Windows 10/11. +archive = PYZ(analysis.pure) # Создаём сжатый архив чистых Python-модулей после завершения анализа. +executable = EXE( # Формируем один переносимый Windows EXE с библиотеками и данными внутри. + archive, # Включаем скомпилированные модули приложения и необходимых Python-пакетов. + analysis.scripts, # Добавляем точку входа и штатные загрузочные сценарии PyInstaller. + [] if component else analysis.binaries, # В компоненте DLL собираются рядом с EXE, а в обычной поставке остаются внутри него. + [] if component else analysis.datas, # Внешний комплект хранит модели OCR и ресурсы в собственной папке _internal. + [], # Дополнительные неанализируемые входные объекты для этой сборки не нужны. + name="PDFScanToVector", # Стабильное имя файла позволяет обновлять приложение простой заменой EXE. + exclude_binaries=component, # Компонент обходится без промежуточного процесса распаковки onefile. + debug=False, # Обычный пользователь не нуждается в подробных сообщениях загрузчика. + bootloader_ignore_signals=False, # Сохраняем стандартную обработку завершения процесса Windows. + strip=False, # Не изменяем структуру поставляемых сторонними пакетами нативных библиотек. + upx=False, # Не используем внешнее переупаковывание DLL, чтобы избежать повреждения Qt-плагинов. + runtime_tmpdir=None, # Используем штатную пользовательскую временную папку Windows. + console=False, # Главное приложение открывается без отдельного консольного окна. + disable_windowed_traceback=False, # При раннем сбое до GUI сохраняем штатное диагностическое сообщение загрузчика. + icon=["assets/app.ico"], # Значок с документом и векторными узлами встраивается в EXE. +) # Завершаем описание автономной сборки. +if component: # Обычный запуск исходного сборщика по-прежнему выдаёт единственный переносимый EXE. + distribution = COLLECT(executable, analysis.binaries, analysis.datas, strip=False, upx=False, name="PDFScanToVector") # Собираем независимую папку с собственными Qt, MuPDF, OpenCV и моделями OCR. diff --git a/tools/pdf-scan-to-vector/README.md b/tools/pdf-scan-to-vector/README.md new file mode 100644 index 0000000..ee24f08 --- /dev/null +++ b/tools/pdf-scan-to-vector/README.md @@ -0,0 +1,68 @@ +# PDF Scan to Vector + +Настольное приложение Windows с оформлением в стиле SETGUI. Преобразует скановые PDF в чёрно-белые векторные контуры и распознаёт русский и английский текст локально на компьютере. + +## Запуск EXE + +Откройте `dist\PDFScanToVector.exe`. Установка Python, Tesseract и доступ к интернету для работы не требуются. При первом запуске единственный EXE распаковывает встроенные библиотеки во временную папку; это может занять несколько секунд. Сборка предназначена для 64-разрядных Windows 10/11. + +1. Нажмите «Открыть PDF…» или перетащите PDF в окно. Кнопка «Пример» открывает встроенный тестовый скан. +2. Выберите режим, язык и разрешение. По умолчанию: векторизация с OCR, русский и английский, 300 DPI. +3. При необходимости задайте страницы, например `1-3, 5`, и поворот по часовой стрелке. +4. Нажмите «Преобразовать документ». Результат, текст выбранной страницы и журнал доступны в отдельных вкладках. +5. Нажмите «Сохранить PDF…». Дополнительно можно сохранить весь распознанный текст в TXT UTF-8 и векторные страницы в ZIP с SVG. + +Исходный файл сохраняется. Повторный запуск использует текущие параметры, поэтому после их изменения необходимо снова нажать кнопку преобразования. Отмена выполняется между этапами: запущенный этап OCR должен завершиться. При закрытии окна рабочий процесс завершается вместе с приложением. + +## Режимы + +| Режим | Графика результата | Текст | +| --- | --- | --- | +| Вектор + распознанный текст | Чёрно-белые заполненные контуры, без растровых изображений | Невидимый слой для поиска, выделения и копирования | +| Вектор + обычный текст | Векторная графика; отделимые распознанные буквы заменены шрифтом | Видимый Unicode-текст для поиска, выделения, копирования и правки в PDF-редакторе | +| Только векторизация | Чёрно-белые заполненные контуры | Без OCR | +| Скан + распознанный текст | Цветное изображение страницы с выбранным разрешением | Невидимый слой для поиска, выделения и копирования | + +Обычная векторизация восстанавливает линии и буквы заполненными контурами. Если буквы выглядят угловатыми, выберите «Вектор + обычный текст»: приложение записывает распознанные слова видимым встроенным шрифтом с кириллицей, подгоняя размер и ширину под исходные надписи. Шрифт может отличаться от оригинального. Нераспознанные подписи и слова, слившиеся с проводниками, остаются контурами; число замен видно в журнале. Проверьте вкладку «Текст OCR», поскольку ошибочно распознанное слово в этом режиме становится видимым. Векторизация не восстанавливает CAD-объекты и структуру таблиц. Для фотографий, цветных печатей и оттенков используйте «Скан + распознанный текст». Рукописный текст не является целевым сценарием. + +Профиль «Улучшенное · схемы и сканы» включён по умолчанию: выравнивает фон бумаги и убирает длинные горизонтальные и вертикальные линии из копии для OCR. Графика результата строится по оригиналу, поэтому подготовка не удаляет проводники из выходного PDF. Для сравнения доступен профиль «Исходное · без подготовки». На мелких подписях попробуйте 400–600 DPI и один язык, если документ не содержит второго. Повышение разрешения не восстанавливает детали, которых нет в исходном скане. + +Если страница содержит готовые текстовые надписи и не содержит изображений, приложение переносит исходный текст в поисковый слой вместо повторного OCR. Это сохраняет мелкие подписи чертежей, которые распознавание может прочитать неверно. Для старых шрифтов ГОСТ с именем `GOST…` восстанавливается кириллица, ошибочно записанная как Latin-1 вместо Windows-1251 (например, `Àâàðèÿ` становится `Авария`). Положение надписей и повороты сохраняются; исходный PDF не изменяется. Растровые и смешанные страницы проходят OCR. В режиме «Только векторизация» текстового слоя нет. + +Большие листы ограничиваются 45 миллионами пикселей: приложение автоматически снижает фактическое разрешение, чтобы ограничить расход памяти. Это разрешение видно в журнале и отчёте проверки. + +## Настройки векторизации + +- **Порог чёрного:** 0 — автоматический метод Оцу; 1–254 — ручной уровень серого. Больший порог помогает сохранить бледные линии и одновременно может добавить шум. +- **Удаление пыли:** минимальная площадь внешнего пятна в квадратных пикселях при 300 DPI. Ноль сохраняет все компоненты. Белые отверстия букв сохраняются независимо от этого фильтра. +- **Упрощение:** допустимое отклонение границы в пикселях при 300 DPI. Меньшее значение сохраняет больше узлов; большее уменьшает размер геометрии. +- **Масштаб просмотра:** Ctrl+колесо, кнопки «+», «−», «По размеру»; увеличенный лист можно перемещать мышью. + +## Исходники и повторная сборка + +### Подключение к SETGUI + +Программа подключается отдельным процессом во вкладке «Инструменты → PDF Scan to Vector». Исходный комплект размещается в существующем сабмодуле `templates`, каталог `tools/pdf-scan-to-vector`; дополнительный сабмодуль не требуется. Подготовленные файлы интеграции находятся в `integration/setgui`, сценарий `integration/apply.py` проверяет и применяет точечные изменения соседних SETGUI и templates, сохраняя резервную копию изменённых файлов. + +В SETGUI первая сборка выполняется через `buildb_bat\BUILD_PDF_VECTOR.bat --setup`, последующие — без `--setup`. Для неё используется отдельное окружение Python 3.13 x64. Полная папка `pdf-vector` устанавливается рядом с SETGUI.exe и в исходный runtime. Её `PDFScanToVector.exe` запускается также самостоятельно. Для непосредственной сборки папки из этого проекта: `.venv\Scripts\python.exe tools\build_component.py`. + +Встроенный режим поддерживает локальный канал `--server`, передачу темы и открытие PDF без перезапуска. При закрытии SETGUI программа предлагает сохранить готовый результат или подтвердить прерывание OCR; отмена сохраняет оба приложения открытыми. Необязательный `--settings ПУТЬ.ini` изолирует профиль при автоматической проверке. Компонент предназначен для Windows 10/11 x64; исходная однофайловая сборка через `build_exe.bat` сохраняется. + +Для разработки нужен Python 3.13 x64. Зависимости зафиксированы в `requirements.txt`; сборочные — в `requirements-build.txt`. Языковые модели находятся в `assets\tessdata` и уже включены в проект. + +Дважды щёлкните `build_exe.bat` в корне проекта. Он запустит PowerShell-сценарий `tools\build.ps1`: установит зависимости в `.venv`, выполнит проверки, соберёт один EXE и проверит его полным сценарием GUI с обработкой тестового скана. Готовый файл появится в `dist\PDFScanToVector.exe`. Окно останется открытым, чтобы можно было прочитать результат или ошибку. Для автоматического запуска без ожидания клавиши используйте `build_exe.bat --no-pause`. + +Если основная версия EXE запущена и Windows запрещает её заменить, новая сборка сохранится в `dist` с меткой времени в имени. Точный путь будет показан в окне сборки; работающее приложение продолжит свой сеанс. + +Запуск исходников: `.venv\Scripts\python.exe app.py`. Необязательный единственный аргумент — путь к PDF. Автопроверка: `.venv\Scripts\python.exe app.py --self-test verification-output\source` или `dist\PDFScanToVector.exe --self-test verification-output\exe`. Папка самопроверки содержит JSON-отчёт, исходный скан, результат, распознанный текст и изображения интерфейса и страницы. + +Обработка выполняется в отдельном процессе: объекты MuPDF не разделяются между потоками. PDF записывается во временный файл и публикуется атомарной заменой. При ошибке или отмене до публикации существующее назначение сохраняется. + +## Документация используемых библиотек + +- [PyMuPDF: OCR и встроенный Tesseract](https://pymupdf.readthedocs.io/en/latest/recipes-ocr.html) +- [PyMuPDF: сохранение OCR PDF из изображения](https://pymupdf.readthedocs.io/en/latest/pixmap.html#Pixmap.pdfocr_tobytes) +- [OpenCV: вложенность контуров](https://docs.opencv.org/4.x/d9/d8b/tutorial_py_contours_hierarchy.html) +- [PyInstaller: автономные приложения](https://pyinstaller.org/en/stable/operating-mode.html) + +Сведения об открытых компонентах и лицензиях находятся в `THIRD_PARTY_NOTICES.md`. diff --git a/tools/pdf-scan-to-vector/THIRD_PARTY_NOTICES.md b/tools/pdf-scan-to-vector/THIRD_PARTY_NOTICES.md new file mode 100644 index 0000000..7d22d94 --- /dev/null +++ b/tools/pdf-scan-to-vector/THIRD_PARTY_NOTICES.md @@ -0,0 +1,19 @@ +# Компоненты и лицензии + +Приложение использует следующие сторонние компоненты. Упоминание здесь не изменяет исходные условия правообладателей. + +| Компонент | Лицензия | Источник | +| --- | --- | --- | +| PySide6 / Qt 6 | LGPLv3 / GPLv3 / коммерческая, согласно условиям конкретных модулей | https://doc.qt.io/qtforpython-6/licenses.html | +| PyMuPDF / MuPDF | AGPLv3 либо коммерческая лицензия Artifex | https://pymupdf.readthedocs.io/en/latest/about.html#license-and-copyright | +| OpenCV | Apache License 2.0 | https://opencv.org/license/ | +| NumPy | BSD-3-Clause | https://numpy.org/doc/stable/license.html | +| Tesseract OCR | Apache License 2.0 | https://github.com/tesseract-ocr/tesseract | +| tessdata_fast, модели rus и eng | Apache License 2.0 | https://github.com/tesseract-ocr/tessdata_fast | +| PyInstaller | GPL с исключением для распространяемых сборок | https://pyinstaller.org/en/stable/license.html | + +Русская и английская модели распознавания загружены из официального репозитория `tesseract-ocr/tessdata_fast`. Их лицензия находится в `assets/tessdata/LICENSE`. + +Текстовый шрифт демонстрационного PDF берётся из встроенного в MuPDF Droid Sans Fallback. Используются геометрический значок приложения и самостоятельная таблица оформления, без зависимости от установки SETGUI. + +Исходники приложения поставляются в этой папке вместе со сценарием повторной сборки и точными версиями зависимостей. При дальнейшем распространении необходимо соблюдать лицензии включённых компонентов. diff --git a/tools/pdf-scan-to-vector/app.py b/tools/pdf-scan-to-vector/app.py new file mode 100644 index 0000000..a06dcb4 --- /dev/null +++ b/tools/pdf-scan-to-vector/app.py @@ -0,0 +1,30 @@ +import multiprocessing as mp # Поддерживаем дочерний процесс внутри автономной сборки PyInstaller. +import sys # Разбираем служебный запуск самопроверки и необязательный путь к PDF. +import argparse # Отличаем открытие PDF от запуска компонента с локальным каналом SETGUI. + + +def main(): # Единственная точка входа для исходников и Windows EXE. + mp.freeze_support() # Дочерний процесс Windows должен войти в обработчик multiprocessing до создания GUI. + if len(sys.argv) == 3 and sys.argv[1] == "--self-test": # Позволяем проверить готовый EXE без ручной работы с диалогами. + from verification import self_test # Тестовый сценарий загружаем только при явном служебном запуске. + return self_test(sys.argv[2]) # Результат проверки записывается в выбранную папку независимо от отсутствия консоли. + from gui import MainWindow, application # Qt импортируется после обработки служебного запуска multiprocessing. + app = application() # Создаём приложение с оформлением SETGUI. + parser = argparse.ArgumentParser(description="PDF Scan to Vector") # Общая командная строка работает в исходниках и автономных сборках. + parser.add_argument("path", nargs="?") # Необязательный путь сохраняет открытие PDF перетаскиванием на EXE. + parser.add_argument("--server") # Имя локального канала передаёт запустившая компонент вкладка SETGUI. + parser.add_argument("--settings") # Отдельный INI позволяет проверять компонент без изменения рабочего профиля. + args = parser.parse_args() # Неизвестные аргументы не трактуются как имена документов. + if args.server: # QtNetwork нужен только при явном запуске внутри SETGUI. + from host import HostedWindow # Адаптер содержит канал управления и защиту несохранённого результата. + window = HostedWindow(args.server, args.settings) # Движок преобразования работает в собственном процессе приложения. + else: # Самостоятельный запуск сохраняет исходный интерфейс программы. + window = MainWindow(args.settings) # Необязательный INI поддерживается также без SETGUI. + window.show() # Показываем готовое окно до возможного открытия переданного документа. + if args.path: # Документ открывается также при одновременной передаче служебных параметров. + window.load_pdf(args.path) # Используем общую проверку формата, пароля и рендеринга. + return app.exec() # Передаём управление циклу событий Qt до закрытия окна. + + +if __name__ == "__main__": # Защищаем запуск интерфейса от повторного выполнения при импорте дочерним процессом. + raise SystemExit(main()) # Возвращаем операционной системе код завершения приложения или самопроверки. diff --git a/tools/pdf-scan-to-vector/assets/app.ico b/tools/pdf-scan-to-vector/assets/app.ico new file mode 100644 index 0000000..4c01733 Binary files /dev/null and b/tools/pdf-scan-to-vector/assets/app.ico differ diff --git a/tools/pdf-scan-to-vector/assets/tessdata/LICENSE b/tools/pdf-scan-to-vector/assets/tessdata/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/tools/pdf-scan-to-vector/assets/tessdata/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/tools/pdf-scan-to-vector/assets/tessdata/eng.traineddata b/tools/pdf-scan-to-vector/assets/tessdata/eng.traineddata new file mode 100644 index 0000000..bbef467 Binary files /dev/null and b/tools/pdf-scan-to-vector/assets/tessdata/eng.traineddata differ diff --git a/tools/pdf-scan-to-vector/assets/tessdata/rus.traineddata b/tools/pdf-scan-to-vector/assets/tessdata/rus.traineddata new file mode 100644 index 0000000..b146cb2 Binary files /dev/null and b/tools/pdf-scan-to-vector/assets/tessdata/rus.traineddata differ diff --git a/tools/pdf-scan-to-vector/build_exe.bat b/tools/pdf-scan-to-vector/build_exe.bat new file mode 100644 index 0000000..a787e16 --- /dev/null +++ b/tools/pdf-scan-to-vector/build_exe.bat @@ -0,0 +1,13 @@ +@chcp 65001 >nul & rem Переключаем консоль в UTF-8 до вывода русских сообщений и чтения комментариев следующих строк. +@echo off & rem Показываем ход сборки без повторного вывода самих команд BAT-файла. +setlocal EnableExtensions DisableDelayedExpansion & rem Ограничиваем переменные текущим запуском и сохраняем восклицательные знаки в путях проекта. +set "PYTHONUTF8=1" & rem Включаем UTF-8 для Python независимо от региональных настроек Windows. +set "PYTHONIOENCODING=utf-8" & rem Согласуем кодировку вывода Python с кодовой страницей консоли 65001. +echo Сборка PDF Scan to Vector: зависимости, тесты, EXE и самопроверка. & rem Объясняем пользователю последовательность действий перед началом работы. +"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -NoLogo -NoProfile -ExecutionPolicy Bypass -File "%~dp0tools\build.ps1" & rem Запускаем существующий сценарий относительно папки BAT; обход политики действует только для этого процесса PowerShell. +set "buildExitCode=%errorlevel%" & rem Сохраняем настоящий код завершения сборки до вывода сообщений и ожидания клавиши. +if "%buildExitCode%"=="0" echo Готово. EXE находится в "%~dp0dist". Точное имя файла указано выше. & rem При успехе показываем папку результата; имя может содержать метку времени, если основная версия запущена. +if not "%buildExitCode%"=="0" echo Ошибка сборки. Код: %buildExitCode%. Подробности приведены выше. & rem Явно отличаем неудачную сборку от готового результата. +if /I not "%~1"=="--no-pause" pause & rem При двойном щелчке оставляем окно открытым; параметр --no-pause подходит для автоматического запуска. +rem Следующая строка восстанавливает окружение и возвращает сохранённый код сборки; после exit нельзя добавлять команды, меняющие этот код. +endlocal & exit /b %buildExitCode% diff --git a/tools/pdf-scan-to-vector/engine.py b/tools/pdf-scan-to-vector/engine.py new file mode 100644 index 0000000..03ff80e --- /dev/null +++ b/tools/pdf-scan-to-vector/engine.py @@ -0,0 +1,230 @@ +from dataclasses import dataclass # Описываем неизменяемые параметры обработки, передаваемые отдельному процессу. +from pathlib import Path # Работаем с Unicode-путями Windows без ручного экранирования разделителей. +import math # Ограничиваем число пикселей страницы перед выделением оперативной памяти. +import os # Атомарно заменяем готовый файл после успешного завершения всех страниц. +import re # Проверяем пользовательские диапазоны страниц целиком, исключая неоднозначный ввод. +import sys # Находим ресурсы как при запуске исходников, так и внутри автономного EXE. +import tempfile # Создаём промежуточный файл рядом с назначением для атомарного переноса. +import traceback # Сохраняем подробности ошибки рабочего процесса в журнале интерфейса. +import cv2 # Выделяем чёрные области скана и аппроксимируем их геометрические контуры. +import numpy as np # Представляем пиксели MuPDF массивом без промежуточных файлов изображений. +import pymupdf as fitz # Читаем PDF, распознаём текст встроенным Tesseract и записываем векторные страницы. + + +@dataclass(frozen=True) # Запрещаем случайное изменение настроек после начала обработки. +class Options: # Группируем настройки одной операции преобразования документа. + dpi: int = 300 # Используем 300 точек на дюйм как исходное разрешение для печатного текста. + mode: str = "vector_ocr" # По умолчанию одновременно получаем контуры и доступный для поиска текст. + language: str = "rus+eng" # Подключаем русскую и английскую модели, включённые в поставку. + threshold: int = 0 # Ноль означает автоматический порог Оцу, остальные значения задают уровень серого. + noise: float = 2.0 # Отбрасываем внешние компоненты площадью менее двух квадратных пикселей при 300 DPI. + simplify: float = 0.45 # Допускаем отклонение контура до 0,45 пикселя при базовых 300 DPI. + pages: str = "" # Пустая строка означает обработку всех страниц исходного PDF. + rotate: int = 0 # Поворот в градусах по часовой стрелке помогает обработать сканы боком. + recognition: str = "enhanced" # Выравнивание фона и удаление длинных линий помогают OCR читать схемы; исходный профиль доступен отдельно. + + +class Cancelled(Exception): # Отличаем пользовательскую отмену от ошибок чтения и распознавания. + pass # Дополнительные поля не нужны: интерфейсу достаточно типа исключения. + + +def asset_path(relative): # Определяем абсолютный путь к ресурсу без зависимости от текущей папки. + return Path(getattr(sys, "_MEIPASS", Path(__file__).resolve().parent)) / "assets" / relative # PyInstaller распаковывает вложенные данные в собственный каталог. + + +def parse_pages(value, total): # Преобразуем запись вида «1-3, 5» в упорядоченные индексы PDF с нуля. + if not value.strip(): # Отсутствие диапазона трактуем как выбор всего документа. + return list(range(total)) # Сохраняем исходный порядок страниц. + selected = set() # Удаляем повторяющиеся номера, чтобы страница не попала в результат дважды. + for part in value.split(","): # Запятая разделяет одиночные страницы и включительные диапазоны. + match = re.fullmatch(r"\s*(\d+)\s*(?:-\s*(\d+)\s*)?", part) # Разрешаем только положительные номера и обычный дефис. + if not match: # Не допускаем частичного распознавания ошибочного пользовательского ввода. + raise ValueError("Страницы задаются так: 1-3, 5, 8-10.") # Возвращаем понятный пример корректного диапазона. + first, last = int(match[1]), int(match[2] or match[1]) # Одиночный номер становится диапазоном из одной страницы. + if not 1 <= first <= last <= total: # Проверяем границы документа и запрещаем обратные диапазоны. + raise ValueError(f"Диапазон должен находиться между 1 и {total}.") # Сообщаем фактическое число доступных страниц. + selected.update(range(first - 1, last)) # Переводим включительные номера пользователя в индексы Python. + return sorted(selected) # Сохраняем порядок оригинала независимо от порядка ввода диапазонов. + + +def check_cancel(cancel): # Проверяем отмену на границах этапов, не повреждая готовые пользовательские файлы. + if cancel is not None and cancel.is_set(): # Событие безопасно передаётся между процессом интерфейса и обработчиком. + raise Cancelled("Обработка отменена. Выходной файл не изменён.") # Прерываем операцию до публикации результата. + + +def rasterize(page, options): # Получаем изображение страницы с учётом поворота и ограничения памяти. + rect = page.rect # Используем видимую область страницы с её исходной ориентацией. + scale = options.dpi / 72 # В PDF один пункт равен 1/72 дюйма, поэтому масштаб переводит пункты в пиксели. + pixels = rect.width * rect.height * scale * scale # Оцениваем площадь изображения до его создания. + if pixels > 45_000_000: # Предел в 45 миллионов пикселей ограничивает память для больших чертежей. + scale *= math.sqrt(45_000_000 / pixels) # Снижаем обе стороны пропорционально, сохраняя геометрию листа. + pix = page.get_pixmap(matrix=fitz.Matrix(scale, scale).prerotate(options.rotate), colorspace=fitz.csRGB, alpha=False) # Белый фон и RGB совместимы со встроенным OCR. + pix.set_dpi(round(scale * 72), round(scale * 72)) # Передаём Tesseract реальное разрешение после ограничения размера. + return pix, scale # Возвращаем масштаб для пересчёта порогов шума и упрощения. + + +def binary_mask(pix, options): # Получаем общую маску чернил для трассировки и удаления заменяемых букв. + rgb = np.frombuffer(pix.samples, dtype=np.uint8).reshape(pix.height, pix.width, 3) # Представляем непрозрачные RGB-данные как трёхканальное изображение. + gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY) # Переводим цветной скан в яркость для чёрно-белой трассировки. + method = cv2.THRESH_BINARY_INV | (cv2.THRESH_OTSU if options.threshold == 0 else 0) # Инвертируем бинарную маску, чтобы чернила стали объектами OpenCV. + _, mask = cv2.threshold(gray, options.threshold, 255, method) # Значение 255 обозначает полностью выбранный пиксель восьмибитной маски. + return mask # Возвращаем самостоятельный массив, не меняя исходные пиксели документа. + + +def trace_svg(pix, options, scale, cancel=None, mask=None): # Восстанавливаем контуры из скана либо готовой маски без заменённых букв. + mask = binary_mask(pix, options) if mask is None else mask # Готовая маска исключает повторную бинаризацию и повторное появление удалённых букв. + contours, hierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # Дерево сохраняет вложенность отверстий и островков внутри контуров. + factor = scale * 72 / 300 # Пересчитываем настройки, заданные для 300 DPI, к фактическому разрешению страницы. + minimum = options.noise * factor * factor # Площадь шума меняется пропорционально квадрату масштаба. + epsilon = options.simplify * factor # Допуск геометрического упрощения меняется линейно вместе с разрешением. + paths, count = [], 0 # Накапливаем замкнутые подконтуры и число сохранённых элементов. + retained = [] # Запоминаем решение по каждому родителю, чтобы удалённый шум не оставлял дочерних отверстий. + for index, contour in enumerate(contours): # Порядок RETR_TREE располагает родителя раньше его потомков. + if index % 256 == 0: # Проверяем отмену каждые 256 контуров, не перегружая межпроцессное событие. + check_cancel(cancel) # Прерываем также долгую трассировку очень подробных сканов. + parent = int(hierarchy[0][index][3]) # Четвёртое поле OpenCV хранит индекс родительского контура. + keep = (parent < 0 and cv2.contourArea(contour) >= minimum) or (parent >= 0 and retained[parent]) # Фильтруем только внешнюю пыль, сохраняя внутреннюю геометрию букв. + retained.append(keep) # Даём потомкам возможность наследовать решение о сохранении компонента. + if not keep: # Пропускаем удалённые шумовые компоненты вместе с их потомками. + continue # Переходим к следующему найденному контуру. + points = cv2.approxPolyDP(contour, epsilon, True).reshape(-1, 2) # Упрощаем замкнутый контур с заданной погрешностью в пикселях. + if len(points) < 3: # Нулевая площадь не образует заполненный полигон SVG. + continue # Исключаем вырожденные линии из набора заполненных областей. + coordinates = " L ".join(f"{int(x)} {int(y)}" for x, y in points) # Записываем координаты каждого угла в системе пикселей скана. + paths.append(f"M {coordinates} Z") # Явно замыкаем каждый подконтур для корректного заполнения. + count += 1 # Учитываем сохранённую геометрию в статистике результата. + width, height = pix.width * 72 / pix.xres, pix.height * 72 / pix.yres # Возвращаем физические размеры листа в пунктах PDF. + body = " ".join(paths) # Объединяем контуры в один составной путь, чтобы правило чётности сохраняло отверстия. + svg = f'' # Чётное заполнение поддерживает вложенные белые области независимо от направления обхода. + return (svg.encode("utf-8") if paths else b""), count # Не передаём пустую SVG-страницу в MuPDF, поскольку чистый лист не содержит команд рисования. + + +def native_text_spans(page): # Извлекаем готовые надписи чертежа, чтобы повторное OCR не искажало мелкий технический шрифт. + if page.get_image_info(): # Наличие нарисованных изображений требует OCR: готовые подписи могут описывать лишь часть скана. + return [] # Сохраняем прежнее распознавание растровых и смешанных страниц. + blocks = page.get_text("dict", flags=fitz.TEXTFLAGS_DICT & ~fitz.TEXT_PRESERVE_IMAGES)["blocks"] # Читаем координаты текста без копирования изображений в оперативную память. + spans = [(line["dir"], span) for block in blocks if block["type"] == 0 for line in block["lines"] for span in line["spans"] if span["text"].strip()] # Сохраняем направление строки вместе с исходной базовой точкой и размером шрифта. + if any("\ufffd" in span["text"] or any(0xE000 <= ord(char) <= 0xF8FF for char in span["text"]) for _, span in spans): # Не принимаем неизвестные символы и частные коды шрифтов за достоверный Unicode. + return [] # Для повреждённой таблицы символов используем распознавание видимых букв. + legacy_fonts = {span["font"] for _, span in spans if span["font"].lower().startswith("gost") and re.search(r"[\u00c0-\u00ff]{3,}", span["text"])} # Старые экспортеры GOST записывают байты Windows-1251 как Latin-1; три последовательные буквы служат признаком этой ошибки. + for _, span in spans: # Исправляем кодировку лишь отмеченного технического шрифта, сохраняя другие языки и обозначения. + if span["font"] in legacy_fonts: # Правильный Unicode и обычные латинские шрифты не требуют перекодировки. + span["text"] = "".join(bytes([ord(char)]).decode("cp1251") if 0xC0 <= ord(char) <= 0xFF or ord(char) in {0xA8, 0xB8} else char for char in span["text"]) # Восстанавливаем русские буквы и Ё/ё из байтов Windows-1251; ASCII, номера и символы оставляем неизменными. + return spans # Возвращаем самостоятельные словари, не меняя исходный PDF и его встроенный шрифт. + + +def write_native_text(target, source, spans, options, cancel=None, visible=False): # Переносим Unicode с координатами и поворотами в видимый либо поисковый слой. + rotation = fitz.Matrix(options.rotate) # В координатах страницы положительный угол даёт пользовательский поворот по часовой стрелке. + bounds = source.rect * rotation # После поворота область может начинаться с отрицательных координат, которые нужно перенести к нулю. + transform = source.rotation_matrix * rotation * fitz.Matrix(1, 0, 0, 1, -bounds.x0, -bounds.y0) * fitz.Matrix(target.rect.width / bounds.width, target.rect.height / bounds.height) # Учитываем исходный /Rotate, дополнительный поворот и округление физических размеров растра. + font = fitz.Font("cjk") # Встроенный Droid Sans Fallback содержит кириллицу и не зависит от установленных шрифтов Windows. + target.insert_font(fontname="SearchText", fontbuffer=font.buffer) # Единственный ресурс шрифта предотвращает повторный разбор одной таблицы Unicode для каждой надписи в PDF-просмотрщиках. + for index, (direction, span) in enumerate(spans): # Переносим целые надписи, сохраняя непрерывные слова для поиска Acrobat. + if index % 64 == 0: # Проверка каждые 64 надписи ограничивает задержку отмены на больших чертежах. + check_cancel(cancel) # Отмена не должна публиковать неполный текстовый слой. + origin = fitz.Point(span["origin"]) * transform # Пересчитываем исходную базовую точку в координаты результата. + endpoint = fitz.Point(span["origin"][0] + direction[0], span["origin"][1] + direction[1]) * transform # Преобразуем единичный вектор строки той же матрицей, что и её начало. + dx, dy = endpoint.x - origin.x, endpoint.y - origin.y # Вычитаем перенос матрицы, получая только направление и масштаб строки. + length = math.hypot(dx, dy) # Масштаб определяет размер шрифта после изменения физических размеров страницы. + dx, dy = dx / length, dy / length # Нормируем направление для произвольного наклона и прямоугольных поворотов. + size = span["size"] * length # Сохраняем высоту исходных букв в пунктах PDF, равных 1/72 дюйма. + box = fitz.Rect(span["bbox"]) # Исходный прямоугольник задаёт длину надписи в её основном направлении. + width = (abs(direction[0]) * box.width + abs(direction[1]) * box.height) * length # Проецируем прямоугольник на направление строки и масштабируем его длину. + stretch = width / max(font.text_length(span["text"], fontsize=size), 0.01) # Подгоняем ширину заменяющего шрифта под надпись; 0,01 пункта защищает от деления на ноль. + target.insert_text(origin, span["text"], fontname="SearchText", fontsize=size, color=0, render_mode=0 if visible else 3, morph=(origin, fitz.Matrix(stretch * dx, -stretch * dy, dy, dx, 0, 0))) # Режим PDF 0 рисует чёрные буквы, режим 3 оставляет поисковый слой; матрица сохраняет направление и ширину. + + +def convert(source, destination, options, notify=None, cancel=None, password=""): # Выполняем полную обработку и публикуем PDF только после успешного завершения. + from text_ocr import recognition_pixmap, text_vector_page # Загружаем обработку видимого текста после инициализации общих функций движка. + notify = notify or (lambda message: None) # Позволяем вызывать движок без графического интерфейса. + if options.mode not in {"vector_ocr", "vector_text", "vector", "ocr"}: # Разрешаем новый режим видимого текста и прежние варианты результата. + raise ValueError("Неизвестный режим обработки.") # Возвращаем явную ошибку вместо неожиданного типа результата. + if not 100 <= options.dpi <= 600 or options.rotate not in {0, 90, 180, 270}: # Ограничиваем разрешение и разрешаем только прямоугольные повороты. + raise ValueError("Разрешение: 100–600 DPI; поворот: 0, 90, 180 или 270°.") # Сообщаем допустимые физические параметры. + if not 0 <= options.threshold <= 254 or options.noise < 0 or options.simplify < 0: # Проверяем числовые параметры бинаризации и аппроксимации. + raise ValueError("Недопустимые параметры векторизации.") # Исключаем некорректные значения до вызова OpenCV. + if options.language not in {"rus+eng", "rus", "eng"}: # Используем только языковые модели из автономной поставки. + raise ValueError("Доступны русский и английский языки.") # Объясняем ограничения выбора модели распознавания. + if options.recognition not in {"enhanced", "original"}: # Проверяем профиль до обработки изображений и запуска языковых моделей. + raise ValueError("Неизвестный профиль распознавания.") # Не подменяем ошибочный профиль незаметным изменением алгоритма. + source, destination = Path(source).resolve(), Path(destination).resolve() # Нормализуем пути перед сравнением и созданием временного файла. + if source == destination: # Защищаем исходный скан от перезаписи даже при прямом вызове движка. + raise ValueError("Выберите имя результата, отличающееся от исходного PDF.") # Предлагаем безопасный путь сохранения. + check_cancel(cancel) # Отмена до открытия документа не должна создавать даже временный результат. + text_pages, stats = [], [] # Собираем текст и статистику в порядке выбранных страниц. + temporary = None # Запоминаем путь промежуточного PDF для обязательной уборки при ошибке. + try: # Гарантируем очистку временного файла при любых ошибках записи и распознавания. + with fitz.open(source) as original, fitz.open() as result: # Держим документы внутри одного процесса, поскольку MuPDF не поддерживает параллельные потоки. + if original.needs_pass and not original.authenticate(password): # Проверяем пароль до доступа к защищённым страницам. + raise ValueError("PDF защищён паролем. Укажите пароль при открытии файла.") # Подсказываем, как получить доступ к содержимому. + selected = parse_pages(options.pages, len(original)) # Проверяем диапазон по реальному числу страниц документа. + if not selected: # Пустой PDF нельзя сохранить как документ с результатами. + raise ValueError("В документе нет страниц.") # Обрабатываем редкий повреждённый или пустой входной файл. + for position, number in enumerate(selected): # Последовательно ограничиваем память одной растровой страницей. + check_cancel(cancel) # Разрешаем отменить операцию между страницами. + notify({"kind": "progress", "value": position * 100 // len(selected), "message": f"Страница {number + 1}: чтение скана"}) # Обновляем ход обработки с учётом выбранного диапазона. + pix, scale = rasterize(original[number], options) # Учитываем физические размеры, разрешение и пользовательский поворот. + if options.mode == "vector_text": # Замена букв требует удаления текстовой геометрии до трассировки. + notify({"kind": "log", "message": f"Страница {number + 1}: векторизация графики и замена букв текстом"}) # Объясняем текущий этап нового режима. + native = native_text_spans(original[number]) if not any(span["type"] == 3 for span in original[number].get_texttrace()) else [] # Невидимый OCR предыдущей векторизации не заменяет видимые контурные буквы: такую страницу снова распознаём и отделяем слова от графики. + text, contours, replacements = text_vector_page(result, original[number], pix, scale, native, options, notify, cancel) # Формируем страницу с видимым шрифтом и векторной графикой. + text_pages.append(text) # Сохраняем тот же Unicode, который доступен в итоговом PDF. + stats.append({"source_page": number + 1, "contours": contours, "characters": len(text), "dpi": pix.xres, "text_replacements": replacements}) # Отчёт связывает охват замены с исходным номером листа. + notify({"kind": "progress", "value": (position + 1) * 100 // len(selected), "message": f"Страница {number + 1} готова · заменено текстом: {replacements}"}) # Используем штатный протокол прогресса для завершения страницы. + continue # Исключаем повторную трассировку букв и дублирование OCR-слоя. + svg, contours = b"", 0 # Инициализируем статистику для режима без трассировки. + if options.mode != "ocr": # В режиме сохранения оригинала геометрическая трассировка не требуется. + notify({"kind": "log", "message": f"Страница {number + 1}: векторизация {pix.width} × {pix.height} пикселей"}) # Показываем фактическую нагрузку и возможное ограничение разрешения. + svg, contours = trace_svg(pix, options, scale, cancel) # Получаем монохромные контуры с сохранёнными отверстиями. + check_cancel(cancel) # Не запускаем дорогой OCR, если пользователь уже нажал отмену. + native = native_text_spans(original[number]) if options.mode != "vector" else [] # Отдаём приоритет готовым надписям векторного чертежа перед повторным OCR. + if native: # Полностью векторная страница уже содержит более точный текст, чем результат распознавания её растра. + notify({"kind": "log", "message": f"Страница {number + 1}: перенос исходного текста с проверкой кодировки"}) # Объясняем в журнале, откуда получен поисковый слой. + target = result.new_page(width=pix.width * 72 / pix.xres, height=pix.height * 72 / pix.yres) # Создаём лист тех же размеров, что и трассированные контуры или сохранённый скан. + if options.mode == "ocr": # Режим сохранения внешнего вида требует исходного растрового представления страницы. + target.insert_image(target.rect, pixmap=pix) # Сохраняем изображение под невидимыми символами без повторного OCR. + write_native_text(target, original[number], native, options, cancel) # Сохраняем исправленный Unicode вместе с исходной геометрией надписей. + text_pages.append(target.get_text(sort=True)) # Интерфейс и TXT получают тот же текст, который доступен для поиска в итоговом PDF. + elif options.mode != "vector": # Распознаём растровые страницы только для двух режимов, которым нужен поисковый слой. + notify({"kind": "log", "message": f"Страница {number + 1}: распознавание {options.language}"}) # Сообщаем о начале этапа, длительность которого зависит от сложности текста. + prepared = recognition_pixmap(pix, options, cancel) # Подготавливаем копию согласно выбранному профилю, сохраняя исходный скан. + payload = prepared.pdfocr_tobytes(language=options.language, tessdata=str(asset_path("tessdata"))) # Встроенный Tesseract распознаёт подготовленное изображение локальными моделями. + with fitz.open("pdf", payload) as recognized: # Открываем временную страницу с исходным изображением и невидимыми символами OCR. + text_pages.append(recognized[0].get_text(sort=True)) # Сохраняем Unicode-текст до любых изменений графического слоя. + if options.mode == "vector_ocr" or prepared is not pix: # Удаляем также подготовленную копию в режиме скана, чтобы не изменять внешний вид исходника. + recognized[0].add_redact_annot(recognized[0].rect, fill=False, cross_out=False) # Помечаем всю страницу без добавления белого перекрывающего прямоугольника. + recognized[0].apply_redactions(images=fitz.PDF_REDACT_IMAGE_REMOVE, graphics=fitz.PDF_REDACT_LINE_ART_NONE, text=fitz.PDF_REDACT_TEXT_NONE) # Удаляем только растровое изображение и сохраняем шрифт, координаты и Unicode OCR. + if options.mode == "ocr" and prepared is not pix: # Результат OCR со сканом должен показывать исходное цветное изображение. + recognized[0].insert_image(recognized[0].rect, pixmap=pix, overlay=False) # Возвращаем исходные пиксели под поисковый текст без смещения координат. + result.insert_pdf(recognized) # Переносим страницу вместе с ресурсами распознанного шрифта. + else: # Режим только векторизации создаёт страницу без невидимых символов. + result.new_page(width=pix.width * 72 / pix.xres, height=pix.height * 72 / pix.yres) # Сохраняем физический размер обработанного листа после поворота. + text_pages.append("") # Поддерживаем соответствие номера страницы и элемента списка текста. + if svg: # Добавляем контуры в оба векторных режима после переноса текстового слоя. + with fitz.open("svg", svg) as drawing: # MuPDF преобразует геометрию SVG в настоящие команды рисования PDF. + with fitz.open("pdf", drawing.convert_to_pdf()) as vector: # Получаем промежуточный документ, содержащий только векторную графику. + result[-1].show_pdf_page(result[-1].rect, vector, 0, overlay=False) # Размещаем контуры под невидимым слоем OCR на весь лист. + stats.append({"source_page": number + 1, "contours": contours, "characters": len(text_pages[-1]), "dpi": pix.xres}) # Отчёт связывает результат с исходным номером листа. + notify({"kind": "progress", "value": (position + 1) * 100 // len(selected), "message": f"Страница {number + 1} готова · контуров: {contours}"}) # Подтверждаем успешное завершение текущей страницы. + check_cancel(cancel) # Отмена после последнего OCR также должна оставить назначение нетронутым. + result.set_metadata({"title": source.stem, "creator": "PDF Scan to Vector", "subject": "Векторизация и локальное распознавание текста"}) # Записываем нейтральные метаданные без подписей ассистента. + result.subset_fonts() # Оставляем в PDF только использованные символы встроенных шрифтов. + handle, temporary = tempfile.mkstemp(prefix=".pdf-vector-", suffix=".pdf", dir=destination.parent) # Временный файл на том же диске позволяет выполнить атомарную замену. + os.close(handle) # Закрываем системный дескриптор, чтобы MuPDF мог открыть файл для записи в Windows. + result.save(temporary, garbage=4, deflate=True) # Удаляем неиспользуемый растр и сжимаем содержимое итогового PDF. + check_cancel(cancel) # Последний контроль отмены выполняем перед изменением выходного файла. + os.replace(temporary, destination) # Публикуем только целиком записанный результат, сохраняя прежний файл при сбое. + return {"path": str(destination), "pages": stats, "text": text_pages} # Возвращаем интерфейсу реальные пути, номера страниц и распознанный текст. + finally: # Завершаем уборку независимо от успешности конвертации. + if temporary and Path(temporary).exists(): # После успешного переноса временного пути уже не существует. + Path(temporary).unlink(missing_ok=True) # Удаляем остаток незавершённой записи, не затрагивая исходный PDF. + + +def worker(source, destination, options, queue, cancel, password=""): # Отдельная точка входа процесса предотвращает блокировку GUI и одновременный доступ MuPDF. + try: # Передаём ошибки межпроцессными сообщениями вместо аварийного закрытия окна. + report = convert(source, destination, options, queue.put, cancel, password) # Выполняем обработку с уведомлениями и общей кнопкой отмены. + queue.put({"kind": "done", "report": report}) # Отправляем подтверждение только после сохранения готового PDF. + except Cancelled as error: # Пользовательская отмена отображается отдельным нейтральным состоянием. + queue.put({"kind": "cancelled", "message": str(error)}) # Позволяем интерфейсу вернуть управление без окна ошибки. + except Exception as error: # Изолируем ошибки повреждённых PDF, моделей OCR и файловой системы. + queue.put({"kind": "error", "message": str(error), "detail": traceback.format_exc()}) # Краткое объяснение показываем пользователю, полный стек оставляем в журнале. diff --git a/tools/pdf-scan-to-vector/gui.py b/tools/pdf-scan-to-vector/gui.py new file mode 100644 index 0000000..c562cf5 --- /dev/null +++ b/tools/pdf-scan-to-vector/gui.py @@ -0,0 +1,590 @@ +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. diff --git a/tools/pdf-scan-to-vector/host.py b/tools/pdf-scan-to-vector/host.py new file mode 100644 index 0000000..401aedf --- /dev/null +++ b/tools/pdf-scan-to-vector/host.py @@ -0,0 +1,91 @@ +"""Локальный адаптер самостоятельного приложения для вкладки SETGUI.""" # Qt и OCR остаются в отдельном процессе с собственными зависимостями. +import ctypes # Встроенному нативному окну Windows требуется восстановление клавиатурного фокуса. +import json # Строковый протокол сохраняет пути Unicode без оболочки командной строки. +import sys # Платформенные операции с HWND применяются только в Windows. +from pathlib import Path # Сопоставляем запрошенный PDF с реально открытым документом. +from PySide6 import QtCore as C, QtWidgets as W # Адаптер использует тот же Qt, что самостоятельная программа. +from PySide6.QtNetwork import QLocalSocket # Именованный локальный канал работает также в EXE без консоли. +from gui import MainWindow # Все операции OCR, предпросмотра и экспорта сохраняют одну реализацию. + + +class HostedWindow(MainWindow): # Расширяем программу только поведением размещения внутри SETGUI. + def __init__(self, server, settings_path=None): # Сервер создаёт конкретная вкладка, а профиль можно изолировать для проверки. + super().__init__(settings_path) # Подготавливаем исходный интерфейс и собственный рабочий каталог. + self._hosted = True # Признак нужен для сохранения документа при запросе выхода из SETGUI. + self._closing = False # Вложенный цикл диалога не должен создавать повторный запрос сохранения. + self.channel = QLocalSocket(self) # Канал принадлежит окну и освобождается вместе с ним. + self.channel.connected.connect(self._ready) # HWND публикуется только после установления локального соединения. + self.channel.readyRead.connect(self._read_commands) # Команды обрабатываются в основном потоке приложения. + self.channel.disconnected.connect(self._disconnected) # Сбой родителя не должен уничтожать несохранённый результат. + W.QApplication.instance().installEventFilter(self) # Щелчок по встроенной форме возвращает фокус её собственному потоку Windows. + self.channel.connectToServer(server) # Подключаемся только к каналу запустившей программу вкладки. + + def send(self, **message): # Одинаковая сериализация используется всеми ответами компонента. + self.channel.write((json.dumps(message, ensure_ascii=True) + "\n").encode("utf-8")) # ASCII-экранирование сохраняет кириллицу независимо от кодовой страницы. + self.channel.flush() # Сообщение об отмене выхода сразу возвращает управление пользователю SETGUI. + + def _ready(self): # Соединение может установиться до первого показа окна. + self.send(event="ready", window=int(self.winId())) # Созданный HWND позволяет родителю проверить владельца и встроить окно. + + def eventFilter(self, watched, event): # Отдельные процессы Qt имеют независимые очереди клавиатурного ввода. + if self._hosted and event.type() == C.QEvent.MouseButtonPress and isinstance(watched, W.QWidget) and watched.window() is self and sys.platform == "win32" and W.QApplication.platformName() != "offscreen": # Исправление применяется только при реальном щелчке внутри встроенного окна Windows. + from ctypes import wintypes # Разрядность указателей HWND должна соответствовать текущему Python. + api = ctypes.WinDLL("user32", use_last_error=True) # Используем системный диспетчер окон без сторонних библиотек. + api.SetFocus.argtypes, api.SetFocus.restype = [wintypes.HWND], wintypes.HWND # Явные типы предотвращают усечение 64-разрядного дескриптора. + self.activateWindow() # Qt восстанавливает логический фокус дочерних элементов. + api.SetFocus(int(self.winId())) # Windows направляет ввод потоку самостоятельной программы. + return super().eventFilter(watched, event) # Обработка исходного щелчка и остальных событий продолжается штатно. + + def _allow_replace(self): # Проверяем рабочий процесс и несохранённый результат перед закрытием или открытием другого PDF. + if self.process is not None: # Действующий OCR нельзя молча завершить при выходе родителя. + answer = W.QMessageBox.question(self, "Преобразование PDF", "Прервать обработку и продолжить?", W.QMessageBox.Yes | W.QMessageBox.Cancel, W.QMessageBox.Cancel) # Отмена по умолчанию сохраняет выполняемую операцию. + if answer != W.QMessageBox.Yes: # Любой отказ оставляет интерфейс и рабочий процесс открытыми. + return False # Родитель получает сообщение об отменённом закрытии. + return True # Штатный closeEvent остановит собственный рабочий процесс перед освобождением ресурсов. + if self.result is not None and not self.result_saved: # Готовый PDF во временной папке ещё не является пользовательским файлом. + answer = W.QMessageBox.question(self, "Результат PDF", "Сохранить обработанный PDF перед продолжением?", W.QMessageBox.Save | W.QMessageBox.Discard | W.QMessageBox.Cancel, W.QMessageBox.Save) # Пользователь решает судьбу конкретного результата. + if answer == W.QMessageBox.Save: # Сохранение использует исходный диалог и атомарную запись программы. + self.save_pdf() # Ошибка записи или отмена диалога сохраняют прежний признак result_saved. + return self.result_saved # Продолжаем только после успешной записи пользовательского PDF. + return answer == W.QMessageBox.Discard # Отмена не уничтожает временный документ. + return True # Без работающего OCR и несохранённого результата дополнительных действий не требуется. + + def _read_commands(self): # Неполная строка остаётся в канале до следующего readyRead. + while self.channel.canReadLine(): # За одно событие обрабатываем все уже полученные команды. + try: # Неверная команда не должна завершать программу с открытым документом. + message = json.loads(bytes(self.channel.readLine(1048577)).decode("utf-8")) # Один мегабайт в байтах покрывает тему SETGUI и ограничивает размер отдельной команды. + command = message.get("command") # Служебные события отличаются явным именем действия. + if command == "close" and not self._closing: # Повторная команда во время диалога игнорируется. + self.close() # Закрытие проходит ту же проверку сохранения, что системная кнопка окна. + elif command == "style": # Тема приходит после встраивания HWND в родительскую вкладку. + self.setStyleSheet(str(message["stylesheet"])) # Самостоятельная программа получает актуальное оформление SETGUI. + elif command == "open": # Новый PDF передаётся через канал без перезапуска приложения. + path = Path(message["path"]).resolve() # Абсолютный путь не зависит от рабочего каталога компонента. + accepted = self.process is None and self._allow_replace() # Во время OCR документ не заменяется даже после подтверждения прерывания. + if accepted: # Только подтверждённая замена может очистить прежний результат. + self.load_pdf(str(path)) # Исходная проверка обрабатывает формат PDF и пароль. + accepted = self.source_path == path # Сообщаем о фактически открытом документе после возможного отказа диалога. + self.send(event="opened", accepted=bool(accepted), path=str(path)) # Родитель отображает результат запроса вместо преждевременного успеха. + except (ValueError, TypeError, KeyError, AttributeError, OSError) as error: # Ошибки формата или файловой системы остаются диагностикой канала. + self.send(event="error", message=str(error)) # SETGUI показывает причину, сохраняя доступ к другим инструментам. + + def _disconnected(self): # При аварии SETGUI приложение превращается в самостоятельное окно. + if self._hosted and not self._closing and self.isVisible(): # Закрытое окно не должно повторно появляться при завершении приложения. + self._hosted = False # Следующее закрытие не требует отправки сообщения исчезнувшему родителю. + self.windowHandle().setParent(None) # Убираем принадлежность нативному контейнеру завершившегося процесса. + self.setWindowFlags(C.Qt.Window) # Возвращаем заголовок и системные кнопки самостоятельного окна. + self.show() # Пользователь продолжает работу с исходным результатом без повторного OCR. + + def closeEvent(self, event): # SETGUI ждёт подтверждённого завершения, сохраняя отзывчивый интерфейс. + if self._closing: # Вложенный цикл вопроса о сохранении может принять ещё одну команду close. + event.ignore() # Защищаем окно от повторного освобождения открытых PDF и очереди OCR. + return # Первый запрос остаётся единственным владельцем процедуры закрытия. + self._closing = True # Фиксируем начало процедуры до показа любого модального диалога. + try: # Флаг снимается также после отмены сохранения или ошибки диалога. + if not self._allow_replace(): # Неуспешное сохранение и отмена оставляют процесс работающим. + event.ignore() # Контейнер SETGUI продолжает показывать тот же документ. + self.send(event="close_cancelled") # Родитель снимает ожидание выхода и не уничтожает вкладку. + return # Временная папка и исходный PDF остаются открытыми. + super().closeEvent(event) # Исходный обработчик завершает OCR, сохраняет профиль и освобождает временные файлы. + finally: # Результат диалога не должен блокировать следующий запрос закрытия. + self._closing = False # Повторное действие пользователя снова проходит полноценную проверку. diff --git a/tools/pdf-scan-to-vector/requirements-build.txt b/tools/pdf-scan-to-vector/requirements-build.txt new file mode 100644 index 0000000..880a543 --- /dev/null +++ b/tools/pdf-scan-to-vector/requirements-build.txt @@ -0,0 +1,3 @@ +-r requirements.txt # Устанавливаем те же версии, которые используются при обычном запуске. +PyInstaller==6.22.2 # Упаковываем приложение вместе с Qt, MuPDF и языковыми моделями в Windows EXE. +pytest==9.1.1 # Проверяем геометрию, OCR, защиту файлов, диапазоны и отмену обработки. diff --git a/tools/pdf-scan-to-vector/requirements.txt b/tools/pdf-scan-to-vector/requirements.txt new file mode 100644 index 0000000..9c07bcc --- /dev/null +++ b/tools/pdf-scan-to-vector/requirements.txt @@ -0,0 +1,4 @@ +PySide6==6.11.1 # Настольные виджеты Qt и оформление интерфейса в стиле SETGUI. +PyMuPDF==1.28.2 # Чтение PDF, локальное OCR Tesseract и запись векторных страниц. +opencv-python-headless==5.0.0.93 # Бинаризация и трассировка без второй конфликтующей поставки Qt. +numpy==2.2.4 # Массивы пикселей для обработки изображений OpenCV. diff --git a/tools/pdf-scan-to-vector/sample.py b/tools/pdf-scan-to-vector/sample.py new file mode 100644 index 0000000..7fa4a94 --- /dev/null +++ b/tools/pdf-scan-to-vector/sample.py @@ -0,0 +1,32 @@ +from pathlib import Path # Позволяем создавать пример и в тестовой папке, и во временном каталоге GUI. +import pymupdf as fitz # Генерируем страницу, затем превращаем её в скан без готового текста. + + +def create_sample(path, pages=2): # Формируем реалистичный двухстраничный пример текста и инженерной графики. + with fitz.open() as scan: # Итоговый пример содержит только растровые изображения страниц. + for number in range(pages): # Несколько страниц проверяют навигацию, диапазоны и объединение PDF. + with fitz.open() as drawing: # Векторный макет нужен исключительно для генерации растрового скана. + page = drawing.new_page(width=595, height=842) # Размер A4 приблизительно равен 595 × 842 пунктам PDF. + font = fitz.Font("cjk") # Встроенный свободный шрифт MuPDF содержит кириллицу и латиницу без файлов Windows. + writer = fitz.TextWriter(page.rect) # Размещаем Unicode-строки через общий движок текстовой вёрстки. + writer.append((48, 65), "ТЕХНИЧЕСКИЙ ДОКУМЕНТ", font=font, fontsize=22) # Крупный русский заголовок проверяет распознавание кириллицы. + writer.append((48, 94), "PDF Scan to Vector / Engineering archive", font=font, fontsize=12) # Смешанная строка проверяет английские обозначения. + writer.append((48, 137), f"Лист {number + 1}. Проверка распознавания текста.", font=font, fontsize=15) # Номер позволяет сопоставить исходный и результирующий листы. + writer.append((48, 166), "Напряжение питания: 24 V. Частота: 50 Hz.", font=font, fontsize=14) # Инженерные величины проверяют цифры и смешанные единицы. + writer.append((48, 194), "Контуры схемы должны оставаться векторными.", font=font, fontsize=13) # Строка описывает ожидаемый результат обработки графики. + writer.append((48, 222), "Отверстия букв: О Р В 8 0. TEST VECTOR 12345.", font=font, fontsize=14) # Замкнутые буквы и цифры позволяют проверить сохранение белых отверстий. + writer.append((48, 672), "Скан → контуры PDF + поисковый слой текста", font=font, fontsize=13) # Нижний блок проверяет распознавание вне основного текста страницы. + writer.append((48, 706), "Обработка выполняется локально. Русский и English.", font=font, fontsize=12) # Проверяем смешанные языки на отдельной строке. + writer.write_text(page) # Добавляем весь текст одним согласованным текстовым слоем макета. + page.draw_rect(fitz.Rect(48, 260, 547, 620), color=(0, 0, 0), width=1.2) # Большая рамка задаёт границы инженерной схемы. + for index in range(4): # Четыре соединённых блока создают простую проверяемую геометрию. + x = 82 + index * 118 # Расстояние между блоками составляет 118 пунктов PDF. + page.draw_rect(fitz.Rect(x, 370, x + 72, 442), color=(0, 0, 0), width=2) # Прямоугольники проверяют ровные горизонтальные и вертикальные линии. + page.draw_circle(fitz.Point(x + 36, 406), 20, color=(0, 0, 0), width=1.8) # Вложенная окружность проверяет отверстия и криволинейные контуры. + if index < 3: # Последний блок не требует соединения с несуществующим соседом. + page.draw_line(fitz.Point(x + 72, 406), fitz.Point(x + 118, 406), color=(0, 0, 0), width=1.5) # Соединяем соседние блоки линией с известной толщиной. + page.draw_line(fitz.Point(82, 520), fitz.Point(514, 520), color=(0, 0, 0), width=0.6) # Тонкая размерная линия проверяет сохранность мелких деталей. + pix = page.get_pixmap(dpi=180, alpha=False) # Растеризация удаляет доступный текст и имитирует сканирование с разрешением 180 DPI. + target = scan.new_page(width=595, height=842) # Создаём чистый лист с исходным физическим форматом A4. + target.insert_image(target.rect, stream=pix.tobytes("png")) # Помещаем только изображение, чтобы пример требовал настоящего OCR. + scan.save(str(Path(path)), deflate=True, garbage=4) # Сохраняем компактный тестовый PDF без скрытого текстового слоя. diff --git a/tools/pdf-scan-to-vector/tests/test_engine.py b/tools/pdf-scan-to-vector/tests/test_engine.py new file mode 100644 index 0000000..5658835 --- /dev/null +++ b/tools/pdf-scan-to-vector/tests/test_engine.py @@ -0,0 +1,112 @@ +from dataclasses import replace # Создаём варианты одного профиля без дублирования всех параметров. +from pathlib import Path # Проверяем существование и содержимое выходных файлов. +from threading import Event # Для синхронных тестов достаточно события с тем же интерфейсом, что у multiprocessing. +import numpy as np # Сравниваем растровые представления исходной и восстановленной геометрии. +import pymupdf as fitz # Проверяем реальные команды PDF, Unicode-текст и структуру изображений. +import pytest # Организуем независимые сценарии и параметризованные проверки диапазонов. +from engine import Cancelled, Options, convert, parse_pages # Тестируем публичные границы движка без имитации алгоритмов. +from sample import create_sample # Создаём настоящий скан, требующий OCR и геометрической трассировки. + + +@pytest.fixture(scope="module") # Генерация двухстраничного примера требуется один раз на группу проверок. +def scan(tmp_path_factory): # Возвращаем входной документ с русскими и английскими надписями. + path = tmp_path_factory.mktemp("сканы") / "Тестовый скан.pdf" # Кириллический каталог проверяет пути Windows и UTF-8. + create_sample(path) # Входной PDF содержит изображения, а не готовую распознанную строку. + return path # Каждый тест создаёт собственный выходной файл, сохраняя общий вход неизменным. + + +@pytest.mark.parametrize("value, expected", [("", [0, 1, 2, 3, 4]), ("1-3, 5", [0, 1, 2, 4]), ("3,1,3", [0, 2]), (" 2 - 4 ", [1, 2, 3])]) # Проверяем весь документ, включительные диапазоны, повторы и пробелы. +def test_page_ranges(value, expected): # Пользовательские номера должны однозначно соответствовать исходным страницам. + assert parse_pages(value, 5) == expected # Сверяем ожидаемые индексы, начиная с нуля. + + +@pytest.mark.parametrize("value", ["0", "6", "3-2", "1,", "abc", "1-3-5", "-2"]) # Некорректные диапазоны нельзя частично принимать или молча обрезать. +def test_bad_ranges(value): # Ошибки выбора страниц должны выявляться до дорогостоящего распознавания. + with pytest.raises(ValueError): # Проверяем явную ошибку вместо неожиданного выбора страниц. + parse_pages(value, 5) # Документ из пяти листов задаёт известные границы проверки. + + +@pytest.mark.parametrize("mode", ["vector_ocr", "vector", "ocr"]) # Каждый режим имеет собственный проверяемый состав результата. +def test_real_conversion(scan, tmp_path, mode): # Проверяем весь путь от растрового скана до сохранённого PDF. + output = tmp_path / f"{mode}.pdf" # Режимы не перезаписывают результаты друг друга. + events = [] # Собираем реальный прогресс обработки для проверки его завершённости. + report = convert(scan, output, Options(mode=mode), events.append) # Запускаем OCR и OpenCV без заглушек. + assert len(report["pages"]) == 2 and report["path"] == str(output.resolve()) # Отчёт должен описывать фактически записанный документ целиком. + assert events[-1]["value"] == 100 # Последнее обновление прогресса означает завершение всех выбранных листов. + with fitz.open(output) as document: # Проверяем повторно открытый PDF, а не только объекты до сохранения. + assert len(document) == 2 # Сохраняем количество и порядок исходных страниц. + for page in document: # Проверяем ожидаемые свойства каждого листа результата. + assert abs(page.rect.width - 595) < 1 and abs(page.rect.height - 842) < 1 # Геометрия A4 сохраняется с погрешностью округления до пикселя. + if mode != "ocr": # Два векторных режима должны полностью удалить растровые изображения. + assert not page.get_images(full=True) and page.get_drawings() # Контуры должны присутствовать именно как геометрические объекты PDF. + else: # Режим сохранения скана обязан оставить исходный вид изображения. + assert page.get_images(full=True) # Проверяем наличие изображения в сохранённом PDF. + if mode != "vector": # OCR должен создавать доступный для поиска Unicode, а не только видимые контуры букв. + assert page.search_for("Напряжение") and page.search_for("VECTOR") # Проверяем поиск русского слова и английской метки непосредственно по координатам PDF. + else: # Только векторизация не должна выдавать фиктивный распознанный текст. + assert not page.get_text().strip() # Геометрические буквы остаются графикой без текстового слоя. + + +def test_white_holes_and_visual_fidelity(scan, tmp_path): # Вложенные контуры букв и окружностей должны сохранять белую внутреннюю область. + output = tmp_path / "geometry.pdf" # Отделяем проверку геометрии от распознавания текста. + convert(scan, output, Options(mode="vector", pages="1", noise=0, simplify=0.25)) # Минимально упрощаем один лист для объективного сравнения. + with fitz.open(scan) as source, fitz.open(output) as result: # Рендерим одинаковую страницу обоих документов. + before_pix = source[0].get_pixmap(dpi=144, colorspace=fitz.csGRAY) # Масштаб два пикселя на пункт упрощает проверку известной геометрии. + after_pix = result[0].get_pixmap(dpi=144, colorspace=fitz.csGRAY) # Сравниваем фактический результат команд PDF, включая правило заполнения. + before = np.frombuffer(before_pix.samples, np.uint8).reshape(before_pix.height, before_pix.width) # Представляем входное изображение матрицей яркостей. + after = np.frombuffer(after_pix.samples, np.uint8).reshape(after_pix.height, after_pix.width) # То же представление используем для восстановленного вектора. + height, width = min(before.shape[0], after.shape[0]), min(before.shape[1], after.shape[1]) # Учитываем округление физического размера до целого пикселя. + mismatch = np.mean((before[:height, :width] < 128) != (after[:height, :width] < 128)) # Измеряем долю пикселей, в которых изменилась чёрно-белая геометрия. + assert mismatch < 0.025 # Допускаем до 2,5 процента различий из-за бинаризации и сглаживания границ скана. + assert after[812, 236] > 245 # Центр первой окружности на схеме обязан остаться белым, а не заполниться чёрным. + assert np.min(after[810:815, 190:202]) < 100 # Левая граница окружности находится у x = (118 − 20) × 2 = 196 пикселей при 144 DPI. + + +def test_selected_page_and_rotation(scan, tmp_path): # Обработка диапазона должна сохранять связь с исходным номером и физический поворот. + output = tmp_path / "rotated.pdf" # Создаём отдельный результат для выбранного второго листа. + report = convert(scan, output, Options(mode="vector", pages="2", rotate=90)) # Обрабатываем только второй лист и поворачиваем его по часовой стрелке. + assert [item["source_page"] for item in report["pages"]] == [2] # Отчёт не должен перенумеровывать выбранный исходный лист как первый. + with fitz.open(output) as document: # Проверяем реальный размер сохранённой страницы. + assert len(document) == 1 and document[0].rect.width > document[0].rect.height # После поворота лист A4 становится горизонтальным. + + +def test_cancel_preserves_existing_file(scan, tmp_path): # Поздняя отмена должна оставлять существующее назначение целиком неизменным. + output = tmp_path / "existing.pdf" # Используем заранее существующий путь для проверки атомарности публикации. + output.write_bytes(b"previous-result") # Специальная строка позволяет обнаружить любую частичную перезапись. + cancel = Event() # Событие предоставляет тот же контракт проверки отмены, что и рабочий процесс GUI. + def notify(message): # Устанавливаем отмену после фактического выполнения последнего листа. + if message["kind"] == "progress" and message["value"] == 100: # Проверяем самую позднюю границу перед записью результата. + cancel.set() # Следующий контроль должен прервать операцию до публикации PDF. + with pytest.raises(Cancelled): # Отмена должна отличаться от ошибки распознавания или файловой системы. + convert(scan, output, Options(mode="vector", pages="1"), notify, cancel) # Движок успевает построить вектор, но не должен заменить назначение. + assert output.read_bytes() == b"previous-result" # Проверяем побайтную сохранность прежнего файла. + assert not list(tmp_path.glob(".pdf-vector-*")) # Не оставляем промежуточные PDF после отменённой операции. + + +def test_original_cannot_be_overwritten(scan): # Защита исходного документа действует также вне графического интерфейса. + initial = scan.read_bytes() # Сохраняем контрольные байты общего входного примера. + with pytest.raises(ValueError, match="отличающееся"): # Движок обязан отвергнуть совпавшие пути до любой записи. + convert(scan, scan, Options(mode="vector")) # Имитируем ошибочный прямой вызов с одинаковыми путями. + assert scan.read_bytes() == initial # Убеждаемся, что исходный скан не изменился. + + +def test_blank_page(tmp_path): # Полностью белый скан не должен вызывать ошибку пустого векторного содержимого. + source, target = tmp_path / "blank.pdf", tmp_path / "blank_vector.pdf" # Разделяем пустой вход и ожидаемый пустой результат. + with fitz.open() as document: # Создаём корректный PDF с одним чистым листом. + document.new_page() # Пустая страница является допустимым содержимым документа. + document.save(source) # Сохраняем настоящий PDF, а не имитацию байтов заголовка. + convert(source, target, Options(mode="vector")) # Трассировка должна корректно завершиться с нулём контуров. + with fitz.open(target) as document: # Проверяем пригодность повторно открытого результата. + assert len(document) == 1 and not document[0].get_images() # Белый лист сохраняется без добавления ненужного растра. + + +def test_encrypted_pdf(scan, tmp_path): # Защищённые документы должны поддерживать явный пароль без его сохранения в результате. + source, target = tmp_path / "locked.pdf", tmp_path / "unlocked_vector.pdf" # Используем отдельный зашифрованный входной пример. + with fitz.open(scan) as document: # Шифруем копию исходного скана, не меняя общий тестовый файл. + document.save(source, encryption=fitz.PDF_ENCRYPT_AES_256, owner_pw="owner", user_pw="test-pass") # Проверяем стандартную защиту PDF AES-256 с пользовательским паролем. + with pytest.raises(ValueError, match="паролем"): # Без пароля движок должен явно отказать до обработки содержимого. + convert(source, target, Options(mode="vector", pages="1")) # Ошибочный запуск не должен создавать готовый выходной файл. + assert not target.exists() # Не оставляем пустой результат после неудачной аутентификации. + convert(source, target, Options(mode="vector", pages="1"), password="test-pass") # Правильный пароль позволяет преобразовать выбранный лист. + with fitz.open(target) as document: # Сохранённый вектор должен быть доступен как самостоятельный PDF. + assert len(document) == 1 and document[0].get_drawings() # Проверяем фактическую графику после расшифровки и трассировки. diff --git a/tools/pdf-scan-to-vector/tests/test_exports.py b/tools/pdf-scan-to-vector/tests/test_exports.py new file mode 100644 index 0000000..8b4ddbe --- /dev/null +++ b/tools/pdf-scan-to-vector/tests/test_exports.py @@ -0,0 +1,63 @@ +from pathlib import Path # Проверяем реальные файлы, создаваемые командами экспорта интерфейса. +import zipfile # Читаем полученный архив страниц SVG независимо от кода записи. +import pytest # Изолируем временные каталоги, диалоги и настройки автоматических проверок. +import pymupdf as fitz # Проверяем экспортированный PDF после повторного открытия. +from engine import convert, Options # Формируем настоящий результат OCR для проверки кнопок экспорта. +from gui import MainWindow, application, W, C # Используем рабочие обработчики интерфейса и штатные виджеты Qt. +from sample import create_sample # Входной документ содержит реальные растровые страницы. + + +@pytest.fixture(scope="module") # Единственный объект QApplication должен жить дольше всех проверяемых окон. +def qt_app(): # Подготавливаем настоящую тему и цикл событий Qt. + return application() # Ссылка фикстуры предотвращает преждевременное уничтожение QApplication. + + +@pytest.fixture() # Каждый сценарий получает собственные документ, результат и настройки. +def window(qt_app, tmp_path, monkeypatch): # Модальные диалоги заменяем только для автоматической проверки действий. + source = tmp_path / "исходный.pdf" # Русское имя дополнительно проверяет сохранение путей экспорта. + create_sample(source) # Двухстраничный скан позволяет проверить сокращённый выбранный диапазон. + view = MainWindow() # Создаём действительное окно со всеми обработчиками экспорта. + view.settings = C.QSettings(str(tmp_path / "settings.ini"), C.QSettings.Format.IniFormat) # Запись тестового профиля не затрагивает реестр пользователя. + errors = [] # Перехватываем предупреждения, чтобы не блокировать автоматический прогон. + monkeypatch.setattr(W.QMessageBox, "warning", lambda *args: errors.append(args[-1])) # Все причины ошибок остаются доступны утверждениям теста. + assert view.load_pdf(source) # Открываем исходный файл через обычную проверку формата и предпросмотра. + report = convert(source, tmp_path / "result.pdf", Options(pages="2")) # Обрабатываем только второй исходный лист с настоящим OCR. + report["mode"] = "vector_ocr" # Интерфейс использует режим для доступности векторного экспорта. + view.report, view.result = report, fitz.open(report["path"]) # Подключаем завершённый результат к рабочим командам GUI. + yield view, errors # Тест вызывает общие обработчики так же, как нажатие соответствующих кнопок. + view.close() # Освобождаем документы, таймеры и внутренний временный каталог после сценария. + + +def test_pdf_text_svg_exports(window, tmp_path, monkeypatch): # Проверяем пользовательские выходные форматы через реальные команды интерфейса. + view, errors = window # Получаем окно с результатом обработки второй исходной страницы. + pdf, text, svg = tmp_path / "готовый.pdf", tmp_path / "текст.txt", tmp_path / "контуры.zip" # Назначения имеют кириллические имена и независимые расширения. + paths = iter((pdf, text, svg)) # Подставляем три назначения в порядке вызова кнопок экспорта. + monkeypatch.setattr(W.QFileDialog, "getSaveFileName", lambda *args: (str(next(paths)), "")) # Имитируем только выбор пути, сохраняя всю рабочую логику экспорта. + view.save_pdf() # Записываем готовый векторный PDF через атомарное копирование. + view.save_text() # Записываем OCR всех обработанных страниц в UTF-8. + view.save_svg() # Записываем набор самостоятельных векторных SVG в архив ZIP. + assert not errors # Ни один из форматов не должен вызывать скрытое предупреждение интерфейса. + with fitz.open(pdf) as document: # Повторное открытие подтверждает целостность экспортированного документа. + assert len(document) == 1 and document[0].search_for("Напряжение") # Экспорт не должен терять выбранный диапазон и поисковый Unicode-слой. + assert "Страница 2" in text.read_text(encoding="utf-8") and "Напряжение" in text.read_text(encoding="utf-8") # Текстовый формат сохраняет исходный номер листа и кириллицу. + with zipfile.ZipFile(svg) as archive: # Проверяем состав архива независимо от обработчика сохранения. + assert archive.namelist() == ["page_0002.svg"] # Имя SVG соответствует исходной странице, а не её позиции в сокращённом результате. + content = archive.read("page_0002.svg").decode("utf-8") # Экспортированная геометрия должна быть стандартным UTF-8 XML. + assert " 0.65 # Область найденного слова должна перекрывать не менее 65 процентов исходной надписи несмотря на различие метрик шрифтов. + assert bool(page.get_images()) == (mode == "ocr") # Совмещённый векторный режим не должен оставлять растровое изображение. + assert len(page.get_fonts()) == 1 # Все надписи должны разделять единственный ресурс шрифта, чтобы читатели PDF не разбирали таблицу Unicode многократно. + + +def test_native_unicode_and_latin_are_preserved(tmp_path): # Корректный русский Unicode и французские акценты нельзя перекодировать как старый ГОСТ. + source, output = tmp_path / "unicode.pdf", tmp_path / "unicode_result.pdf" # Вход и выход независимы для проверки сохранения исходных букв. + with fitz.open() as document: # Создаём страницу с двумя разными языками в обычном Unicode-шрифте. + page = document.new_page(width=250, height=140) # Размер в пунктах PDF достаточен для двух коротких надписей. + writer = fitz.TextWriter(page.rect) # Универсальный встроенный шрифт позволяет записать кириллицу без системных зависимостей. + writer.append((30, 45), "Авария №1 Ёж", font=fitz.Font("cjk"), fontsize=12) # Проверяем дополнительные символы, которые не сводятся к основному русскому алфавиту. + writer.append((30, 80), "déjà français", font=fitz.Font("cjk"), fontsize=12) # Латинские диакритические знаки должны сохранить исходный смысл. + writer.write_text(page) # Записываем видимые исходные надписи перед трассировкой. + document.save(source) # Сохраняем полноценный входной документ. + options = Options(dpi=150) # Умеренное разрешение достаточно для проверки невидимости поискового слоя. + convert(source, output, options) # Переносим правильный Unicode поверх векторных контуров. + geometry = tmp_path / "geometry.pdf" # Контрольный вариант содержит те же контуры без поискового слоя. + convert(source, geometry, replace(options, mode="vector")) # Изолируем влияние добавленного текста на видимые пиксели. + with fitz.open(output) as result, fitz.open(geometry) as vector: # Проверяем действительные сохранённые ресурсы и видимый результат. + assert result[0].search_for("Авария №1 Ёж") and result[0].search_for("déjà français") # Поиск должен работать для кириллицы, номера, Ё и латинских акцентов. + assert np.array_equal(np.frombuffer(result[0].get_pixmap().samples, np.uint8), np.frombuffer(vector[0].get_pixmap().samples, np.uint8)) # Невидимый текст не должен изменять ни одного пикселя отрисованной геометрии. + + +def test_mixed_page_still_requires_ocr(): # Готовая подпись рядом со сканом не должна выключать распознавание текста внутри изображения. + with fitz.open() as document: # Создаём в памяти страницу со смешанным растровым и текстовым содержимым. + page = document.new_page(width=250, height=140) # Небольшая страница подходит для проверки выбора источника текста. + page.insert_text((20, 25), "VH1") # Один готовый номер не описывает остальные надписи растровой схемы. + image = fitz.Pixmap(fitz.csRGB, fitz.IRect(0, 0, 20, 20), False) # Создаём RGB-изображение размером 20 на 20 пикселей без альфа-канала. + image.clear_with(255) # Белое изображение достаточно для проверки наличия реального растрового объекта. + page.insert_image(fitz.Rect(20, 40, 100, 120), pixmap=image) # Размещаем растр в видимой части страницы, чтобы он был обнаружен через get_image_info. + assert not native_text_spans(page) # Смешанный лист должен проходить OCR вместо переноса одной готовой подписи. diff --git a/tools/pdf-scan-to-vector/tests/test_text_ocr.py b/tools/pdf-scan-to-vector/tests/test_text_ocr.py new file mode 100644 index 0000000..31ed39d --- /dev/null +++ b/tools/pdf-scan-to-vector/tests/test_text_ocr.py @@ -0,0 +1,136 @@ +from threading import Event # Проверяем штатную отмену подготовки и удаления букв без отдельного процесса. +import numpy as np # Создаём маски пересекающихся линий и сравниваем реальные пиксели сканов. +import pymupdf as fitz # Проверяем видимый текст, изображения и повторное открытие PDF. +import pytest # Изолируем файлы и параметризуем повороты и профили распознавания. +from engine import Cancelled, Options, convert, rasterize # Используем публичный движок с настоящей трассировкой и OCR. +from sample import create_sample # Создаём скан с кириллицей, латиницей и геометрией схемы. +from text_ocr import recognition_pixmap, replace_word_shapes # Проверяем сохранность оригинального изображения и пересекающих слово линий. + + +def test_scanned_words_become_visible_text(tmp_path): # Новый режим должен заменять контуры настоящими буквами без двойного поискового слоя. + source, target = tmp_path / "scan.pdf", tmp_path / "text.pdf" # Отдельные пути гарантируют сохранность исходного документа. + create_sample(source) # Вход содержит растровые страницы без готового текста. + original = source.read_bytes() # Сравниваем исходник побайтно после завершения обработки. + report = convert(source, target, Options(mode="vector_text", pages="1")) # Запускаем новый режим с улучшенным OCR и удалением контуров букв. + assert source.read_bytes() == original # Подготовка OCR и удаление букв не должны изменять входной PDF. + assert report["pages"][0]["text_replacements"] > 10 # Несколько слов обязаны действительно перейти в видимый текст. + with fitz.open(target) as document: # Проверяем сохранённый файл после удаления неиспользуемых ресурсов. + page = document[0] # В выбранном диапазоне остаётся одна исходная страница. + assert not page.get_images(full=True) and page.get_drawings() # Графика остаётся векторной без спрятанной растровой копии. + assert page.get_text().count("Напряжение") == 1 # Заменённое слово не должно повторяться в видимом и невидимом слоях. + assert page.search_for("Напряжение") and page.search_for("VECTOR") # Русские и английские слова остаются доступными для поиска. + visible = [span for span in page.get_texttrace() if span["type"] == 0] # Нулевой тип трассы означает реальное рисование букв, а не только поиск. + assert any("Напряжение" in "".join(chr(char[0]) for char in span["chars"]) for span in visible) # Убеждаемся, что русское слово записано видимым шрифтом. + + +def test_previous_vector_ocr_can_be_replaced(tmp_path): # Невидимый OCR предыдущего результата нельзя принять за готовые видимые надписи. + source, previous, target = tmp_path / "scan.pdf", tmp_path / "old.pdf", tmp_path / "new.pdf" # Имитируем повторную обработку старого векторного результата с поисковым слоем. + create_sample(source) # Начинаем с настоящего растрового скана с кириллицей. + convert(source, previous, Options(mode="vector_ocr", pages="1")) # Прежний режим сохраняет контурные буквы и невидимый Unicode. + report = convert(previous, target, Options(mode="vector_text")) # Новый режим должен распознать и удалить именно видимые контурные слова. + assert report["pages"][0]["text_replacements"] > 10 # Подтверждаем, что слова удалось отделить, а не просто продублировать скрытые надписи. + with fitz.open(previous) as before, fitz.open(target) as after: # Сравниваем количество подконтуров реально сохранённых PDF. + before_items = sum(len(drawing["items"]) for drawing in before[0].get_drawings()) # Каждый штрих контурных букв увеличивает число команд графики прежнего результата. + after_items = sum(len(drawing["items"]) for drawing in after[0].get_drawings()) # После замены букв должны остаться преимущественно линии и нераспознанные обозначения. + assert after_items < before_items / 2 # Существенное сокращение геометрии выявляет ошибочное наложение шрифта поверх старых букв. + assert after[0].get_text().count("Напряжение") == 1 # В повторно обработанном PDF не должно быть дублей поискового текста. + + +def test_word_edges_leave_no_letter_contours(tmp_path): # Последние буквы и надстрочные знаки должны удаляться вместе со всем распознанным словом. + source, target = tmp_path / "letters.pdf", tmp_path / "clean.pdf" # Изолируем чисто текстовый скан от других сценариев проверки. + with fitz.open() as original, fitz.open() as scan: # Создаём сначала надпись, затем входной PDF исключительно с растровым изображением. + page = original.new_page(width=420, height=120) # Поля вокруг единственной строки облегчают OCR без влияния графики. + font = fitz.Font("cjk") # Встроенный шрифт содержит все знаки русской надписи. + page.insert_font(fontname="Russian", fontbuffer=font.buffer) # Подключаем кириллицу без зависимости от системных шрифтов. + page.insert_text((20, 70), "Проверка распознавания текста", fontname="Russian", fontsize=18) # Длинное слово выявляет недооценку OCR-ширины последней буквы. + scan.new_page(width=420, height=120).insert_image(page.rect, pixmap=page.get_pixmap(dpi=300)) # Растровый вход исключает перенос готового Unicode вместо настоящего OCR. + scan.save(source) # Сохраняем изображение строки как отдельный исходный PDF. + convert(source, target, Options(mode="vector_text", language="rus")) # Распознаём русскую строку и заменяем её обычным текстом. + with fitz.open(target) as result: # Проверяем фактическую геометрию после сохранения и очистки ресурсов. + assert result[0].search_for("распознавания") # Полное слово остаётся доступным для поиска в видимом шрифте. + assert not result[0].get_drawings() # На чисто текстовом листе после замены не должно оставаться ни одного контура буквы. + + +@pytest.mark.parametrize("source_rotation", [0, 90]) # Проверяем также PDF с исходным атрибутом поворота страницы. +@pytest.mark.parametrize("rotation", [0, 90, 180, 270]) # Все четыре пользовательские ориентации должны сохранять обычный текст. +def test_native_visible_text_and_rotations(tmp_path, rotation, source_rotation): # Готовые подписи нужно переносить без OCR и без оставшихся контурных дублей. + source, target = tmp_path / "native.pdf", tmp_path / "visible.pdf" # Создаём отдельные вход и результат для каждой ориентации. + with fitz.open() as document: # Подготавливаем векторную страницу с исходным Unicode и проводником. + page = document.new_page(width=360, height=240) # Прямоугольная страница выявляет ошибки координат при повороте. + font = fitz.Font("cjk") # Кириллица должна присутствовать в самом исходном документе. + page.insert_font(fontname="Russian", fontbuffer=font.buffer) # Встраиваем шрифт для независимости теста от Windows. + page.insert_text((265, 110), "Авария", fontname="Russian", fontsize=15) # Надпись правее короткой стороны выявляет неполное удаление текста у повёрнутого листа. + page.insert_text((140, 190), "SIGNAL", fontname="Russian", fontsize=12, rotate=90) # Вертикальное обозначение проверяет сохранение направления исходной строки. + page.draw_line((15, 220), (345, 220)) # Проводник должен остаться векторной графикой после удаления текста. + page.set_rotation(source_rotation) # Исходный поворот хранится отдельно от координат содержимого PDF. + document.save(source) # Сохраняем настоящий документ с двумя надписями и одной линией. + report = convert(source, target, Options(mode="vector_text", rotate=rotation, dpi=150)) # На готовом тексте разрешение влияет только на трассировку проводника. + assert report["pages"][0]["text_replacements"] == 2 # Обе готовые надписи должны быть перенесены без повторного OCR. + with fitz.open(target) as document: # Проверяем видимость Unicode и оставшуюся геометрию результата. + page = document[0] # Вход содержит одну страницу для каждой комбинации поворотов. + assert page.search_for("Авария") and page.search_for("SIGNAL") # Текст должен находиться независимо от ориентации надписей. + assert all(span["type"] == 0 for span in page.get_texttrace()) # Перенесённые подписи должны отображаться видимым шрифтом. + assert len(page.get_drawings()) == 1 # Контуры букв удалены: единственным рисованным объектом остаётся исходный проводник. + + +def test_word_removal_preserves_crossing_line(): # Замена надписи не должна разрывать проводник внутри её OCR-прямоугольника. + mask = np.zeros((80, 180), np.uint8) # Маска в пикселях содержит отдельные компоненты букв и длинную линию. + mask[32:48, 55:65] = 255 # Первое пятно имитирует отдельную толстую букву слова. + mask[32:48, 70:80] = 255 # Вторая буква расположена рядом с первой и не касается проводника. + mask[52, :] = 255 # Горизонтальный проводник пересекает область слова и выходит далеко за её границы. + pix = fitz.Pixmap(fitz.csRGB, 180, 80, np.full((80, 180, 3), 255, np.uint8).tobytes(), False) # Одинаковые физические и пиксельные координаты упрощают проверку удаления. + pix.set_dpi(72, 72) # При 72 DPI один пункт PDF соответствует одному пикселю маски. + accepted = replace_word_shapes(mask, [(53, 30, 82, 54, "AB", 0, 0, 0)], pix) # OCR-прямоугольник включает обе буквы и пересекающий проводник. + assert len(accepted) == 1 and not mask[32:48, 55:80].any() # Отдельные буквы удаляются для последующей записи шрифтом. + assert np.all(mask[52, :] == 255) # Проводник остаётся непрерывным даже внутри заменённой надписи. + + +@pytest.mark.parametrize("source_rotation", [0, 90, 180, 270]) # Ошибка проявлялась при исходном /Rotate, когда видимые и внутренние размеры листа различаются. +@pytest.mark.parametrize("rotation", [0, 90]) # Дополнительный пользовательский поворот не должен влиять на полноту удаления старых букв. +def test_rotated_table_has_no_outlined_text_duplicates(tmp_path, source_rotation, rotation): # Проверяем видимую графику ячеек после удаления нового шрифта, а не только единственность поискового текста. + source, target = tmp_path / "table.pdf", tmp_path / "clean_table.pdf" # Независимые файлы защищают исходный чертёж при проверке замены текста. + with fitz.open() as document: # Создаём небольшой чертёж с таблицей в нижней части высокого листа. + page = document.new_page(width=300, height=500) # При /Rotate 90 видимая высота 300 пунктов не охватывала текст с координатой y больше 300. + for y in (340, 385, 430, 475): # Горизонтальные границы задают три ячейки высотой 45 пунктов PDF. + page.draw_line((40, y), (180, y)) # Линии таблицы должны сохраняться независимо от замены цифр. + for x in (40, 180): # Замыкаем левую и правую стороны таблицы. + page.draw_line((x, 340), (x, 475)) # Вертикальные границы остаются отдельной графикой, которую нельзя удалять вместе с текстом. + for baseline in (371, 416, 461): # Надписи находятся целиком внутри ячеек, вдали от их границ. + page.insert_text((80, baseline), "0,5", fontname="tiit", fontsize=24) # Курсивный исходный шрифт воспроизводит заметное наложение цифр на новый обычный шрифт. + original_boxes = page.search_for("0,5") # Запоминаем области оригинальных цифр до сохранения исходного поворота. + page.set_rotation(source_rotation) # Поворот листа хранится отдельно от координат текстовых команд PDF. + document.save(source) # Сохраняем настоящий векторный вход без изображений и скрытого OCR. + convert(source, target, Options(mode="vector_text", dpi=150, rotate=rotation)) # Проверяем штатную ветку переноса готовых надписей в новый видимый текст. + with fitz.open(source) as original, fitz.open(target) as result: # Проверяем повторно открытый PDF после окончательной записи и сжатия. + page = result[0] # В результате находится один лист с тремя заменёнными надписями. + assert len(page.search_for("0,5")) == 3 # Поиск должен находить одну запись в каждой ячейке без текстовых дублей. + assert page.get_drawings() and not page.get_images(full=True) # Таблица сохраняет векторные линии без скрытого исходного растра. + extra_rotation = fitz.Matrix(rotation) # Независимо строим преобразование координат исходных ячеек. + bounds = original[0].rect * extra_rotation # Пользовательский поворот может переносить начало листа в отрицательные координаты. + transform = original[0].rotation_matrix * extra_rotation * fitz.Matrix(1, 0, 0, 1, -bounds.x0, -bounds.y0) * fitz.Matrix(page.rect.width / bounds.width, page.rect.height / bounds.height) # Учитываем оба поворота и округление физических размеров растра при 150 DPI. + page.add_redact_annot(page.rect, fill=False, cross_out=False) # Для проверки временно убираем новый шрифт из результата, не меняя файл на диске. + page.apply_redactions(images=fitz.PDF_REDACT_IMAGE_NONE, graphics=fitz.PDF_REDACT_LINE_ART_NONE, text=fitz.PDF_REDACT_TEXT_REMOVE) # Оставляем только фактические векторные контуры и линии таблицы. + for box in original_boxes: # Каждая область цифр должна стать полностью белой после удаления нового шрифта. + pix = page.get_pixmap(matrix=fitz.Matrix(3, 3), colorspace=fitz.csGRAY, clip=box * transform) # Увеличение втрое выявляет даже тонкие остатки старых курсивных букв. + assert np.min(np.frombuffer(pix.samples, np.uint8)) == 255 # Любой чёрный пиксель внутри ячейки означает оставшийся контур и видимое удвоение текста. + + +@pytest.mark.parametrize("profile", ["enhanced", "original"]) # Цветной результат обязан сохранять оригинальный скан при обоих профилях OCR. +def test_ocr_preparation_preserves_scan(tmp_path, profile): # Улучшенное распознавание не должно менять видимое изображение результата. + source, target = tmp_path / "scan.pdf", tmp_path / "search.pdf" # Независимые файлы позволяют сравнить сохранённый результат с оригиналом. + create_sample(source) # Реальный скан содержит линии, которые подготовка удаляет исключительно из OCR-копии. + options = Options(mode="ocr", pages="1", recognition=profile) # Обрабатываем одну страницу с выбранным профилем распознавания. + convert(source, target, options) # Выполняем полный путь записи и подстановки исходного изображения. + with fitz.open(source) as before, fitz.open(target) as after: # Сравниваем пиксели изображения из готового результата и исходного рендера. + pix, _ = rasterize(before[0], options) # Получаем те же размеры и исходные цвета, которые должен содержать результат. + image = fitz.Pixmap(after, after[0].get_images()[0][0]) # Читаем непосредственно сохранённый объект изображения без дополнительного сглаживания. + assert image.samples == pix.samples # OCR-подготовка не должна стирать линии или менять цвет изображения результата. + assert after[0].search_for("Напряжение") # Сохранение внешнего вида должно сопровождаться рабочим поисковым слоем. + + +def test_cancel_preparation(): # Дополнительный этап подготовки должен подчиняться штатной отмене обработки. + cancel = Event() # Используем событие с тем же контрактом, что у процесса GUI. + cancel.set() # Имитируем отмену до начала обработки изображения. + pix = fitz.Pixmap(fitz.csRGB, 8, 8, bytes([255] * 8 * 8 * 3), False) # Малый белый RGB-скан достаточен для проверки границы этапа. + with pytest.raises(Cancelled): # Отмена должна отличаться от ошибки OpenCV или языковой модели. + recognition_pixmap(pix, Options(), cancel) # Проверка события выполняется до выделения дополнительных масок. diff --git a/tools/pdf-scan-to-vector/text_ocr.py b/tools/pdf-scan-to-vector/text_ocr.py new file mode 100644 index 0000000..c47e8d0 --- /dev/null +++ b/tools/pdf-scan-to-vector/text_ocr.py @@ -0,0 +1,118 @@ +import math # Переводим границы OCR из пунктов PDF в целые пиксели без обрезания края букв. +import cv2 # Выравниваем фон и отделяем связные компоненты букв от графики схемы. +import numpy as np # Работаем с пиксельными масками без промежуточных файлов. +import pymupdf as fitz # Получаем OCR-координаты и рисуем настоящий Unicode-текст в PDF. +from engine import asset_path, binary_mask, check_cancel, rasterize, trace_svg, write_native_text # Используем общие преобразования движка; модуль загружается после инициализации engine. + + +def recognition_pixmap(pix, options, cancel=None): # Улучшаем только копию для OCR, сохраняя исходную геометрию и цвет результата. + if options.recognition == "original": # Исходный профиль позволяет сравнить OCR без подготовки на необычных сканах. + return pix # Не копируем изображение при отключённой пользователем подготовке. + check_cancel(cancel) # Проверяем отмену перед операциями над большим изображением. + rgb = np.frombuffer(pix.samples, np.uint8).reshape(pix.height, pix.width, 3) # Читаем RGB без изменения исходного Pixmap. + gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY) # Для распознавания формы знаков достаточно яркости изображения. + background = cv2.GaussianBlur(gray, (0, 0), max(3, pix.xres / 30)) # Размытие около 10 пикселей при 300 DPI оценивает медленно меняющийся фон бумаги. + normalized = cv2.divide(gray, np.maximum(background, 1), scale=255) # Деление на фон ослабляет тени; единица защищает чёрные области от деления на ноль. + _, ink = cv2.threshold(normalized, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU) # Автоматический порог выделяет чернила на выровненном фоне. + for horizontal in (True, False): # Находим горизонтальные и вертикальные линии таблиц и схем отдельно. + check_cancel(cancel) # Позволяем отменить дополнительную обработку между проходами. + length = max(round(80 * pix.xres / 300), round((pix.width if horizontal else pix.height) * 0.06)) # Минимум 80 пикселей при 300 DPI и 6 процентов стороны исключает обычные штрихи букв. + kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (length, 1) if horizontal else (1, length)) # Узкое окно выделяет только длинные непрерывные прямые сегменты. + lines = cv2.morphologyEx(ink, cv2.MORPH_OPEN, kernel) # Размыкание оставляет длинные линии, отбрасывая отдельные символы. + normalized[lines != 0] = 255 # Убираем найденные линии белым цветом исключительно из OCR-копии. + prepared = fitz.Pixmap(fitz.csRGB, pix.width, pix.height, cv2.cvtColor(normalized, cv2.COLOR_GRAY2RGB).tobytes(), False) # Размер копии совпадает с оригиналом, поэтому координаты слов не смещаются. + prepared.set_dpi(pix.xres, pix.yres) # Сохраняем фактическое разрешение после ограничения памяти больших листов. + return prepared # Передаём OCR копию, оставляя исходные пиксели для выходного документа. + + +def replace_word_shapes(mask, words, pix, cancel=None): # Удаляем компоненты букв, сохраняя линии, которые выходят за границы OCR-слова. + accepted = [] # Заменяем только слова, чьи чернила удалось отделить от окружающей схемы. + for index, word in enumerate(words): # OCR возвращает четыре координаты в пунктах PDF и затем текст слова. + if index % 32 == 0: # Проверяем отмену каждые 32 слова для больших чертежей. + check_cancel(cancel) # Не оставляем частично обработанный документ при отмене. + if not word[4].strip() or "\ufffd" in word[4] or not any(char.isalnum() for char in word[4]): # Не считаем отдельные линии и неизвестные символы достоверными надписями. + continue # Сомнительная геометрия сохраняется контурами. + padding = max(3, math.ceil((word[3] - word[1]) * pix.yres / 72 * 0.12)) # Допуск 12 процентов высоты слова и минимум три пикселя покрывает недооценённые OCR-рамки последних букв и надстрочные знаки. + x0, y0 = max(0, math.floor(word[0] * pix.xres / 72) - padding), max(0, math.floor(word[1] * pix.yres / 72) - padding) # Расширяем область с учётом фактического размера надписи и разрешения скана. + x1, y1 = min(pix.width, math.ceil(word[2] * pix.xres / 72) + padding), min(pix.height, math.ceil(word[3] * pix.yres / 72) + padding) # Ограничиваем расширенную область размерами изображения. + if x1 <= x0 or y1 <= y0: # Некорректный прямоугольник не должен создавать пустую область OpenCV. + continue # Сохраняем графику без попытки удаления повреждённой области. + halo = max(4, y1 - y0) # Поле высотой со слово позволяет увидеть выходящие за его пределы проводники. + left, top, right, bottom = max(0, x0 - halo), max(0, y0 - halo), min(pix.width, x1 + halo), min(pix.height, y1 + halo) # Обрабатываем локальное окружение вместо массива меток на весь лист. + region = mask[top:bottom, left:right] # Представление массива позволяет изменить исключительно выбранные компоненты оригинальной маски. + total, labels, stats, _ = cv2.connectedComponentsWithStats(region, connectivity=8) # Восьмисвязность объединяет диагональные штрихи букв в одну компоненту. + removable = np.zeros(total, dtype=bool) # Нулевая метка является фоном и всегда остаётся исключённой из удаления. + incomplete = False # Не допускаем замену слова, если возле его края остаётся компонент размером с букву. + for label_id in range(1, total): # Проверяем только реальные связные пятна вокруг надписи. + x, y, width, height, area = stats[label_id] # Координаты и размеры измеряются в пикселях, площадь — в квадратных пикселях. + removable[label_id] = x + left >= x0 and y + top >= y0 and x + left + width <= x1 and y + top + height <= y1 and width < 8 * max(height, 1) # Удаляем целиком вложенные компоненты; соотношение сторон 8 исключает длинные подчёркивания и проводники. + overlaps = x + left < x1 - padding and x + left + width > x0 + padding and y + top < y1 - padding and y + top + height > y0 + padding # Проверяем пересечение с основным прямоугольником слова, исключая случайные детали в полях. + incomplete |= bool(not removable[label_id] and overlaps and 0.2 * (y1 - y0) <= height <= 1.5 * (y1 - y0) and width < 3 * (y1 - y0) and width < 8 * max(height, 1)) # Компонент высотой с букву за рамкой требует сохранения всего слова контурами; длинные проводники этому правилу не мешают. + removal = removable[labels] # Преобразуем решения по компонентам в локальную пиксельную маску удаления. + ink_count = np.count_nonzero(mask[y0:y1, x0:x1]) # Измеряем количество чернил внутри распознанного прямоугольника. + if not incomplete and ink_count and np.count_nonzero(removal) >= ink_count * 0.85: # Требуем отделения минимум 85 процентов чернил и отсутствия неубранных компонентов букв, сохраняя пересекающие проводники. + rows, columns = np.nonzero(removal) # Измеряем фактические чернила: общая высота OCR-строки завышает размер слов без заглавных букв. + ink_box = ((left + columns.min()) * 72 / pix.xres, (top + rows.min()) * 72 / pix.yres, (left + columns.max() + 1) * 72 / pix.xres, (top + rows.max() + 1) * 72 / pix.yres) # Переводим тесную рамку удалённых букв обратно в пункты PDF для правильной высоты и длины шрифта. + region[removal] = 0 # Удаляем только компоненты букв, не закрывая окружающую графику белым прямоугольником. + accepted.append((*word, ink_box)) # Сохраняем исходную OCR-рамку для удаления поискового дубля и отдельную рамку чернил для видимого текста. + return accepted # Неотделимые и нераспознанные подписи продолжают отображаться исходными контурами. + + +def write_visible_words(target, words, cancel=None): # Рисуем OCR-слова обычным шрифтом с кириллицей вместо многоугольных букв. + font = fitz.Font("cjk") # Встроенный Droid Sans Fallback обеспечивает одинаковую кириллицу без установки шрифтов Windows. + target.insert_font(fontname="VisibleText", fontbuffer=font.buffer) # Один ресурс шрифта уменьшает PDF и ускоряет открытие в просмотрщиках. + metrics = {} # Кешируем фактические высоты символов: глобальная рамка CJK-шрифта не совпадает с видимыми габаритами кириллицы. + for index, word in enumerate(words): # Каждое слово сохраняет собственное положение на странице. + if index % 32 == 0: # Проверка между группами слов поддерживает отмену больших текстовых слоёв. + check_cancel(cancel) # Не записываем неполный слой после отмены пользователя. + box, text = fitz.Rect(word[8] if len(word) > 8 else word[:4]), word[4] # Рамка реальных чернил сохраняет высоту строчных букв; исходная OCR-рамка остаётся запасным вариантом для прямого вызова. + for char in set(text) - set(" \t\r\n"): # Измеряем каждый новый символ один раз, независимо от числа повторений в документе. + if char not in metrics: # Повторяющиеся буквы используют уже вычисленные высоты. + with fitz.open() as measurement: # Временная страница позволяет измерить реальные габариты через публичный рендерер PDF. + probe = measurement.new_page(width=240, height=240) # Квадрат 240 пунктов вмещает символ размером 100 пунктов вместе с выносными элементами. + probe.insert_font(fontname="Probe", fontbuffer=font.buffer) # Для измерения используем тот же шрифт, которым будет записан результат. + probe.insert_text((60, 150), char, fontname="Probe", fontsize=100) # Базовая точка 150 пунктов и размер 100 дают точность измерения около одного процента. + pixels = probe.get_pixmap(colorspace=fitz.csGRAY, alpha=False) # При 72 DPI один пиксель соответствует одному пункту временной страницы. + rows = np.flatnonzero(np.any(np.frombuffer(pixels.samples, np.uint8).reshape(pixels.height, pixels.width) < 200, axis=1)) # Порог 200 из 255 отбрасывает почти белые пиксели сглаживания, сохраняя видимые края. + metrics[char] = ((150 - rows[0]) / 100, (150 - rows[-1] - 1) / 100) if len(rows) else (font.ascender, font.descender) # Возвращаем высоты над и под базовой линией в долях размера шрифта; пустой знак получает общие метрики. + upper, lower = max(metrics[char][0] for char in text if not char.isspace()), min(metrics[char][1] for char in text if not char.isspace()) # Учитываем верхние знаки и нижние выносные элементы всех букв слова. + size = box.height / max(upper - lower, 0.01) # Подбираем размер в пунктах PDF по высоте знаков; 0,01 защищает от пустых метрик. + origin = fitz.Point(box.x0, box.y0 + upper * size) # Совмещаем верх букв с OCR-прямоугольником через базовую линию шрифта. + stretch = box.width / max(font.text_length(text, fontsize=size), 0.01) # Сохраняем длину надписи и расстояние до соседних обозначений. + target.insert_text(origin, text, fontname="VisibleText", fontsize=size, color=0, render_mode=0, morph=(origin, fitz.Matrix(stretch, 1))) # Нулевой режим PDF рисует видимые чёрные буквы, горизонтальный масштаб сохраняет ширину слова. + + +def text_vector_page(result, source, pix, scale, native, options, notify, cancel=None): # Строим векторную графику и видимый текст без дублирования контурных букв. + if native: # Уже готовый Unicode надёжнее повторного OCR векторного технического шрифта. + target = result.new_page(width=pix.width * 72 / pix.xres, height=pix.height * 72 / pix.yres) # Создаём лист с физическими размерами повёрнутого скана. + with fitz.open() as graphics: # Удаляем текст исключительно из временной копии документа. + graphics.insert_pdf(source.parent, from_page=source.number, to_page=source.number) # Копируем страницу вместе с поворотом и векторной графикой. + graphics[0].add_redact_annot(graphics[0].rect * graphics[0].derotation_matrix, fill=False, cross_out=False) # Удаление текста принимает координаты до /Rotate: обратный поворот охватывает весь лист, включая таблицы за короткой стороной повёрнутой страницы. + graphics[0].apply_redactions(images=fitz.PDF_REDACT_IMAGE_NONE, graphics=fitz.PDF_REDACT_LINE_ART_NONE, text=fitz.PDF_REDACT_TEXT_REMOVE) # Удаляем только текст, сохраняя линии, изображения и остальные объекты. + geometry, _ = rasterize(graphics[0], options) # Рендерим оставшуюся графику с исходными настройками разрешения и поворота. + svg, contours = trace_svg(geometry, options, scale, cancel) # Векторизуем графику без букв, которые будут записаны шрифтом. + write_native_text(target, source, native, options, cancel, visible=True) # Переносим исправленный Unicode видимым шрифтом с исходными базовыми точками и наклоном. + replacements = len(native) # Число перенесённых надписей помогает оценить охват обработки. + else: # Для растрового листа сначала определяем содержание и расположение слов с помощью OCR. + prepared = recognition_pixmap(pix, options, cancel) # Улучшаем фон и удаляем линии из отдельной копии для распознавания. + payload = prepared.pdfocr_tobytes(language=options.language, tessdata=str(asset_path("tessdata"))) # Используем локальные модели русского и английского языка. + check_cancel(cancel) # Проверяем отмену сразу после дорогостоящего OCR. + with fitz.open("pdf", payload) as recognized: # Временная страница содержит изображение и скрытый Unicode в физических координатах. + mask = binary_mask(pix, options) # Для итоговой графики используем чернила оригинала, а не изменённую OCR-копию. + words = replace_word_shapes(mask, recognized[0].get_text("words", sort=True), pix, cancel) # Отделяем буквы от пересекающих границы слова проводников. + svg, contours = trace_svg(pix, options, scale, cancel, mask=mask) # Заменённые слова исключены из маски и не появляются повторными контурами. + recognized[0].add_redact_annot(recognized[0].rect, fill=False, cross_out=False) # Помечаем растровую копию для удаления без изменений скрытого текста. + recognized[0].apply_redactions(images=fitz.PDF_REDACT_IMAGE_REMOVE, graphics=fitz.PDF_REDACT_LINE_ART_NONE, text=fitz.PDF_REDACT_TEXT_NONE) # Убираем растр, сохраняя поисковый слой слов, оставшихся контурами. + for word in words: # Удаляем скрытые дубликаты слов, которые получат видимый шрифт. + recognized[0].add_redact_annot(fitz.Rect(word[:4]), fill=False, cross_out=False) # OCR-прямоугольник задаёт область удаления старого поискового текста. + if words: # Пустой набор областей не нуждается в применении удаления. + recognized[0].apply_redactions(images=fitz.PDF_REDACT_IMAGE_NONE, graphics=fitz.PDF_REDACT_LINE_ART_NONE, text=fitz.PDF_REDACT_TEXT_REMOVE) # Предотвращаем двойное выделение и повторение заменённых слов при копировании. + result.insert_pdf(recognized) # Переносим страницу с оставшимся поисковым слоем и ресурсами шрифта. + target = result[-1] # Получаем итоговую страницу после изменения структуры документа. + write_visible_words(target, words, cancel) # Рисуем принятые слова обычным шрифтом, сохраняя возможность поиска и копирования. + replacements = len(words) # Считаем только слова, действительно заменённые видимым текстом. + if svg: # Полностью текстовой странице может не требоваться оставшаяся векторная графика. + with fitz.open("svg", svg) as drawing, fitz.open("pdf", drawing.convert_to_pdf()) as vector: # Преобразуем контуры графики в настоящие команды PDF. + target.show_pdf_page(target.rect, vector, 0, overlay=False) # Размещаем оставшуюся графику под текстовыми слоями. + notify({"kind": "log", "message": f"Заменено текстом: {replacements}; неотделимые и нераспознанные подписи сохранены контурами"}) # Объясняем охват замены без обещания безошибочного распознавания. + return target.get_text(sort=True), contours, replacements # Текст интерфейса соответствует сохранённому PDF, включая оставшийся поисковый слой. diff --git a/tools/pdf-scan-to-vector/theme.py b/tools/pdf-scan-to-vector/theme.py new file mode 100644 index 0000000..879820e --- /dev/null +++ b/tools/pdf-scan-to-vector/theme.py @@ -0,0 +1,39 @@ +STYLE = """/* Используем палитру и оформление панелей соседнего проекта SETGUI. */ +QWidget { background: #10151d; color: #dce6f2; font-family: "Segoe UI"; font-size: 10pt; } /* Основной фон и читаемый шрифт SETGUI. */ +QMainWindow { background: #0d1219; } /* Более тёмная рамка отделяет рабочую область. */ +QLabel { background: transparent; } /* Подписи не перекрывают цвет родительских панелей. */ +QFrame#header { background: #151d28; border-bottom: 1px solid #263345; } /* Верхняя панель повторяет оформление SETGUI. */ +QLabel#brand { color: #62b0ff; font-size: 19pt; font-weight: 700; } /* Синий знак приложения задаёт визуальный акцент. */ +QLabel#title { color: #f4f8fc; font-size: 15pt; font-weight: 600; } /* Заголовок обозначает назначение окна. */ +QLabel#muted { color: #8291a5; } /* Второстепенные данные имеют спокойный серый оттенок. */ +QLabel#section { color: #f4f8fc; font-size: 11pt; font-weight: 600; } /* Названия групп выделены без лишних рамок. */ +QFrame#panel { background: #151d28; border: 1px solid #263345; border-radius: 7px; } /* Боковые блоки повторяют скруглённые панели SETGUI. */ +QPushButton { background: #243247; border: 1px solid #344762; border-radius: 5px; padding: 7px 12px; } /* Базовые кнопки имеют достаточную область нажатия. */ +QPushButton:hover { background: #2d405b; border-color: #52647c; } /* Наведение помогает отличить интерактивные элементы. */ +QPushButton:pressed { background: #1c293b; } /* Нажатая кнопка визуально утоплена. */ +QPushButton:disabled { color: #627086; background: #192230; border-color: #263345; } /* Недоступные команды сохраняют структуру интерфейса. */ +QPushButton#primary { background: #1570d8; border-color: #2584ec; color: white; font-weight: 600; padding: 11px; } /* Главная команда обработки использует основной синий цвет SETGUI. */ +QPushButton#primary:hover { background: #2584ec; } /* Подсветка подтверждает доступность запуска. */ +QPushButton#primary:disabled { background: #192230; color: #627086; border-color: #344762; } /* Во время обработки повторный запуск явно заблокирован. */ +QLineEdit, QComboBox, QSpinBox, QDoubleSpinBox { background: #0d131c; border: 1px solid #34445a; border-radius: 5px; padding: 6px; selection-background-color: #1570d8; } /* Поля настроек повторяют тёмный ввод SETGUI. */ +QComboBox::drop-down { width: 22px; border: 0; } /* Сохраняем место для стандартной стрелки раскрытия. */ +QComboBox QAbstractItemView { background: #151d28; selection-background-color: #243247; } /* Список вариантов остаётся частью тёмной темы. */ +QTabWidget::pane { border: 1px solid #263345; background: #10151d; } /* Рамка связывает вкладки с областью предпросмотра. */ +QTabBar::tab { background: #151d28; color: #91a0b4; padding: 10px 16px; border-bottom: 2px solid transparent; } /* Вкладки имеют спокойное исходное состояние. */ +QTabBar::tab:selected { background: #1c2838; color: white; border-bottom: 2px solid #2f91ff; } /* Активная вкладка отмечена синей линией как в SETGUI. */ +QListWidget { background: #10151d; border: 0; outline: 0; } /* Список страниц визуально объединён с левой панелью. */ +QListWidget::item { padding: 8px; margin: 3px; border: 1px solid transparent; border-radius: 4px; } /* Карточки страниц имеют постоянную геометрию. */ +QListWidget::item:selected { background: #1c304a; border-color: #2f91ff; } /* Выбранная страница хорошо заметна среди миниатюр. */ +QListWidget::item:hover { background: #1c2838; } /* Наведение показывает возможность перехода на страницу. */ +QPlainTextEdit { background: #0d131c; border: 1px solid #263345; padding: 8px; selection-background-color: #1570d8; } /* OCR и журнал сохраняют высокий контраст текста. */ +QGraphicsView { background: #0b1017; border: 0; } /* Тёмный стол подчёркивает белый лист PDF. */ +QProgressBar { background: #0d131c; border: 1px solid #263345; border-radius: 4px; text-align: center; min-height: 20px; } /* Прогресс читается на фоне панели состояния. */ +QProgressBar::chunk { background: #1570d8; border-radius: 3px; } /* Заполнение повторяет акцент главной кнопки. */ +QSplitter::handle { background: #263345; } /* Разделитель позволяет менять ширину списка и предпросмотра. */ +QScrollArea { border: 0; } /* Настройки прокручиваются без дополнительной внешней рамки. */ +QScrollBar:vertical { background: #10151d; width: 10px; } /* Узкая вертикальная полоса не отвлекает от документа. */ +QScrollBar::handle:vertical { background: #34445a; min-height: 24px; border-radius: 4px; } /* Ползунок остаётся различимым в длинных списках. */ +QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0; } /* Убираем лишние кнопки на концах полосы. */ +QToolTip { background: #243247; color: #f4f8fc; border: 1px solid #52647c; padding: 6px; } /* Подсказки объясняют параметры без засорения интерфейса. */ +QStatusBar { background: #0d1219; color: #8291a5; } /* Нижняя строка показывает состояние локальной обработки. */ +""" # Завершаем таблицу оформления без внешней зависимости от SETGUI. diff --git a/tools/pdf-scan-to-vector/tools/build.ps1 b/tools/pdf-scan-to-vector/tools/build.ps1 new file mode 100644 index 0000000..ad3aa54 --- /dev/null +++ b/tools/pdf-scan-to-vector/tools/build.ps1 @@ -0,0 +1,49 @@ +$ErrorActionPreference = 'Stop' # Останавливаем сборку при ошибке файловой системы или отсутствии необходимых ресурсов. +$projectPath = Split-Path -Parent $PSScriptRoot # Все пути вычисляем относительно проекта, а не текущего каталога PowerShell. +Set-Location -LiteralPath $projectPath # Запускаем проверки и сборку в корневой папке приложения. +$pythonPath = Join-Path $projectPath '.venv\Scripts\python.exe' # Используем отдельное окружение с зафиксированными зависимостями. +if (-not (Test-Path -LiteralPath $pythonPath)) { # Подготавливаем окружение при первом запуске сборки. + python -m venv .venv # Системный Python нужен только разработчику, а не пользователю готового EXE. + if ($LASTEXITCODE -ne 0) { throw 'Не удалось создать окружение Python.' } # Не продолжаем сборку после неудачной подготовки интерпретатора. +} # Завершаем проверку наличия изолированного окружения. +& $pythonPath -m pip install -r requirements-build.txt # Устанавливаем точные версии GUI, обработки PDF и упаковщика. +if ($LASTEXITCODE -ne 0) { throw 'Не удалось установить зависимости.' } # Не создаём сборку с неполным набором библиотек. +& $pythonPath -m pytest -q # Проверяем настоящую векторизацию, поисковый слой, отмену и защиту исходника. +if ($LASTEXITCODE -ne 0) { throw 'Проверки не пройдены.' } # Не публикуем приложение при регрессии обработки документов. +& $pythonPath tools\make_icon.py # Создаём собственный геометрический значок PDF без внешних редакторов. +if ($LASTEXITCODE -ne 0) { throw 'Не удалось создать значок.' } # Отсутствие ресурса должно быть выявлено до упаковки. +$releaseDirectory = Join-Path $projectPath 'build\release' # Сначала собираем во внутреннюю папку, чтобы запущенный пользовательский EXE не мешал упаковке. +& $pythonPath -m PyInstaller --noconfirm --clean --distpath $releaseDirectory PDFScanToVector.spec # Проверенная спецификация исключает конфликтующий ICU из PATH и создаёт отдельный файл для самопроверки. +if ($LASTEXITCODE -ne 0) { throw 'Не удалось собрать EXE.' } # Явно проверяем код внешней программы PowerShell. +$executablePath = Join-Path $releaseDirectory 'PDFScanToVector.exe' # Проверяем новый исполняемый файл до замены опубликованной версии. +$verificationPath = Join-Path $projectPath 'verification-output\exe' # Отделяем результаты проверки сборки от исходного приложения. +$checkProcess = Start-Process -FilePath $executablePath -ArgumentList @('--self-test', ('"' + $verificationPath + '"')) -WindowStyle Hidden -PassThru # Проверяем GUI, дочерний процесс, русский OCR и векторные страницы непосредственно в готовом EXE. +if (-not $checkProcess.WaitForExit(240000)) { # Ограничиваем ожидание четырьмя минутами на обычном компьютере Windows. + Stop-Process -Id $checkProcess.Id -Force # Завершаем только запущенную сборочным сценарием проверку. + throw 'Самопроверка EXE превысила время ожидания.' # Не считаем зависшую проверку успешным выпуском. +} # Завершаем обработку предельного времени проверки. +if ($checkProcess.ExitCode -ne 0) { throw 'Самопроверка EXE не пройдена. См. verification-output\exe\verification.json.' } # Причина сбоя остаётся доступной в машиночитаемом отчёте. +$distributionDirectory = Join-Path $projectPath 'dist' # Готовые проверенные сборки публикуем в постоянную папку проекта. +New-Item -ItemType Directory -Path $distributionDirectory -Force | Out-Null # Создаём папку распространения также при самой первой сборке проекта. +$publishedPath = Join-Path $distributionDirectory 'PDFScanToVector.exe' # Обычно обновляем привычное имя исполняемого файла. +try { # Замена основного EXE может быть запрещена Windows, если приложение сейчас запущено. + Copy-Item -LiteralPath $executablePath -Destination $publishedPath -Force # Публикуем только сборку, уже прошедшую полную самопроверку. +} catch { # При занятом основном файле сохраняем новое приложение отдельно, не останавливая пользовательский сеанс. + $publishedPath = Join-Path $distributionDirectory ('PDFScanToVector_' + (Get-Date -Format 'yyyyMMdd_HHmmss_fff') + '.exe') # Метка времени до миллисекунды исключает конфликт с предыдущими дополнительными сборками. + Copy-Item -LiteralPath $executablePath -Destination $publishedPath # Новое имя позволяет завершить сборку даже при открытой основной версии. + Write-Host 'Основной EXE недоступен для замены; новая сборка сохранена под отдельным именем.' # Поясняем пользователю, почему имя файла отличается от обычного. +} # Завершаем публикацию новой версии без принудительного закрытия пользовательского приложения. +Copy-Item -LiteralPath README.md -Destination dist\README.txt # Добавляем краткое руководство рядом с готовым исполняемым файлом. +Copy-Item -LiteralPath THIRD_PARTY_NOTICES.md -Destination dist\THIRD_PARTY_NOTICES.txt # Сохраняем сведения о лицензиях поставляемых компонентов. +$checksumAlgorithm = [System.Security.Cryptography.SHA256]::Create() # Используем встроенный .NET, чтобы контрольная сумма не зависела от доступности командлета Get-FileHash в Windows PowerShell. +$checksumStream = [System.IO.File]::OpenRead($publishedPath) # Читаем готовый EXE потоком, не загружая весь файл в оперативную память. +try { # Гарантируем освобождение файлового дескриптора после расчёта суммы. + $checksumBytes = $checksumAlgorithm.ComputeHash($checksumStream) # Рассчитываем 256-битный SHA-256 опубликованного исполняемого файла. +} finally { # Выполняем очистку также при ошибке чтения EXE. + $checksumStream.Dispose() # Снимаем блокировку с файла после проверки целостности. + $checksumAlgorithm.Dispose() # Освобождаем ресурсы криптографического алгоритма .NET. +} # Завершаем потоковый расчёт контрольной суммы. +$artifactChecksum = [pscustomobject]@{ Algorithm = 'SHA256'; Hash = [System.BitConverter]::ToString($checksumBytes).Replace('-', ''); Path = $publishedPath } # Формируем читаемую шестнадцатеричную сумму и точный путь новой сборки. +($artifactChecksum.Hash + ' ' + (Split-Path -Leaf $publishedPath)) | Set-Content -LiteralPath dist\SHA256SUMS.txt -Encoding UTF8 # Контрольная сумма всегда относится к новой сборке, включая вариант с отдельным именем. +$artifactChecksum | Format-List # Показываем путь и контрольную сумму готового исполняемого файла в окне BAT. +Write-Host ('Готовый EXE: ' + $publishedPath) # Явно показываем точное назначение сборки после всех проверок и сохранения сопроводительных файлов. diff --git a/tools/pdf-scan-to-vector/tools/build_component.py b/tools/pdf-scan-to-vector/tools/build_component.py new file mode 100644 index 0000000..bc737d4 --- /dev/null +++ b/tools/pdf-scan-to-vector/tools/build_component.py @@ -0,0 +1,62 @@ +"""Сборка независимой папки PDF Scan to Vector для SETGUI.""" # Обычный однофайловый выпуск сохраняет исходный сценарий tools/build.ps1. +import argparse # Параметр установки задаёт конкретную папку компонента. +import os # Вариант упаковки передаётся существующему spec через окружение. +import shutil # Комплект копируется целиком вместе с приватными DLL и моделями OCR. +import subprocess # Сборщик запускается тем же интерпретатором, в котором установлены закреплённые зависимости. +import sys # Выбранный Python не зависит от PATH пользователя. +import tempfile # Обновление готовится в уникальной папке на том же томе. +from pathlib import Path # Все пути разрешаются относительно расположения исходников. + +ROOT = Path(__file__).resolve().parents[1] # Сценарий находится в tools внутри самостоятельной программы. + + +def deploy_runtime(source, destination): # Заменяем только собственную папку компонента с возможностью отката. + source, destination = Path(source).resolve(), Path(destination).resolve() # Проверки пересечения выполняются по абсолютным путям. + if not (source / "PDFScanToVector.exe").is_file(): # Частичная сборка не должна заменить установленную программу. + raise FileNotFoundError("В комплекте отсутствует PDFScanToVector.exe: " + str(source)) # Отказ содержит точный проверяемый путь. + if source == destination or source in destination.parents or destination in source.parents: # Исходный комплект и назначение не могут содержать друг друга. + raise ValueError("Каталоги сборки и установки не должны пересекаться") # Предотвращаем копирование компонента внутрь самого себя. + destination.parent.mkdir(parents=True, exist_ok=True) # Создаём только явно выбранный родительский каталог установки. + update = Path(tempfile.mkdtemp(prefix=".pdf-vector-update-", dir=destination.parent)).resolve() # Временный комплект расположен на том же томе для атомарного переименования. + staging, backup = update / "new", update / "old" # Предыдущая версия остаётся рядом до успешной установки новой. + installed = False # Флаг отличает успешную установку от неудачного отката. + try: # Любая ошибка копирования оставляет прежний комплект доступным пользователю. + shutil.copytree(source, staging) # Сначала полностью готовим новый набор EXE, DLL, моделей и лицензий. + if destination.exists(): # Чистая установка не требует резервной версии. + destination.rename(backup) # Заблокированная работающим приложением папка вызывает отказ без принудительного завершения. + try: # После переноса старой версии восстанавливаем её при отказе публикации новой. + staging.rename(destination) # Публикуем весь комплект одной операцией файловой системы. + installed = True # Старый комплект теперь можно удалить из уникальной временной папки. + except OSError: # Ошибка финального переименования не должна оставлять отсутствующий компонент. + if backup.exists(): # Резервная версия присутствует только при обновлении существующей установки. + backup.rename(destination) # Возвращаем прежний комплект по исходному адресу. + raise # Сборщик сообщает об ошибке установки вместо ложного успеха. + finally: # Удаляем временную папку только после проверки границ и возможности восстановления. + if installed or not backup.exists(): # Неудачный откат сохраняет резервные файлы для ручного восстановления. + if update.parent != destination.parent or not update.name.startswith(".pdf-vector-update-"): # Защищаем рекурсивное удаление проверкой разрешённого абсолютного пути. + raise RuntimeError("Неожиданный временный каталог: " + str(update)) # Непроверенный путь никогда не передаётся удалению. + shutil.rmtree(update) # Удаляется только собственный уникальный каталог завершённого обновления. + return destination # Вызывающая сторона получает точное расположение проверенного комплекта. + + +def main(argv=None): # Один сценарий используется непосредственно и оболочкой сборки SETGUI. + parser = argparse.ArgumentParser(description=__doc__) # Стандартная справка описывает назначение отдельного компонента. + parser.add_argument("--deploy-dir", type=Path, action="append", default=[]) # Несколько назначений позволяют установить один комплект для EXE и исходного SETGUI. + args = parser.parse_args(argv) # Пути не интерпретируются командной оболочкой. + if sys.platform != "win32" or sys.version_info[:2] != (3, 13) or sys.maxsize <= 2**32: # Закреплённые библиотеки рассчитаны на Windows и Python 3.13 x64. + parser.error("Нужен Python 3.13 x64 для Windows") # Не создаём комплект с другой платформой или разрядностью. + environment = dict(os.environ, PDF_SCAN_COMPONENT="1") # Единственный spec переключается на независимую папку вместо onefile. + work = ROOT / "build/component" # Артефакты не попадают в исходники общей библиотеки templates. + command = [sys.executable, "-m", "PyInstaller", "--noconfirm", "--clean", "--distpath", str(work / "dist"), "--workpath", str(work / "work"), str(ROOT / "PDFScanToVector.spec")] # Сборка использует закреплённое окружение и абсолютные назначения. + subprocess.run(command, cwd=ROOT, env=environment, check=True) # Ненулевой результат запрещает публикацию неполной программы. + runtime = work / "dist/PDFScanToVector" # Имя папки совпадает с COLLECT существующего spec. + for name in ("README.md", "THIRD_PARTY_NOTICES.md"): # Руководство и лицензии сопровождают каждую переносимую установку. + shutil.copy2(ROOT / name, runtime / name) # Пользователь получает сведения о работе программы и сторонних компонентах рядом с EXE. + for destination in args.deploy_dir: # Сборка выполняется один раз для всех явно заданных назначений. + print(deploy_runtime(runtime, destination)) # Установка использует проверяемое обновление с сохранением предыдущей версии при отказе. + print(runtime) # Без установки сценарий также выдаёт полный путь готового комплекта. + return 0 # Успешное завершение означает полную сборку и все запрошенные установки. + + +if __name__ == "__main__": # Импорт функций проверки не запускает тяжёлую упаковку приложения. + raise SystemExit(main()) # Код сборки передаётся BAT и другим автоматическим сценариям. diff --git a/tools/pdf-scan-to-vector/tools/make_icon.py b/tools/pdf-scan-to-vector/tools/make_icon.py new file mode 100644 index 0000000..75df0bf --- /dev/null +++ b/tools/pdf-scan-to-vector/tools/make_icon.py @@ -0,0 +1,24 @@ +from pathlib import Path # Находим каталог ресурсов относительно самого сценария генерации. +from PySide6 import QtCore as C, QtGui as G, QtWidgets as W # Рисуем значок тем же Qt, который уже нужен приложению. + + +app = W.QApplication.instance() or W.QApplication([]) # Графический движок нужен для растеризации текста и геометрии значка. +image = G.QImage(256, 256, G.QImage.Format.Format_ARGB32) # Мастер-изображение 256 × 256 пикселей соответствует крупному значку Windows. +image.fill(C.Qt.GlobalColor.transparent) # Прозрачный фон позволяет значку выглядеть естественно в панели задач. +painter = G.QPainter(image) # Все детали рисуем в собственной памяти, не управляя рабочим столом Windows. +painter.setRenderHint(G.QPainter.RenderHint.Antialiasing) # Сглаживаем диагонали листа и углы геометрии. +painter.setPen(C.Qt.PenStyle.NoPen) # У внешней рамки не требуется отдельная линия обводки. +painter.setBrush(G.QColor("#151d28")) # Фон значка повторяет фон панели SETGUI. +painter.drawRoundedRect(C.QRectF(8, 8, 240, 240), 48, 48) # Скруглённая квадратная основа хорошо различима в разных размерах. +painter.setBrush(G.QColor("#1570d8")) # Основной синий цвет связывает значок с кнопкой обработки. +painter.drawRoundedRect(C.QRectF(58, 36, 140, 184), 12, 12) # Силуэт страницы обозначает назначение программы для документов. +painter.setPen(G.QPen(G.QColor("#ffffff"), 9)) # Белые линии имеют достаточную толщину после уменьшения значка. +painter.drawLine(84, 77, 170, 77) # Верхняя линия символизирует распознанный текст. +painter.drawLine(84, 101, 150, 101) # Вторая короткая линия отличает текстовый блок от контура листа. +painter.drawEllipse(C.QRectF(91, 132, 66, 55)) # Замкнутая геометрия иллюстрирует векторный результат. +painter.setBrush(G.QColor("#62b0ff")) # Светлые узлы показывают характерные точки векторного контура. +for x, y in ((91, 159), (124, 132), (157, 159), (124, 187)): # Четыре контрольные точки находятся на краях эллипса. + painter.drawRect(C.QRectF(x - 5, y - 5, 10, 10)) # Квадратные маркеры остаются видимыми в средних размерах Windows. +painter.end() # Завершаем рисование перед кодированием ресурса ICO. +target = Path(__file__).resolve().parent.parent / "assets" / "app.ico" # Значок входит в один и тот же каталог ресурсов исходников и EXE. +assert image.save(str(target), "ICO"), "Не удалось сохранить значок ICO" # Проверяем наличие встроенного кодировщика Qt и фактическую запись значка. diff --git a/tools/pdf-scan-to-vector/verification.py b/tools/pdf-scan-to-vector/verification.py new file mode 100644 index 0000000..6c114fc --- /dev/null +++ b/tools/pdf-scan-to-vector/verification.py @@ -0,0 +1,84 @@ +from pathlib import Path # Храним отчёт и изображения проверки в явно указанной папке. +import json # Машиночитаемый отчёт позволяет проверить также EXE без консольного вывода. +import time # Ограничиваем длительность проверки рабочего процесса и обрабатываем события GUI. +import traceback # Сохраняем причину провала самопроверки в отдельном отчёте. +import pymupdf as fitz # Проверяем структуру PDF, поиск текста и отсутствие растровых объектов. +from sample import create_sample # Генерируем тестовый PDF, который содержит только сканы. +from engine import Options, convert # Проверяем перенос готового текста также внутри собранного автономного приложения. + + +def verify_native_text(directory): # Воспроизводим ошибку поиска «Авария» на векторном чертеже со старой кодировкой ГОСТ. + source, destination = directory / "legacy_drawing.pdf", directory / "legacy_searchable.pdf" # Сохраняем вход и результат проверки отдельно от растрового примера. + with fitz.open() as document: # Формируем небольшой настоящий PDF без растровых изображений. + page = document.new_page(width=300, height=200) # Размеры в пунктах PDF ограничивают время встроенной самопроверки. + page.insert_text((40, 60), "Àâàðèÿ VH1", fontsize=12) # Воспроизводим Latin-1-коды, ошибочно использованные вместо русских байтов Windows-1251. + document.xref_set_key(page.get_fonts()[0][0], "BaseFont", "/GOSTtypeA") # Указываем имя старого технического шрифта для проверки восстановления кодировки. + page.set_rotation(90) # Пользовательский чертёж также содержит исходный поворот страницы на 90 градусов. + document.save(source) # Проверяем обработку сохранённого документа вместо временного объекта в памяти. + initial = source.read_bytes() # Контрольные байты подтверждают, что исправление не меняет оригинал. + report = convert(source, destination, Options(dpi=150)) # Запускаем настоящий движок со штатным векторным поисковым слоем. + with fitz.open(destination) as result: # Проверяем итоговый документ после сохранения и сокращения встроенного шрифта. + assert result[0].search_for("Авария") and result[0].search_for("VH1") # Русское слово и латинская метка должны находиться по координатам страницы. + assert not result[0].get_images() and len(result[0].get_fonts()) == 1 # Слой должен оставаться векторным и использовать единственный ресурс поискового шрифта. + assert "Авария" in report["text"][0] and source.read_bytes() == initial # Отчёт содержит исправленный Unicode, а оригинал сохраняется побайтно. + + +def self_test(directory): # Выполняем полный сценарий GUI и обработки в отдельном процессе для исходников и EXE. + from gui import MainWindow, application, W, C # Подключаем настоящий интерфейс, Qt и настройки без подмены рабочего процесса. + directory = Path(directory).resolve() # Отчёт всегда привязан к однозначному абсолютному пути. + directory.mkdir(parents=True, exist_ok=True) # Позволяем первому запуску создать собственную папку проверки. + window = None # Гарантируем закрытие окна также при ошибке в середине сценария. + try: # Любое исключение превращаем в проверяемый JSON-отчёт. + source = directory / "sample_scan.pdf" # Сохраняем исходный пример для визуального сравнения. + create_sample(source) # Создаём два листа без готового OCR и векторной графики. + with fitz.open(source) as scan: # Проверяем, что тест действительно начинает со сканового PDF. + assert all(not page.get_text().strip() and page.get_images() for page in scan) # OCR должен распознать текст, а не извлечь уже готовые символы. + app = application() # Используем те же стиль, шрифты и графический движок, что и обычный запуск. + window = MainWindow() # Создаём полноценный интерфейс вместе с очередью обработки и таймерами. + window.settings = C.QSettings(str(directory / "test.ini"), C.QSettings.Format.IniFormat) # Изолируем записи тестового профиля от обычных настроек пользователя. + window.resize(1440, 920) # Фиксируем размер контрольного изображения интерфейса. + window.show() # Обеспечиваем настоящую раскладку виджетов перед снимком окна. + assert window.load_pdf(source) # Проверяем открытие, миниатюры и первый предпросмотр. + window.mode.setCurrentIndex(window.mode.findData("vector_text")) # Самопроверка EXE должна запускать новый режим с видимым шрифтом и реальным OCR. + window.recognition.setCurrentIndex(window.recognition.findData("enhanced")) # Фиксируем улучшенную подготовку независимо от сохранённых настроек пользователя. + window.language.setCurrentIndex(window.language.findData("rus+eng")) # Проверяем обе включённые языковые модели. + window.dpi.setCurrentIndex(window.dpi.findData(300)) # Фиксируем разрешение независимо от сохранённого пользовательского профиля. + window.rotate.setCurrentIndex(0) # Тестовый пример уже имеет правильную ориентацию листов. + window.threshold.setValue(0) # Используем автоматическую бинаризацию скана. + window.noise.setValue(2) # Воспроизводим штатную фильтрацию мелкой пыли. + window.simplify.setValue(0.45) # Воспроизводим штатную точность аппроксимации. + window.start_conversion() # Проверяем именно кнопку запуска и межпроцессный протокол GUI. + deadline = time.monotonic() + 180 # Самопроверка не должна бесконечно ждать зависший OCR. + while window.process is not None and time.monotonic() < deadline: # Ждём завершения реального рабочего процесса с ограничением времени. + app.processEvents() # Прогресс, миниатюры и отрисовка должны продолжать работать во время OCR. + time.sleep(0.02) # Уменьшаем загрузку процессора в цикле автоматической проверки. + assert window.process is None, "Превышено время ожидания рабочего процесса" # Проверяем корректное завершение дочернего процесса. + assert window.report and window.result, window.log.toPlainText() # Отчёт и PDF должны появиться через настоящий интерфейс. + destination = directory / "sample_vector_text.pdf" # Оставляем результат нового режима рядом с исходным сканом для визуального сравнения. + destination.write_bytes(Path(window.report["path"]).read_bytes()) # Копируем проверяемый результат до очистки внутренней временной папки. + with fitz.open(destination) as result: # Проверяем содержимое повторно открытого PDF после записи. + assert len(result) == 2 # Все страницы должны сохраниться в исходном порядке. + assert all(not page.get_images(full=True) for page in result) # Векторный PDF не должен содержать спрятанный исходный растр. + assert all(page.get_drawings() for page in result) # Проверяем наличие настоящих команд векторного рисования. + assert all(any(span["type"] == 0 for span in page.get_texttrace()) for page in result) # Каждый лист должен содержать видимые шрифтовые буквы вместо одного невидимого OCR-слоя. + assert all(page["text_replacements"] > 0 for page in window.report["pages"]) # Подтверждаем фактическую замену распознанных контурных слов обычным текстом. + text = "\n".join(page.get_text() for page in result) # Извлекаем Unicode из фактически сохранённого поискового слоя. + assert "Напряжение" in text and "VECTOR" in text, text # Подтверждаем русское и английское распознавание. + assert result[0].search_for("Напряжение") # Проверяем, что текст не только извлекается, но и находится по координатам страницы. + result[0].get_pixmap(dpi=110).save(directory / "result_page.png") # Рендер результата используется для независимой визуальной проверки. + window.tabs.setCurrentIndex(1) # Контрольный снимок показывает готовый векторный результат в рабочем окне. + for _ in range(12): # Даём Qt завершить отложенную раскладку и отрисовку миниатюр. + app.processEvents() # Снимок должен отражать окончательное состояние виджетов. + time.sleep(0.02) # Короткий интервал позволяет Windows обновить поверхности окна. + window.grab().save(str(directory / "interface.png")) # Сохраняем реальное изображение GUI для проверки компоновки. + (directory / "recognized.txt").write_text(text, encoding="utf-8") # Подтверждаем корректную запись кириллицы в текстовый файл. + verify_native_text(directory) # Проверяем новую ветвь переноса текста как при запуске исходников, так и внутри EXE. + report = {"ok": True, "pages": window.report["pages"], "searchable_russian": True, "searchable_english": True, "searchable_legacy_gost": True, "raster_images": 0, "pdf_bytes": destination.stat().st_size} # Отчёт содержит проверенные свойства растрового примера и чертежа с ошибочной кодировкой. + (directory / "verification.json").write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8") # Машиночитаемый отчёт не зависит от наличия консоли у EXE. + return 0 # Нулевой код означает прохождение полного сценария. + except Exception: # Любой сбой сохраняем вместе с подробным стеком для диагностики сборки. + (directory / "verification.json").write_text(json.dumps({"ok": False, "error": traceback.format_exc()}, ensure_ascii=False, indent=2), encoding="utf-8") # Записываем причину без потери Unicode-текста ошибки. + return 1 # Ненулевой код позволяет сборочному сценарию остановить публикацию неисправного EXE. + finally: # Завершаем рабочий процесс и закрываем файлы также при провале проверки. + if window is not None: # Окно могло не создаться из-за ошибки импорта или инициализации. + window.close() # Общий обработчик освобождает Qt, процессы и внутренние временные файлы.