Histogram Equalization

It’s still not possible for us to know what image[i,j] contains, but FWIW note that 1 is a literal that automatically gets parsed as Int (Int64 on most systems):

julia> typeof(1)

I don’t understand why you think you need the UInt8() conversion here, but adding 1 to the result of UInt8() makes this conversion superfluous anyway due to type promotion that happens when adding a UInt8 and an Int:

julia> UInt8(255)

julia> UInt8(255) + 1

julia> typeof(UInt8(255) + 1)
1 Like

Again, this is not a good idea, since you will get an error unless image[i,j] * 255 is exactly a whole number. Therefore, you should use round or trunc instead.

1 Like

I understand now how it works. Thanks!

if you see the code, I’m didn’t add “+1” to

frequency[UInt8(image[i,j] * 255) ] += 1

which doesn’t make sense to get a histogram. so i updated that line to

frequency[UInt8(image[i,j] * 255) +1 ] += 1  #this works

The explanation for using UInt8 and multiplying by 255 is explained my tutor as follow,

You need to cast like this in order to use the image values for access. The internal representation uses Normed{UInt8, 8}, since this corresponds directly to the underlying data representation (UInt8), but also behaves like a floating point number, so you can do useful calculations on the images without converting between representations.

and the image is Gray image

i couldn’t upload the image as it’s in .tif file.

But you’re doing it here:

UInt8(image[i,j] * 255) +1 will not be an UInt8, because an UInt8 plus an Int64 is an Int64, and 1 is an Int64, look:

julia> typeof(UInt8(5) + 1)

Since you don’t provide any example image data, it’s difficult to say whether what your tutor is saying is correct, but it looks strange to me. As far as I understand image[i,j] * 255 will be a Float32, and in that case there’s no obvious need to use UInt8, but I guess no harm, either. But I am very skeptical of using UInt8() instead of round(UInt8, ) or trunc(UInt8, ).

Okay to reduce the confusion I went ahead an installed TestImages. Here’s what’s happening (I think):

julia> using Images, TestImages

julia> image = testimage("cameraman.tif");

julia> typeof(image)

So image is an array of Gray{Normed{UInt8,8}} elements:

julia> image[1,1]

If you multiply those by an Int, as you do, you end up with:

julia> image[1,1]*255

that doesn’t work for indexing, you need an integer. You converted this back to UInt8:

julia> UInt8(image[1,1]*255)

but then you’re directly adding a 1, which as we said is just a literal that gets parsed as an Int64, and adding that to your UInt8 just gives you a regular Int:

julia> UInt8(image[1,1]*255)+1

So this is essentially the same as doing:

julia> Int(image[1,1]*255)+1

Thanks for looking that up.

Question is, is

guaranteed to always be a whole number?

I don’t know enough about how images are represented, but there might be something about the Gray{N0f8} that means it holds discrete levels of 255 shades of gray which will always be an integer between 1 and 255 when multiplied by 255?

@DNF I noticed once of your reply saying, where the below code is initialized.

out[UInt8([i,j] * 255)]

Dumb me, I didn’t do that. Now I initialize with,

out = zeros(Uint8, sizeof(image))

As I already initialized out with UInt8, I don’t need to do the conversion again in the code. So now I can change the line to

out[i,j] = cdf[image[i,j] + 1]

And, I have attached an .png file and the code to show the working of histogram for the line, frequency[UInt8(image[i,j] * 255)+1 ] += 1

julia> function myHis(image)
       m, n = size(image)
       frequency = zeros(256)
           for i in 1:m, j in 1:n
               frequency[UInt8(image[i,j] * 255)+1 ] += 1    
        return frequency ./ sizeof(image)


between 0 and 255.
0 represents black and 255 represents white