pypng | Pure Python library for PNG image | Image Editing library

It looks like imageio.imwrite will do the right thing if you convert the data type of the array to numpy.uint16 before writing the PNG file:

If you need 4bpp then you should use bitdepth=4 and you have to create array with values 0..15 (for greyscale image) and also array with 16 values (R,G,B) for palette (for color image)

I use PIL to load RGB image and convert to image with 16 colors/indexes to palette with 16 colors (RGB)

Original Answer

I think this does what you ask:

This question is too broad. What happens with the Dockerfile you've created?

You don't need docker compose unless you have multiple containers that need to interact.

Some general observations from your current Dockerfile:

• It would be better to collapse the pip install commands into a single statement. In docker, each statement creates a file system layer, and the layers in between the pip install commmands probably serve no useful purpose.
• It's better to declare dependencies in setup.py or a requirements.txt file (pip install -r requirements.txt), with fixed version numbers (foopackage==0.0.1) to ensure a repeatable build.
• I'd recommend packaging your Django app into a python package and installing it with pip (cd /code/; pip install .) rather than directly adding the code directory.
• You're missing a statement (CMD or ENTRYPOINT) to execute the app. See https://docs.docker.com/engine/reference/builder/#cmd

Key ingredients:

h5py to read the h5 file. Determine the format of your image and use PIL.

Let us suppose it's RGB format (https://support.hdfgroup.org/products/java/hdfview/UsersGuide/ug06imageview.html)

Suppose your image is located at Photos/Image 1 then you can do.

Given all the new information I am updating my answer with a few more tips for debugging the issue.

I found a site here which creates sample transparent images. I created a 64x64 cyan (R=0, G=255, B=255) image with a transparency layer of 0.5. I used this to test your code.

I read in the image two ways to compare: im1 = cv2.imread(fileName) and im2 = cv2.imread(fileName,cv2.IMREAD_UNCHANGED). np.shape(im1) returned (64,64,3) and np.shape(im2) returned (64,64,4). This is why that flag is required--the default imread settings in opencv will read in a transparent image as a normal RGB image.

However opencv reads in as BGR instead of RGB, and since you cannot save out with opencv, you'll need to convert it to the correct order otherwise the image will have reversed color. For example, my cyan image, when viewed with the reversed color appears like this:

You can change this using openCV's color conversion function like this im = cv2.cvtColor(im, cv2.COLOR_BGRA2RGBA) (Here is a list of all the color conversion codes). Again, double check the size of your image if you need to, it should still have four channels since you converted it to RGBA.

You can now add your noise to your image. Just so you know, this is also going to add noise to your alpha channel as well, randomly making some pixels more transparent and others less transparent. The random_noise function from skimage converts your image to float and returns it as float. This means the image values, normally integers ranging from 0 to 255, are converted to decimal values from 0 to 1. Your line img = Image.fromarray(noise_img, 'RGB') does not know what to do with the floating point noise_img. That's why the image is all messed up when you save it, as well as when I tried to show it.

So I took my cyan image, added noise, and then converted the floats back to 8 bits.

Found the answer thanks to this Post which led me to ImageTk.PhotoImage:

Here is my understanding of what you want to do:

1. Load the data from Scaled_Flow.npy. This is a 32 bit floating point numpy array with shape (2, 375, 1242, 2).

2. Convert Scaled_Flow[1] (an array with shape (375, 1242, 2)) to 16 bit unsigned integers by:

   • multiplying by 64,
   • adding 2**15, and
   • casting the values to np.uint16.

   That is the inverse of this description that you quoted: "To convert the u-/v-flow into floating point values, convert the value to float, subtract 2^15 and divide the result by 64.0".

3. Increase the length of the third dimension from 2 to 3 by concatenating an array of all 1s.
4. Save the result to a PNG file.

Here's one way you can do that. To create the PNG file, I'll use numpngw, a library that I wrote for creating PNG and animated PNG files from numpy arrays. If you give numpngw.write_png a numpy array with data type np.uint16, it will create a PNG file with 16 bits per channel (i.e. a 48 bit image in this case).

The conda package, sssdgc::png seems to be libpng12: