Just do

Image.fromarray(np.array(img).astype(np.uint8).transpose(1,2,0))

Seems that your array needs to be of type uint8, then everything works.

Working example:

import numpy as np
from PIL import Image
from PIL.PngImagePlugin import PngInfo
a = np.array([[[255, 0, 0], [0, 255, 0]],     # Red   Green
              [[0, 0, 255], [0, 0, 0]]],      # Blue  Black
             dtype=np.uint8)      
img = Image.fromarray(a).convert("RGB")
metadata = PngInfo()                    # I need to add metadata, thus the use of Pillow and **not cv2**
metadata.add_text("key", "value")
img.save("test.png", pnginfo=metadata)

Cheers!

rgb = np.dstack((r,g,b))  # stacks 3 h x w arrays -> h x w x 3

To also convert floats 0 .. 1 to uint8 s,

rgb_uint8 = (np.dstack((r,g,b)) * 255.999) .astype(np.uint8)  # right, Janna, not 256

I think you want this, where the ranges of the RGB vales are integers in range 0..255:

import numpy as np
from PIL import Image

# Make random 28x28 RGB image
img =np.random.randint(0,256,(28,28,3), dtype=np.uint8)

# Convert to PIL Image
pImg=Image.fromarray(img, mode='RGB')

Now check what we have:

In [19]: pImg                                                                                       
Out[19]: <PIL.Image.Image image mode=RGB size=28x28 at 0x120CE9CF8>

And save:

pImg.save('result.png')

In your comment you specify that the red_arr, etc. are arrays of the range -4000 to 4000.

But if we take a look at the specifications of the Image.from_array modes, then we see that it expects a matrix of three bytes (values from zero to 255).

This is however not per se a problem: we can perform:

def rescale(arr):
    arr_min = arr.min()
    arr_max = arr.max()
    return (arr - arr_min) / (arr_max - arr_min)

red_arr_b = 255.0 * rescale(red_arr)
green_arr_b = 255.0 * rescale(green_arr)
blue_arr_b = 255.0 * rescale(blue_arr)

arr[:,:,0] = red_arr_b
arr[:,:,1] = green_arr_b
arr[:,:,2] = blue_arr_b

img = Image.fromarray(arr.astype(int), 'RGB')

So first we rescale to a range 0 to 255, and then we feed that array to the PIL.

It is also possible that we want to scale red, green and blue the same way. In that case we can use:

def rescale(arr):
    arr_min = arr.min()
    arr_max = arr.max()
    return (arr - arr_min) / (arr_max - arr_min)

arr[:,:,0] = red_arr
arr[:,:,1] = green_arr
arr[:,:,2] = blue_arr

arr = 255.0 * rescale(arr)

img = Image.fromarray(arr.astype(int), 'RGB')

I think this should work - no idea if it's decent Python:

#!/usr/local/bin/python3
from PIL import Image
import numpy as np
import re

# Read in entire file
with open('sensordata.txt') as f:
   s = f.read()

# Find anything that looks like numbers
l=re.findall(r'\d+',s)

# Convert to numpy array and reshape
data = np.array(l).reshape((24,32,3))

# Convert to image and save
img = Image.fromarray(data, 'RGB')
img.save('result.png')

I enlarged and contrast-stretched the image subsequently so you can see it!

You can use newer OpenCV python interface (if I'm not mistaken it is available since OpenCV 2.2). It natively uses numpy arrays:

import cv2
im = cv2.imread("abc.tiff")
print(type(im))

result:

<type 'numpy.ndarray'>

In order to interpret an array as an RGB image, it needs to have 3 channels. A channel is the 3rd dimension in the numpy array. So change your code to this:

img2 = Image.fromarray(arr.reshape(200,300,3), 'RGB')

I should mention that you talk about your flattened array being 1x3072, yet the example code seems to assume 200x300x3, which would be 1x180,000 when flattened. Which of these two is the truth, I couldn't tell you.