Добавить проверку Flash SCI, системные диалоги и векторизацию PDF
Расширить протокол SCI проверкой содержимого Flash и комплектом RAM-ядер. Добавить утилиту векторизации PDF с OCR, общие диалоги DSView и проверки.
This commit is contained in:
@@ -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. */
|
||||
@@ -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 без доступа к системным часам. */
|
||||
|
||||
@@ -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
@@ -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"]
|
||||
|
||||
@@ -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.
|
||||
@@ -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.
@@ -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
@@ -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(),
|
||||
|
||||
@@ -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, ¤tPid);
|
||||
if (!IsWindow(parent) || currentPid != parentPid) {
|
||||
@@ -732,6 +733,7 @@ bool MainFrame::ShowEmbedded(quintptr parentId)
|
||||
qApp->quit();
|
||||
return;
|
||||
}
|
||||
+ dialogs->refresh(); // Переносим открытые настройки только при фактической смене экрана или отделении DSView.
|
||||
DWORD available = 0;
|
||||
const HANDLE input = GetStdHandle(STD_INPUT_HANDLE);
|
||||
if (PeekNamedPipe(input, NULL, 0, NULL, &available, NULL) && available) {
|
||||
@@ -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.
|
||||
@@ -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; // Успех означает корректное размещение, владение и сохранение экранных границ.
|
||||
} // Внешние приложения, приборы и пользовательские записи во время проверки не затрагиваются.
|
||||
@@ -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'):
|
||||
|
||||
@@ -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.
|
||||
|
||||
Исходники приложения поставляются в этой папке вместе со сценарием повторной сборки и точными версиями зависимостей. При дальнейшем распространении необходимо соблюдать лицензии включённых компонентов.
|
||||
@@ -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.
|
||||
Binary file not shown.
Binary file not shown.
@@ -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%
|
||||
@@ -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
@@ -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.
|
||||
@@ -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 # Переключение страниц не должно вызывать предупреждения.
|
||||
@@ -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) # Проверка события выполняется до выделения дополнительных масок.
|
||||
@@ -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, включая оставшийся поисковый слой.
|
||||
@@ -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.
|
||||
@@ -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 и фактическую запись значка.
|
||||
@@ -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, процессы и внутренние временные файлы.
|
||||
Reference in New Issue
Block a user