GIMP: результаты POC не совпадают с GIMP для режима наложения «Вычитание»

Question

Я пытался реализовать режимы смешивания GEGL, Color Dodge и Subtract , как часть POC в Python. Последовательность, которой я придерживаюсь, - это Dodge, за которым следует Subtract. Я имел в виду следующие источники для своей реализации:

1. Характеристики SVG: компоновкиhttps://www.w3.org/TR/SVGCompositing/#comp-op-property
2. Реализации GEGL для Color Dodge и Subtract.

Смешивание Color Dodge работает правильно и «почти» идентично результатам GIMP (для некоторых пикселей я получаю разницу максимумов в 1 яркости, но этого достаточно). Однако результаты, которые я получаю для Subtract, полностью отличаются от того, что наблюдается в GIMP. Я понял, что Subtract - это простая разница по элементам для каждого канала отдельно.

Работаю с линейным RGB. Ниже приводится моя реализация на Python:

      import cv2
import numpy as np

# Colour Dodge mode
# Alpha channel is assumed to be 1 (Opacity 100%) as this serves the purpose and 
# simplifies implementation.
def applyColourDodge(srcImage, destImage, alphaImage, iterations):
    aComp =  alphaCh + alphaCh - alphaCh * alphaCh
    
    sCdC = srcImage + destImage
    numComponents = srcImage.shape;
    numDims = len(numComponents);
    compImage = srcImage.copy()

    isAlphaPresent = False
    for channel in range(0, numComponents[numDims-1]):
        numRows = srcImage.shape[0]
        numCols = srcImage.shape[1]
        for row in range(0, numRows):
            for col in range (0, numCols):
                if (sCdC[row,col, channel] >= 1):
                    compImage[row, col, channel] = 1
                else:
                    if (srcImage[row, col, channel] == 1):
                        compImage[row, col, channel] = 1
                    else:
                        cD = destImage[row, col, channel]
                        cS = srcImage[row, col, channel]

                        if (cD == 1):
                            compImage[row, col, channel] = 1
                        else:
                            compImage[row, col, channel] = cS/(1 - cD)

    if (isAlphaPresent):
        compImage[:,:,numComponents[numDims-1]] = aComp

    return compImage

# Subtract mode
def applySubtract(srcImage, destImage, alphaImage):
    aComp =  alphaCh + alphaCh - alphaCh * alphaCh
    
    numComponents = srcImage.shape;
    numDims = len(numComponents);

    compImage = np.zeros(srcImage.shape, dtype = "float64")
    isAlphaPresent = False
    for ch in range(0, numComponents[numDims-1]):
        compImage[:,:,ch] = srcImage[:,:,ch] - destImage[:,:,ch]

    if (isAlphaPresent):
        compImage[:,:,numComponents[numDims-1]] = aComp

    return compImage

ipFolder = "D:/Work/TIS/IssueWorkedOn/VP-17871 - Dual Colour Capsules/Dual Color Caps Samples/"

ipString = 'Test Image.bmp'
refString = 'Brown Black Dodge Final.bmp'

ipBGR = cv2.imread(ipFolder + ipString, cv2.IMREAD_COLOR)

ipORG = ipBGR.copy() # Retain the original image
ipBGR = ipBGR.astype("float64") 
ipBGR = ipBGR/255 # Normalise in range [0, 1]

alphaCh = np.ones(ipBGR.shape[:2], dtype = "float64") # Alpha channel

srcImage = ipBGR.copy() # Bottom layer
destImage = srcImage.copy() # Top layer

# For debugging purpose
numComponents = ipBGR.shape;
numRows = srcImage.shape[0]
numCols = srcImage.shape[1]
print(ipORG[int(numRows/2),int(numCols/4),:])
print(ipORG[int(numRows/2),int(3*numCols/4),:])

# Actual composite generation. Desired flow: Dodge -> Dodge -> Subtract
compImage = applyColourDodge(srcImage, destImage, alphaCh, 2)
# compImage = applyColourDodge(compImage, srcImage, alphaCh, 2)
compImage = applySubtract(compImage, srcImage, alphaCh)

# Remap in the range [0, 255]
compImage = compImage * 255
compImage = compImage.astype("uint8")

print(compImage[int(numRows/2),int(numCols/4),:])
print(compImage[int(numRows/2),int(3*numCols/4),:])

# For visualisation
orgWin = "Original Image"
filWin = 'Composite Image'
toolWin = 'Tool Composite'

cv2.namedWindow(orgWin, cv2.WINDOW_FREERATIO)
cv2.namedWindow(filWin, cv2.WINDOW_FREERATIO)
cv2.imshow(orgWin, ipBGR)
cv2.imshow(filWin, compImage)
cv2.imshow(toolWin, ipRef)
cv2.waitKey(0)
cv2.destroyAllWindows()

Итак, для режима вычитания я взял результат операции Dodge как верхний слой, а исходное исходное изображение - за нижний слой. Непрозрачность установлена ​​на 100%, поскольку это служит моей цели и упрощает реализацию.

Структура кода не чистая. Так что извините меня за это. Во-первых, я хочу исправить алгоритм.

Ниже приводится двухцветное тестовое изображение, которое я использовал для проверки:Исходное изображение . Тройка RGB для левой половины: (71, 66, 50) и правой половины: (22, 255, 182).

Результат Color Dodge из GIMP и POC . Тройки RGB для обоих изображений одинаковы - Слева: (98, 89, 62); Справа: (24, 255, 255).

Вот результаты после применения Subtract: GIMP, POC . Я вижу резкую разницу в конечном составном изображении: триплеты RGB из изображения GIMP: (69, 60, 35) и (4, 255, 255) триплеты RGB из изображения POC: (27, 23, 12) и (2, 0 , 73)

Я попытался найти похожие проблемы на SO и обнаружил , это и этоэто . Но это не могло помочь мне понять поведение, которое я наблюдал. Я был бы признателен, если бы кто-нибудь мог мне помочь в этом отношении.