Linear Inverted Image on Opencv

Question

I'm trying to emulate the linear invert function in GIMP with opencv and python. I can't find more information on how that function has been implemented, besides it being used under linear light.Since I read that opencv imports linear BGR images, I proceeded to trying normal inversion on a RGB opencv but I can only replicate the common inversion method on GIMP.

Inversion function:

def negative(image):
    img_negative = (255-image)
    return img_negative

Original

Linear Inverted (Negative) Image on GIMP

Inverted (Negative) Image on GIMP

Any insight would be appreciated.

Answer 1

It took a little bit of trial and error, but in addition to you inverting the image, you also have to do some scaling and translation as well.

What I did specifically was in addition to inverting the image, I truncated any values that were beyond intensity 153 for every channel and saturated them to 153. After using this intermediate output, I shift the range such that the lowest value gets mapped to 102 and the highest value gets mapped to 255. This is simply done by adding 102 to every value in the intermediate output.

When I did that, I got a similar image to the one you're after.

In other words:

import cv2
import numpy as np

im = cv2.imread('input.png') # Your image goes here
im_neg = 255 - im
im_neg[im_neg >= 153] = 153 # Step #1
im_neg = im_neg + 102 # Step #2
cv2.imshow('Output', np.hstack((im, im_neg)))
cv2.waitKey(0)
cv2.destroyWindow('Output')

Thankfully, the minimum and maximum values are 0 and 255 which makes this process simpler. I get this output and note that I'm concatenating both images together:

Take note your desired image is stored in im_neg. If you want to see just the image by itself:

Compared to yours:

It's not exactly what you see in the output image you provide, especially because there seems to be some noise around the coloured squares, but this is the closest I could get it to and one could argue that the result I produced is better perceptually.

Hope this helps!

Answer 2

Gimp as of 2.10 works in linear color space and if you look at the original source code for the function it's just bitwise not. SO, here's what the code should look like in opencv-python:

import numpy as np
import cv2

#https://www.pyimagesearch.com/2015/10/05/opencv-gamma-correction/

def adjust_gamma(image, gamma=1.0):
    # build a lookup table mapping the pixel values [0, 255] to
    # their adjusted gamma values
    invGamma = 1.0 / gamma
    table = np.array([((i / 255.0) ** invGamma) * 255
        for i in np.arange(0, 256)]).astype("uint8")

    # apply gamma correction using the lookup table
    return cv2.LUT(image, table)

def invert_linear(img):
    x= adjust_gamma(img, 1/2.2)
    x= cv2.bitwise_not(x)
    y=  adjust_gamma(x, 2.2)

    return y