Ytukyg

PIL (Python Imaging Library) and Numpy work well together.

I use the following functions.

from PIL import Image

import numpy as np



def load_image( infilename ) :

    img = Image.open( infilename )

    img.load()

    data = np.asarray( img, dtype="int32" )

    return data



def save_image( npdata, outfilename ) :

    img = Image.fromarray( np.asarray( np.clip(npdata,0,255), dtype="uint8"), "L" )

    img.save( outfilename )

The 'Image.fromarray' is a little ugly because I clip incoming data to [0,255], convert to bytes, then create a grayscale image. I mostly work in gray.

An RGB image would be something like:

 outimg = Image.fromarray( ycc_uint8, "RGB" )

 outimg.save( "ycc.tif" )

You can also use matplotlib for this.

from matplotlib.image import imread



img = imread('abc.tiff')

print(type(img))

output:
<class 'numpy.ndarray'>

You need to use cv.LoadImageM instead of cv.LoadImage:

In [1]: import cv

In [2]: import numpy as np

In [3]: x = cv.LoadImageM('im.tif')

In [4]: im = np.asarray(x)

In [5]: im.shape

Out[5]: (487, 650, 3)

Late answer, but I've come to prefer the imageio module to the other alternatives

import imageio

im = imageio.imread('abc.tiff')

Similar to cv2.imread(), it produces a numpy array by default, but in RGB form.

def opencv_image_as_array(im):

  """Interface image from OpenCV's native format to a numpy array.



  note: this is a slicing trick, and modifying the output array will also change

  the OpenCV image data.  if you want a copy, use .copy() method on the array!

  """

  import numpy as np

  w, h, n = im.width, im.height, im.channels

  modes = {1:"L", 3:"RGB"}#, 4:"RGBA"}

  if n not in modes:

    raise StandardError('unsupported number of channels: {0}'.format(n))

  out = np.asarray(im) if n == 1 else np.asarray(im)[:,:,::-1]  ## BGR -> RGB

  return out

When using the answer from David Poole I get a SystemError with gray scale PNGs and maybe other files. My solution is:

import numpy as np

from PIL import Image



img = Image.open( filename )

try:

    data = np.asarray( img, dtype='uint8' )

except SystemError:

    data = np.asarray( img.getdata(), dtype='uint8' )

Actually img.getdata() would work for all files, but it's slower, so I use it only when the other method fails.

As of today, your best bet is to use:

img = cv2.imread(image_path)   # reads an image in the BGR format

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)   # BGR -> RGB

You'll see img will be a numpy array of type:

<class 'numpy.ndarray'>

I also adopted imageio, but I found the following machinery useful for pre- and post-processing:

import imageio

import numpy as np



def imload(*a, **k):

    i = imageio.imread(*a, **k)

    i = i.transpose((1, 0, 2))  # x and y are mixed up for some reason...

    i = np.flip(i, 1)  # make coordinate system right-handed!!!!!!

    return i/255





def imsave(i, url, *a, **k):

    # Original order of arguments was counterintuitive. It should

    # read verbally "Save the image to the URL" — not "Save to the

    # URL the image."



    i = np.flip(i, 1)

    i = i.transpose((1, 0, 2))

    i *= 255



    i = i.round()

    i = np.maximum(i, 0)

    i = np.minimum(i, 255)



    i = np.asarray(i, dtype=np.uint8)



    imageio.imwrite(url, i, *a, **k)

The rationale is that I am using numpy for image processing, not just image displaying. For this purpose, uint8s are awkward, so I convert to floating point values ranging from 0 to 1.

When saving images, I noticed I had to cut the out-of-range values myself, or else I ended up with a really gray output. (The gray output was the result of imageio compressing the full range, which was outside of [0, 256), to values that were inside the range.)

There were a couple other oddities, too, which I mentioned in the comments.