Изначально просто хотел сделать блюр кроссплатформенным. Но безобидная тема блюров совершенно незаметно переросла в задачу алгоритмической и аппаратной оптимизации, решение проблем многопоточности на разных платформах, поиск ответов на неожиданно возникающие вопросы.
Ответы превращались в заметки. Заметки в черновики. И в какой-то момент понял: это уже не просто «статья про блюр». Это исследование того, как устроено программное обеспечение на стыке математики, архитектуры процессора и компиляторов.
Пролог: Зачем и о чём
Это не статья в классическом смысле. Это точка входа в серию статей-исследований, объединённых общей темой.
Первой целью было просто перевести уже написанные ранее алгоритмы на кроссплатформенные рельсы. Для VCL.TBitmap всё работало, но привязка к VCL и Windows начинала смущать: хотелось получить быстрый блюр без привязки к экосистеме.
По мере продвижения появилась и другая цель: разогнать блюр до субсветовых скоростей, встать наравне с Direct2D или даже обогнать его. Начался процесс оптимизации.
Забегая вперёд — да, получилось. На малых изображениях ускорение относительно D2D достигло 2.5x. На больших — идём ноздря в ноздрю. А поскольку здесь представлен кроссплатформенный модуль, это означает, что блюр можно использовать на серверах без видеокарты, в консоли, только CPU, только математика.
Конечно, скорость CPU-реализаций сильно зависит от железа и количества ядер. Чем больше логических ядер у железа, тем быстрее блюр. Потому что мы захватываем их все.
Однако в процессе разгона алгоритмов возник закономерный вопрос: не теряется ли качество при такой оптимизации? Так родилась ещё одна цель — контроль качества. Потому что быстрый, но некачественный блюр никому не нужен.
Поэтому здесь не только готовые решения, но и ответы — почему то или иное решение лучше нескольких предыдущих. И какие предыдущие были отметены, в силу малой производительности или потенциальной глючности.
Надеюсь, этот путь окажется полезным. Видя весь маршрут, можно сделать ответвление и пойти своим путём.
Часть 1: Теория
Здесь содержится напоминание о ранее опубликованных материалах, без которых дальнейшее повествование было бы неполным.
Математика и TBitmap: VCL
Подробнейший разбор математики блюра и реализации на VCL.TBitmap. В первых трёх частях цикла построен фундамент, математическое обоснование, на котором всё строится.
- Blur в Delphi. Часть I: Gaussian Blur: Математический эталон и фундамент нашего разгона. Разрушаем квадратичную сложность наивной 2D-свёртки O(r2) и переходим к линейным проходам O(r).
- Blur в Delphi. Часть II: Box, Stack, Downscale: Ломаем линейную зависимость и выходим на константное время O(1) на пиксель. Парад математических и алгоритмических фокусов.
- Blur в Delphi. Часть III: Альфа-канал: Разбираемся, откуда берутся «грязные» цветные ореолы, белые каёмки и почему для правильного размытия жизненно необходим Premultiplied Alpha. Укрощаем скрытые сюрпризы VCL Delphi.
Кроссплатформенный TBitmap: VCL, FMX, LCL
Уход от VCL.TBitmap в сторону кроссплатформы. Конструирование абстракции IImageSurface32. Демо на всех трёх экосистемах.
- Единый интерфейс изображения: VCL, FMX, LCL: Проектируем ультра-лёгкий интерфейс IImageSurface32 — мостик, отделяющий чистые алгоритмы от капризов экосистем. Разбираем хардкорные платформенные нюансы: принудительный своп каналов BGRA vs RGBA на мобильных ОС, укрощение bottom-up памяти в Windows и опасности пересоздания дескрипторов в LCL. Проводим боевое крещение сквозного альфа-блендинга: один и тот же математический код одновременно компилируется и летает во всех трех экосистемах.
Часть 2: Инструменты
Прежде чем разгонять алгоритмы, нужно научиться их измерять. Собираем движок бенчмарка, метрики качества и визуализацию — всё, без чего оптимизация превращается в гадание.
Бенчмарк: VCL, FMX, LCL
В предыдущих частях цикла у нас уже был бенчмарк. Но он: 1) заточен только под VCL.TBitmap; 2) заточен только под блюр; 3) не понимает ни в FMX, ни в LCL. А наша задача – переход на кроссплатформенные рельсы, где измерять скорость выполнения ой как надо.
Поэтому нам нужен новый бенчмарк, более универсальный и безусловно кроссплатформенный.
Эффект: атомарная сущность
Статья вводит базовое понятие цикла — «эффект» как неделимую единицу обработки изображения, которую можно измерить. Эффект получает исходную поверхность IImageSurface32, параметры (TValue) и опциональный таймер IEffectTimer, а возвращает новую поверхность и флаг успеха. Входная поверхность не изменяется, что делает эффекты атомарными, предсказуемыми и легко тестируемыми.
Эффект — это обёртка над методом обработки изображения, сводящая всё разнообразие вызовов к одному интерфейсу. Это позволяет построить более универсальный бенчмарк, рассчитанный не только на блюр, и не только на время выполнения.
Бенчмарк: конструкция движка
У нас теперь есть реестр эффектов. Пора их измерить. И сделать это так, чтобы один и тот же движок работал и в VCL, и в FMX, и в LCL.
Конструируем ядро измерительной системы. Обеспечиваем честные замеры времени выполнения. Делаем так, чтобы измерять можно было не только время, но и… всё, что угодно, лишь бы значение замера бенчмарка было Double. Разбираемся со статистикой: почему медиана лучше среднего по выборке замеров, как определить степень «разбросанности» выборки, какие статистические параметры нам вообще нужны.
Конструкция механизма: Точка сборки
Статья описывает как собрать воедино эффекты и бенчмарки. Точка сборки всей системы. Здесь алгоритмы размытия и сами бенчмарки превращаются в эффекты с единой сигнатурой и регистрируются в реестре. Ключевая идея: бенчмарк — это такой же эффект, как и блюр. Он получает массив эффектов, конфигурацию и события прогресса/результата. Адаптеры через фабрики-замыкания (Delphi) или классы-исполнители (FPC) приводят всё разнообразие алгоритмов к единому интерфейсу. В итоге добавление нового эффекта в бенчмарк сводится к его реализации, регистрации и одному GUID в списке, без правки движка и UI.
Инструменты анализа: VCL
Кроссплатформенное ядро: блюры, абстракция ImageSurface32, механизм бенчмарка — не зависит от операционной системы. Оно работает на Windows, Linux и macOS, потому что использует только математику, работу с памятью и стандартные типы данных. Но ядро — это только половина задачи. Вторая половина — инструменты, которыми это ядро исследуется: сравнение изображений по метрикам качества и визуализация результатов бенчмарка. И здесь возникает принципиально иная ситуация.
Почему только VCL
Дело в том, что инструмент анализа не поставляется пользователю. Это то, чем пользуется разработчик, чтобы понять, какой алгоритм лучше, где теряется качество, насколько велик разброс замеров. Это инструмент, чтобы доказать те или иные выводы. А для этого нужна среда, в которой разработчик может отлаживать, останавливать, смотреть промежуточные результаты, менять параметры на лету.
VCL — это та среда, где у меня есть полный контроль: пошаговая отладка, инспекция объектов, знакомые инструменты, физический доступ к машине. Писать то же самое на FMX или LCL, честно говоря, не вижу смысла. И вот почему.
Есть техническая причина. Инструменты типа TImageMetric и ChartVCL завязаны на вещи, которые в кроссплатформенном виде потребовали бы отдельной инфраструктуры. Сравнение изображений — это запуск внешнего процесса compare.exe, перехват stderr, парсинг вывода. Теоретически это можно сделать через TProcess и на FPC, но тогда нужно тестировать на каждой платформе, подстраивать парсинг под разные версии утилиты, разбираться с особенностями путей и кодировок.
Вторая причина: в VCL для визуализации используем TCanvas, GDI+, антиалиасинг, шрифты. В FMX уже свой холст, в LCL — свои заморочки, и каждого свои метрики текста, свои особенности отрисовки. Кроссплатформенный рендерер графиков — это отдельный проект, а не «тот же код, но с условной компиляцией». И этот рендерер не является целью данного проекта.
Поэтому разделение сознательное и жёсткое. Ядро — кроссплатформенное. Инструменты анализа делаем в VCL. Не потому что VCL «лучше», а потому что именно в VCL могу гарантировать, что инструмент работает так, как задумано. Кроссплатформенные версии графиков и сравнения не являются актуальной задачей. Сначала надо убедиться, что сами алгоритмы хороши. А для этого достаточно одной платформы, на которой можно проверить всё до последней цифры.
Как сравнить изображения: Image Magick Compare
Помимо скорости, необходимо контролировать качество изображений. Любые оптимизации так или иначе крадут качество. Есть в мире интуитивный баланс «цена/качество», и мы хотим этот баланс соблюсти. Чем измерить качество и что нам это даст?
Статья вводит контроль качества как отдельный слой исследования. Разбираются три метрики: MSE как «математический микроскоп», PSNR как «инженерный баланс», SSIM как «контролёр визуальных дефектов». Даётся трактовка значений и порогов (например, PSNR > 40 дБ — идеал, SSIM > 0.995 — отлично). Инструментом выбран ImageMagick Compare: независимый, кроссплатформенный, проверенный в индустрии.
Модуль TImageMetric инкапсулирует запуск compare.exe, перехват stderr (метрики идут туда, а не в stdout), парсинг результата. Демонстрация на четырёх алгоритмах из третьей части (Fast Gaussian, Triple Box, Stack, DownUp) против эталона Direct2D показывает: все проходят визуальный тест (SSIM > 99.5%), Fixed-point Gaussian — лидер по точности, Stack — лучший баланс, Triple Box — парадокс: теория обещает больше, чем даёт практика. Подробности читаем в заметке.
Подключение и визуализация бенчмарка
Бенчмарк умеет мерить. Но таблица из пятидесяти ячеек — это не то, по чему сразу видно, кто быстрее. В этой статье — как превратить сырые замеры в графики, которые читаются с первого взгляда. Конструируем VCL-ядро графического рендеринга: абстрактный массив TBenchResult становится наглядной инфографикой.
Отдельно разбираем архитектурный трюк: бенчмарк — это рядовой графический эффект, выдающий на выходе готовую карту замеров.
Преодолеваем визуальный хаос при сравнении алгоритмов с разным порядком скоростей: спасаем графики ультрабыстрых методов от превращения в нечитаемую плоскую «вермишель» с помощью логарифмического масштабирования и точечного исключения тяжёлых выбросов через VAxisIgnored.
А также узнаём, почему с GDI+ мы соревноваться не будем.
Часть 3: Блюр
Здесь начинается сам разбор алгоритмов. Каждый метод разобран с двух сторон: сначала однопоточная реализация на Double, затем — распараллеливание, переход на Fixed-Point, контроль качества и сравнение с Direct2D.
Классический Гаусс (Double)
Сепарабельный гаусс на Double: два прохода, симметричное ядро, кэширование строк. Первая попытка распараллеливания через TParallel.For проваливается — 2831 мс вместо 618 и каша из пикселей. Разбираем правило локальности переменных, ClampByte и локальный кэш указателей строк, которые дают 126 мс. Плюс неожиданный сюжет: почему метрики качества на PNG врут, а на BMP — нет. В итоге получаем математически выверенный эталон размытия.
Быстрый Гаусс (Fixed-Point)
Разбор глубокой оптимизации сепарабельного размытия Гаусса при переходе на кроссплатформенные рельсы. Избавляемся от вещественных чисел (Double) в пользу шустрой целочисленной арифметики (Fixed-Point), побеждаем промахи кэша процессора с помощью транспонирования памяти.
В статье подробно разобран перенос вычислений в многопоточный режим TParallel.For и представлены бенчмарки производительности в x86/x64 режимах в сравнении с системным эталоном Direct2D.
Анализ качества изображений показал, что кроссплатформенный fixed-point алгоритм функционально эквивалентен float-версии.
На очень малых сигмах обходим Direct2D.
Тройной Box
Оптимизация тройного размытия прямоугольным ядром (Box Blur) на базе скользящей суммы. Переход на кроссплатформенную абстрактную поверхность. Уходим от дорогого целочисленного деления (div) в пользу fixed-point арифметики с таблицей обратных вычислений, уничтожаем скрытые перевычисления адресов памяти.
Анализ качества изображений преподнес сюрприз: за счет правильного математического округления (RECIP_HALF) вместо усечения дроби fixed-point алгоритм оказался точнее классики и практически идеально воспроизводит аппаратный Direct2D, при этом на x64 полностью обходит его по скорости во всём диапазоне сигм.
Шустрый Stack

В третьей части нашего цикла мы беремся за оптимизацию легендарного алгоритма Stack Blur. Мы последовательно устраним узкие места: избавимся от тяжелого деления в горячем цикле, уберем скрытые перевычисления адресов памяти из-за синтаксического сахара и вынесем аллокацию стека наружу, открыв прямой путь к безопасной многопоточности.
За счет перехода на fixed-point арифметику и распараллеливание нам удалось ускорить софтверный код почти в 7 раз. Благодаря всего двум проходам по памяти вместо шести алгоритм продемонстрировал феноменальную стабильность кэша процессора и предсказуемость (коэффициент вариации всего 1–2%), оставив позади аппаратный Direct2D на малых изображениях (600 x 600). А детальный анализ качества по метрикам MSE, PSNR и SSIM доказал, что оптимизированная версия с округлением RECIP_HALF работает точнее честной классики.
Мы наконец-то обогнали Direct2D.
Хитрый DownUp

Четвёртый подход меняет саму парадигму оптимизации: вместо того чтобы считать быстрее, мы учимся считать меньше. Разбираем четырёхступенчатую схему: агрессивное уменьшение кадра (Downscale), быстрый Stack Blur на крошечной площади, обратное растягивание (Upscale) и финальный лёгкий проход Box Blur для сглаживания «кубиков». Для этого с нуля пишем кроссплатформенный ресамплер по методу ближайшего соседа на fixed-point арифметике. Экспериментально доказываем, почему отказ от многопоточности при ресайзе оказался единственно верным решением.
Бенчмарки на x86/x64 позволили вывести точку перелома, после которой сокращение объёма данных даёт кратный выигрыш: DownUp Blur обходит аппаратный Direct2D даже на крупных изображениях 2560×1600. Проверка качества через ImageMagick Compare честно зафиксировала цену этой скорости: падение точности до 41–44 дБ по метрике PSNR (против 48 дБ у Stack Blur), что делает алгоритм идеальным инструментом для UI-эффектов и превью, где важен мгновенный отклик, а не попиксельная ретушь.
Побеждаем видеокарту на больших сигмах, просто перестав делать лишнюю работу.
Универсальный Blur-диспетчер
Архитектура, которая объединяет все алгоритмы.
Листинг IP76.Imaging.Blur
VCL
Скачать демо VCL
FMX
Демо в FMX
Проблемы с ANR в Android
Скачать демо FMX
LCL
Проблемы с многопоточностью в Lazarus
Демо в LCL
Скачать демо LCL
Часть 4: Размытие как инструмент обработки
Иногда размытие нужно не для красоты, а для извлечения информации:
- Увеличение чёткости (Unsharp Mask). Классический метод повышения резкости через вычитание размытой версии из оригинальной. Техника, обратная размытию.
- Перевод в истинное чёрно-белое. Это не просто обесцвечивание, а взвешенное суммирование каналов с предварительным размытием для подавления шума Эффективность этой фильтрации мы будем оценивать комплексно, используя уже обкатанную связку PSNR и SSIM, чтобы математически доказать: шум ушел, но важные детали и контраст изображения не пострадали.
- Сглаживание шума (Denoising). Размытие как простейший фильтр подавления высокочастотного шума.
- Выделение контуров (Edge Detection) — через разницу между размытой и оригинальной версией.
Это уже не про «красиво», а про «полезно». И здесь наш набор алгоритмов тоже пригодится.
Часть 5: Визуальные эффекты на основе размытия
Размытие — это не только финальный эффект, но и строительный блок для множества других техник:
- Эффект Ортона (Orton Effect). Наложение размытой и резкой версий изображения для создания свечения. Классика пейзажной фотографии, реализуемая за пару проходов.
- Радиальный блюр (Radial Blur). Размытие от центра к краям. Эффект движения, скорости, фокусировки внимания.
- Motion Blur (размытие в движении). Имитация длинной выдержки. Можно сделать за несколько проходов с разными смещениями.
- Глубина резкости (Depth of Field). Размытие фона с сохранением резкого объекта в фокусе. Использует карту глубины и несколько проходов с разными радиусами.
Все эти эффекты строятся на одних и тех же алгоритмах: Box, Stack, Gaussian. Собранный пул позволяет применять их как кирпичики для более сложных конструкций.
Как будет пополняться сборник
Я не ставлю точку. По мере появления новых исследований, экспериментов и реализаций буду добавлять их сюда. Это не законченная книга, а живой документ, который растёт вместе с моим пониманием темы.








