In this article, we have explained the process of how to display and save a Numpy array as an Image. This requires Numpy and PIL library.
Table of contents:
- Display Numpy array as Image
- Complete Python Code
Display Numpy array as Image
Import the relevant library to display and save Numpy array as Image. We import numpy library to create Numpy array and PIL library to add support for display and saving.
from PIL import Image
import numpy as np
Create a sample Numpy array and convert the array to PIL format using fromarray[] function of PIL.
height = 500
weight = 500
channel = 3
img_numpy = np.zeros[[height, weight, channel], dtype=np.uint8]
img = Image.fromarray[img_numpy, "RGB"]
To view the image from the terminal use the show[] function:
# Display the Numpy array as Image
img.show[]
This will open a new terminal window where the image will be displayed.
To save the Numpy array as a local image, use the save[] function and pass the image filename with the directory where to save it.
# Save the Numpy array as Image
image_filename = "opengenus_image.jpeg"
img.save[image_filename]
This will save the Numpy array as a jpeg image.
Complete Python Code
Following is the complete Python code to display and save Numpy array as Image:
from PIL import Image
import numpy as np
height = 500
weight = 500
channel = 3
img_numpy = np.zeros[[height, weight, channel], dtype=np.uint8]
img = Image.fromarray[img_numpy, "RGB"]
# Display the Numpy array as Image
img.show[]
# Save the Numpy array as Image
image_filename = "opengenus_image.jpeg"
img.save[image_filename]
With this article at OpenGenus, you must have the complete idea of how to display and save Numpy array as image.
This section addresses basic image manipulation and processing using the core scientific modules NumPy and SciPy. Some of the operations covered by this tutorial may be useful for other kinds of multidimensional array processing than image processing. In particular, the submodule provides functions operating on n-dimensional NumPy arrays.
See also
For more advanced image processing and image-specific routines, see the tutorial , dedicated to the module.
Image = 2-D numerical array
[or 3-D: CT, MRI, 2D + time; 4-D, …]
Here, image == Numpy array
>>> face_memmap = np.memmap['face.raw', dtype=np.uint8, shape=[768, 1024, 3]]4
Tools used in this tutorial:
>>> face_memmap = np.memmap['face.raw', dtype=np.uint8, shape=[768, 1024, 3]]
5: basic array manipulation>>> face_memmap = np.memmap['face.raw', dtype=np.uint8, shape=[768, 1024, 3]]
6:>>> face_memmap = np.memmap['face.raw', dtype=np.uint8, shape=[768, 1024, 3]]
2 submodule dedicated to image processing [n-dimensional images]. See the documentation:>>> from scipy import ndimage
Common tasks in image processing:
- Input/Output, displaying images
- Basic manipulations: cropping, flipping, rotating, …
- Image filtering: denoising, sharpening
- Image segmentation: labeling pixels corresponding to different objects
- Classification
- Feature extraction
- Registration
- …
Chapters contents
Writing an array to a file:
from scipy import misc import imageio f = misc.face[] imageio.imsave['face.png', f] # uses the Image module [PIL] import matplotlib.pyplot as plt plt.imshow[f] plt.show[]
Creating a numpy array from an image file:
>>> from scipy import misc >>> import imageio >>> face = misc.face[] >>> imageio.imsave['face.png', face] # First we need to create the PNG file >>> face = imageio.imread['face.png'] >>> type[face] >>> face.shape, face.dtype [[768, 1024, 3], dtype['uint8']]
dtype is uint8 for 8-bit images [0-255]
Opening raw files [camera, 3-D images]
>>> face.tofile['face.raw'] # Create raw file >>> face_from_raw = np.fromfile['face.raw', dtype=np.uint8] >>> face_from_raw.shape [2359296,] >>> face_from_raw.shape = [768, 1024, 3]
Need to know the shape and dtype of the image [how to separate data bytes].
For large data, use
>>> face_memmap = np.memmap['face.raw', dtype=np.uint8, shape=[768, 1024, 3]]9 for memory mapping:
>>> face_memmap = np.memmap['face.raw', dtype=np.uint8, shape=[768, 1024, 3]]
[data are read from the file, and not loaded into memory]
Working on a list of image files
>>> for i in range[10]: ... im = np.random.randint[0, 256, 10000].reshape[[100, 100]] ... imageio.imsave['random_%02d.png' % i, im] >>> from glob import glob >>> filelist = glob['random*.png'] >>> filelist.sort[]
Use
>>> for i in range[10]: ... im = np.random.randint[0, 256, 10000].reshape[[100, 100]] ... imageio.imsave['random_%02d.png' % i, im] >>> from glob import glob >>> filelist = glob['random*.png'] >>> filelist.sort[]0 and
>>> for i in range[10]: ... im = np.random.randint[0, 256, 10000].reshape[[100, 100]] ... imageio.imsave['random_%02d.png' % i, im] >>> from glob import glob >>> filelist = glob['random*.png'] >>> filelist.sort[]1 to display an image inside a
>>> for i in range[10]: ... im = np.random.randint[0, 256, 10000].reshape[[100, 100]] ... imageio.imsave['random_%02d.png' % i, im] >>> from glob import glob >>> filelist = glob['random*.png'] >>> filelist.sort[]2:
>>> f = misc.face[gray=True] # retrieve a grayscale image >>> import matplotlib.pyplot as plt >>> plt.imshow[f, cmap=plt.cm.gray]
Increase contrast by setting min and max values:
>>> plt.imshow[f, cmap=plt.cm.gray, vmin=30, vmax=200] >>> # Remove axes and ticks >>> plt.axis['off'] [-0.5, 1023.5, 767.5, -0.5]
Draw contour lines:
>>> plt.contour[f, [50, 200]]
[]
For smooth intensity variations, use
>>> for i in range[10]: ... im = np.random.randint[0, 256, 10000].reshape[[100, 100]] ... imageio.imsave['random_%02d.png' % i, im] >>> from glob import glob >>> filelist = glob['random*.png'] >>> filelist.sort[]3. For fine inspection of intensity variations, use
>>> for i in range[10]: ... im = np.random.randint[0, 256, 10000].reshape[[100, 100]] ... imageio.imsave['random_%02d.png' % i, im] >>> from glob import glob >>> filelist = glob['random*.png'] >>> filelist.sort[]4:
>>> plt.imshow[f[320:340, 510:530], cmap=plt.cm.gray, interpolation='bilinear'] >>> plt.imshow[f[320:340, 510:530], cmap=plt.cm.gray, interpolation='nearest']
[]
See also
More interpolation methods are in Matplotlib’s examples.
See also
3-D visualization: Mayavi
See .
- Image plane widgets
- Isosurfaces
- …
Images are arrays: use the whole
>>> face_memmap = np.memmap['face.raw', dtype=np.uint8, shape=[768, 1024, 3]]5 machinery.
from scipy import misc import imageio f = misc.face[] imageio.imsave['face.png', f] # uses the Image module [PIL] import matplotlib.pyplot as plt plt.imshow[f] plt.show[]0
[]
from scipy import misc import imageio f = misc.face[] imageio.imsave['face.png', f] # uses the Image module [PIL] import matplotlib.pyplot as plt plt.imshow[f] plt.show[]1
>>> for i in range[10]: ... im = np.random.randint[0, 256, 10000].reshape[[100, 100]] ... imageio.imsave['random_%02d.png' % i, im] >>> from glob import glob >>> filelist = glob['random*.png'] >>> filelist.sort[]6
Exercise
- Open as an array the
>>> for i in range[10]: ... im = np.random.randint[0, 256, 10000].reshape[[100, 100]] ... imageio.imsave['random_%02d.png' % i, im] >>> from glob import glob >>> filelist = glob['random*.png'] >>> filelist.sort[]
7 logo [//scikit-image.org/_static/img/logo.png], or an image that you have on your computer. - Crop a meaningful part of the image, for example the python circle in the logo.
- Display the image array using
>>> for i in range[10]: ... im = np.random.randint[0, 256, 10000].reshape[[100, 100]] ... imageio.imsave['random_%02d.png' % i, im] >>> from glob import glob >>> filelist = glob['random*.png'] >>> filelist.sort[]
0. Change the interpolation method and zoom to see the difference. - Transform your image to greyscale
- Increase the contrast of the image by changing its minimum and maximum values. Optional: use
>>> for i in range[10]: ... im = np.random.randint[0, 256, 10000].reshape[[100, 100]] ... imageio.imsave['random_%02d.png' % i, im] >>> from glob import glob >>> filelist = glob['random*.png'] >>> filelist.sort[]
9 [read the docstring!] to saturate 5% of the darkest pixels and 5% of the lightest pixels. - Save the array to two different file formats [png, jpg, tiff]
from scipy import misc import imageio f = misc.face[] imageio.imsave['face.png', f] # uses the Image module [PIL] import matplotlib.pyplot as plt plt.imshow[f] plt.show[]2
[]
Local filters: replace the value of pixels by a function of the values of neighboring pixels.
Neighbourhood: square [choose size], disk, or more complicated structuring element.
Gaussian filter from
>>> face_memmap = np.memmap['face.raw', dtype=np.uint8, shape=[768, 1024, 3]]2:
from scipy import misc import imageio f = misc.face[] imageio.imsave['face.png', f] # uses the Image module [PIL] import matplotlib.pyplot as plt plt.imshow[f] plt.show[]3
Uniform filter
from scipy import misc import imageio f = misc.face[] imageio.imsave['face.png', f] # uses the Image module [PIL] import matplotlib.pyplot as plt plt.imshow[f] plt.show[]4
[]
Sharpen a blurred image:
from scipy import misc import imageio f = misc.face[] imageio.imsave['face.png', f] # uses the Image module [PIL] import matplotlib.pyplot as plt plt.imshow[f] plt.show[]5
increase the weight of edges by adding an approximation of the Laplacian:
from scipy import misc import imageio f = misc.face[] imageio.imsave['face.png', f] # uses the Image module [PIL] import matplotlib.pyplot as plt plt.imshow[f] plt.show[]6
[]
Noisy face:
from scipy import misc import imageio f = misc.face[] imageio.imsave['face.png', f] # uses the Image module [PIL] import matplotlib.pyplot as plt plt.imshow[f] plt.show[]7
A Gaussian filter smoothes the noise out… and the edges as well:
from scipy import misc import imageio f = misc.face[] imageio.imsave['face.png', f] # uses the Image module [PIL] import matplotlib.pyplot as plt plt.imshow[f] plt.show[]8
Most local linear isotropic filters blur the image [
>>> f = misc.face[gray=True] # retrieve a grayscale image >>> import matplotlib.pyplot as plt >>> plt.imshow[f, cmap=plt.cm.gray]1]
A median filter preserves better the edges:
from scipy import misc import imageio f = misc.face[] imageio.imsave['face.png', f] # uses the Image module [PIL] import matplotlib.pyplot as plt plt.imshow[f] plt.show[]9
[]
Median filter: better result for straight boundaries [low curvature]:
>>> from scipy import misc >>> import imageio >>> face = misc.face[] >>> imageio.imsave['face.png', face] # First we need to create the PNG file >>> face = imageio.imread['face.png'] >>> type[face] >>> face.shape, face.dtype [[768, 1024, 3], dtype['uint8']]0
[]
Other rank filter:
>>> f = misc.face[gray=True] # retrieve a grayscale image >>> import matplotlib.pyplot as plt >>> plt.imshow[f, cmap=plt.cm.gray]2,
>>> f = misc.face[gray=True] # retrieve a grayscale image >>> import matplotlib.pyplot as plt >>> plt.imshow[f, cmap=plt.cm.gray]3
Other local non-linear filters: Wiener [
>>> f = misc.face[gray=True] # retrieve a grayscale image >>> import matplotlib.pyplot as plt >>> plt.imshow[f, cmap=plt.cm.gray]4], etc.
Non-local filters
Exercise: denoising
- Create a binary image [of 0s and 1s] with several objects [circles, ellipses, squares, or random shapes].
- Add some noise [e.g., 20% of noise]
- Try two different denoising methods for denoising the image: gaussian filtering and median filtering.
- Compare the histograms of the two different denoised images. Which one is the closest to the histogram of the original [noise-free] image?
See also
More denoising filters are available in
>>> f = misc.face[gray=True] # retrieve a grayscale image >>> import matplotlib.pyplot as plt >>> plt.imshow[f, cmap=plt.cm.gray]5, see the tutorial.
See wikipedia for a definition of mathematical morphology.
Probe an image with a simple shape [a structuring element], and modify this image according to how the shape locally fits or misses the image.
Structuring element:
>>> from scipy import misc >>> import imageio >>> face = misc.face[] >>> imageio.imsave['face.png', face] # First we need to create the PNG file >>> face = imageio.imread['face.png'] >>> type[face] >>> face.shape, face.dtype [[768, 1024, 3], dtype['uint8']]1
Erosion = minimum filter. Replace the value of a pixel by the minimal value covered by the structuring element.:
>>> from scipy import misc >>> import imageio >>> face = misc.face[] >>> imageio.imsave['face.png', face] # First we need to create the PNG file >>> face = imageio.imread['face.png'] >>> type[face] >>> face.shape, face.dtype [[768, 1024, 3], dtype['uint8']]2
Dilation: maximum filter:
>>> from scipy import misc >>> import imageio >>> face = misc.face[] >>> imageio.imsave['face.png', face] # First we need to create the PNG file >>> face = imageio.imread['face.png'] >>> type[face] >>> face.shape, face.dtype [[768, 1024, 3], dtype['uint8']]3
Also works for grey-valued images:
>>> from scipy import misc >>> import imageio >>> face = misc.face[] >>> imageio.imsave['face.png', face] # First we need to create the PNG file >>> face = imageio.imread['face.png'] >>> type[face] >>> face.shape, face.dtype [[768, 1024, 3], dtype['uint8']]4
[]
Opening: erosion + dilation:
>>> from scipy import misc >>> import imageio >>> face = misc.face[] >>> imageio.imsave['face.png', face] # First we need to create the PNG file >>> face = imageio.imread['face.png'] >>> type[face] >>> face.shape, face.dtype [[768, 1024, 3], dtype['uint8']]5
Application: remove noise:
>>> from scipy import misc >>> import imageio >>> face = misc.face[] >>> imageio.imsave['face.png', face] # First we need to create the PNG file >>> face = imageio.imread['face.png'] >>> type[face] >>> face.shape, face.dtype [[768, 1024, 3], dtype['uint8']]6
[]
Closing: dilation + erosion
Many other mathematical morphology operations: hit and miss transform, tophat, etc.
Synthetic data:
>>> from scipy import misc >>> import imageio >>> face = misc.face[] >>> imageio.imsave['face.png', face] # First we need to create the PNG file >>> face = imageio.imread['face.png'] >>> type[face] >>> face.shape, face.dtype [[768, 1024, 3], dtype['uint8']]7
Use a gradient operator [Sobel] to find high intensity variations:
>>> from scipy import misc >>> import imageio >>> face = misc.face[] >>> imageio.imsave['face.png', face] # First we need to create the PNG file >>> face = imageio.imread['face.png'] >>> type[face] >>> face.shape, face.dtype [[768, 1024, 3], dtype['uint8']]8
[]
- Histogram-based segmentation [no spatial information]
>>> from scipy import misc >>> import imageio >>> face = misc.face[] >>> imageio.imsave['face.png', face] # First we need to create the PNG file >>> face = imageio.imread['face.png'] >>> type[face] >>> face.shape, face.dtype [[768, 1024, 3], dtype['uint8']]9
[]
Use mathematical morphology to clean up the result:
>>> face.tofile['face.raw'] # Create raw file >>> face_from_raw = np.fromfile['face.raw', dtype=np.uint8] >>> face_from_raw.shape [2359296,] >>> face_from_raw.shape = [768, 1024, 3]0
[]
Exercise
Check that reconstruction operations [erosion + propagation] produce a better result than opening/closing:
>>> face.tofile['face.raw'] # Create raw file >>> face_from_raw = np.fromfile['face.raw', dtype=np.uint8] >>> face_from_raw.shape [2359296,] >>> face_from_raw.shape = [768, 1024, 3]1
Exercise
Check how a first denoising step [e.g. with a median filter] modifies the histogram, and check that the resulting histogram-based segmentation is more accurate.
See also
More advanced segmentation algorithms are found in the
>>> for i in range[10]: ... im = np.random.randint[0, 256, 10000].reshape[[100, 100]] ... imageio.imsave['random_%02d.png' % i, im] >>> from glob import glob >>> filelist = glob['random*.png'] >>> filelist.sort[]7: see .
See also
Other Scientific Packages provide algorithms that can be useful for image processing. In this example, we use the spectral clustering function of the
>>> f = misc.face[gray=True] # retrieve a grayscale image >>> import matplotlib.pyplot as plt >>> plt.imshow[f, cmap=plt.cm.gray]7 in order to segment glued objects.