Добавить проверку Flash SCI, системные диалоги и векторизацию PDF

Расширить протокол SCI проверкой содержимого Flash и комплектом RAM-ядер.
Добавить утилиту векторизации PDF с OCR, общие диалоги DSView и проверки.
This commit is contained in:
2026-11-18 16:03:53 +03:00
parent 4825465583
commit afdf62cfa4
50 changed files with 2670 additions and 51 deletions
+2
View File
@@ -7,6 +7,8 @@ cmake-build-*/
*.a
*.elf
*.bin
# Встроенные ядра F28335 являются ресурсами поставки, а не промежуточными результатами пользовательской сборки.
!python/set_devices/sci_kernels/*.bin
*.hex
*.map
*.lst
@@ -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('<HH', data, 18), (0, 0), 'primary_bootloader.obj отклоняет ненулевой адрес входа') # Восемь резервных слов после ключа оставляют entry на смещении 18 октетов.
self.assertEqual(struct.unpack_from('<HHH', data, 22), (2, 0, 0)) # Первый блок должен загрузить двухсловный переход по словному адресу 0x000000.
document = ET.fromstring(subprocess.check_output([str(compiler / 'bin/ofd2000.exe'), '-x', str(image.with_suffix('.out'))])) # Извлекает исходную точку входа COFF до её переопределения транспортным заголовком SCI8.
File diff suppressed because one or more lines are too long
@@ -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. */
+3 -1
View File
@@ -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 без доступа к системным часам. */
+60 -6
View File
@@ -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. */
File diff suppressed because one or more lines are too long
+1 -1
View File
@@ -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"]
+20
View File
@@ -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.
+10
View File
@@ -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)
File diff suppressed because one or more lines are too long
@@ -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.
File diff suppressed because one or more lines are too long
@@ -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"
}
]
}
Binary file not shown.
Binary file not shown.
Binary file not shown.
+31 -4
View File
@@ -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("<H", sum(tx) & 65535)) # Независимый эталон суммы следует опубликованному исходнику TI SendCheckSum.
if expected: session.accept((tx[-(expected - 2):] if expected > 2 else b'') + struct.pack("<H", sum(tx) & 65535)) # Ответ VR1 содержит только записанные данные без заголовка секции, затем независимую checksum TI.
if not tx: zero_acks += 1 # Пустой остаток TI подтверждается отдельным нулевым словом.
else: pytest.fail("Автомат SCI не завершился") # Отсутствие терминального перехода считается ошибкой протокола.
assert bytes(received) == image # MCU получил ровно исходный Flash SCI8 без переименования или подмены содержимого.
assert bytes(received) == (image[:2] + b'VR\x01\x00' + image[6:] if verify else image) # Verify меняет только запрос в резерве заголовка; адреса и все программируемые октеты исходного BIN неизменны.
assert pauses == [3000, 3000] and session.progress == 100 # Порядок ожиданий совпадает с TI f05_DownloadImage.
assert zero_acks == int(words > 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('<H', sum(tx) & 65535) # Слова Flash и контрольная сумма формируются независимо от production-проверки.
if expected == 4 and tx == b'\x5A\xA5': break # После 1024 слов по адресу 0x330100 остаётся одно слово по адресу 0x330500.
session.accept(reply) # Все предыдущие блоки и их физическое содержимое считаются корректными.
damaged = bytearray(reply) # Сохраняет эталонную checksum неизменной для сценариев повреждения памяти.
if fault in ('first', 'last'): damaged[0 if fault == 'first' else 1] ^= 1 # Оба октета последнего слова должны проверяться, включая старший.
elif fault == 'checksum': damaged[-1] ^= 1 # Правильные физические данные не оправдывают неверное подтверждение TI.
else: damaged.pop() # Усечённый ответ нельзя засчитать как завершённую проверку.
with pytest.raises(ValueError, match='0x330500' if fault in ('first', 'last') else None): session.accept(bytes(damaged)) # Передаёт неизменяемый UART-ответ; отказ запрещает терминатор и сообщает адрес повреждённого слова Flash.
with pytest.raises(ValueError): session.next() # После неуспешной проверки автомат остаётся остановленным до нового явного сеанса.
assert session.progress < 100 # Непроверенный остаток не выдаётся за полностью завершённую прошивку.
def test_verify_requires_capable_kernel_before_first_exchange(): # Старый RAM-бинарник не должен привести к записи с обещанной, но отсутствующей проверкой.
with pytest.raises(ValueError, match='RAM-ядро TI не поддерживает Verify'): Session(sci8(0x9000, [1]), sci8(0x328000, [2]), verify=True) # Неподдерживаемый комплект отклоняется ещё до autobaud.
+45 -9
View File
@@ -34,6 +34,7 @@ def recipe_digest():
inputs += [recipe / 'zynq-ethernet/ethernet.patch'] # Геометрия цифровых дорожек и анализаторов входит в Ethernet-патч, поэтому его изменение также требует пересборки runtime.
inputs += [recipe / 'scope-channel.patch', recipe / 'native/scope_demo.h', recipe / 'native/scope_trace.h', recipe / 'motor-currents.patch'] # Шкала фазных токов и поддержка нового графического декодера входят в версию нативного компонента.
inputs += [recipe / 'decoder-scope.patch', recipe / 'native/decoder_scope.h'] # Отдельные окна выбранных осциллограмм входят в версию рецепта и требуют обновления нативного компонента.
inputs += [recipe / 'host-dialogs.patch', recipe / 'native/host_dialogs.h'] # Привязка настроек к текущему окну и монитору входит в версию встроенного DSView.
digest = hashlib.sha256()
for item in inputs:
digest.update(item.relative_to(recipe.parents[1]).as_posix().encode('utf-8') + b'\0')
@@ -70,15 +71,27 @@ def main():
parser.add_argument('--output', type=Path, required=True)
parser.add_argument('--msys-root', type=Path, default=Path(r'C:\setcorp\tools\msys64'))
parser.add_argument('--extra-patch', type=Path)
parser.add_argument('--win7', action='store_true') # Совместимый вариант использует официальный Python 3.8 вместо Python из современного MSYS2.
parser.add_argument('--python-root', type=Path) # Заголовки и import library берутся из полной установки Python 3.8.10 x64.
args = parser.parse_args()
source, output = args.source.resolve(), args.output.resolve()
prefix = args.msys_root.resolve() / 'ucrt64'
python_root = args.python_root.resolve() if args.python_root else None # Явный путь исключает случайное обнаружение Python 3.14 через CMAKE_PREFIX_PATH.
if args.win7 and (not python_root or not (python_root / 'include/Python.h').is_file() or not (python_root / 'libs/python38.lib').is_file()): # Одной DLL недостаточно для компиляции libsigrokdecode.
raise SystemExit('--win7 requires --python-root with Python 3.8.10 x64 headers and libs/python38.lib') # Ошибка возникает до применения патчей и длительной компиляции.
if args.win7: # Точное закрепление версии проверяется независимо от названий файлов установки.
version = subprocess.check_output([str(python_root / 'python.exe'), '-I', '-c', 'import sys, struct; print(sys.version_info[:3], struct.calcsize("P"))'], text=True).strip() # Используем изолированный режим, чтобы внешний PYTHONPATH не подменял стандартные модули.
if version != '(3, 8, 10) 8': # Python 3.8.10 x64 является закреплённой совместимой установкой; размер указателя восемь байт означает x64.
raise SystemExit('Expected Python 3.8.10 x64, got ' + version) # Не применяем патчи и не собираем смешанный ABI при неверной установке.
if not (prefix / 'bin/cmake.exe').is_file():
raise SystemExit('Install the MSYS2 UCRT64 dependencies listed in README.md first.')
revision = subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=source, text=True).strip()
if not revision.startswith(REVISION):
raise SystemExit('Expected DSView revision ' + REVISION + ', got ' + revision)
patch_cmd = ['git', 'apply', '--ignore-space-change']
dialog_patch = Path(__file__).with_name('host-dialogs.patch') # Отдельный завершающий патч расширяет уже собранную интеграцию без изменения прежних канонических патчей.
if subprocess.run(patch_cmd + ['--reverse', '--check', str(dialog_patch)], cwd=source, capture_output=True).returncode == 0: # Повторная сборка сначала возвращает прежний контекст базового рецепта, только если новый патч применён целиком.
subprocess.run(patch_cmd + ['--reverse', str(dialog_patch)], cwd=source, check=True) # Временное снятие собственного патча сохраняет возможность повторно проверить всю исходную цепочку интеграции.
for retired_name in ('driver-summary.patch', 'gate-pair-checkbox.patch'):
retired = Path(__file__).with_name(retired_name)
if subprocess.run(['git', 'apply', '--ignore-space-change', '--reverse', '--check', str(retired)],
@@ -103,6 +116,8 @@ def main():
if subprocess.run(patch_cmd + ['--reverse', '--check'], cwd=source, input=combined,
capture_output=True).returncode:
subprocess.run(patch_cmd, cwd=source, input=combined, check=True)
subprocess.run(patch_cmd + [str(dialog_patch)], cwd=source, check=True) # Настройки получают окончательное поведение после всех базовых и Ethernet-изменений MainFrame.
shutil.copy2(Path(__file__).with_name('native') / 'host_dialogs.h', source / 'DSView/pv/host_dialogs.h') # Общий фильтр диалогов поставляется заголовком без изменения схемы moc внешнего проекта.
shutil.copy2(Path(__file__).with_name('native') / 'pwm_waveform.h', source / 'DSView/pv/view/pwm_waveform.h')
for name in ('scope_demo.h', 'scope_trace.h'): # Переносимая модель и Qt-дорожка устанавливаются рядом с базовым Trace.
shutil.copy2(Path(__file__).with_name('native') / name, source / 'DSView/pv/view' / name) # Копируем канонические исходники без изменения внешнего проекта Zynq.
@@ -110,10 +125,16 @@ def main():
env = dict(os.environ)
env['PATH'] = os.pathsep.join([str(prefix/'bin'), str(args.msys_root/'usr/bin'), env.get('PATH', '')])
env['PKG_CONFIG_PATH'] = str(prefix/'lib/pkgconfig')
build = source/'build-win64'
build = source / ('build-win7' if args.win7 else 'build-win64') # Разные ABI Python не разделяют CMakeCache и объектные файлы.
compatibility = [] # Обычная сборка сохраняет прежний выбор Python из MSYS2.
if args.win7: # Все цели DSView и libsigrokdecode компилируются для Windows 7 SP1.
build.mkdir(parents=True, exist_ok=True) # Отдельный CMake-фрагмент хранится рядом с промежуточными файлами совместимой сборки.
definitions = build / 'win7-target.cmake' # Исходный CMakeLists upstream переопределяет CXX_FLAGS, поэтому нужные макросы задаются на уровне целей.
definitions.write_text('# Целевые Win32 API ограничены Windows 7, то есть NT 6.1.\nadd_compile_definitions(_WIN32_WINNT=0x0601 WINVER=0x0601) # Значение 0x0601 соответствует минимальной целевой ОС.\n', encoding='utf-8') # Генерируемый код и русские комментарии сохраняются в UTF-8.
compatibility = ['-DPython3_EXECUTABLE=' + str(python_root / 'python.exe'), '-DPython3_INCLUDE_DIR=' + str(python_root / 'include'), '-DPython3_LIBRARY=' + str(python_root / 'libs/python38.lib'), '-DCMAKE_PROJECT_INCLUDE=' + definitions.as_posix()] # Явные пути предотвращают выбор libpython3.14, а project include задаёт макросы независимо от флагов upstream.
subprocess.run([str(prefix/'bin/cmake.exe'), '-S', str(source), '-B', str(build), '-G', 'Ninja',
'-DCMAKE_POLICY_VERSION_MINIMUM=3.5', '-DCMAKE_CXX_STANDARD=11',
'-DCMAKE_POLICY_DEFAULT_CMP0167=OLD', '-DCMAKE_PREFIX_PATH='+prefix.as_posix()],
'-DCMAKE_POLICY_DEFAULT_CMP0167=OLD', '-DCMAKE_PREFIX_PATH='+prefix.as_posix(), *compatibility], # Параметры совместимости передаются только варианту Win7.
env=env, check=True)
subprocess.run([str(prefix/'bin/cmake.exe'), '--build', str(build), '--parallel', '6'], env=env, check=True)
output.mkdir(parents=True, exist_ok=True)
@@ -124,12 +145,19 @@ def main():
package_decoders(output)
for name in ('COPYING', 'NEWS25', 'NEWS31', 'ug25.pdf', 'ug31.pdf'):
shutil.copy2(source/name, output/name)
stdlib = sorted((prefix/'lib').glob('python3.*'))
stdlib = [item for item in stdlib if (item/'encodings').is_dir()]
if len(stdlib) != 1:
raise RuntimeError('Expected exactly one Python standard library in UCRT64')
shutil.copytree(stdlib[0], output/'lib'/stdlib[0].name, dirs_exist_ok=True,
ignore=shutil.ignore_patterns('__pycache__', 'site-packages', 'test', 'tests', 'idlelib', 'tkinter', 'ensurepip'))
ignored = shutil.ignore_patterns('__pycache__', 'site-packages', 'test', 'tests', 'idlelib', 'tkinter', 'ensurepip', '_test*', '_tkinter*', '*.exe', '*.lib') # Исключаем тесты и служебные установщики distutils/venv: они не используются декодерами и могут иметь другую разрядность либо требовать MSVCR80.
if args.win7: # Официальный CPython использует Windows-структуру Lib/DLLs вместо раскладки MinGW lib/python3.x.
shutil.copytree(python_root / 'Lib', output / 'Lib', dirs_exist_ok=True, ignore=ignored) # encodings и переносимые стандартные модули должны находиться рядом с DSView.
shutil.copytree(python_root / 'DLLs', output / 'DLLs', dirs_exist_ok=True, ignore=ignored) # Расширения соответствуют ABI Python 3.8 и не берутся из MSYS2.
for name in ('python38.dll', 'python3.dll', 'python.exe', 'vcruntime140.dll', 'vcruntime140_1.dll', 'LICENSE.txt'): # Комплект содержит интерпретатор, его MSVC runtime и лицензию CPython.
if (python_root / name).is_file(): # Некоторые выпуски x64 не содержат отдельную vcruntime140_1.dll.
shutil.copy2(python_root / name, output / name) # Официальная DLL сохраняет поддержку Windows 7 SP1 с обновлённым UCRT.
(output / 'python38._pth').write_text('Lib\nDLLs\n.\n', encoding='utf-8') # Изолированный поиск Python не зависит от реестра, PYTHONHOME и установленных на целевом ПК интерпретаторов.
else: # Современный вариант продолжает использовать стандартную библиотеку того же MSYS2, что его libpython.
stdlib = [item for item in sorted((prefix / 'lib').glob('python3.*')) if (item / 'encodings').is_dir()] # Выбираем только каталог с полноценным пакетом кодировок.
if len(stdlib) != 1: # Неоднозначный выбор ABI нельзя принимать при упаковке.
raise RuntimeError('Expected exactly one Python standard library in UCRT64') # Сохраняем прежнюю проверку комплектности SDK.
shutil.copytree(stdlib[0], output / 'lib' / stdlib[0].name, dirs_exist_ok=True, ignore=ignored) # Python и его расширения соответствуют выбранной современной библиотеке.
for name in ('platforms', 'imageformats', 'iconengines', 'styles'):
shutil.copytree(prefix/'share/qt5/plugins'/name, output/name, dirs_exist_ok=True)
shutil.copytree(prefix/'share/licenses', output/'licenses', dirs_exist_ok=True)
@@ -143,7 +171,12 @@ def main():
seen.add(binary)
info = subprocess.check_output([str(prefix/'bin/objdump.exe'), '-p', str(binary)], env=env, text=True, errors='replace')
for dll in re.findall(r'DLL Name:\s*(\S+)', info):
dependency, target = prefix/'bin'/dll, output/dll
dependency, target = prefix/'bin'/dll, output/dll # По умолчанию зависимости Qt, GLib и FFTW берутся из того же SDK.
if args.win7 and (python_root / 'DLLs' / dll).is_file(): # Расширения официального Python используют свои OpenSSL 1.1 и прочие библиотеки, отсутствующие в современном MSYS2.
dependency = python_root / 'DLLs' / dll # Не заменяем зависимость Python 3.8 новым несовместимым ABI из SDK.
if target.is_file(): # Вариант Win7 заранее устанавливает собственные python38.dll и VC runtime.
queue.append(target) if target not in seen else None # Проверяем их транзитивные импорты, не подменяя DLL случайной копией из SDK.
continue # Уже выбранный целевой компонент сохраняет приоритет над библиотекой сборщика.
if dependency.is_file():
if target not in seen:
shutil.copy2(dependency, target)
@@ -165,12 +198,15 @@ def main():
shutil.copy2(Path(__file__).with_name('motor-currents.patch'), output / 'motor-currents.patch') # Исходники расширения токовых графиков поставляются вместе с GPL-компонентом.
for name in ('decoder-scope.patch', 'native/decoder_scope.h'): # Исходники самостоятельного осциллографа нужны для воспроизводимости поставляемого GPL-компонента.
shutil.copy2(Path(__file__).parent / name, output / Path(name).name) # Патч интеграции и заголовок виджета соответствуют скомпилированному расширению.
for name in ('host-dialogs.patch', 'native/host_dialogs.h'): # Исходники размещения диалогов поставляются вместе с соответствующей версией компонента.
shutil.copy2(Path(__file__).parent / name, output / Path(name).name) # Полный runtime содержит патч MainFrame и реально использованный фильтр окон.
(output / 'scope-channel-1').write_text('DSView Zynq demo scope channels 1\n', encoding='utf-8') # Маркер различает установленный компонент с добавлением осциллографических дорожек.
(output/'SOURCE.txt').write_text('https://github.com/DreamSourceLab/DSView\nCommit: '+revision+'\nPatches: setgui-host.patch, decoder-panel.patch, windows-usb-events.patch, pwm-waveform.patch (pwm_waveform.h)\nLicense: GPL-3.0-or-later (COPYING)\n', encoding='utf-8')
with (output / 'SOURCE.txt').open('a', encoding='utf-8') as manifest: # Происхождение нового источника сохраняется в пользовательском runtime.
manifest.write('Scope: scope-channel.patch, scope_demo.h, scope_trace.h\nModel: zynq/demo/hdmi_usb_menu/scope_signal.h (scope_hz, scope_peak_v, scope_colors, scope_value_v, scope_interval_extrema)\n') # Указываем исходные параметры и функции для проверки соответствия проекту Zynq.
manifest.write('Motor currents: motor-currents.patch; decoders/pwm_motor; common/setgui_decoders/pwm_motor.py\n') # Поставляемые исходники связывают графики ампер с единственной переносимой моделью двигателя.
manifest.write('Detached decoder scopes: decoder-scope.patch; decoder_scope.h\n') # Манифест фиксирует отдельные окна конкретных графических областей декодеров.
manifest.write('Hosted dialogs: host-dialogs.patch; host_dialogs.h\n') # Происхождение управления владельцем и монитором настроек доступно в установленном компоненте.
(output/'host-build.json').write_text(json.dumps({
'recipe': recipe_digest(),
'executable': hashlib.sha256((output/'DSView.exe').read_bytes()).hexdigest(),
+29
View File
@@ -0,0 +1,29 @@
diff --git a/DSView/pv/mainframe.cpp b/DSView/pv/mainframe.cpp
--- a/DSView/pv/mainframe.cpp
+++ b/DSView/pv/mainframe.cpp
@@ -62,4 +62,5 @@
#include "ui/popupdlglist.h"
+#include "host_dialogs.h" // Настройки встроенного анализатора следуют за текущим окном SETGUI и его монитором.
#ifdef _WIN32
@@ -721,9 +722,9 @@ bool MainFrame::ShowEmbedded(quintptr parentId)
SetParent(child, parent);
if (GetLastError() != 0 || GetParent(child) != parent) return false;
_mainWindow->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, &currentPid);
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) {
+93
View File
@@ -0,0 +1,93 @@
#pragma once // Заголовок подключается один раз независимо от порядка включения исходников встроенного DSView.
#include <QApplication> // Фильтр видит только диалоги текущего процесса DSView.
#include <QDialog> // Настройки и сообщения отделяются от меню, осциллограмм и других самостоятельных окон.
#include <QEvent> // Первое размещение выполняется после события показа диалога.
#include <QPointer> // Отложенная операция не обращается к уже закрытому окну настроек.
#include <QList> // Видимые диалоги упорядочиваются от родительских настроек к вложенным подтверждениям.
#include <QRect> // Геометрия сохраняет отрицательные координаты мониторов слева и сверху от основного.
#include <QTimer> // Нулевая задержка ждёт завершения автоматического размещения окна средствами Qt.
#include <algorithm> // Стабильная сортировка исключает зависимость размещения вложенных окон от порядка topLevelWidgets.
#ifdef Q_OS_WIN // Нативное встраивание DSView и владение окном SETGUI относятся к Windows.
#include <windows.h> // 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<HWND>(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<QDialog*>(parent) && parent->isVisible()) { anchor = reinterpret_cast<HWND>(parent->winId()); break; } // Ближайший видимый диалог сохраняет естественную цепочку модальных окон.
} // Обычные QWidget между диалогом и DSView не подменяют владельца плавающего окна.
SetWindowLongPtr(window, GWLP_HWNDPARENT, reinterpret_cast<LONG_PTR>(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<QDialog*>(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<QPointer<QDialog>> dialogs; // Безопасные указатели исключают обращение к подтверждению, которое могло закрыться при перемещении родителя.
for (QWidget *widget : QApplication::topLevelWidgets()) { // Просматриваем только окна собственного процесса DSView.
if (auto dialog = qobject_cast<QDialog*>(widget)) dialogs.append(QPointer<QDialog>(dialog)); // Осциллограммы, меню и окна других приложений не участвуют в перемещении.
} // Порядок topLevelWidgets сам по себе не определяет отношения между родителями и потомками.
std::stable_sort(dialogs.begin(), dialogs.end(), [](const QPointer<QDialog> &left, const QPointer<QDialog> &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<QDialog*>(watched)) { // Фильтр не затрагивает раскрывающиеся меню и самостоятельные графики DSView.
_watch.start(); // С этого показа перенос между экранами обслуживается также внутри модального exec диалога.
const QPointer<QDialog> 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.
+49
View File
@@ -0,0 +1,49 @@
#include <QApplication> // Проверка использует тот же Qt 5, которым собран встроенный DSView.
#include <QDialog> // Настройки моделируются настоящими верхнеуровневыми окнами Qt.
#include <QScreen> // Доступные мониторы позволяют проверить реальный перенос, если компьютер имеет несколько экранов.
#include <QThread> // Короткие интервалы дают завершиться отложенному размещению окна.
#include <cstdio> // Результат геометрических и нативных проверок выводится без графических предупреждений.
#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<HWND>(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<HWND>(frame.winId()), parent = reinterpret_cast<HWND>(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<HWND>(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<HWND>(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; // Успех означает корректное размещение, владение и сохранение экранных границ.
} // Внешние приложения, приборы и пользовательские записи во время проверки не затрагиваются.
+3 -1
View File
@@ -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'):
+9
View File
@@ -0,0 +1,9 @@
.venv/
build/
dist/
__pycache__/
*.py[cod]
.pytest_cache/
verification-output/
tmp/
*.log
@@ -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.
File diff suppressed because one or more lines are too long
@@ -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.
Исходники приложения поставляются в этой папке вместе со сценарием повторной сборки и точными версиями зависимостей. При дальнейшем распространении необходимо соблюдать лицензии включённых компонентов.
+30
View File
@@ -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()) # Возвращаем операционной системе код завершения приложения или самопроверки.
Binary file not shown.

After

Width:  |  Height:  |  Size: 264 KiB

@@ -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.
+13
View File
@@ -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%
+230
View File
@@ -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'<svg xmlns="http://www.w3.org/2000/svg" width="{width}pt" height="{height}pt" viewBox="0 0 {pix.width} {pix.height}"><path fill="black" fill-rule="evenodd" d="{body}"/></svg>' # Чётное заполнение поддерживает вложенные белые области независимо от направления обхода.
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()}) # Краткое объяснение показываем пользователю, полный стек оставляем в журнале.
File diff suppressed because one or more lines are too long
+91
View File
@@ -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 # Повторное действие пользователя снова проходит полноценную проверку.
@@ -0,0 +1,3 @@
-r requirements.txt # Устанавливаем те же версии, которые используются при обычном запуске.
PyInstaller==6.22.2 # Упаковываем приложение вместе с Qt, MuPDF и языковыми моделями в Windows EXE.
pytest==9.1.1 # Проверяем геометрию, OCR, защиту файлов, диапазоны и отмену обработки.
@@ -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.
+32
View File
@@ -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 без скрытого текстового слоя.
@@ -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() # Проверяем фактическую графику после расшифровки и трассировки.
@@ -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 "<svg" in content and "<path" in content and "<image" not in content # Не допускаем сохранения растровой картинки под расширением SVG.
def test_export_protects_original(window, monkeypatch): # Проверяем дополнительную защиту исходника в обработчике диалога сохранения.
view, errors = window # Окно содержит отдельный готовый результат и открытый исходный документ.
original = view.source_path.read_bytes() # Сохраняем байты исходного скана до ошибочного выбора пути.
monkeypatch.setattr(W.QFileDialog, "getSaveFileName", lambda *args: (str(view.source_path), "")) # Имитируем выбор оригинала как назначения выходного PDF.
view.save_pdf() # Обработчик обязан отклонить назначение до копирования данных.
assert errors and view.source_path.read_bytes() == original # Пользователь получает объяснение, а оригинал остаётся побайтно неизменным.
def test_preview_maps_selected_source_page(window): # Сокращённый диапазон не должен привязывать результат к ошибочному исходному листу.
view, errors = window # Результат содержит только вторую страницу двухстраничного скана.
view.refresh_page(0) # Переходим на лист, который не обрабатывался.
assert "не входила" in view.text.toPlainText() and not view.result_preview.scene().items() # Пустой предпросмотр объясняется пропущенным диапазоном вместо показа чужого результата.
view.refresh_page(1) # Переходим на действительно обработанный второй исходный лист.
assert "Напряжение" in view.text.toPlainText() and view.result_preview.scene().items() # Текст и геометрия должны синхронно относиться к выбранной странице.
assert not errors # Переключение страниц не должно вызывать предупреждения.
+108
View File
@@ -0,0 +1,108 @@
import json # Проверяем настоящий строковый обмен через локальный канал.
import os # Qt без рабочего стола позволяет повторять проверки на машине сборки.
import time # Ограничиваем ожидание асинхронных событий реальным сроком.
import uuid # Каналы параллельных запусков проверок не пересекаются.
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") # Режим задаётся до первого создания QApplication.
import pymupdf as fitz # Создаём реальные PDF без пользовательских документов.
import pytest # Фикстуры освобождают окна и временные профили после каждого сценария.
from PySide6.QtNetwork import QLocalServer # Проверяем тот же канал, которым управляет вкладка SETGUI.
from gui import application # Используем фактическое оформление и жизненный цикл программы.
from host import HostedWindow # Адаптер проверяется вместе с настоящим исходным интерфейсом.
def wait_until(predicate, app): # Локальный цикл обслуживает Qt во время ожидания ответа компонента.
deadline = time.monotonic() + 5 # Пять секунд достаточно для обмена внутри одного процесса без OCR.
while not predicate() and time.monotonic() < deadline: # Готовность проверяется без бесконечного ожидания.
app.processEvents() # Соединение и команды обрабатываются настоящим циклом Qt.
time.sleep(0.005) # Короткая пауза не загружает ядро процессора ожиданием.
assert predicate() # Неполученный ответ является отказом проверки, а не молчаливым успехом.
@pytest.fixture # Каждая проверка получает собственные канал, настройки и рабочий каталог.
def hosted(tmp_path): # Исходные пользовательские документы и реестр Windows не затрагиваются.
app = application() # Все тестовые окна используют единственный экземпляр QApplication.
server = QLocalServer() # Управляющая сторона повторяет локальный сервер SETGUI.
assert server.listen("pdf-vector-test-" + uuid.uuid4().hex) # Проверка не использует постоянные имена каналов.
window = HostedWindow(server.serverName(), tmp_path / "profile.ini") # Параметры программы записываются только в папку проверки.
window.show() # Полный интерфейс получает нормальные события видимости и закрытия.
wait_until(server.hasPendingConnections, app) # Ожидаем фактического подключения адаптера.
channel = server.nextPendingConnection() # Тест управляет ровно одним подключённым окном.
wait_until(channel.canReadLine, app) # Готовность должна передать целую строку JSON.
ready = json.loads(bytes(channel.readLine())) # Читаем настоящее сообщение вместо подмены метода send.
assert ready == {"event": "ready", "window": int(window.winId())} # Родитель получает реальный дескриптор созданного окна.
yield app, window, channel # Сценарий может отправлять команды и проверять сохранность документа.
window.result_saved = True # Освобождение фикстуры не должно показывать диалог, уже проверенный сценарием.
window.close() # Штатный обработчик закрывает PDF и удаляет собственный временный каталог.
channel.abort() # Завершаем управляющую сторону только после закрытия окна.
server.close() # Освобождаем уникальное имя локального сервера.
app.processEvents() # Qt завершает отложенные события освобождения канала.
def send(channel, **message): # Команды передаются тем же форматом, что из внешнего SETGUI.
channel.write((json.dumps(message) + "\n").encode("utf-8")) # Путь Unicode передаётся без shell и изменения разделителей.
channel.flush() # Обмен начинается до следующего действия сценария.
def test_local_protocol_opens_unicode_pdf_and_reports_bad_command(hosted, tmp_path): # Реальное открытие подтверждается фактическим состоянием исходного окна.
app, window, channel = hosted # Сохраняем доступ к приложению и управляющему каналу.
path = tmp_path / "Схема с пробелами.pdf" # Кириллица и пробелы проверяют сериализацию пути.
with fitz.open() as document: # Искусственный PDF создаётся без внешних библиотек или файлов.
document.new_page() # Достаточно одной страницы для проверки загрузки и предпросмотра.
document.save(path) # Сохраняем настоящий PDF в изолированном каталоге.
send(channel, command="open", path=str(path)) # Команда должна открыть документ в существующем процессе.
wait_until(channel.canReadLine, app) # Ответ поступает после исходной проверки PDF.
reply = json.loads(bytes(channel.readLine())) # Проверяем сообщение, которое реально получит SETGUI.
assert reply["event"] == "opened" and reply["accepted"] # Успех означает открытие документа, а не только приём строки.
assert window.source_path == path.resolve() and len(window.source) == 1 # Исходное окно содержит именно запрошенную страницу.
channel.write(b"[]\n") # Неверный тип JSON воспроизводит повреждённую команду локального протокола.
channel.flush() # Ошибочная команда должна быть обработана немедленно.
wait_until(channel.canReadLine, app) # Адаптер отвечает диагностикой без закрытия PDF.
assert json.loads(bytes(channel.readLine()))["event"] == "error" # Отказ не превращается в исключение главного цикла.
assert window.source_path == path.resolve() and window.isVisible() # Документ и интерфейс сохраняются после ошибки канала.
def test_cancel_close_preserves_unsaved_result_and_replies_to_host(hosted, monkeypatch): # Отмена выхода должна сохранить также родительский SETGUI.
app, window, channel = hosted # Используем готовый интерфейс с настоящим локальным соединением.
window.result = fitz.open() # Имитируем уже сформированный результат без дорогого повторного OCR.
window.result.new_page() # Непустой PDF должен остаться доступным после отказа от выхода.
monkeypatch.setattr("host.W.QMessageBox.question", lambda *_args: window_button_cancel()) # Выбираем системный ответ «Отмена» без интерактивного диалога проверки.
send(channel, command="close") # Запрос приходит тем же путём, что при выходе из SETGUI.
wait_until(channel.canReadLine, app) # Родитель обязан получить явный отказ вместо бесконечного ожидания.
assert json.loads(bytes(channel.readLine())) == {"event": "close_cancelled"} # Событие снимает ожидание закрытия внешней вкладки.
assert window.isVisible() and len(window.result) == 1 # Несохранённый документ остаётся открытым и пригодным к экспорту.
assert not window.result_saved # Отмена не должна ложно отмечать PDF сохранённым.
def window_button_cancel(): # Числовое значение ответа берётся из того же Qt, что проверяемое окно.
from PySide6.QtWidgets import QMessageBox # Локальный импорт не создаёт дополнительных виджетов.
return QMessageBox.Cancel # Сохраняем семантику настоящей кнопки отмены диалога.
@pytest.mark.parametrize("save_succeeds", [True, False]) # Ошибка экспорта должна сохранять окно так же, как явная отмена выхода.
def test_close_saves_result_only_after_successful_export(hosted, tmp_path, monkeypatch, save_succeeds): # Проверяем реальный путь Save через диалог и атомарную публикацию PDF.
from PySide6.QtWidgets import QMessageBox # Используем штатные ответы той же привязки Qt.
app, window, channel = hosted # Сценарий управляет настоящим окном через локальный канал.
original = tmp_path / "Исходный скан.pdf" # Этот путь должен остаться неизменным после сохранения результата.
original.write_bytes(b"unchanged source") # Для проверки сохранности исходника достаточно контрольных байтов.
result = tmp_path / "Готовый результат.pdf" # Пользовательский файл отделён от временного PDF приложения.
window.source_path = original # Диалог сохранения предлагает имя относительно исходного документа.
window.result = fitz.open() # Создаём уже готовый результат без повторного запуска OCR.
window.result.new_page() # Сохранённый PDF должен содержать действительную страницу.
temporary = tmp_path / "temporary.pdf" # Отчёт ссылается на готовый внутренний файл программы.
window.result.save(temporary) # Временный документ записывается до вызова экспортной команды.
window.report = {"path": str(temporary)} # Экспорт использует тот же путь, который возвращает настоящий рабочий процесс.
monkeypatch.setattr("host.W.QMessageBox.question", lambda *_args: QMessageBox.Save) # Выбираем сохранение перед выходом вместо обхода проверки.
monkeypatch.setattr("gui.W.QFileDialog.getSaveFileName", lambda *_args: (str(result), "PDF")) # Диалог возвращает изолированное имя пользовательского результата.
monkeypatch.setattr("gui.W.QMessageBox.warning", lambda *_args: QMessageBox.Ok) # Ошибка записи диагностируется без модального ожидания ручного ввода тестировщика.
if not save_succeeds: # Отсутствующий временный файл имитирует реальную ошибку чтения при экспорте.
temporary.unlink() # Атомарный экспорт обязан отказаться от публикации и не отмечать PDF сохранённым.
send(channel, command="close") # Запрос проходит всю процедуру закрытия HostedWindow.
wait_until(lambda: not window.isVisible() if save_succeeds else channel.canReadLine(), app) # Успех завершает окно, ошибка должна ответить родителю отменой выхода.
assert window.result_saved == save_succeeds # Флаг относится только к реально опубликованному пользовательскому файлу.
assert original.read_bytes() == b"unchanged source" # Исходный документ сохраняется независимо от результата экспорта.
if save_succeeds: # Успех проверяется чтением фактического PDF, а не только состоянием интерфейса.
with fitz.open(result) as saved: # Новый документ должен быть корректным после закрытия всех внутренних ресурсов.
assert len(saved) == 1 # Пользовательский результат содержит исходную тестовую страницу.
else: # Ошибка сохранения оставляет возможность исправить назначение и повторить экспорт.
assert json.loads(bytes(channel.readLine())) == {"event": "close_cancelled"} # SETGUI снимает ожидание завершения и сохраняет рабочий сеанс.
assert window.isVisible() and not result.exists() # Частичный пользовательский файл не публикуется при отказе атомарного копирования.
@@ -0,0 +1,72 @@
from dataclasses import replace # Проверяем варианты режима и поворота без дублирования полного профиля обработки.
import numpy as np # Сравниваем внешний вид результата с вариантом без текстового слоя.
import pymupdf as fitz # Создаём настоящие PDF с готовыми надписями и проверяем поиск после сохранения.
import pytest # Перебираем независимые сочетания исходного и пользовательского поворотов.
from engine import Options, convert, native_text_spans # Проверяем перенос исходного текста и выбор между ним и OCR.
@pytest.fixture() # Каждый тест получает собственный небольшой чертёж с ошибочной кодировкой шрифта ГОСТ.
def legacy_drawing(tmp_path): # Воспроизводим ошибку Latin-1 вместо Windows-1251 без зависимости от пользовательского документа.
path = tmp_path / "чертёж.pdf" # Русское имя одновременно проверяет поддержку Unicode-путей.
with fitz.open() as document: # Формируем векторный вход без растровых изображений и готового OCR.
page = document.new_page(width=300, height=200) # Небольшие размеры в пунктах PDF ускоряют полный цикл трассировки.
page.insert_text((40, 60), "Àâàðèÿ VH1", fontsize=12) # Байты слова «Авария» в Windows-1251 ошибочно представлены латинскими Unicode-кодами.
page.insert_text((160, 160), "Ïàíåëü", fontsize=12, rotate=90) # Вертикальная подпись проверяет собственное направление текста независимо от поворота листа.
font_xref = page.get_fonts()[0][0] # Находим фактический ресурс шрифта, использованный обеими надписями.
document.xref_set_key(font_xref, "BaseFont", "/GOSTtypeA") # Имитируем имя старого технического шрифта, для которого применяется восстановление кодировки.
page.draw_line((20, 100), (280, 100)) # Линия схемы должна сохраниться под невидимым текстом.
document.save(path) # Проверяем повторное чтение сохранённого входа вместо объектов в памяти.
return path # Каждый сценарий создаёт отдельный результат и сохраняет общий оригинал.
@pytest.mark.parametrize("mode", ["vector_ocr", "ocr"]) # Проверяем поиск как поверх контуров, так и поверх сохранённого изображения.
@pytest.mark.parametrize("rotation", [0, 90, 180, 270]) # Все разрешённые повороты должны одинаково сохранять Unicode и координаты.
@pytest.mark.parametrize("source_rotation", [0, 90]) # Исходный /Rotate должен учитываться вместе с дополнительным пользовательским поворотом.
def test_legacy_search_and_coordinates(legacy_drawing, tmp_path, mode, rotation, source_rotation): # Поиск должен находить исправленное слово непосредственно над исходной подписью.
with fitz.open(legacy_drawing) as document: # Меняем только ориентацию отдельного тестового входа.
document[0].set_rotation(source_rotation) # Имитируем повёрнутые страницы чертежей из CAD-экспортера.
document.saveIncr() # Сохраняем поворот без изменения текста и его шрифта.
initial = legacy_drawing.read_bytes() # Контрольные байты доказывают сохранность входа при исправлении кодировки.
output = tmp_path / "готовый.pdf" # Выход не перезаписывает входной чертёж.
report = convert(legacy_drawing, output, Options(mode=mode, rotate=rotation, dpi=150)) # Используем настоящий движок, чтобы проверить сохранение ресурсов и текстовых матриц.
assert legacy_drawing.read_bytes() == initial # Исправление должно действовать лишь на выходной поисковый слой.
with fitz.open(legacy_drawing) as source, fitz.open(output) as result: # Поиск проверяем в повторно открытом результате после сжатия и сокращения шрифтов.
page = result[0] # В результате выбран единственный тестовый лист.
matches = page.search_for("Авария") # Именно это слово не находилось на пользовательском скриншоте.
assert len(matches) == 1 and page.search_for("Панель") and page.search_for("VH1") # Исправляем обе ориентации кириллицы и сохраняем латинские обозначения.
assert "Авария" in report["text"][0] and "Àâàðèÿ" not in page.get_text() # TXT и PDF должны содержать одинаковый исправленный Unicode.
rotation_matrix = fitz.Matrix(rotation) # Формируем ожидаемую геометрию без обращения к внутреннему помощнику переноса текста.
bounds = source[0].rect * rotation_matrix # Поворот определяет смещение начала страницы к нулевым координатам.
expected = source[0].search_for("Àâàðèÿ")[0] * source[0].rotation_matrix * rotation_matrix * fitz.Matrix(1, 0, 0, 1, -bounds.x0, -bounds.y0) # Преобразуем исходный прямоугольник надписи независимо от заменяющего шрифта.
expected = expected * fitz.Matrix(page.rect.width / bounds.width, page.rect.height / bounds.height) # Учитываем округление размеров результата до пикселя при 150 DPI.
assert (matches[0] & expected).get_area() / expected.get_area() > 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 вместо переноса одной готовой подписи.
@@ -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) # Проверка события выполняется до выделения дополнительных масок.
+118
View File
@@ -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, включая оставшийся поисковый слой.
+39
View File
@@ -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.
+49
View File
@@ -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) # Явно показываем точное назначение сборки после всех проверок и сохранения сопроводительных файлов.
@@ -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 и другим автоматическим сценариям.
@@ -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 и фактическую запись значка.
+84
View File
@@ -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, процессы и внутренние временные файлы.