Develop Reference

How to deal with negative pixel values in images loaded using simpleITK

I have been working on DICOM CT scan images. I used simleITK to read the images to a numpy array. But the image pixel values are negative float values as shown in the image and the dtype of each pixel is float32. How to convert this pixel values to be able to train a TensorFlow 3D CNN model?
# Read the .nii image containing the volume with SimpleITK:
sitk_obj = sitk.ReadImage(filename)
# and access the numpy array:
image = sitk.GetArrayFromImage(sitk_obj)
negative pixel values
negative pixel values
The images read are of different shapes, how can I resize them to a specific constant image shapes?(as shown in below image)
different image shapes

If you use SimpleITK's RescaleIntensity function, you can rescale the pixel values to whatever range you require. Here's the docs for that function:
https://simpleitk.org/doxygen/latest/html/namespaceitk_1_1simple.html#af34ebbd0c41ae0d0a7a152ac1382bac6
To resize your images you can use SimpleITK's ResampleImageFilter. Here's the docs for that class:
https://simpleitk.org/doxygen/latest/html/classitk_1_1simple_1_1ResampleImageFilter.html
The following StackOverflow answer shows how to create a reference image that you resample your image onto:
https://stackoverflow.com/a/48065819/3712577
And this Github Gist how to resample several images to the same reference image:
https://gist.github.com/zivy/79d7ee0490faee1156c1277a78e4a4c4
Note that SimpleITK considers images as objects in physical space. So if the image origins, directions, and pixel spacings do not match up, then you will not get the result you expect.

Convert boolean matrtix to image matrix in python

I have obtained boolean matrix from sauvola thresholding using scikit image library now I want to do further processing like blob detection on image. How to convert map boolean matrix to grayscale binary image in python.
Followed this link https://stackoverflow.com/a/47667753/9155046
but the output image need to be mapped to grayscale.

Apply "reverse" colormap/lookup-table to generate grayscale image from RGB

We have a large dataset of thermal/infrared images. Due to some error, we received the data not as single-layer-TIFs or something, but the camera software already applied a colormap and I'm now looking at RGB jpg files.
I was able to "reconstruct" the used colormap from an image found online, and now I'm looking for an efficient way to revert the RGB images to grayscale to be able to work with it. Small problem, not all of the image RGB triplets may be represented in my reconstructed colormap, so right now my python script does something like that:
I = cv2.imread('image.jpg')
Iout = I[:,:,0] * 0
for i in range(0, I.shape[0]):
for j in range(0, I.shape[1]):
# calculate square difference between value and colormap and find idx
Iout[i,j]=idx
This works, but is painfully slow because of the for-loops.
Is there any way to use a lookup table with the RGB values (3D or something) which can be applied to the image as a whole? For values not in the colormap it should select the "closest" one, like I did with suqared differences above.

How to get the origin coordinate and pixel physical dimension from a PNG image

I've been searching all day for a way to get the physical dimension from a PNG image.I need to convert a PNG file into a numpy array, which is easy.
However, I cannot find a way to get the physical dimension of each pixel in the same image. Additionally, I need the origin of the image (i.e. the coordinate)
I understand that the physical dimension of a pixel is stored on a PNG image on the pHYs as part of the metadata. So I attempted to get all the metadata by following these steps: In Python, how do I read the exif data for an image?
However, the ._getifex() is not an actual method in the current version.

digital image read as an array of integers

Using Python's PIL module, we can read an digital image into an array of integers,
from PIL import Image
from numpy import array
img = Image.open('x.jpg')
im = array(img) # im is the array representation of x.jpg
I wonder how does PIL interpret an image as an array? First I tried this
od -tu1 x.jpg
and it indeed gave a sequence of numbers, but how does PIL interpret a color image into a 3D array?
In short, my question is that I want to know how can I get a color image's array representation without using any module like PIL, how could do the job using Python?

Well, it depends on the image format I would say.
For a .jpg, there is a complete description of the format that permits to read the image .
You can read it here
What PIL does is exactly what you did at first. But then it reads the bytes following the specifications, which allow it to transform this into a human readable format (in this case an array).
It may seem complex for JPEG, but if you take png (the version without compression) everything can seem way more simple.
For example this image
If you open it, you will see something like that :
You can see several information on top that corresponds to the header.
Then you see all those zeroes, that are the numerical representation of black pixels of the image (the top left corner).
If you open the image with PIL, you will get an array that is mostly filled with 0.
If you want to know more about the first bytes, look at the png specifications chapter 11.2.2.
You will see that some of the bytes corresponds to the width and height of the image. This is how PIL is able to create the array :).
Hope this helps !

Depends on the color mode. In PIL an image is stored as a list of integers with all channels interleaved on a per-pixel basis.
To illustrate this:
Grayscale image: [pixel1, pixel2, pixel3, ...]
RGB: [pixel1_R, pixel1_G, pixel1_B, pixel2_R, pixel_2_G, ...]
Same goes for RBGA and so on.