"""

Function to get the cdf of an array

Args:

a (array): array to build the cdf from.

If the shape is 1 dimensional, it is assumed to be a pdf

If the shape is 2 dimensional, it is assumed to be a gray-scale img

dcValues (int): maximum value of any element in the array

For images this will be 255

Returns:

a single-dimension array cdf

Raises:

ValueError: image shape is not 2 (gray-scale) or 3 (color)

"""

if (len(np.shape(a)) == 1):

# it's a pdf

pdf = a

else:

# get histogram from the image

# first check if image is gray-scale or not

if (len(np.shape(a)) == 2):

# gray-scale image, look at channels [0]

# args: images, channels, mask, histSize, ranges

hist = cv2.calcHist([a],[0],None,[dcValues],[0,dcValues])

else:

raise ValueError("Invalid number of channels found: {}".format(

len(np.shape(a))

))

# get PDF of histogram

# probability is the total histogram value, divided by total pixels

pdf = hist / np.prod(np.shape(a))

# get CDF of histogram

cdf = np.cumsum(pdf)

"""

Function to build lookup table based on another image or pdf

Args:

im (array): image with initial histogram to be modified

target (array): image or pdf to modify the im's histogram

maxCount (int): maximum digital counts for the image

Returns:

a lookup table to perform on a histogram

"""

# build the image cdf

imgCDF = build_cdf(im, maxCount)

# build the target (image or pdf) cdf

tarCDF = build_cdf(target, maxCount)

# build the lookup table

# for every value, get the result from the imgCDF;

# then, find the first index that exists for that value in the tarCDF.

lut = np.arange(maxCount+1)

for i in range(maxCount):

# sometimes our imgCDF is higher than the tarCDF ever is

# lets put that at the maxCount

if (imgCDF[i] > np.amax(tarCDF)):

lut[i] = maxCount

else:

lut[i] = np.argmax(np.where( tarCDF >= imgCDF[i], 1, 0 ))

"""

Function to build lookup table for a given image

Args:

im (array): image to build initial histogram from

value (integer): percent of CDF to remove from the histogram

dcValues (integer): total number of digital counts

Returns:

a lookup table to perform on a histogram

"""

# get the cdf

cdf = build_cdf(im, dcValues-1)

# remove value/2 from each side

# subtract by value/2, get the absolute value, find the argmin

# the value closest to 0 will be the best

# get the lower end of the CDF

lowerCDF = cdf - ((value/2)/100)

absLowCDF = np.absolute(lowerCDF)

minIndex = np.argmin(absLowCDF)

# get the higher end of the CDF

higherCDF = (-cdf+1) - ((value/2)/100)

absHighCDF = np.absolute(higherCDF)

maxIndex = np.argmin(absHighCDF)

# the number of values we want to change, over how many values we'll cover

# basically, rise over run

slope = (dcValues-1) / (maxIndex - minIndex)

intercept = slope*(minIndex)

# create linear array

linearArray = np.arange(dcValues)

# build mask to clip lookup table

# zero out elements under the minIndex and max elements over the maxIndex

lowMask = linearArray < minIndex

highMask = linearArray > maxIndex

linearArray = (slope*linearArray) - intercept

np.place(linearArray, lowMask, 0)

np.place(linearArray, highMask, dcValues - 1)

"""

Function to build lookup table for a given color image

Refer to the build_linear_lookup_table for a better understanding of the

function.

Returns:

several lookup table to perform on each color-band's histogram

"""

blut = build_linear_lookup_table(im[:,:,0], value, dcValues)

glut = build_linear_lookup_table(im[:,:,1], value, dcValues)

rlut = build_linear_lookup_table(im[:,:,2], value, dcValues)

"""

Function to build lookup table for a given color image

Refer to the build_match_lookup_table for a better understanding of the

function.

Returns:

several lookup table to perform on each color-band's histogram

"""

# check if target is color

if (len(np.shape(target)) == 3):

# color target

blut = build_match_lookup_table(im[:,:,0], target[:,:,0], maxCount)

glut = build_match_lookup_table(im[:,:,1], target[:,:,1], maxCount)

rlut = build_match_lookup_table(im[:,:,2], target[:,:,2], maxCount)

else:

blut = build_match_lookup_table(im[:,:,0], target, maxCount)

glut = build_match_lookup_table(im[:,:,1], target, maxCount)

rlut = build_match_lookup_table(im[:,:,2], target, maxCount)

"""

Function to run histogram enhancement and histogram matching for a given

image. The function returns an image after the histogram matching or

enhancement has been performed.

Args:

im (array): image to be modified based on the etype or target

etype (optional[string]): type of enhancement to perform

Can be 'linear2', 'linear3', etc..., to do a linear enhancement

based on the CDF.

Can be 'equalize' to do enhancement based on a flat histogram.

Can be 'match', to do an image or histogram (PDF) based enhancement.

target (optional[image, histogram]): image or histogram to match against

Can be None, to do enhancement based on other etypes.

maxCount (optional[int]): the maximum value for a digital count.

Returns:

the enhanced image

Raises:

TypeError: if image is not a numpy ndarray

TypeError: if target is not a numpy ndarray when performing a match

ValueError: if etype did not contain a digit: e.g. 'linear3'

ValueError: if etype is not 'linear', 'match', or 'equalize'

"""

outputImage = np.zeros(np.shape(im))

# get int type for the image (to return to that later)

dtype = im.dtype

# type checking, look at the above Raises section

if (not isinstance(im, np.ndarray)):

raise TypeError("image is not a numpy ndarray; use openCV's imread")

# use the etype to determine type of transform

if (not isinstance(etype, str)):

raise TypeError("etype is not a string value");

if (etype.find("linear") == 0):

# linear was at index 0, so we're doing a linear transformation

linearValue = etype.split("linear")[1]

if(not linearValue.isdigit()):

# check if "linear" was not followed by a digit

raise ValueError("linear etype should contain a digit")

# linear percentage to enhance by

linPct = int(linearValue)

# perform linear enhancement

if (len(np.shape(im)) == 3):

# color image, build special lookup table

lut = build_color_linear_lookup_table(im, linPct, maxCount + 1)

outputImage[:,:,0] = lut[0][im[:,:,0]]

outputImage[:,:,1] = lut[1][im[:,:,1]]

outputImage[:,:,2] = lut[2][im[:,:,2]]

else:

lut = build_linear_lookup_table(im, linPct, maxCount + 1)

outputImage = lut[im]

elif (etype == "match"):

if (not isinstance(target, np.ndarray)):

raise TypeError("target is not a numpy ndarray")

else:

# perform match enhancement

if (len(np.shape(im)) == 3):

# color image, build special lookup table

lut = build_color_match_lookup_table(im, target, maxCount)

outputImage[:,:,0] = lut[0][im[:,:,0]]

outputImage[:,:,1] = lut[1][im[:,:,1]]

outputImage[:,:,2] = lut[2][im[:,:,2]]

else:

lut = build_match_lookup_table(im, target, maxCount)

outputImage = lut[im]

elif (etype == "equalize"):

# build pdf to match against

equalizePDF = np.zeros(maxCount)

equalizePDF.fill(1/maxCount)

# perform match enhancement

if (len(np.shape(im)) == 3):

# color image, build special lookup table

lut = build_color_match_lookup_table(im, equalizePDF, maxCount)

outputImage[:,:,0] = lut[0][im[:,:,0]]

outputImage[:,:,1] = lut[1][im[:,:,1]]

outputImage[:,:,2] = lut[2][im[:,:,2]]

else:

lut = build_match_lookup_table(im, equalizePDF, maxCount)

outputImage = lut[im]

else:

raise(ValueError, "etype must be 'linear', 'match', or 'equalize'")

outputImage = np.array(outputImage, dtype)

"""

# Compare Histograms ======================================================#

print("plot original image")

plotImgHist(im)

print("plot output image")

plotImgHist(outputImage)

"""