Алгоритм сепарабельного гауссова размытия мы подробно рассмотрели ранее. Нашей текущей задачей является переход с VCL.TBitmap на IImageSurface32. Как было заявлено ранее, математика не меняется. Суть самого появления абстракции IImageSurface32 – это единая математика во всех экосистемах. Второй задачей является оптимизация и распараллеливание алгоритма.
Однопоточная реализация
Размытие по Гауссу (Gaussian Blur) — один из самых популярных алгоритмов в графических редакторах и системах компьютерного зрения. Однако наивная реализация двумерной свертки «в лоб» работает крайне медленно: для изображения размером W x H и радиуса ядра R алгоритм требует O(W x H x R2) операций. При больших радиусах обработка даже одной фотографии может занять минуты.
Немного теории: Разделяй и властвуй
Эффективным способом оптимизации является сепарабельное (разделяемое) размытие. Этот подход снижает сложность алгоритма до O(W x H x R), что позволяет обрабатывать графику в разы быстрее.
Математическое свойство двумерной функции Гаусса

заключается в том, что её можно разделить на две независимые одномерные функции:

Для нас это означает фундаментальную вещь: вместо тяжелой двумерной свертки матрицы мы можем выполнить два последовательных одномерных прохода.
Проход 1: Размываем исходное изображение только по горизонтали (по строкам). Результат сохраняем во временный буфер.
Проход 2: Размываем полученный временный буфер только по вертикали (по столбцам).
Результат будет абсолютно идентичен классическому двумерному размытию, но количество математических операций станет несоизмеримо меньше.
Оптимизация структуры данных: симметричное ядро
Поскольку функция Гаусса симметрична относительно центра G(x) = G(-x), нет необходимости хранить массив весов целиком. Достаточно рассчитать и сохранить только центральный пиксель и правую (или левую) половину вектора.
|
1 2 3 4 5 6 7 |
type TKernel1D = record Radius: Integer; Weights: array of Double; // Weights[0] = центр, Weights[i] = смещение ±i // Симметричное ядро: храним только половину + центр end; |
Шаг 1: Генерация одномерного ядра Гаусса
Функция MakeGaussianKernel1D рассчитывает веса на основе коэффициента Sigma (среднеквадратичного отклонения). Радиус ядра классически выбирается как 3*Sigma, так как за пределами этого диапазона значения функции стремятся к нулю. Обратите внимание на этап нормализации в конце: сумма всех весов (с учетом симметрии) должна быть строго равна 1.0. Если этого не сделать, изображение после размытия станет темнее или светлее исходного.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
function MakeGaussianKernel1D(Sigma: Double): TKernel1D; var I: Integer; Sum, W: Double; begin // Радиус = 3*Sigma, округляем вверх. Минимум 1 Result.Radius := Max(1, Ceil(Sigma * 3)); SetLength(Result.Weights, Result.Radius + 1); // Вычисляем веса Sum := 0; for I := 0 to Result.Radius do begin W := Exp(-(I * I) / (2 * Sigma * Sigma)); Result.Weights[I] := W; if I = 0 then Sum := Sum + W // центральный - один раз else Sum := Sum + 2*W; // симметричные - дважды end; // Нормализуем, чтобы сумма = 1 for I := 0 to Result.Radius do Result.Weights[I] := Result.Weights[I] / Sum; end; |
Шаг 2: Реализация двухпроходного размытия
Основная процедура BlurGaussianSeparable принимает исходный интерфейс изображения Bitmap и значение Sigma, возвращая размытую копию в Result.
Внутри используются две важные техники:
Кэширование строк (TScanLineCache): Прямое обращение к пикселям через функции графических движков (вроде Pixels[X, Y]) работает медленно из-за постоянных проверок границ и пересчета адресов памяти. Кэширование указателей на строки (Scanline) ускоряет доступ в десятки раз.
Обработка краев (Clamp): Функция Clamp предотвращает выход индекса за пределы текстуры. Если фильтр «выглядывает» за границу картинки, он дублирует крайний пиксель.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 |
procedure BlurGaussianSeparable(const Bitmap: IImageSurface32; Sigma: Double; out Result: IImageSurface32); var K: TKernel1D; W, H, X, Y, I: Integer; SX, SY: Integer; SumR, SumG, SumB, SumA, Weight: Double; SrcCache, TmpCache, DstCache: TScanLineCache; Tmp: IImageSurface32; SrcPx: TPixel32; begin Result := nil; K := MakeGaussianKernel1D(Sigma); W := Bitmap.Width; H := Bitmap.Height; // Промежуточный буфер (после горизонтального прохода) Tmp := Bitmap.CreateSurface; Tmp.AlphaMode := Bitmap.AlphaMode; Tmp.SetSize(W, H); // Финальный результат (после вертикального прохода) Result := Bitmap.CreateSurface; Result.AlphaMode := Bitmap.AlphaMode; Result.SetSize(W, H); SrcCache := BuildScanLineCache(Bitmap); TmpCache := BuildScanLineCache(Tmp); DstCache := BuildScanLineCache(Result); // Проход 1: горизонтальный for Y := 0 to H - 1 do begin for X := 0 to W - 1 do begin SumR := 0; SumG := 0; SumB := 0; SumA := 0; for I := -K.Radius to K.Radius do begin SX := Clamp(X + I, 0, W - 1); Weight := K.Weights[Abs(I)]; SrcPx := SrcCache[Y]^[SX]; SumB := SumB + SrcPx.B * Weight; SumG := SumG + SrcPx.G * Weight; SumR := SumR + SrcPx.R * Weight; SumA := SumA + SrcPx.A * Weight; end; with TmpCache[Y]^[X] do begin B := Clamp(Round(SumB), 0, 255); G := Clamp(Round(SumG), 0, 255); R := Clamp(Round(SumR), 0, 255); A := Clamp(Round(SumA), 0, 255); end; end; end; // Проход 2: вертикальный for Y := 0 to H - 1 do begin for X := 0 to W - 1 do begin SumR := 0; SumG := 0; SumB := 0; SumA := 0; for I := -K.Radius to K.Radius do begin SY := Clamp(Y + I, 0, H - 1); Weight := K.Weights[Abs(I)]; SrcPx := TmpCache[SY]^[X]; SumB := SumB + SrcPx.B * Weight; SumG := SumG + SrcPx.G * Weight; SumR := SumR + SrcPx.R * Weight; SumA := SumA + SrcPx.A * Weight; end; with DstCache[Y]^[X] do begin B := Clamp(Round(SumB), 0, 255); G := Clamp(Round(SumG), 0, 255); R := Clamp(Round(SumR), 0, 255); A := Clamp(Round(SumA), 0, 255); end; end; end; end; |
Архитектурные нюансы алгоритма
Независимость каналов: Обработка каналов (BGRA) производится раздельно в вещественных переменных (Double). Округление и отсечение до диапазона 0..255 происходит только в момент записи пикселя в кэш. Это сводит к минимуму погрешности накопления при математических операциях.
Память vs Скорость: Алгоритм требует выделения памяти под дополнительный промежуточный буфер Tmp того же размера, что и картинка. Это небольшая плата за колоссальный выигрыш в скорости.
Локальность данных: Первый проход работает по строкам — это максимально дружелюбно для кэша процессора, так как данные считываются последовательно. Второй проход идет по вертикали, что вызывает частые промахи кэша (cache misses).
Математика не изменилась
Возьмём любой diff-инструмент (у меня это Araxis Merge) и посмотрим различия. Видим различие в типах и подготовке изображений:
И абсолютно никаких изменений в математике, как обещано:
Несмотря на высокую скорость, этот код в текущем виде работает в одном потоке. Обращаем внимание, что расчет каждого пикселя (и каждой строки) полностью независим от соседних. Это делает алгоритм идеальным кандидатом для распараллеливания.
Многопоточная реализация
В предыдущем разделе мы разобрали, как разделить двумерную свертку Гаусса на два независимых одномерных прохода. Это снизило сложность алгоритма, но код всё ещё выполнялся последовательно в одном потоке.
Рассмотрим механизм TParallel.For, архитектуру параллельной версии алгоритма и микрооптимизации работы с памятью.
Механизм TParallel.For
Переходим к давно обещанному многопоточному блюру. В качестве ознакомительного материала есть прекрасная статья «Параллельное программирование в Delphi XE7». Мне она в своё время сильно помогла, респект автору.
Для нашего случая отлично подходит TParallel.For. В теории, надо просто заменить внешний цикл по строкам:
|
1 2 3 4 5 6 7 8 9 10 |
// было: for Y := 0 to Height - 1 do BlurRow(Y); // стало: TParallel.For(0, Height - 1, procedure(Y: Integer) begin BlurRow(Y); end); |
Чтобы рассказать, как работает механизм распараллеливания, надо писать целую статью (и, наверное, не одну). Поэтому постараюсь кратко и тезисно.
TParallel.For берёт диапазон [Low..High] и сам делит его между рабочими потоками пула. Ключевых момента три:
Может показаться, что в таком случае у нас будет огромное число потоков. Это не так, потоков будет по числу ядер, а не по числу итераций. Пул поднимает ProcessorCount * 2 рабочих потоков (на 6-ядерном CPU — 12). Не «поток на строку», а горстка потоков, каждый из которых обрабатывает пачку строк. Накладные расходы на создание потоков платятся один раз, а не 1000 раз.
Работа раздаётся динамически, а не нарезается заранее. Наивное «раздели 1000 строк на 12 равных кусков» проседает, если одни куски считаются дольше других. TParallel.For вместо этого держит общий атомарный курсор: освободившийся поток забирает следующую порцию сам. Кто быстрее управился, тот и берёт ещё. Ядра не простаивают, нагрузка выравнивается автоматически.
Главный поток ждёт завершения. Вызов блокируется, пока все итерации не отработают. Это значит, что после TParallel.For результат гарантированно готов, синхронизировать вручную ничего не нужно.
Почему сепарабельный блюр — идеальный кандидат
Сепарабельность — это когда двумерное размытие раскладывается на два одномерных прохода: сначала размываем по горизонтали, потом по вертикали (или наоборот). И именно это даёт TParallel.For идеальные условия:
- Итерации независимы. В горизонтальном проходе каждая строка обрабатывается сама по себе, строке
Yне нужны результаты строки Y-1. Нет зависимостей, поэтому нет блокировок, нет гонок, потокам нечего делить. Ровно то, что параллелизм очень любит. - Итерации однородны. Каждая строка содержит примерно одинаковый объём работы. Курсор раздаёт порции ровно, ядра загружены равномерно.
- Работа тяжёлая, порция крупная. Обработка целой строки пикселей — это заметный кусок вычислений. Накладные расходы на раздачу задачи ничтожны на его фоне, и распараллеливание даёт почти линейный выигрыш по числу ядер.
Между проходами есть единственная точка синхронизации: горизонтальный проход должен полностью завершиться до старта вертикального. Но TParallel.For её обеспечивает сам, самим фактом ожидания:
|
1 2 3 |
TParallel.For(0, Height - 1, HorizontalBlur); // ждёт всех // ВНИМАНИЕ: У нас другие условия цикла, тут только для иллюстрации теории TParallel.For(0, Width - 1, VerticalBlur); // стартует по готовому |
Итог: сепарабельный блюр — это «идеальный параллельный цикл» из учебника. У нас на руках независимые однородные итерации крупного размера с одинаковым объёмом вычислений. Предполагаем, что TParallel.For разгоняет алгоритм примерно во столько раз, сколько ядер, буквально без усложнения кода.
Попытка распараллелить «в лоб»: фиаско
Давайте возьмём код классического блюра и добавим ему «параллельности». Мы уловили основную мысль, что потоки — это просто. Поэтому просто меняем нужные for на TParallel.For:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 |
procedure BlurGaussianSeparableP(const Bitmap: IImageSurface32; Sigma: Double; out Result: IImageSurface32); var K: TKernel1D; W, H {, X, Y, I}: Integer; SX, SY: Integer; SumR, SumG, SumB, SumA, Weight: Double; SrcCache, TmpCache, DstCache: TScanLineCache; Tmp: IImageSurface32; SrcPx: TPixel32; begin Result := nil; K := MakeGaussianKernel1D(Sigma); W := Bitmap.Width; H := Bitmap.Height; // Промежуточный буфер (после горизонтального прохода) Tmp := Bitmap.CreateSurface; Tmp.AlphaMode := Bitmap.AlphaMode; Tmp.SetSize(W, H); // Финальный результат (после вертикального прохода) Result := Bitmap.CreateSurface; Result.AlphaMode := Bitmap.AlphaMode; Result.SetSize(W, H); SrcCache := BuildScanLineCache(Bitmap); TmpCache := BuildScanLineCache(Tmp); DstCache := BuildScanLineCache(Result); // Проход 1: горизонтальный // for Y := 0 to H - 1 do TParallel.For(0, H-1, procedure(Y: Integer) var X, I: Integer; begin for X := 0 to W - 1 do begin SumR := 0; SumG := 0; SumB := 0; SumA := 0; for I := -K.Radius to K.Radius do begin SX := Clamp(X + I, 0, W - 1); Weight := K.Weights[Abs(I)]; SrcPx := SrcCache[Y][SX]; SumB := SumB + SrcPx.B * Weight; SumG := SumG + SrcPx.G * Weight; SumR := SumR + SrcPx.R * Weight; SumA := SumA + SrcPx.A * Weight; end; with TmpCache[Y][X] do begin B := Clamp(Round(SumB), 0, 255); G := Clamp(Round(SumG), 0, 255); R := Clamp(Round(SumR), 0, 255); A := Clamp(Round(SumA), 0, 255); end; end; end); // Проход 2: вертикальный // for Y := 0 to H - 1 do TParallel.For(0, H-1, procedure(Y: Integer) var X, I: Integer; begin for X := 0 to W - 1 do begin SumR := 0; SumG := 0; SumB := 0; SumA := 0; for I := -K.Radius to K.Radius do begin SY := Clamp(Y + I, 0, H - 1); Weight := K.Weights[Abs(I)]; SrcPx := TmpCache[SY][X]; SumB := SumB + SrcPx.B * Weight; SumG := SumG + SrcPx.G * Weight; SumR := SumR + SrcPx.R * Weight; SumA := SumA + SrcPx.A * Weight; end; with DstCache[Y][X] do begin B := Clamp(Round(SumB), 0, 255); G := Clamp(Round(SumG), 0, 255); R := Clamp(Round(SumR), 0, 255); A := Clamp(Round(SumA), 0, 255); end; end; end); end; |
Получаем удивительную картину:

Однопоточная версия слева (618 миллисекунд) и параллельная версия справа (2831 мс). Мало того, что картинка получилась загадочная, так и время выполнения, прямо скажем, отнюдь не многопоточное. Не такого мы ждали. Не такого… Что случилось?
Казалось бы, простое правило «замени for на TParallel.For и готово» — не работает. Замена одной строки действительно запускает 12 потоков (на 6 ядрах), но они тут же начинают драться за общие переменные-аккумуляторы, объявленные снаружи цикла. В результате цветная каша (гонка данных) и время в разы хуже однопоточного (ядра дерутся за одну кэш-линию вместо счёта).
Правило распараллеливания цикла: переменные только для чтения (ядро, размеры, кэши) можно оставить общими; всё, что итерация меняет (суммы, временные индексы, буфер пикселя), обязано быть локальным внутри тела цикла, своим у каждого потока.
Этого можно достигнуть переносом критических переменных внутрь procedure(Y). Каша исчезнет, скорость станет той, ради которой всё затевалось.
Попытка два: получилось
Давайте учтём всё, что узнали в предыдущем разделе и унесём все критические переменные внутрь итерации.
Комментарии внутри оставлены специально, чтобы видеть что переехало внутрь потоков.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 |
// Неоптимизированный вариант. Попытка 2 procedure BlurGaussianSeparableP(const Bitmap: IImageSurface32; Sigma: Double; out Result: IImageSurface32); var K: TKernel1D; W, H {, X, Y, I}: Integer; // SX, SY: Integer; // SumR, SumG, SumB, SumA, Weight: Double; SrcCache, TmpCache, DstCache: TScanLineCache; Tmp: IImageSurface32; // SrcPx: TPixel32; begin Result := nil; K := MakeGaussianKernel1D(Sigma); W := Bitmap.Width; H := Bitmap.Height; // Промежуточный буфер (после горизонтального прохода) Tmp := Bitmap.CreateSurface; Tmp.AlphaMode := Bitmap.AlphaMode; Tmp.SetSize(W, H); // Финальный результат (после вертикального прохода) Result := Bitmap.CreateSurface; Result.AlphaMode := Bitmap.AlphaMode; Result.SetSize(W, H); SrcCache := BuildScanLineCache(Bitmap); TmpCache := BuildScanLineCache(Tmp); DstCache := BuildScanLineCache(Result); // Проход 1: горизонтальный // for Y := 0 to H - 1 do TParallel.For(0, H-1, procedure(Y: Integer) var X, I, SX: Integer; SumR, SumG, SumB, SumA, Weight: Double; SrcPx: TPixel32; begin for X := 0 to W - 1 do begin SumR := 0; SumG := 0; SumB := 0; SumA := 0; for I := -K.Radius to K.Radius do begin SX := Clamp(X + I, 0, W - 1); Weight := K.Weights[Abs(I)]; SrcPx := SrcCache[Y][SX]; SumB := SumB + SrcPx.B * Weight; SumG := SumG + SrcPx.G * Weight; SumR := SumR + SrcPx.R * Weight; SumA := SumA + SrcPx.A * Weight; end; with TmpCache[Y][X] do begin B := Clamp(Round(SumB), 0, 255); G := Clamp(Round(SumG), 0, 255); R := Clamp(Round(SumR), 0, 255); A := Clamp(Round(SumA), 0, 255); end; end; end); // Проход 2: вертикальный // for Y := 0 to H - 1 do TParallel.For(0, H-1, procedure(Y: Integer) var X, I, SY: Integer; SumR, SumG, SumB, SumA, Weight: Double; SrcPx: TPixel32; begin for X := 0 to W - 1 do begin SumR := 0; SumG := 0; SumB := 0; SumA := 0; for I := -K.Radius to K.Radius do begin SY := Clamp(Y + I, 0, H - 1); Weight := K.Weights[Abs(I)]; SrcPx := TmpCache[SY][X]; SumB := SumB + SrcPx.B * Weight; SumG := SumG + SrcPx.G * Weight; SumR := SumR + SrcPx.R * Weight; SumA := SumA + SrcPx.A * Weight; end; with DstCache[Y][X] do begin B := Clamp(Round(SumB), 0, 255); G := Clamp(Round(SumG), 0, 255); R := Clamp(Round(SumR), 0, 255); A := Clamp(Round(SumA), 0, 255); end; end; end); end; |
Вот сейчас заработало, как надо:

Картинка и время (136 мс против 618 мс) нас вполне устраивают. Но нет предела совершенству! Не очень нравится обращение к кэшам ScanLines, сформированным вне цикла. Также, необходимо оптимизировать работу по строкам в вертикальном проходе, скачки по ним дорогого стоят, постоянный промах кэша. К тому же, повсеместно использование Clamp — это ветвление в цикле. Пора заменить Clamp(Value, MinVal, MaxVal) на более шустрый ClampByte (где MinVal=0, MaxVal=255) везде, где это уместно.
Попытка три: отлично
Теперь, собрав все грабли и хотелки, пишем финальную версию.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
procedure BlurGaussianSeparableP(const Bitmap: IImageSurface32; Sigma: Double; out Result: IImageSurface32); var K: TKernel1D; W, H: Integer; SrcCache, TmpCache, DstCache: TScanLineCache; Tmp: IImageSurface32; begin Result := nil; K := MakeGaussianKernel1D(Sigma); W := Bitmap.Width; H := Bitmap.Height; // Промежуточный буфер (после горизонтального прохода) Tmp := Bitmap.CreateSurface; Tmp.AlphaMode := Bitmap.AlphaMode; Tmp.SetSize(W, H); // Финальный результат (после вертикального прохода) Result := Bitmap.CreateSurface; Result.AlphaMode := Bitmap.AlphaMode; Result.SetSize(W, H); SrcCache := BuildScanLineCache(Bitmap); TmpCache := BuildScanLineCache(Tmp); DstCache := BuildScanLineCache(Result); // Проход 1: горизонтальный TParallel.For(0, H-1, procedure(Y: Integer) var X, I, SX: Integer; SumR, SumG, SumB, SumA, Weight: Double; SrcPx: TPixel32; DstPx: PPixel32; SrcRow: PPixel32Array; DstRow: PPixel32Array; begin SrcRow := SrcCache[Y]; DstRow := TmpCache[Y]; for X := 0 to W - 1 do begin SumR := 0; SumG := 0; SumB := 0; SumA := 0; for I := -K.Radius to K.Radius do begin SX := Clamp(X + I, 0, W - 1); Weight := K.Weights[Abs(I)]; SrcPx := SrcRow^[SX]; SumB := SumB + SrcPx.B * Weight; SumG := SumG + SrcPx.G * Weight; SumR := SumR + SrcPx.R * Weight; SumA := SumA + SrcPx.A * Weight; end; DstPx := @DstRow^[X]; DstPx^.B := ClampByte(Round(SumB)); DstPx^.G := ClampByte(Round(SumG)); DstPx^.R := ClampByte(Round(SumR)); DstPx^.A := ClampByte(Round(SumA)); end; end); // Проход 2: вертикальный TParallel.For(0, H-1, procedure(Y: Integer) var X, I, SY: Integer; SumR, SumG, SumB, SumA, Weight: Double; SrcPx: TPixel32; DstPx: PPixel32; DstRow: PPixel32Array; Rows: array of PPixel32Array; // указатели на нужные строки Tmp begin DstRow := DstCache[Y]; // Предпосчёт: какие строки понадобятся для этого Y (с учётом Clamp) SetLength(Rows, 2*K.Radius + 1); for I := -K.Radius to K.Radius do begin SY := Clamp(Y + I, 0, H - 1); Rows[I + K.Radius] := TmpCache[SY]; end; for X := 0 to W - 1 do begin SumR := 0; SumG := 0; SumB := 0; SumA := 0; for I := 0 to 2*K.Radius do begin Weight := K.Weights[Abs(I - K.Radius)]; SrcPx := Rows[I]^[X]; SumB := SumB + SrcPx.B * Weight; SumG := SumG + SrcPx.G * Weight; SumR := SumR + SrcPx.R * Weight; SumA := SumA + SrcPx.A * Weight; end; DstPx := @DstRow^[X]; DstPx^.B := ClampByte(Round(SumB)); DstPx^.G := ClampByte(Round(SumG)); DstPx^.R := ClampByte(Round(SumR)); DstPx^.A := ClampByte(Round(SumA)); end; end); end; |
Получаем на выходе такой результат:

По сравнению с попыткой 2 (136 мс), мы получили 126.5 миллисекунд, т.е. прирост примерно 7%. Кажется, что ради такого скромного выигрыша не стоило было городить Rows и ClampByte? Но при большей картинке разрыв будет больше. Давайте разберём все микрооптимизации, повлиявшие на скорость выполнения.
Анатомия микрооптимизации
Разгоняем Clamp
В графических движках функция отсечения значений в диапазон 0..255 — это одна из самых «горячих» точек. В наивной реализации она выглядит как два последовательных условия:
|
1 2 3 4 |
if V < 0 then V := 0 else if V > 255 then V := 255; |
Внутри глубоких циклов обработки миллионов пикселей эти ветвления становятся катастрофой. Они ломают конвейер процессора из-за промахов предсказателя переходов.
Чтобы решить эту проблему, в нашем движке используется функция ClampByte, работающая на уровне быстрых побитовых операций:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// Ветвление-минимум версия // Разбор трюка (важно: работает ТОЛЬКО для 32-битного знакового Integer): // V < 0 -> (V shr 31) = 1 -> 1 - 1 = 0 -> Result = 0 // V > 255 -> (V shr 31) = 0 -> 0 - 1 = -1 = $FF..FF -> Byte(..) = 255 // 0..255 -> (V and $FFFFFF00) = 0 -> Result = V // shr для Integer в Delphi — логический сдвиг, поэтому знаковый бит // корректно уезжает в младший разряд // Если сменить тип V на Int64 — сломается function ClampByte(V: Int32): Byte; const MASK = Int32(not 255); //$FFFFFF00; begin if V and MASK = 0 then Result := V else // Byte(...) - явный каст, иначе упадёт при {$R+} Result := Byte((V shr 31) - 1); end; |
Наивный подход требует двух проверок: сначала на выход за нижнюю границу, затем за верхнюю. На миллиардах итераций это заставляет предсказатель переходов процессора работать в два раза интенсивнее, удваивая риск промаха и сброса конвейера CPU.
ClampByte устроен хитрее. Формально в нём тоже есть if, но условие V and MASK = 0 истинно для подавляющего большинства пикселей (все значения 0..255), поэтому предсказатель переходов почти никогда не ошибается. А в редкой «плохой» ветке только две операции, которые дают либо 0 (для отрицательных), либо 255 (для превышающих). Итог тот же, что у наивного Clamp, но с минимальной ценой за предсказание. Именно поэтому в горячих циклах мы заменяем Clamp(.., 0, 255) на ClampByte везде, где это уместно.
Локализация переменных внутри анонимного метода
Все счетчики (X, I, SX), промежуточные суммы (SumR, SumG…) и указатели объявлены внутри анонимной процедуры. Каждый рабочий поток операционной системы получает свой экземпляр этих переменных в собственном стеке. Это гарантирует потокобезопасность и исключает состояние гонки.
Оптимизация адресации памяти
В однопоточной версии к пикселям обращались через двумерный кэш: SrcCache[Y]^[SX]. Это заставляло процессор на каждой итерации высчитывать адрес строки заново.
В параллельной версии адрес строки извлекается во внешнем цикле всего один раз:
|
1 2 3 |
SrcRow := SrcCache[Y]; // Указатель на начало строки Y // Во внутреннем цикле работаем напрямую с одномерным массивом: SrcPx := SrcRow^[SX]; |
Запись результата оптимизирована аналогично — через прямую работу с указателем DstPx := @DstRow^[X], что минимизирует накладные расходы на копирование структур.
Борьба с кэш-промахами
Про промах кеша можно почитать тут «Cache Miss (Промах кэша)» или тут «Кэш-промах».
Вертикальный проход традиционно страдает от плохой локализации данных в кэше процессора: для расчета одного пикселя приходится прыгать по разным строкам памяти (TmpCache[SY]^[X]). Для ухода от этой проблемы применим такое решение — локальный кэш указателей строк для текущего потока:
|
1 2 3 4 5 6 7 |
// Предпосчёт: какие строки понадобятся для этого Y SetLength(Rows, 2*K.Radius + 1); for I := -K.Radius to K.Radius do begin SY := Clamp(Y + I, 0, H - 1); Rows[I + K.Radius] := TmpCache[SY]; end; |
Теперь во внутреннем цикле по X вместо повторного вызова Clamp и обращения к глобальному TmpCache[SY] поток мгновенно берет готовый указатель из компактного локального массива Rows[I].
Небольшой промежуточный итог
ClampByte нам пригодится повсеместно — в методах блюра при назначении байтам каналов значений используется Clamp(.., 0, 255), мы эти вызовы заменим на ClampByte. Rows — напоминание, что если есть возможность кэшировать, надо кэшировать. Этот приём нам ещё не раз пригодится. Самое главное — всё что может измениться в потоке, запихиваем внутрь потока.
И на этом остановимся. Тут есть куда оптимизировать, но вся эта оптимизация уже есть в сепарабельном блюре на fixed-point. Если нам нужен математический эталон на числах с плавающей точкой, то он у нас уже есть и мы можем его получить за очень хорошее время, этого достаточно.
Осталось убедиться, что мы действительно получаем эталон. Ведь за всеми этими TParallel.For, локальными кэшами и битовыми масками легко потерять главное: не изменилась ли сама картинка? Не принесла ли оптимизация артефактов, которых не было в однопоточной версии? Именно это мы сейчас и проверим.
Анализ схожести изображений
В прошлой статье у нас появилась утилита для сравнения изображений по трём метрикам. Сравним, насколько отличны друг от друга одно- и многопоточные версии.

Неотличимы. Сравним многопоточную версию на поверхностях с аналогичным алгоритмом, но на VCL.TBitmap.

И снова один-в-один. Теперь финальный тест — сравниваем в Direct2D.

Прекрасные результаты!
- MSE = 0,000004. Среднеквадратичная ошибка практически равна нулю. Пиксели двух изображений почти идентичны.
- PSNR = 53,536 дБ. Очень высокий показатель (обычно >40 дБ уже считается отличным качеством). Говорит о минимальном уровне искажений.
- SSIM = 0,999317. Структурное сходство близко к 1 (максимум). Визуально и структурно изображения неотличимы для глаза.
Методы работают идентично по результату. Метрики подтверждают, что наша версия не вносит никаких артефактов или искажений.
У нас появилась возможность сравнить то же самое, но в формате PNG.

| Метрика | BMP | PNG | Разница |
|---|---|---|---|
| MSE | 0,000004 | 0,000005 | +25% |
| PSNR | 53,536 дБ | 53,052 дБ | −0,48 дБ |
| SSIM | 0,999317 | 0,979575 | −0,020 |
MSE и PSNR практически не изменились — разница в четвёртом-пятом знаке после запятой. Это подтверждает: средняя величина ошибки та же, алгоритм работает так же точно, физическая точность воспроизведения D2D сохраняется.
SSIM заметно упал с 0,9993 до 0,9796. Это артефакт формата PNG и способа сравнения, а не деградация алгоритма. ImageMagick при сравнении PNG не выполняет premultiply, поэтому «мусорные» RGB-значения под полупрозрачными пикселями дают локальные структурные расхождения, которые SSIM ловит. В BMP-файле (в нашем случае он точно premultiplied) эти значения уже корректны, и SSIM это видит.
Посмотрим карту различий:

Обе карты структурно идентичны: тот же силуэт, те же зоны концентрации различий, та же «рябь» в гладких областях. Значит, дело не алгоритме размытия, и в выборе контейнера (BMP или PNG). Формат не меняет пространственную картину ошибки. Различия между картами лежат в интенсивности красного, а не в его расположении..
Разница между BMP и PNG
Парадокс. Визуально PNG-карта не выглядит «хуже», красный на ней может казаться даже бледнее. Но метрики SSIM у PNG хуже (0,9796 против 0,9993). Это ровно то, о чём мы говорили: ImageMagick при работе с PNG не выполняет premultiply, поэтому часть различий «съедается» и красный становится бледнее. Это не значит, что ошибка меньше, она просто иначе распределена по каналам.
Обращаем внимание на нижнюю полосу, она есть в обеих картах и одинаково интенсивна. Это граница изображения (не объекта). Здесь работают граничные условия, и именно здесь они дают максимальное расхождение с D2D.
Пиксель на границе
Мы используем Clamp на граничных пикселях изображения. Эта схема называется Replication Padding (дублирование краев): [ A, A, | A, B, C, D, | D, D ].

Давайте попробуем применить схему с зеркальным отражением пикселей. Их две — через граничный пиксел, либо через границу пикселя. Поясню:
Mirror Padding (граничный пиксель не повторяется): [ C, B, | A, B, C, D, | C, B ].

Reflect Padding (граничный пиксель повторяется): [ B, A, | A, B, C, D, | D, C ].

Гугл, правда, дал другие определения — первый он назвал Reflect (дескать, синоним), а второй — Symmetric Padding. Разные источники дают разную терминологию, но, как бы они не назывались, мы будем реализовывать вторую стратегию, через границу.
Стратегия Reflect (Symmetric) Padding
Напишем новую функцию, которая возвращает индекс по стратегии Reflect (Symmetric) Padding:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
// Преобразование индекса по Reflect стратегии - повтор граничного function Reflect(I, L: Integer): Integer; inline; begin // Основной диапазон: Почти всегда работает это условие if (I >= 0) and (I < L) then Exit(I); // Невообразимый случай, но всякое случается // Для массивов из 1 элемента или пустых паддинг не имеет смысла if L < 2 then Exit(0); // Надеемся, что mod будет не так часто (строим кэш индексов) I := I mod (2 * L); if I < 0 then I := 2 * L + I; if I >= L then I := 2 * L - I - 1; Result := I; end; |
Заменим (а ещё лучше подведём под директиву компилятора) вызовы Clamp на Reflect:
|
1 2 3 4 5 6 |
{$IFDEF REFLECT_MODE} SY := Reflect(Y + I, H); {$ELSE} SY := Clamp(Y + I, 0, H - 1); {$ENDIF} |
И если сейчас посмотрим карту различий:

то увидим, что все граничные кляксы исчезли.
Сам по себе результат — отличный. И карта, и цифры заметно изменились по сравнению с предыдущим замером. Разберём.
Что стало лучше по цифрам
| Метрика | Было (BMP) | Стало (BMP) | Отличие |
|---|---|---|---|
| MSE | 0,000004 | 0,000001 | ×4 меньше |
| PSNR | 53,54 дБ | 59,00 дБ | +5,5 дБ |
| SSIM | 0,99932 | 0,99937 | +0,00005 |
PSNR вырос на 5,5 дБ и это очень много. Каждые +3 дБ = ошибка вдвое меньше. То есть MSE упал в 4 раза. Вы вышли в зону 59 дБ, где различия — это уже уровень последнего бита float32, а не реальная ошибка.
SSIM практически не изменился. Это тоже информативно: структура не поменялась, изменилась только величина ошибки, а не её характер.
Что показательно в паре BMP/PNG
- MSE в BMP (0,000001) ровно в 2 раза меньше, чем в PNG (0,000002).
- PSNR в BMP на 1,17 дБ выше, и это согласуется с MSE (разница в 2 раза ≈ 3 дБ, но здесь чуть меньше из-за логарифма).
- SSIM в BMP 0,9994, в PNG 0,9798 — та же история, что и раньше.
Это подтверждает гипотезу: PNG-представление даёт завышенную ошибку из-за отсутствия premultiply в ImageMagick Compare. Причём теперь, когда алгоритм стал точнее, разрыв между BMP и PNG увеличился, потому что реальная ошибка настолько мала, что артефакт сравнения PNG стал доминирующим вкладом.
Иными словами: в PNG мы измеряем уже не разницу алгоритмов, а разницу в способе сравнения.
По мере приближения алгоритма к эталону, метрики в BMP-представлении уходят в область 59 дБ и SSIM 0,9994, что соответствует точности float32. При этом метрики в PNG-представлении перестают реагировать на улучшение алгоритма, их значение определяется уже не разницей изображений, а способом интерпретации прозрачности инструментом сравнения. Это демонстрирует, что BMP-представление является корректной метрикой для оценки алгоритмов размытия с альфа-каналом, а PNG-представление — справочной.
Выводы по разделу
Проведённые измерения показывают, что зеркальная стратегия обработки граничных пикселей даёт наилучшее совпадение с D2D Gaussian Blur в режиме D2D1_BORDER_MODE_HARD. В сочетании с сепарабельным гауссом на числах с плавающей запятой это позволяет достичь PSNR 59,0 дБ и SSIM 0,9994, то есть уровня функциональной идентичности эталону. Карта различий подтверждает: остаточные расхождения носят численный, а не структурный характер и сосредоточены исключительно на границах изображения и объекта.
Однако дальнейшее сравнение граничных стратегий показало, что разница между reflect и clamp по метрикам незначительна для практических задач. При этом clamp существенно дешевле вычислительно: он не требует модульной арифметики, ветвлений и предвычисленных таблиц индексов. В горячем цикле сепарабельной свёртки это даёт заметный выигрыш в производительности.
Поэтому в рамках данного проекта принято следующее инженерное решение:
- Для всех алгоритмов размытия использовать стратегию clamp. Это обеспечивает максимальную скорость при сохранении визуального качества. Разница с reflect лежит в пределах, незначимых для практического применения.
- Зеркальная стратегия сохраняется только для классического гауссова размытия, используемого в качестве эталонного алгоритма в системах, где Direct2D недоступен. Здесь приоритет отдаётся точности воспроизведения D2D, а не скорости. Для включения reflect-стратегии используется директива компилятора REFLECT_MODE.
- Для оценки качества алгоритмов используется BMP-представление (потому что premultiplied alpha). Именно оно измеряет качество самого алгоритма, а не артефакты инструмента сравнения. PNG-представление (straight alpha) приводится справочно: как показано в разделе, ImageMagick Compare не выполняет premultiply перед сравнением, поэтому метрики в PNG определяются не разницей изображений, а способом интерпретации прозрачности. По мере приближения алгоритма к эталону разрыв между BMP- и PNG-метриками растёт, что наглядно демонстрирует: PNG-метрики перестают быть мерой качества алгоритма.
Таким образом, дальнейшие эксперименты в работе проводятся в BMP-представлении и с clamp-границами для всех алгоритмов, кроме эталонного. Это решение обеспечивает баланс между точностью измерений, скоростью работы и воспроизводимостью результатов.
Общий итог и что дальше
В этой части исследования мы проделали большую архитектурную работу: успешно перенесли единую математику размытия на абстракцию IImageSurface32, распараллелили вычисления с помощью TParallel.For и устранили коварные «подводные камни» многопоточности вроде гонки данных и кэш-промахов процессора.
Использование строгих графических метрик (MSE, PSNR, SSIM) доказало: наше многопоточное сепарабельное размытие на числах с плавающей точкой (Double) обеспечивает функциональную идентичность эталонному Direct2D Gaussian Blur. Мы достигли впечатляющего качества в PSNR 59,0 дБ и SSIM 0,9994, окончательно разобравшись с артефактами сравнения прозрачности и выбрав оптимальную стратегию обработки границ clamp.
Однако, глядя на финальный код, мы понимаем: мы выжали максимум из многопоточности, но далеко не максимум из процессора.
Текущая проблема: Вычисления в плавающей запятой (Double) и обработка каналов по отдельности — это колоссальная нагрузка на CPU. Наш алгоритм всё ещё тратит драгоценные такты на конвертацию типов, вещественную арифметику и обращение к памяти. Настоящая скорость в компьютерном зрении и графических движках достигается там, где властвует чистая целочисленная магия.
В следующей статье мы совершим следующий квантовый скачок:
- Полностью откажемся от Double и переведём всю математику Гаусса на арифметику с фиксированной запятой (Fixed-Point). Получим колоссальное ускорение.
- Ещё сильнее ускоримся за счёт параллельных вычислений.
- Снова убедимся в качестве предложенных алгоритмов.

