A proper way to convert 2D Array into RGB or GrayScale image for precision difference

Question

I have a 2D CNN model where I perform a classification task. My images are all coming from a sensor data after conversion.

So, normally, my way is to convert them into images using the following approach

newsize = (9, 1000)
pic = acc_normalized[0]
img = Image.fromarray(np.uint8(pic*255), 'L')
img = img.resize(newsize)
image_path = "Images_Accel"
image_name = "D1." + str(2)
img.save(f"{image_path}/{image_name}.jpeg")

This is what I obtain:

However, their precision is sort of important. For instance, some of the numerical values are like:

117.79348187327987 or 117.76568758022673.

As you see in the above line, their difference is the digits, when I use uint8, it only takes 117 to when converting it into image pixels and it looks the same, right? But, I'd like to make them different. In some cases, the difference is even at the 8th or 10th digit.

So, when I try to use mode F and save them .jpeg in Image.fromarray line it gives me error and says that PIL cannot write mode F to jpeg.

Then, I tried to first convert them RGB like following;

img = Image.fromarray(pic, 'RGB')

I am not including np.float32 just before pic or not multiplying it by 255 as it is. Then, I convert this image to grayscale. This is what I got for RGB image;

After converting RGB into grayscale:

As you see, it seems that there is a critical different between the first pic and the last pic. So, what should be the proper way to use them in 2D CNN classification? or, should I convert them into RGB and choose grayscale in CNN implementation and a channel of 1? My image dimensions 1000x9. I can even change this dimension like 250x36 or 100x90. It doesn't matter too much. By the way, in the CNN network, I am able to get more than 90% test accuracy when I use the first-type of image.

The main problem here is using which image conversion method I'll be able to take into account those precision differences across the pixels. Would you give me some idea?

---- EDIT -----

Using .tiff format I made some quick comparisons.

First of all, my data looks like the following;

So, if I convert this first reading into an image using the following code where I use np.float64 and L gives me a grayscale image;

newsize = (9, 1000)
pic = acc_normalized[0]
img = Image.fromarray(np.float64(pic), 'L')
img = img.resize(newsize)
image_path = "Images_Accel"
image_name = "D1." + str(2)
img.save(f"{image_path}/{image_name}.tiff")

It gives me this image;

Then, the first 15x9 matrix seems like following image; The contradiction is that if you take a closer look at the numerical array, for instance (1,4) member, it's a complete black where the numerical array is equal to 0.4326132099074307. For grayscale images, black means that it's close to 0 cause it makes white if it's close to 1. However, if it's making a row operation, there is another value closer to 0 and I was expecting to see it black at (1,5) location. If it does a column operation, there is again something wrong. As I said, this data has been already normalized and varies within 0 and 1. So, what's the logic that it converts the array into an image? What kind of operation it does?

Secondly, if I first get an RGB image of the data and then convert it into a grayscale image, why I am not having exactly the same image as what I obtained first? Should the image coming from direct grayscale conversion (L method, np.float64) and the one coming from RGB-based (first I get RGB then convert it to grayscale) be the same? There is a difference in black-white pixels in those images. I do not know why we have it.

---- EDIT 2 ----

.tiff image with F mode and np.float32 gives the following;

A proper way to convert 2D Array into RGB or GrayScale image for precision difference

Answers (1)

Related Questions