This is easily done with PIL/Pillow. Create a new grayscale image of the proper size, and convert each array value to the range 0-255 and copy it in. I added a resize at the end to make the pixels easier to see.

from PIL import Image

array1 = [[0.48, 0.4,  0.56, 0.32, 0.52],
 [0.36, 0.56, 0.56, 0.68, 0.56],
 [0.32, 0.72, 0.88, 0.44, 0.56],
 [0.56, 0.64, 0.76, 0.52, 0.48],
 [0.32, 0.88, 0.56, 0.52, 0.4 ]]

width1 = 5
height1 = 5

im = Image.new('L', (width1, height1))
pix = im.load()
for y in range(height1):
    for x in range(width1):
        pix[x, y] = int(array1[y][x] * 255.9999)

im = im.resize((width1 * 10, height1 * 10), resample=Image.NEAREST)
im.save(r'c:\temp\temp.png')

Your array of "binary values" is an array of bytes?

If so, you can do (using Pillow) after resizing it:

from PIL import Image
im = Image.fromarray(arr)

And then im.show() to see it.

If your array has only 0's and 1's (1-bit depth or b/w) you may have to multiply it to 255

im = Image.fromarray(arr * 255)

Here an example:

>>> arr = numpy.random.randint(0,256, 100*100) #example of a 1-D array
>>> arr.resize((100,100))
>>> im = Image.fromarray(arr)
>>> im.show()

Edit (2018):

This question was written in 2011 and Pillow changed ever since requiring to use the mode='L' parameter when loading with fromarray.

Also on comments below it was said arr.astype(np.uint8) was needed as well, but I have not tested it

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.

How about doing it with Pillow:

from PIL import Image
img = Image.open('image.png').convert('L')
img.save('greyscale.png')

If an alpha (transparency) channel is present in the input image and should be preserved, use mode LA:

img = Image.open('image.png').convert('LA')

Using matplotlib and the formula

Y' = 0.2989 R + 0.5870 G + 0.1140 B 

you could do:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg

def rgb2gray(rgb):
    return np.dot(rgb[...,:3], [0.2989, 0.5870, 0.1140])

img = mpimg.imread('image.png')     
gray = rgb2gray(img)    
plt.imshow(gray, cmap=plt.get_cmap('gray'), vmin=0, vmax=1)
plt.show()

From what I understand, you're trying to display the numbers in your matrix as different shades of grey and make it large enough to fit on a poster. So, like @pandita, I would also use Matplotlib as this can be done pretty easily.

import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np

height, width = 50, 33 #in pixels
spines = 'left', 'right', 'top', 'bottom'

labels = ['label' + spine for spine in spines]

tick_params = {spine : False for spine in spines}
tick_params.update({label : False for label in labels})

img = np.random.randint(0, 4097, (height, width))

img *= 255. / 4096

desired_width = 8 #in inches
scale = desired_width / float(width)

fig, ax = plt.subplots(1, 1, figsize=(desired_width, height*scale))
img = ax.imshow(img, cmap=cm.Greys_r, interpolation='none')

#remove spines
for spine in spines:
    ax.spines[spine].set_visible(False)

#hide ticks and labels
ax.tick_params(**tick_params)

#preview
plt.show()

#save
fig.savefig('test.png', dpi=300)

Produces the following image ...

Two issues. Firstly, you are not converting to greyscale. Secondly, the whole point of numpy is to vectorise and avoid for loops because they are slow.

So starting with this image:

You want something like this:

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

# Load coins and convert to greyscale
grey = np.array(Image.open('coins.png').convert('L'))

# Threshold at 128
thresholded=((grey>128)*255).astype(np.uint8)

# Save
Image.fromarray(thresholded).save('result.png')

With PIL it should work like this

from PIL import Image

I8 = (((I - I.min()) / (I.max() - I.min())) * 255.9).astype(np.uint8)

img = Image.fromarray(I8)
img.save("file.png")

If you have opencv installed, you can try:

cv2.imread('1.png', cv2.IMREAD_GRAYSCALE)

Also, you can also try PIL.

from PIL import Image
Image.fromarray(array)

I didn't see this one on the internet, but this one works! thanks to my teacher!

skimage.io.imsave('1.png', np.around(image*255).astype(np.uint8))

To use this, you have to have skimage preinstalled.

pip3 install scikit-image

Thanks @Cris Luengo in the comment above to point out that

"From the docs, it looks like matplotlib only saves RGB or RGBA format image files. You’ll have to use a different package to save a gray-scale image. OpenCV as suggested below is just one option. There are many. Try PIL."

Give him an upvote when you saw it!

I frequently work with images as NumPy arrays - I do it like so:

import numpy as np
from PIL import Image

x=Image.open('im1.jpg','r')
x=x.convert('L') #makes it greyscale
y=np.asarray(x.getdata(),dtype=np.float64).reshape((x.size[1],x.size[0]))

<manipulate matrix y...>

y=np.asarray(y,dtype=np.uint8) #if values still in range 0-255! 
w=Image.fromarray(y,mode='L')
w.save('out.jpg')

If your array values y are no longer in the range 0-255 after the manipulations, you could step up to 16-bit TIFFs or simply rescale.

-Aldo

See the answers in another thread.

Essentially:

gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
np.dot(rgb[...,:3], [0.299, 0.587, 0.114])