Here are two ways to do that in Python/OpenCV. Both are based upon the ratio of the log(mid-gray)/log(mean). Results are often reasonable, especially for dark image, but do not work in all cases. For bright image, invert the gray or value image, process as for dark images, then invert again and recombine if using the value image.

• Read the input
• Convert to gray or HSV value
• Compute the ratio log(mid-gray)/log(mean) on the gray or value channel
• Raise the input or value to the power of the ratio
• If using the value channel, combine the new value channel with the hue and saturation channels and convert back to RGB

Input:

import cv2
import numpy as np
import math

# read image
img = cv2.imread('lioncuddle1.jpg')

# METHOD 1: RGB

# convert img to gray
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# compute gamma = log(mid*255)/log(mean)
mid = 0.5
mean = np.mean(gray)
gamma = math.log(mid*255)/math.log(mean)
print(gamma)

# do gamma correction
img_gamma1 = np.power(img, gamma).clip(0,255).astype(np.uint8)



# METHOD 2: HSV (or other color spaces)

# convert img to HSV
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
hue, sat, val = cv2.split(hsv)

# compute gamma = log(mid*255)/log(mean)
mid = 0.5
mean = np.mean(val)
gamma = math.log(mid*255)/math.log(mean)
print(gamma)

# do gamma correction on value channel
val_gamma = np.power(val, gamma).clip(0,255).astype(np.uint8)

# combine new value channel with original hue and sat channels
hsv_gamma = cv2.merge([hue, sat, val_gamma])
img_gamma2 = cv2.cvtColor(hsv_gamma, cv2.COLOR_HSV2BGR)

# show results
cv2.imshow('input', img)
cv2.imshow('result1', img_gamma1)
cv2.imshow('result2', img_gamma2)
cv2.waitKey(0)
cv2.destroyAllWindows()

# save results
cv2.imwrite('lioncuddle1_gamma1.jpg', img_gamma1)
cv2.imwrite('lioncuddle1_gamma2.jpg', img_gamma2)

Result from method 1:

Result from method 2:

I know I am late, but I would suggest using gamma correction.

Now what is gamma correction?

I will make it clear in layman's terms:

• To display image on a screen, input voltage is needed.
• This voltage is output as light intensity.
• In perfect world, input voltage would be linear to output intensity.
• But the real screen output is close to an exponential curve, the exponent being gamma.

Since the computer screen applies a gamma value to the image on screen, the process of applying inverse gamma to counter this effect is called gamma correction.

Here is the code for the same using OpenCV 3.0.0 and python:

import cv2
import numpy as np

def adjust_gamma(image, gamma=1.0):

   invGamma = 1.0 / gamma
   table = np.array([((i / 255.0) ** invGamma) * 255
      for i in np.arange(0, 256)]).astype("uint8")

   return cv2.LUT(image, table)

x = 'C:/Users/524316/Desktop/stack/test.jpg'  #location of the image
original = cv2.imread(x, 1)
cv2.imshow('original',original)

gamma = 0.5                                   # change the value here to get different result
adjusted = adjust_gamma(original, gamma=gamma)
cv2.putText(adjusted, "g={}".format(gamma), (10, 30),cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 3)
cv2.imshow("gammam image 1", adjusted)

cv2.waitKey(0)
cv2.destroyAllWindows()

Here is the original image:

Applying gamma of value 0.5 will yield:

Applying gamma of value 1.5 will yield:

Applying gamma of value 2.5 will yield:

Applying gamma of value 1.0 will yield the same image.

Code was borrowed from this link

So in order to properly converted a linear image to sRGB I had to use a transfer function, which for sRGB, can be simplified with gamma.

Here's what I ended up using, and worked very well.

    #Read image (.exr)
    im=cv2.imread(newPath,-1)
    
    #Remove alpha if present
    im = im[:,:,:3]    
    
    #resize image
    dsize = (400,200)
    ldrDrago = cv2.resize(im, dsize)    
        
    #Convert to sRGB
    ldrDrago = ldrDrago ** (1 / 2.2)
    
    
    #Write jpeg
    cv2.imwrite(filename+".jpg", ldrDrago * 255)

On a high level, I believe that your problem is simply one of method compatibility: LUT works on the standard 8-bit format. You have to convert your image to that format before feeding it to the method. Alternately, you can write your own 12-bit LUT method, replacing all of the upper limits in the original code with your 4095/4096.

as I understand your question, you are mainly trying to detect the edges of the card? Or are you trying to separate the card completely (i.e. cut out) from the image?

Your use of gamma is simply changing apparent contrast of the entire image after you convert it to gray. OpenCV has a lot of edge and object detection routines of its own, as I am assuming you are trying to do pre-processing to help?

A CONCEPTS (Not Code) ANSWER:

SEPARATE CHANNELS

Let me point you in a different direction. If the input images are always color, consider using only one of the three RGB color channels. Here's an example:

RED CHANNEL:

GREEN CHANNEL:

BLUE CHANNEL:

Notice how much more contrast the blue channel has relative to the red channel. Depending on the image contents, you will typically find that one channel has better separation for the desired object.

If you look at the histogram:

You can see that the blue channel has the greatest distance between the peaks on the right (the desired object) and the left peak (bright spot on the table). But the red channel has everything bunched up in the middle.

As an idea, you could use peak detection/peak location/distance between peaks to programmatically determine relative contrasts in each color channel.

You can also determine which color channel has its peak the farthest from the same peak in another channel, and then SUBTRACT or use DIFFERENCE or DIVIDE the two channels (example of this in "channel math" below).

The Table Cloth

Now with the table cloth, it has a very high contrast pattern on it — white(gray) that is lighter than the ID card and green that is darker than the card. The card is mostly in between.

Using a curves tool from an image editor to provide a graphical example, you can see that clamping the lower AND upper levels to black, you can isolate the mid-ranged card.

But again, notice the histogram:

While nearly everything is clumped in the midrange values, the RED channel does have a small peak near black. Using this as a guide, we turn off the green and blue channels, and then CLAMP values below and values above the range of the card's value.

CURVES TOOL:

And then the resultant red channel only - note this is inverted to make the resulting contrast more clear:

SUMMARY

So the jist of these isolation concepts is to

1. Examine each color channel to determine which one has best contrast. This will be looking for a peak that is most different from the other channels AND/OR looking for peaks in a channel with the widest "valley" between them.
2. Clamp low and high values to isolate the desired object. This will use the peaks found in A, with a threshold, to determine the points to clamp and ramp into the desired image.

The problem with just using a general "gamma" adjustment is that you're going to be dragging the entire image around to change apparent contrast, when what you are really trying to do is eliminate (clamp) portions of the image that are not relevant.

While I realize this isn't exactly what you were asking, I hope it was useful nevertheless. Also, I'd suggest checking out more of the detection functions in OpenCV if you aren't already.

BONUS: FUN WITH CHANNEL MATH

This may or may not have utility for you, but multiplying, dividing, subtracting, difference, exclusion between color channels can sometimes help get rid of unwanted background objects. Take the table cloth and the pattern.

Lets MULTIPLY the GREEN and BLUE channels and get THIS:

Now lets DIVIDE by the RED channel

Now adjust the GAMMA of the RED channel to eliminate the tablecloth pattern (Gamma Adjusted to 1.57):

With this resultant image:

Which of course can have further contrast enhancement now that the tablecloth pattern is gone.