Sampling a Greyscale image into 8 levels - image

Question

What I am trying to do:-
Using MATLAB, I am trying to read a Greyscale image (having pixel values bw range 0-255) i.e. an 8bit image into like 3 bit image, hence it is like sampling the range into 8 different levels. For example if the pixel value is 25 then as it comes bw range 0-31, it will be assigned value 0, for bw 32-63 level will be 1 and so on until finally range 224-255 it will be on range 7.
After that I am counting the total no of pixels in different levels.
Code:-
img=imread('Cameraman.bmp');
r=size(img,1);
c=size(img,2);
pixel_count=zeros(9,1);
for i=1:r
for j=1:c
if fix(img(i,j)/31)==8
img(i,j)
end
img(i,j)=fix(img(i,j)/33);
pixel_count(img(i,j)+1)=pixel_count(img(i,j)+1)+1;
end
end
pixel_count
My Problem:-
Even if the range of each pixel is from 0-255, and I am dividing it into 8 levels, I am getting a total of 9 levels.
For debugging it I added the if statement in the code and my output is:--
ans = 248
ans = 250
ans = 249
ans = 249
ans = 235
ans = 249
ans = 249
ans = 235
...and more
pixel_count =
11314
3741
2061
5284
12629
25590
4439
437
41
As you can see for some values like 249,235 and more I am getting the extra 9th level.
What is the problem here. Please help.
Thank You.

Answer 1

You aren't dividing by the right value properly. You need to divide by 32, then take the floor / fix. Between 0-31, if you divide by 32 then take the floor / fix, you get the value 0, between 31-63, you get 1, up until 224-255 which gives you 7.
Also, your for loop is incorrect. You are mistakenly replacing the pixel of the input image with its bin location. I would also change the precision to double. It seems that with my experiments, using fix combined with a uint8 image gives me that random 9th bin index that you're talking about.
Take a look at some sample results from my REPL:
>> fix(240/32) + 1
ans =
8
>> fix(uint8(240)/32) + 1
ans =
9
>> fix(uint8(255)/32) + 1
ans =
9
>> fix(255/32) + 1
ans =
8
Therefore, it's a problem with the image type. For any values that are beyond 240, the value when being divided by 32 as it's uint8 gets rounded so that 240 / 32 = 7.5 but because it's uint8 and it's an integer, it gets rounded to 8, then adding 1 makes it go to 9. Therefore, anything beyond 240 will get rounded to 8 and ultimately giving you 9 when adding by 1.
So, simply change the division to be 32, not 33 or 31 and fix what I said above:
img=imread('Cameraman.bmp');
img = double(img); %// Change
r=size(img,1);
c=size(img,2);
pixel_count=zeros(8,1); %// Change
for i=1:r
for j=1:c
pix = fix(img(i,j)/32); %// Change here
pixel_count(pix+1)=pixel_count(pix+1) + 1; %// Change
end
end
pixel_count
As a minor note, to check to see if you're right, use histc:
pixel_count = histc(fix(double(img(:))/32) + 1, 1:8);
If you got your code right, your code and with what I wrote above should match. Using the cameraman.tif image that's built-in to the Image Processing Toolbox, let's compare the outputs:
>> pixel_count
pixel_count =
13532
2500
2104
8341
15333
22553
817
356
>> pixel_count2 = histc(fix(double(img(:))/32) + 1, 1:8)
pixel_count2 =
13532
2500
2104
8341
15333
22553
817
356
Looks good to me!