I had to write this recently and ended up with

indices = np.dstack(np.indices(im.shape[:2]))
data = np.concatenate((im, indices), axis=-1)

Where im is a numpy array. You are probably better off reading the images straight into numpy arrays with

from scipy.misc import imread
im = imread("farm.jpg")

Or, better still if you have Scikit Image installed

from skimage.io import imread
im = imread("farm.jpg")

First convert the RGB values in the last dimension to the HEX value using whatever function you like. This SO answer may help.

Reshape then works on any number of dimensions:

import numpy as np

def rgb2hex(r, g, b):
    return '#%02x%02x%02x' % (r, g, b)

vfunc = np.vectorize(rgb2hex)

a = (np.random.uniform(0,1,(10,5,5,3))*255).astype(int)

c = vfunc(a[:,:,:,0], a[:,:,:,1], a[:,:,:,2])

c.reshape((10,25))

Using cv2 -Read more here

import cv2
img = cv2.imread('path/to/img.jpg')
resized = cv2.resize(img, (128, 128), cv2.INTER_LINEAR)
print pic

Using skimage - Read more here

import skimage.io as skio
faces = skio.imread_collection('path/to/images/*.pgm',conserve_memory=True) # can load multiple images at once

Using Scipy - Read more here

from scipy import misc
pic = misc.imread('path/to/img.jpg')
print pic

Plotting Images

import matplotlib.pyplot as plt
plt.imshow(faces[0],cmap=plt.cm.gray_r,interpolation="nearest")
plt.show()

There would be several ways to do the comparison to give us a boolean array and then, we just need to convert to int array with type conversion. So, for the comparison, one simple way would be to compare against 255 and check for ALL matches along the last axis. This would correspond to checking for [255, 255, 255, 255]. Thus, one approach would be like so -

((arr == 255).all(-1)).astype(int)

Sample run -

In [301]: arr
Out[301]: 
array([[[255, 255, 255, 255],
        [  0,   0,   0, 255],
        [  0,   0,   0, 255]],

       [[  0,   0,   0, 255],
        [255, 255, 255, 255],
        [255, 255, 255, 255]]])

In [302]: ((arr == 255).all(-1)).astype(int)
Out[302]: 
array([[1, 0, 0],
       [0, 1, 1]])

I think the answer is wrong. The Image.fromarray( ____ , 'L') function seems to only work properly with an array of integers between 0 and 255. I use the np.uint8 function for this.

You can see this demonstrated if you try to make a gradient.

import numpy as np
from PIL import Image

# gradient between 0 and 1 for 256*256
array = np.linspace(0,1,256*256)

# reshape to 2d
mat = np.reshape(array,(256,256))

# Creates PIL image
img = Image.fromarray(np.uint8(mat * 255) , 'L')
img.show()

Makes a clean gradient

vs

import numpy as np
from PIL import Image

# gradient between 0 and 1 for 256*256
array = np.linspace(0,1,256*256)

# reshape to 2d
mat = np.reshape(array,(256,256))

# Creates PIL image
img = Image.fromarray( mat , 'L')
img.show()

Has the same kind of artifacting.

If your objective is to save a numpy array as an image, your approach have a problem. The function plt.savefig saves an image of the plot, not the array. Also transforming an array into an image may carry some precision loss (when converting from float64 or float32 to uint16). That been said, I suggest you use skimage and imageio:

import imageio
import numpy as np

from skimage import img_as_uint

data = np.load('0058_00086_brown_2_recording1.wav.npy')
print("original", data.shape)

img = img_as_uint(data)
imageio.imwrite('image.png', img)
load = imageio.imread('image.png')

print("image", load.shape)

This script loads the data you provided and prints the shape for verification

data = np.load('0058_00086_brown_2_recording1.wav.npy')
print("original", data.shape)

then it transform the data to uint, saves the image as png and loads it:

img = img_as_uint(data)
imageio.imwrite('image.png', img)
load = imageio.imread('image.png')

the output of the script is:

original (64, 25)
image (64, 25)

i.e. the image is loaded with the same shape that data. Some notes:

• image.png is saved as a grayscale image
• To save to .jpg just change to imageio.imwrite('image.jpg', img)
• In the case of .png the absolute average distance from the original image was 3.890e-06 (this can be verified using np.abs(img_as_float(load) - data).sum() / data.size)

Information about skimage and imageio can be found in the respectives websites. More on saving numpy arrays as images can be found in the following answers: [1], [2], [3] and [4].

I'm not an expert but I can think of some ways, not sure what you want to achieve though so you might not like my solutions:

from PIL import Image
from numpy import*

temp=asarray(Image.open('test.jpg'))
for j in temp:
    new_temp = asarray([[i[0],i[1]] for i in j]) # new_temp gets the two first pixel values

Furthermore, you can use .resize():

from PIL import Image
from numpy import*

temp=asarray(Image.open('test.jpg'))
x=temp.shape[0]
y=temp.shape[1]*temp.shape[2]

temp.resize((x,y)) # a 2D array
print(temp)

And if you convert the picture to black&white, the array becomes 2D automatically:

from PIL import Image
from numpy import*

temp=Image.open('THIS.bmp')
temp=temp.convert('1')      # Convert to black&white
A = array(temp)             # Creates an array, white pixels==True and black pixels==False
new_A=empty((A.shape[0],A.shape[1]),None)    #New array with same size as A

for i in range(len(A)):
    for j in range(len(A[i])):
        if A[i][j]==True:
            new_A[i][j]=0
        else:
            new_A[i][j]=1

Three solutions are:

1. using matplotlib:

   from matplotlib import pyplot as plt
   
   plt.imshow(decrypted, interpolation='nearest', cmap='gray')
   plt.savefig('decrypted1.png')
   plt.show()
   

2. using PIL:

   from PIL import Image
   
   img = Image.fromarray(decrypted.astype(np.uint8), 'L')
   img.save('decrypted2.png')
   img.show()
   

3. using cv2:

   import cv2
   
   cv2.imwrite('decrypted3.png', decrypted)
   cv2.imshow("decrypted3", decrypted)
   cv2.waitKey()
   

That can be accomplished using slice syntax

a[:,:,0]

You need to use np.transpose to rearrange dimensions. Now, n x m x 3 is to be converted to 3 x (n*m), so send the last axis to the front and shift right the order of the remaining axes (0,1). Finally , reshape to have 3 rows. Thus, the implementation would be -

img.transpose(2,0,1).reshape(3,-1)

Sample run -

In [16]: img
Out[16]: 
array([[[155,  33, 129],
        [161, 218,   6]],

       [[215, 142, 235],
        [143, 249, 164]],

       [[221,  71, 229],
        [ 56,  91, 120]],

       [[236,   4, 177],
        [171, 105,  40]]])

In [17]: img.transpose(2,0,1).reshape(3,-1)
Out[17]: 
array([[155, 161, 215, 143, 221,  56, 236, 171],
       [ 33, 218, 142, 249,  71,  91,   4, 105],
       [129,   6, 235, 164, 229, 120, 177,  40]])