Фильтр реалистичной, «пленочной» коррекции теней

30 октября, 20152 ноября, 2015 ~ Denis Svinarchuk

Сегодня я не буду подробно описывать как с помощью Metal Framework и Metal Shading Language запрограммировать фильтр. Т.е. не буду останавливаться на деталях реализации. В целом, предыдущего поста должно было быть достаточно для уверенного понимания как варится программа с использованием этих средств.

Сегодня мы сосредоточимся на идее нового фильтра с точки зрения разработчика этого фильтра (инженера или математика) и покажем как от идеи до воплощения в коде заставить железку работать на благо, например, эстетики. Подумаем как сделать изображение более «привлекательным» в некоторых, специальных случаях.

В общем начнем простыми и местами научными методами учить наш iPhone или iPad быстро и качественно корректировать тени несколько недоэкспонированных или высококонтрастных фотографий и, возможно, потерявших непростительно много деталей в тенях. Предлагаемый способ можно назвать универсальным алгоритмом коррекции теней произвольных изображений, в отличие, скажем, от версии Adobe реализованной в инструменте Shadows/Highlights алгоритм, который я опишу сегодня, нельзя воспроизвести средствами фоторедакторов, по крайней мере пока.

Этот алгоритм используется как часть одного большого фильтра изображений в новой версии фото-приложения Degradr. И надо сказать существенно влияет на конечный результат всей работы.

Если по чесноку, и вот без этого кривляния, основная цель сегодняшнего поста показать как легко можно сосредоточиться на идее и не тратить время на прикладную часть: сбивании пальцев рук в ацкие мозоли при набивании текста программы фильтра. Metal Framework и Metal Shading Language — это все, что вам нужно для реализации вашей идеи. Сосредоточьтесь на главном: на реализации.

Идея

Основная задача при коррекции теней изображения состоит в «вытягивании» пропавших деталей в сильно контрастных изображениях. При этом средние тона и светлоты не должны участвовать в осветлении.

Возьмем исходную картинку создадим две копии, сложим эти копии в режиме смешения Screen, который как известно осветляет изображение в целом. По сути, это будет гамма-коррекция со значением гаммы 2, примененной к инвертированной версии исходной картинки и затем восстановленной из негатива.

${f(rgb) = S(L(rgb)_{1},L(rgb)_{2})}$ — функция смешивания слоев яркостных каналов изображения,
где ${S = (1.0 - ((1.0 - L_{1})(1.0 - L_{2})))}$ — функция смешивание в режиме Screen

Выглядеть такая штука (смешивание изображения с самим собой) будет так:

На графике хорошо видно, что это частный случай функции гамма-коррекции. Или как если бы мы применили инструмент «Кривые» к изображению в Photoshop-е аккуратно притянув сплайны к нужным точкам. Но кривые, и сплайны — это слишком грубая работа для пытливого ума. Не наш, в общем метод…

Нетрудно догадаться, что функцию можно применить дважды и получить еще более высветляющую кривую:

Вот эту функцию, которая более, и возьмем за основу «высветляющей» части фильтра — это будет гамма коррекция негатива изображения с гаммой равной 4 и последующим «отпечатком» в исходный позитив (поэтому я назвал коррекцию «пленочной» — работаем с «негативом»):

${L_{o} = 1 - (1-L_{i})^{4}}$

Однако полученное изображение будет светлым по всему полю, а нам нужно только в тенях. Чтобы избежать лишнего осветления применим к результату свертку функций смешивания исходного изображения и полученного в нормальном режиме. Где свертка будет функцией смешивания в альфа канале с усилением значения яркостного канала в тенях и ослаблением смешивания в светах. Свертку можно придумать и будет она примерно такой:

Свертку можно придумать любую, вы можете свою, даже может быть еще лучше. Но смысл должен быть тут ясен: нам нужна плавная монотонно-убывающая функция. Хотя подойдет и просто линейная, но работать она будет хуже. При желании, вы сможете это проверить после сборки проекта, заменив мою версию на свою.

Напомню как смешиваются каналы в нормальном режиме с учетом альфа-композиции двух исходных изображений:

${C^{rgb}_{o} = \frac{\alpha_{i}}{\alpha_{s}}C^{rgb}_{i}+(1-\frac{\alpha_{i}}{\alpha_{s}})C^{rgb}_{s}}$

Или результирующее выражение свертки для нашего случая:

${(L_{i}*L_{s})(C^{rgb}_{o}) = \frac{\alpha_{i}}{\alpha_{s}}C^{rgb}_{i}+(1-\frac{\alpha_{i}}{\alpha_{s}})C^{rgb}_{s}}W_{c_{o}}$

Вес осветленного изображения в зависимости от значения яркостного канала исходного изображения подобрать несложно:

${W_{c_{o}}(L_{i}) = \frac{W}{\exp^{\frac{6K_{s}L_{i}}{w_{t}}}}w_{t}\ \begin{cases}0\leq{W}\leq1\\0<{w_{t}}\leq1\\1\leq{K_{s}}\leq5\end{cases}}$ ,

${C^{rgb}_{z}}$

${o\ }$

${i\ }$

${s\ }$

${L_{i}}$

${L_{s}}$

${W}$

${K_{s}}$

${w_{t}}$

Небольшой update по следам дискуссии

Результирующая функция-свертка от функции гамма-коррекции инвертированного изображения и веса альфа канала получается такой (синяя ~~кривая~~ — поправили, исправляю: «магическая некривая линия коррекции теней»):

Куём математику в железо: проверяем гипотезу

//
//  IMPFilter.metal
//  ImageMetalling-00
//
//  Created by denis svinarchuk on 27.10.15.
//  Copyright © 2015 ImageMetalling. All rights reserved.
//

#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;

inline float4 blendNormal(float4 c2, float4 c1)
{
    //
    // from: https://github.com/BradLarson/GPUImage
    //
    
    float4 outputColor;
    
    float a = c1.a + c2.a * (1.0 - c1.a);
    float alphaDivisor = a + step(a, 0.0);
    
    outputColor.r = (c1.r * c1.a + c2.r * c2.a * (1.0 - c1.a))/alphaDivisor;
    outputColor.g = (c1.g * c1.a + c2.g * c2.a * (1.0 - c1.a))/alphaDivisor;
    outputColor.b = (c1.b * c1.a + c2.b * c2.a * (1.0 - c1.a))/alphaDivisor;
    outputColor.a = a;
    
    return clamp(outputColor, float4(0.0), float4(1.0));
}

typedef struct{
    packed_float4 shadows;       // [level, weight, tonal width, slop]
} IMPShadows;


//
// Прямое переложение функции расчета веса светов в якростном канале сигнала
//
inline float luminance_weight(float Li, float W, float Wt, float Ks){
    return W / exp( 6 * Ks * Li / Wt) * (Wt * 0.5);
}

//
// РЕзультирующая функция коррекции теней
//
inline float4 adjustShadows(float4 source, constant IMPShadows &adjustment)
{
    float3 rgb = source.rgb;

    //
    // выучите эту строчку наизусть, используется почти везде
    // можно запомнить как 3/6/1
    //
    // почитать можно тут: https://en.wikipedia.org/wiki/Relative_luminance
    // исходная формула относительной яркости в колорометрии:
    // Y = 0.2126 R + 0.7152 G + 0.0722 B
    // но мы работаем не с колорметрически измеренным значением RGB, а с представлением
    // rgb в виде sRGB цветового пространства. Так случилось, что быстрое преобразование:
    // L(rgb)= (r,g,b)(0.299, 0.587, 0.114)', для наших целей подходит лучше
    // и подтверждается рядом экспериментов с большим набором изображений.
    //
    float luminance = dot(rgb, float3(0.299, 0.587, 0.114));

    //
    // Распаковываем выходной буфер, прилетевший из памяти приложения в память GPU
    // подразумеваем:
    // 1. x - уровень воздействия фильтра
    // 2. y - коэффициент нормализации фильтра (по умолчанию = 1 и мы его не трогаем)
    // 3. z - тональная ширина охвата фильтра, т.е. насколько далеко мы восстанавливаем тени от черной точки
    // 4. w - коэффициент наклона (slope) кривой фильтра, т.е. скорость сниения воздействия в зависимости от
    //        яркости
    //
    float4 shadows(adjustment.shadows);
    
    float weight = luminance_weight(luminance,
                                    shadows.y,
                                    shadows.z,
                                    shadows.w);
    
    //
    // Альфа канал - функция уровня воздействия фильтра и вес от яркости
    //
    float  a(shadows.x * weight);
    
    //
    // Функция смешивания в режиме screen 2 раза или
    // гаммакорекция негатива с гаммой == 4
    //
    float3 c(1.0 - pow((1.0 - rgb),4));
    
    //
    // Результат смешиваем в нормальном режиме с учетом композиции в альфа канале
    //
    return blendNormal (source, float4 (c , a));
}


kernel void kernel_adjustSHL(
                             texture2d<float, access::sample> inTexture [[texture(0)]],
                             texture2d<float, access::write> outTexture [[texture(1)]],
                             constant IMPShadows &adjustment             [[buffer(0)]],
                             uint2 gid [[thread_position_in_grid]]
                             )
{
    float4 inColor = inTexture.read(gid);
    outTexture.write(adjustShadows(inColor, adjustment), gid);
}

Весь остальной код, с некоторыми изменениями, копируем из предыдущего проекта. В итоге получаем: аппликуху магически «улучшающую» любые фотографии. Скачать исходный код можно поссылке. Cобирать проект в папке: ImageMetalling-01.

Добавлю небольшие пояснения по коду MSL. В нем можно увидеть вот такой кусок:

typedef struct{
    packed_float4 shadows;       // [level, weight, tonal width, slop]
} IMPShadows;
...
    constant IMPShadows &adjustment             [[buffer(0)]],
....

Он означает, что мы передаем в память GPU не готовую структуру данных, а упакованную, т.е. без побайтного выравнивания. Разработчики Metal позаботились о возможности упаковать произвольную структуру данных в основном коде приложения и передать её в программу исполняемую на GPU. Поскольку мы не знаем о природе выравнивания данных в памяти GPU, мы должны использовать такую нотацию для многомерных структур. Очевидно, что в нашем случаем можно сконструировать свою структуру для параметризации функции фильтра, но помня о главном принципе программиста: не плодить лишних сущностей, использовали готовый вектор класса float4 из комплекта Metal Framework.

В проект можно подгрузить любую свою фотографию, можно даже переделать код для чтения изображений из Camera Roll и запись обратно. Я ~~украл~~ взял фотоку Павла Косенко с каким-то экстремальным случаем теней, и поэкспериментировал с ней:

Бинго! Работает. Можно нас поздравить: наша теория работает в железе, и скорее всего она верна.

Что еще можно сказать?..
Совсем не трудно догадаться, что операция затемнения светов строго симметрична осветлению теней. Единственное отличие, которое можно себе вообразить: нужно инвертировать свертку и смешивать изображения в режиме Multiply.

Notice (отчего-то спрашивают): По тексту, когда мы говорим об изображении, всегда имеется в виду один пиксел. Мы продолжаем помнить о параллелизме вычислений: функция фильтра вычисляется для каждого пиксела отдельно и сразу. Я думаю, вы привыкните к этому скоро, если еще не имели дело с вычислениями на графических сопроцессорах.

Если заметили ашипку, если написал глупость, если что-то не понятно: комментируйте или пишите на: imagemetalling [*] gmail.com .